D  Grammar

translation-unit:

(empty)
external-declaration translation-unit_opt
using identifier ; translation-unit
namespace identifier ; translation-unit
using identifier { translation-unit } translation-unit
namespace identifier { translation-unit } translation-unit
extern "C" { translation-unit } translation-unit
extern "C include" { translation-unit } 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 ;
let identifier-list ;
resetable_opt region < type-var > identifier ;
resetable_opt region identifier ;
resetable_opt region identifier = ( expression ) ;
alias < type-var > identifier = 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:

auto
register
static
extern
extern "C"
typedef
abstract

type-specifier:

_
_::kind
void
char
short
int
long
float
double
signed
unsigned
enum-specifier
struct-or-union-specifier
datatype-specifier
type-var
$( parameter-list )
region_t
region_t < any-type-name >
dynregion_t < any-type-name >
dynregion_t < any-type-name, any-type-name >
tag_t
tag_t < any-type-name >
valueof_t ( expression )
typedef-name type-params_opt

kind:

identifier
typedef-name

type-qualifier:

const
restrict
volatile
@numelts ( assignment-expression )
@region ( any-type-name )
@thin
@fat
@zeroterm
@nozeroterm
@notnull
@nullable

enum-specifier:

enum identifier_opt { enum-declaration-list }
enum identifier

enum-field:

identifier
identifier = constant-expression

enum-declaration-list:

enum-field
enum-field , enum-declaration-list

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:

struct
union
@tagged 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

datatype-specifier:

@extensible_opt datatype identifier type-params_opt { datatypefield-list }
@extensible_opt datatype identifier type-params_opt
@extensible_opt datatype identifier . identifier type-params_opt

datatypefield-list:

datatypefield
datatypefield ;
datatypefield , datatypefield-list
datatypefield ; datatypefield-list

datatypefield-scope: one of

extern   static

datatypefield:

datatypefield-scope_opt identifier
datatypefield-scope_opt identifier ( parameter-list )

declarator:

pointer_opt direct-declarator

direct-declarator:

identifier
( declarator )
direct-declarator [ assignment-expression_opt ] zeroterm-qualifier_opt
direct-declarator ( parameter-type-list )
direct-declarator ( effect_opt region-order_opt )
direct-declarator ( identifier-list_opt )
direct-declarator < type-name-list >

effect:

; effect-set

region-order:

: region-order-list

region-order-list:

atomic-effect > type-var
atomic-effect > type-var, region-order-list

zeroterm-qualifier: one of

@zeroterm   @nozeroterm

pointer:

* range_opt region_opt type-qualifier-list_opt pointer_opt
@ range_opt region_opt type-qualifier-list_opt pointer_opt
? region_opt type-qualifier-list_opt pointer_opt

range:

{ assignment-expression }

region:

_
type-var

type-qualifier-list:

type-qualifier
type-qualifier-list type-qualifier

parameter-type-list:

parameter-list effect_opt region-order_opt
parameter-list , ... effect_opt region-order_opt
... inject_opt parameter-declaration effect_opt region-order_opt
parameter-list , ... inject_opt parameter-declaration effect_opt region-order_opt

effect-set:

atomic-effect
atomic-effect + effect-set

atomic-effect:

{ }
{ region-set }
type-var
regions ( any-type-name )

region-set:

type-var
type-var , region-set

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
array-initializer

array-initializer:

{ initializer-list_opt }
{ initializer-list , }
{ for identifier < expression : expression }

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

any-type-name:

type-name
{ }
{ region-set }
any-type-name + atomic-effect

type-name-list:

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

abstract-declarator:

pointer
pointer_opt direct-abstract-declarator

direct-abstract-declarator:

( abstract-declarator )
direct-abstract-declarator_opt [ assignment-expression_opt ]zeroterm-qualifier_opt
direct-abstract-declarator_opt ( parameter-type-list_opt )
direct-abstract-declarator_opt ( effect_opt region-order_opt )
direct-abstract-declarator < type-name-list >

statement:

labeled-statement
expression-statement
compound-statement
selection-statement
iteration-statement
jump-statement
reset_region ( expression ) ;

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 && 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 ;
fallthru ( argument-expression-list_opt ) ;

pattern:

_
( pattern )
integer-constant
- integer-constant
floating-constant
character-constant
NULL
identifier
identifier type-params_opt ( tuple-pattern-list )
$ ( tuple-pattern-list )
identifier ( tuple-pattern-list )
identifier_opt { type-params_opt field-pattern-list_opt }
& pattern
* identifier
identifier as pattern
identifier < type-var >
identifier < _ >

tuple-pattern-list:

...
pattern
pattern , tuple-pattern-list

field-pattern:

pattern
designation pattern

field-pattern-list:

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

expression:

assignment-expression
expression , assignment-expression

assignment-expression:

conditional-expression
unary-expression assignment-operator assignment-expression
unary-expression :=: assignment-expression

assignment-operator: one of

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

conditional-expression:

logical-or-expression
logical-or-expression ? expression : conditional-expression
throw conditional-expression
new array-initializer
new logical-or-expression
rnew ( expression ) array-initializer
rnew ( expression ) logical-or-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 )
offsetof ( type-name , identifier )
offsetof ( type-name , integer-constant )
malloc ( assignment-expression )
rmalloc ( assignment-expression , assignment-expression )
calloc ( assignment-expression , sizeof ( type-name ) )
rcalloc ( assignment-expression , assignment-expression , sizeof ( type-name ) )
numelts ( assignment-expression )
tagcheck ( postfix-expression . identifier )
tagcheck ( postfix-expression -> identifier )
valueof ( type-name )

unary-operator: one of

&   *   +   -   ~  !

postfix-expression:

primary-expression
postfix-expression [ expression ]
postfix-expression ( argument-expression-list_opt )
postfix-expression . identifier
postfix-expression -> identifier
postfix-expression ++
postfix-expression --
( type-name ) { initializer-list }
( type-name ) { initializer-list , }

primary-expression:

identifier
constant
string
( expression )
primary-expression <>
primary-expression @ < type-name-list >
$( argument-expression-list )
identifier { type-params_opt initializer-list }
( { block-item-list } )

argument-expression-list:

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

constant:

integer-constant
character-constant
floating-constant
NULL