The Grammar of Cyclone

Quick links: declaration, struct-or-union-specifier, enum-specifier, declarator, statement, pattern, expression

translation-unit:

external-declaration translation-unit_opt
using identifier ; translation-unit
namespace identifier ; translation-unit
using identifier { translation-unit }
namespace identifier { translation-unit }


external-declaration:

function-definition
declaration


function-definition:

declaration-specifiers_opt declarator declaration-list_opt compound-statement


declaration:

declaration-specifiers init-declarator-list_opt ;
let pattern = expression ;


declaration-list:

declaration
declaration-list declaration


declaration-specifiers:

storage-class-specifier declaration-specifiers_opt
type-specifier declaration-specifiers_opt
type-qualifier declaration-specifiers_opt
function-specifier declaration-specifiers_opt


storage-class-specifier: one of

auto register static extern typedef abstract


(The C9X type-specifiers _Bool, _Complex, and _Imaginary are not yet supported)
type-specifier: one of

void char short int long float double signed
unsigned struct-or-union-specifier enum-specifier
typedef-name type-params_opt
type-var bool Bool Char Short Int Long Float Double
$ ( parameter-list )


type-qualifier: one of

const restrict volatile


function-specifier:
inline


struct-or-union-specifier:

struct-or-union { struct-declaration-list }
struct-or-union identifier type-params_opt { struct-declaration-list }
struct-or-union identifier type-params_opt


type-params:

< type-name-list >


struct-or-union: one of

struct union


struct-declaration-list:

struct-declaration
struct-declaration-list struct-declaration


init-declarator-list:

init-declarator
init-declarator-list , init-declarator


init-declarator:

declarator
declarator = initializer


struct-declaration:

specifier-qualifier-list struct-declarator-list ;


specifier-qualifier-list:

type-specifier specifier-qualifier-list_opt
type-qualifier specifier-qualifier-list_opt


struct-declarator-list:

struct-declarator
struct-declarator-list , struct-declarator


struct-declarator:

declarator
declarator_opt : constant-expression


enum-specifier:

enum { enumerator-list }
enum identifier type-params_opt { enumerator-list }
enum identifier type-params_opt
xenum identifier { enumerator-list }
xenum identifier


enumerator-list:

enumerator
enumerator-list , enumerator


enumerator:

identifier
identifier = constant-expression
identifier ( parameter-list )


declarator:

pointer_opt direct-declarator


(We do not support C9X [*] direct-declarators.)
direct-declarator:

identifier
( declarator )
direct-declarator [ constant-expression_opt ]
direct-declarator ( parameter-type-list )
direct-declarator ( identifier-list_opt )
direct-declarator [ ? ]
direct-declarator < type-name-list >


pointer:

* type-qualifier-list_opt pointer_opt
@ type-qualifier-list_opt pointer_opt


type-qualifier-list:

type-qualifier
type-qualifier-list type-qualifier


parameter-type-list:

parameter-list
parameter-list , ...


parameter-list:

parameter-declaration
parameter-list , parameter-declaration


parameter-declaration:

specifier-qualifier-list declarator
specifier-qualifier-list abstract-declarator_opt


identifier-list:

identifier
identifier-list , identifier


initializer:

assignment-expression
{ initializer-list_opt }
{ initializer-list , }


initializer-list:

designation_opt initializer
initializer-list , designation_opt initializer


designation:

designator-list =


designator-list:
designator
designator-list designator


designator:
[ constant-expression ]
. identifier


type-name:

specifier-qualifier-list abstract-declarator_opt


type-name-list:

type-name
type-name-list , type-name


abstract-declarator:

pointer
pointer_opt direct-abstract-declarator


(We do not support C9X [*] direct-abstract-declarators.)
direct-abstract-declarator:

( abstract-declarator )
direct-abstract-declarator_opt [ constant-expression_opt ]
direct-abstract-declarator_opt ( parameter-type-list_opt )
direct-abstract-declarator_opt [ ? ]
direct-abstract-declarator < type-name-list >


statement:

labeled-statement
expression-statement
compound-statement
selection-statement
iteration-statement
jump-statement
cut statement
splice statement


(We treat the case and default labels specially; see switch-clauses)
labeled-statement:

identifier : statement


expression-statement:

expression_opt ;


compound-statement:

{ block-item-list_opt }


block-item-list:

block-item
block-item block-item-list


block-item:

declaration
statement


selection-statement:

if ( expression ) statement
if ( expression ) statement else statement
switch ( expression ) { switch-clauses }
try statement catch { switch-clauses }


switch-clauses:

(empty)
default : block-item-list
case pattern : block-item-list_opt switch-clauses
case pattern where expression : block-item-list_opt switch-clauses


iteration-statement:

while ( expression ) statement
do statement while ( expression ) ;
for ( expression_opt ; expression_opt ; expression_opt ) statement
for ( declaration expression_opt ; expression_opt ) statement


jump-statement:

goto identifier ;
continue ;
break ;
return ;
return expression ;
fallthru ;


pattern:

_
( pattern )
integer-constant
- integer-constant
floating-constant
character-constant
null
true
false
identifier
identifier type-params_opt ( tuple-pattern-list )
$ ( tuple-pattern-list )
identifier type-params_opt { }
identifier type-params_opt { field-pattern-list }
& pattern


tuple-pattern-list:

(empty)
pattern
tuple-pattern-list , pattern


field-pattern-list:

field-pattern
field-pattern-list , field-pattern


field-pattern:

pattern
designation pattern


expression:

assignment-expression
expression , assignment-expression


assignment-expression:

conditional-expression
unary-expression assignment-operator assignment-expression


assignment-operator: one of

= *= /= %= += -= <<= >>= &= ^= |=


conditional-expression:

logical-or-expression
logical-or-expression ? expression : conditional-expression


constant-expression:

conditional-expression


logical-or-expression:

logical-and-expression
logical-or-expression || logical-and-expression


logical-and-expression:

inclusive-or-expression
logical-and-expression && inclusive-or-expression


inclusive-or-expression:

exclusive-or-expression
inclusive-or-expression | exclusive-or-expression


exclusive-or-expression:

and-expression
exclusive-or-expression ^ and-expression


and-expression:

equality-expression
and-expression & equality-expression


equality-expression:

relational-expression
equality-expression == relational-expression
equality-expression != relational-expression


relational-expression:

shift-expression
relational-expression < shift-expression
relational-expression > shift-expression
relational-expression <= shift-expression
relational-expression >= shift-expression


shift-expression:

additive-expression
shift-expression << additive-expression
shift-expression >> additive-expression


additive-expression:

multiplicative-expression
additive-expression + multiplicative-expression
additive-expression - multiplicative-expression


multiplicative-expression:

cast-expression
multiplicative-expression * cast-expression
multiplicative-expression / cast-expression
multiplicative-expression % cast-expression


cast-expression:

unary-expression
( type-name ) cast-expression


unary-expression:

postfix-expression
++ unary-expression
-- unary-expression
unary-operator cast-expression
sizeof unary-expression
sizeof ( type-name )
raise unary-expression


unary-operator: one of

& * + - ~ !


postfix-expression:

primary-expression
postfix-expression [ expression ]
postfix-expression ( )
postfix-expression ( argument-expression-list )
postfix-expression . identifier
postfix-expression -> identifier
postfix-expression ++
postfix-expression --
( type-name ) { initializer-list }
( type-name ) { initializer-list , }
new { initializer-listopt }
new { initializer-list , }
new { for identifier < expression : expression }
fill ( expression )
codegen ( function-definition )


primary-expression:

identifier
constant
string
( expression )
identifier <>
$ ( argument-expression-list )
identifier { initializer-list }
( { block-item-list } )


argument-expression-list:

assignment-expression
argument-expression-list , assignment-expression


constant:

integer-constant
character-constant
floating-constant
enumeration-constant
true
false
null