d3.dlr

%right dot
%right else
%right basicTypePrimExpr
%left basTypeDeclSuff
%left blockInitStructInit
%left declTmpParm
%left idenList
%left tempInst
%left cmpAndExpr
%left noScopeFuncBody
%left parmTempValPar
%left argListFrstExpr
%right dotdotdot
%right plusplus minusminus 
%right star
%right div modulo
%right plus minus tilde
%right leftshift rightshift unsignedrightshift
%right equal notequal is bangis less greater lessequal greaterequal
%right and xor or logicaland logicalor
%right questionmark
%right assign plusassign minusassign starassign divassign moduloassign leftshiftassign rightshiftassign andassign xorassign orassign tildeassign unsignedrightshiftassign xorxorassign
%right comma
%right lbrack rbrack lparen rparen
%left semicolon


S := Module;

Module :=
	ModuleDeclaration DeclDefs;
	| DeclDefs;

ModuleDeclaration :=
	module ModuleFullyQualifiedName semicolon;

ModuleFullyQualifiedName :=
	ModuleName;
	| Packages dot ModuleName;

ModuleName :=
	identifier;

Packages :=
	PackageName;
	| Packages dot PackageName;

PackageName :=
	identifier;

DeclDefs :=
	DeclDef;
	| DeclDef DeclDefs;

DeclDef :=
	AttributeSpecifier;
	| ImportDeclaration;
	| EnumDeclaration;
	| ClassDeclaration;
	| InterfaceDeclaration;
	| AggregateDeclaration;
	| Declaration;
	| Constructor;
	| Destructor;
	| UnitTest;
	| StaticConstructor;
	| StaticDestructor;
	| SharedStaticConstructor;
	| SharedStaticDestructor;
	| ConditionalDeclaration;
	| DebugSpecification;
	| VersionSpecification;
	| StaticAssert;
	| TemplateDeclaration;
	| TemplateMixinDeclaration;
	| TemplateMixin;
	| MixinDeclaration;
	| semicolon;

ImportDeclaration :=
	import ImportList semicolon;
	| static ImportList semicolon;

ImportList :=
	Import;
	| ImportBindings;
	| Import comma ImportList;

Import :=
	ModuleFullyQualifiedName;
	| ModuleAliasIdentifier assign ModuleFullyQualifiedName;

ImportBindings :=
	Import colon ImportBindList;

ImportBindList :=
	ImportBind;
	| ImportBind comma ImportBindList;

ImportBind :=
	identifier;
	| identifier assign identifier;

ModuleAliasIdentifier :=
	identifier;

MixinDeclaration :=
	mixin lparen AssignExpression rparen semicolon;

Declaration :=
	AliasDeclaration;
	| AliasThisDeclaration;
	| Decl;

AliasDeclaration :=
	alias BasicType Declarator;
	
AliasThisDeclaration := 
	alias identifier this;

Decl :=
	StorageClasses Decl;
	| BasicType Declarators semicolon;
	| BasicType Declarator FunctionBody;
	| AutoDeclaration;

Declarators :=
	DeclaratorInitializer;
	| DeclaratorInitializer comma DeclaratorIdentifierList;

DeclaratorInitializer :=
	Declarator;
	| Declarator assgin Initializer;

DeclaratorIdentifierList :=
	DeclaratorIdentifier;
	| DeclaratorIdentifier comma DeclaratorIdentifierList;

DeclaratorIdentifier :=
	identifier;
	| identifier assgin Initializer;

AutoDeclaration := 
	StorageClasses AutoDeclarationX semicolon; 
	
AutoDeclarationX := 
	identifier assign Initializer;
	| AutoDeclarationX comma identifier assign Initializer;

BasicType :=
	BasicTypeX;
	| dot IdentifierList;
	| IdentifierList;
	| Typeof %prec basicTypePrimExpr;
	| Typeof dot IdentifierList;
	| const lparen Type rparen;
	| immutable lparen Type rparen;
	| shared lparen Type rparen;
	| inout lparen Type rparen;

BasicTypeX :=
	bool;
	| byte;
	| ubyte;
	| short;
	| ushort;
	| int;
	| uint;
	| long;
	| ulong;
	| char;
	| wchar;
	| dchar;
	| float;
	| double;
	| real;
	| ifloat;
	| idouble;
	| ireal;
	| cfloat;
	| cdouble;
	| creal;
	| void;

BasicType2 :=
	star;
	| lbrack rbrack %prec basTypeDeclSuff;
	| lbrack AssignExpression rbrack %prec basTypeDeclSuff;
	| lbrack AssignExpression dotdot AssignExpression rbrack;
	| lbrack Type rbrack %prec basTypeDeclSuff;
	| delegate Parameters FunctionAttributes;
	| function Parameters FunctionAttributes;
	| delegate Parameters;
	| function Parameters;

BasicTypes2 :=
	BasicType2;
	| BasicType2 BasicTypes2;

Declarator :=
	BasicType2 identifier;
	| BasicType2 identifier DeclaratorSuffixes;
	| BasicType2 lparen Declarator rparen;
	| BasicType2 lparen Declarator rparen DeclaratorSuffixes;
	| identifier %prec declTmpParm;
	| identifier DeclaratorSuffixes;
	| lparen Declarator rparen;
	| lparen Declarator rparen DeclaratorSuffixes;

DeclaratorSuffixes :=
	DeclaratorSuffix;
	| DeclaratorSuffix DeclaratorSuffixes;

DeclaratorSuffix :=
	lbrack rbrack;
	| lbrack AssignExpression rbrack;
	| lbrack Type rbrack;
	| Parameters;
	| Parameters Constraint;
	| Parameters MemberFunctionAttributes Constraint;
	| Parameters MemberFunctionAttributes;
	| TemplateParameterList Parameters Constraint;
	| TemplateParameterList Parameters MemberFunctionAttributes;
	| TemplateParameterList Parameters MemberFunctionAttributes Constraint;
	| TemplateParameterList Parameters;

IdentifierList :=
	identifier %prec idenList;
	| identifier dot IdentifierList;
	| TemplateInstance %prec tempInst;
	| TemplateInstance dot IdentifierList;

StorageClasses :=
	StorageClass;
	| StorageClass StorageClasses;

StorageClass :=
	abstract;
	| auto;
	| const;
	| deprecated;
	| extern;
	| final;
	| immutable;
	| inout;
	| shared;
	| nothrow;
	| override;
	| pure;
	| ref;
	| scope;
	| static;
	| synchronized;
	| gshared;
	| thread;

Property :=
	disable;
	| safe;
	| system;
	| trusted;
	| property;

Type :=
	BasicType;
	| BasicType Declarator2;

Declarator2 :=
	BasicType2 DeclaratorSuffixes;
	| BasicType2;
	| DeclaratorSuffixes;
	| BasicType2 lparen Declarator2 rparen DeclaratorSuffixes;
	| lparen Declarator2 rparen DeclaratorSuffixes;
	| BasicType2 lparen Declarator2 rparen;
	| lparen Declarator2 rparen;

Parameters :=
	lparen ParameterList rparen;
	| lparen rparen;

ParameterList :=
	Parameter;
	| Parameter comma ParameterList;
	| dotdotdot;

Parameter :=
	InOut BasicType Declarator;
	| InOut BasicType Declarator dotdotdot;
	| InOut BasicType Declarator assign DefaultInitializerExpression;
	| InOut Type InOut Type dotdotdot;
	| BasicType Declarator %prec parmTempValPar;
	| BasicType Declarator dotdotdot;
	| BasicType Declarator assign DefaultInitializerExpression;
	| Type InOut Type dotdotdot;

InOut :=
	InOutX;
	| InOut InOutX;

InOutX :=
	in;
	| out;
	| ref;
	| lazy;
	| scope;

FunctionAttributes :=
	FunctionAttribute;
	| FunctionAttribute FunctionAttributes;

FunctionAttribute :=
	nothrow;
	| pure;
	| Property;

MemberFunctionAttributes :=
	MemberFunctionAttribute;
	| MemberFunctionAttribute MemberFunctionAttributes;

MemberFunctionAttribute :=
	const;
	| immutable;
	| inout;
	| shared;
	| FunctionAttribute;

DefaultInitializerExpression :=
	assign AssignExpression;
	| file;
	| line;

Initializer :=
	VoidInitializer;
	| NonVoidInitializer;

NonVoidInitializer :=
	AssignExpression;
	| ArrayInitializer;
	| StructInitializer;

ArrayInitializer :=
	lbrack rbrack;
	| lbrack ArrayMemberInitializations rbrack;

ArrayMemberInitializations :=
	ArrayMemberInitialization;
	| ArrayMemberInitialization comma;
	| ArrayMemberInitialization comma ArrayMemberInitializations;

ArrayMemberInitialization :=
	NonVoidInitializer;
	| AssignExpression colon NonVoidInitializer;

StructInitializer :=
	lcurly rcurly;
	| lcurly StructMemberInitializers rcurly;

StructMemberInitializers :=
	StructMemberInitializer;
	| StructMemberInitializer comma;
	| StructMemberInitializer comma StructMemberInitializers;

StructMemberInitializer :=
	NonVoidInitializer;
	| identifier colon NonVoidInitializer;

Typeof :=
	typeof lparen Expression rparen;
	| typeof lparen return rparen;

VoidInitializer :=
	void;

AttributeSpecifier :=
	Attribute colon;
	| Attribute DeclarationBlock;

Attribute :=
	AlignAttribute;
	| LinkageAttribute;
	| Pragma;
	| ProtectionAttribute;
	| __gshared;
	| __thread;
	| abstract;
	| auto;
	| const;
	| deprecated;
	| disable;
	| extern;
	| final;
	| immutable;
	| inout;
	| override;
	| property;
	| ref;
	| safe;
	| scope;
	| shared;
	| static;
	| synchronized;
	| system;
	| trusted;

DeclarationBlock :=
	DeclDef;
	| lcurly DeclDefs rcurly;
	| lcurly rcurly;

LinkageAttribute :=
	extern lparen LinkageType rparen;

LinkageType :=
	identifier;

AlignAttribute :=
	align;
	| align lparen Integer rparen;

ProtectionAttribute :=
	export;
	| package;
	| private;
	| protected;
	| public;

Pragma :=
	pragma lparen identifier rparen;
	| pragma lparen identifier comma ArgumentList rparen;

Expression :=
	CommaExpression;

CommaExpression :=
	AssignExpression;
	| AssignExpression comma CommaExpression;

AssignExpression :=
	ConditionalExpression;
	| ConditionalExpression assign AssignExpression;
	| ConditionalExpression plusassign AssignExpression;
	| ConditionalExpression minusassign AssignExpression;
	| ConditionalExpression starassign AssignExpression;
	| ConditionalExpression divassign AssignExpression;
	| ConditionalExpression moduloassign AssignExpression;
	| ConditionalExpression andassign AssignExpression;
	| ConditionalExpression orassign AssignExpression;
	| ConditionalExpression xorassign AssignExpression;
	| ConditionalExpression tildeassign AssignExpression;
	| ConditionalExpression leftshiftassign AssignExpression;
	| ConditionalExpression rightshiftassign AssignExpression;
	| ConditionalExpression unsignedrightshiftassign AssignExpression;
	| ConditionalExpression xorxorassign AssignExpression;

ConditionalExpression :=
	OrOrExpression;
	| OrOrExpression questionmark Expression colon ConditionalExpression;

OrOrExpression :=
	AndAndExpression;
	| OrOrExpression logicalor AndAndExpression;

AndAndExpression :=
	OrExpression;
	| AndAndExpression logicaland OrExpression;
	| CmpExpression;
	| AndAndExpression logicaland CmpExpression;

OrExpression :=
	XorExpression;
	| OrExpression or XorExpression;

XorExpression :=
	AndExpression;
	| XorExpression xor AndExpression;

AndExpression :=
	ShiftExpression %prec cmpAndExpr;
	| AndExpression and ShiftExpression;

CmpExpression :=
	ShiftExpression;
	| EqualExpression;
	| IdentityExpression;
	| RelExpression;
	| InExpression;

EqualExpression :=
	ShiftExpression equal ShiftExpression;
	| ShiftExpression notequal ShiftExpression;

IdentityExpression :=
	ShiftExpression is ShiftExpression;
	| ShiftExpression bangis ShiftExpression;

RelExpression :=
	ShiftExpression less ShiftExpression;
	| ShiftExpression lessequal ShiftExpression;
	| ShiftExpression greater ShiftExpression;
	| ShiftExpression greaterequal ShiftExpression;
	| ShiftExpression bangsquareassign ShiftExpression;
	| ShiftExpression bangsquare ShiftExpression;
	| ShiftExpression square ShiftExpression;
	| ShiftExpression squareassign ShiftExpression;
	| ShiftExpression banggreater ShiftExpression;
	| ShiftExpression banggreaterassign ShiftExpression;
	| ShiftExpression bangless ShiftExpression;
	| ShiftExpression banglessequal ShiftExpression;

InExpression :=
	ShiftExpression in ShiftExpression;
	| ShiftExpression bangin ShiftExpression;

ShiftExpression :=
	AddExpression;
	| ShiftExpression leftshift AddExpression;
	| ShiftExpression rightshift AddExpression;
	| ShiftExpression unsignedrightshift AddExpression;

AddExpression :=
	MulExpression;
	| AddExpression plus MulExpression;
	| AddExpression minus MulExpression;
	| CatExpression;

CatExpression :=
	AddExpression tilde MulExpression;

MulExpression :=
	PowExpression;
	| MulExpression star PowExpression;
	| MulExpression div PowExpression;
	| MulExpression modulo PowExpression;

PowExpression :=
	PostfixExpression;
	| PostfixExpression xorxor UnaryExpression;

UnaryExpression :=
	and UnaryExpression;
	| increment UnaryExpression;
	| decrement UnaryExpression;
	| star UnaryExpression;
	| minus UnaryExpression;
	| plus UnaryExpression;
	| bang UnaryExpression;
	| ComplementExpression;
	| lparen Type rparen dot identifier;
	| NewExpression;
	| DeleteExpression;
	| CastExpression;
	| PowExpression;

ComplementExpression :=
	tilde UnaryExpression;

NewExpression :=
	 new AllocatorArguments Type lbrack AssignExpression rbrack;
	| new Type lbrack AssignExpression rbrack;
	| new AllocatorArguments Type lparen ArgumentList lparen;
	| new Type lparen ArgumentList lparen;
	| new AllocatorArguments Type;
	| new Type;
	| NewAnonClassExpression;

AllocatorArguments :=
	lparen ArgumentList rparen;
	| lparen rparen;

ArgumentList :=
	AssignExpression %prec argListFrstExpr;
	| AssignExpression comma;
	| AssignExpression comma ArgumentList;

ClassArguments :=
	class lparen ArgumentList rparen;
	| class lparen rparen;
	| class;

DeleteExpression :=
	delete UnaryExpression;

CastExpression :=
	cast lparen Type rparen UnaryExpression;
	| cast lapren CastQual rparen UnaryExpression;
	| cast lparen rpaten UnaryExpression;

CastQual :=
	const;
	| const shared;
	| shared const;
	| inout;
	| inout shared;
	| shared inout;
	| immutable;
	| shared;

PostfixExpression :=
	PrimaryExpression;
	| PostfixExpression dot IdentifierOrTemplateInstance;
	| PostfixExpression dot NewExpression;
	| PostfixExpression plusplus;
	| PostfixExpression minusminus;
	| PostfixExpression lparen rparen;
	| PostfixExpression lparen ArgumentList rparen;
	| IndexExpression;
	| SliceExpression;

IndexExpression :=
	PostfixExpression lbrack ArgumentList rbrack;

SliceExpression :=
	PostfixExpression lbrack rbrack;
	| PostfixExpression lbrack AssignExpression dotdot AssignExpression rbrack;

PrimaryExpression :=
	identifier;
	| dot identifier;
	| TemplateInstance;
	| dot TemplateInstance;
	| this;
	| super;
	| null;
	| true;
	| false;
	| dollar;
	| file;
	| line;
	| IntegerLiteral;
	| FloatLiteral;
	| CharacterLiteral;
	| StringLiterals;
	| ArrayLiteral;
	| AssocArrayLiteral;
	| Lambda;
	| FunctionLiteral;
	| AssertExpression;
	| MixinExpression;
	| ImportExpression;
	| BasicType dot identifier;
	| Typeof;
	| TypeidExpression;
	| IsExpression;
	| lparen Expression rparen;
	| TraitsExpression;

Lambda :=
	identifier arrow AssignExpression;
	| ParameterAttributes arrow AssignExpression;

ArrayLiteral :=
	lbrack ArgumentList rbrack;

AssocArrayLiteral :=
	lbrack KeyValuePairs rbrack;

KeyValuePairs :=
	KeyValuePair;
	| KeyValuePair comma KeyValuePairs;

KeyValuePair :=
	KeyExpression colon ValueExpression;

KeyExpression :=
	AssignExpression;

ValueExpression :=
	AssignExpression;

FunctionLiteral :=
	function Type ParameterAttributes FunctionBody;
	| function ParameterAttributes FunctionBody;
	| function Type FunctionBody;
	| function FunctionBody;
	| delegate Type ParameterAttributes FunctionBody;
	| delegate ParameterAttributes FunctionBody;
	| delegate Type FunctionBody;
	| delegate FunctionBody;
	| ParameterAttributes FunctionBody;
	| FunctionBody;

ParameterAttributes :=
	Parameters;
	| Parameters FunctionAttributes;

AssertExpression :=
	assert lparen AssignExpression rparen;
	| assert lparen AssignExpression comma AssignExpression rparen;

MixinExpression :=
	mixin lparen AssignExpression rparen;

ImportExpression :=
	import lparen AssignExpression rparen;

TypeidExpression :=
	typeid lparen Type rparen;
	| typeid lparen Expression rparen;

IsExpression :=
	is lparen Type rparen;
	| is lparen Type colon TypeSpecialization rparen;
	| is lparen Type equal TypeSpecialization rparen;
	| is lparen Type identifier rparen;
	| is lparen Type identifier colon TypeSpecialization rparen;
	| is lparen Type identifier equal TypeSpecialization rparen;
	| is lparen Type identifier equal TypeSpecialization comma TemplateParameterList rparen;

TypeSpecialization :=
	Type;
	| class;
	| const;
	| delegate;
	| enum;
	| function;
	| immutable;
	| inout;
	| interface;
	| return;
	| shared;
	| struct;
	| super;
	| union;

TraitsExpression :=
	__traits lparen TraitsKeyword comma TraitsArguments rparen;

TraitsKeyword :=
	identifier;

TraitsArguments :=
	TraitsArgument;
	| TraitsArgument comma TraitsArguments;

TraitsArgument :=
	AssignExpression;
	| Type;

Statement :=
    semicolon;
    | NonEmptyStatement;
    | ScopeBlockStatement;

NoScopeNonEmptyStatement :=
    NonEmptyStatement;
    | BlockStatement;

NoScopeStatement :=
    semicolon;;
    | NonEmptyStatement;
    | BlockStatement;

NonEmptyOrScopeBlockStatement :=
    NonEmptyStatement;
    | ScopeBlockStatement;

NonEmptyStatement :=
    NonEmptyStatementNoCaseNoDefault;
    | CaseStatement;
    | CaseRangeStatement;
    | DefaultStatement;

NonEmptyStatementNoCaseNoDefault :=
    LabeledStatement;
    | ExpressionStatement;
    | DeclarationStatement;
    | IfStatement;
    | WhileStatement;
    | DoStatement;
    | ForStatement;
    | ForeachStatement;
    | SwitchStatement;
    | FinalSwitchStatement;
    | ContinueStatement;
    | BreakStatement;
    | ReturnStatement;
    | GotoStatement;
    | WithStatement;
    | SynchronizedStatement;
    | TryStatement;
    | ScopeGuardStatement;
    | ThrowStatement;
    | AsmStatement;
    | PragmaStatement;
    | MixinStatement;
    | ForeachRangeStatement;
    | ConditionalStatement;
    | StaticAssert;
    | TemplateMixin;
    | ImportDeclaration;

ScopeStatement :=
    NonEmptyStatement;
    | BlockStatement;

ScopeBlockStatement :=
    BlockStatement;

LabeledStatement :=
	identifier colon NoScopeStatement;

BlockStatement :=
	lcurly rcurly %prec blockInitStructInit;
	| lcurly StatementList rcurly;

StatementList :=
	Statement;
	| Statement StatementList;

ExpressionStatement :=
	Expression semicolon;

DeclarationStatement :=
	Declaration;

IfStatement :=
	if lparen IfCondition rparen ThenStatement;
	| if lparen IfCondition rparen ThenStatement else ElseStatement;

IfCondition :=
	Expression;
	| auto identifier assign Expression;
	| BasicType BasicTypes2 Declarator assign Expression;
	| BasicType Declarator assign Expression;

ThenStatement :=
	ScopeStatement;

ElseStatement :=
	ScopeStatement;

WhileStatement :=
	while lparen Expression rparen ScopeStatement;

DoStatement :=
	do ScopeStatement while lparen Expression rparen semicolon;

ForStatement :=
    for lparen Initialize Test semicolon Increment rparen ScopeStatement;
    | for lparen Initialize Test semicolon rparen ScopeStatement;
    | for lparen Initialize semicolon Increment rparen ScopeStatement;
    | for lparen Initialize semicolon rparen ScopeStatement;

Initialize :=
	semicolon;
	| NoScopeNonEmptyStatement;

// expression was opt
Test :=
	Expression;

// expression was opt
Increment :=
	Expression;

ForeachStatement :=
	Foreach lparen ForeachTypeList semicolon Aggregate rparen NoScopeNonEmptyStatement;

Foreach :=
	foreach;
	| foreach_reverse;

ForeachTypeList :=
	ForeachType;
	| ForeachType comma ForeachTypeList;

ForeachType :=
	ref Type identifier;
	| ref identifier;
	| Type identifier;
	| identifier;

Aggregate :=
	Expression;

SwitchStatement :=
	switch lparen Expression rparen ScopeStatement;

CaseStatement :=
	case ArgumentList colon ScopeStatementList;

CaseRangeStatement :=
	case FirstExp colon dotdot case LastExp colon ScopeStatementList;

FirstExp :=
	AssignExpression;

LastExp :=
	AssignExpression;

DefaultStatement :=
	default colon Statement;

ScopeStatementList :=
    StatementListNoCaseNoDefault;

StatementListNoCaseNoDefault :=
    StatementNoCaseNoDefault;
    | StatementNoCaseNoDefault StatementListNoCaseNoDefault;

StatementNoCaseNoDefault :=
    semicolon;
    | NonEmptyStatementNoCaseNoDefault;
    | ScopeBlockStatement;

FinalSwitchStatement :=
	final switch lparen Expression rparen ScopeStatement;

ContinueStatement :=
	continue semicolon;
	| continue identifier semicolon;

BreakStatement :=
	break semicolon;
	| break identifier semicolon;

ReturnStatement :=
	return semicolon;
	| return Expression semicolon;

GotoStatement :=
	goto identifier semicolon;
	| goto default semicolon;
	| goto case semicolon;
	| goto case Expression semicolon;

WithStatement :=
	with lparen Expression rparen ScopeStatement;
	| with lparen Symbol rparen ScopeStatement;
	| with lparen TemplateInstance rparen ScopeStatement;

SynchronizedStatement :=
	synchronized ScopeStatement;
	| synchronized lparen Expression rparen ScopeStatement;

TryStatement :=
	try ScopeStatement Catches;
	| try ScopeStatement Catches FinallyStatement;
	| try ScopeStatement FinallyStatement;

Catches :=
	LastCatch;
	| Catch;
	| Catch Catches;

LastCatch :=
	catch NoScopeNonEmptyStatement;

Catch :=
	catch lparen CatchParameter rparen NoScopeNonEmptyStatement;

CatchParameter :=
	BasicType identifier;

FinallyStatement :=
	finally NoScopeNonEmptyStatement;

ThrowStatement :=
	throw Expression semicolon;

ScopeGuardStatement :=
	scope lparen exit rparen NonEmptyOrScopeBlockStatement;
	| scope lparen success rparen NonEmptyOrScopeBlockStatement;
	| scope lparen failure rparen NonEmptyOrScopeBlockStatement;

AsmStatement :=
	asm lcurly rcurly;
	| asm lcurly AsmInstructionList rcurly;

AsmInstructionList :=
	AsmInstruction semicolon;
	| AsmInstruction semicolon AsmInstructionList;

PragmaStatement :=
	Pragma NoScopeStatement;

MixinStatement :=
	mixin lparen AssignExpression rparen semicolon;

ForeachRangeStatement :=
	Foreach lparen ForeachType semicolon LwrExpression dotdot UprExpression rparen ScopeStatement;

LwrExpression :=
	Expression;

UprExpression :=
	Expression;

AggregateDeclaration :=
	struct identifier StructBody;
	| union identifier StructBody;
	| struct identifier semicolon;
	| union identifier semicolon;
	| StructTemplateDeclaration;
	| UnionTemplateDeclaration;

StructBody :=
	lcurly StructBodyDeclarations rcurly;
	| lcurly rcurly;

StructBodyDeclarations :=
	StructBodyDeclaration;
	| StructBodyDeclaration StructBodyDeclarations;

StructBodyDeclaration :=
	DeclDef;
	| StructAllocator;
	| StructDeallocator;
	| StructPostblit;
	| AliasThis;
	
StructAllocator := 
	ClassAllocator;
	
StructDeallocator :=
	ClassDeallocator;

StructPostblit :=
	this lparen this rparen FunctionBody;

ClassDeclaration :=
	class identifier BaseClassList ClassBody;
	| class identifier ClassBody;
	| ClassTemplateDeclaration;

BaseClassList :=
	colon SuperClass;
	| colon SuperClass comma Interfaces;
	| Interfaces;

SuperClass :=
	identifier;

Interfaces :=
	Interface;
	| Interface comma Interfaces;

Interface :=
	identifier;

ClassBody :=
	lcurly rcurly;
	| lcurly ClassBodyDeclarations rcurly;

ClassBodyDeclarations :=
	ClassBodyDeclaration;
	| ClassBodyDeclaration ClassBodyDeclarations;

ClassBodyDeclaration :=
	DeclDef;
	| Invariant;
	| ClassAllocator;
	| ClassDeallocator;

Constructor :=
	this Parameters FunctionBody;
	| TemplatedConstructor;

TemplatedConstructor :=
    this lparen TemplateParameterList rparen Parameters Constraint FunctionBody;
    | this lparen TemplateParameterList rparen Parameters FunctionBody;

Destructor :=
	tilde this lparen rparen FunctionBody;

StaticConstructor :=
	static this lparen rparen FunctionBody;

StaticDestructor :=
	static tilde this lparen rparen FunctionBody;

SharedStaticConstructor :=
	shared static this lparen rparen FunctionBody;

SharedStaticDestructor :=
	shared static tilde this lparen rparen FunctionBody;

Invariant :=
	invariant lparen rparen BlockStatement;

ClassAllocator :=
	new Parameters FunctionBody;

ClassDeallocator :=
	delete Parameters FunctionBody;

AliasThis :=
	alias identifier this semicolon;

NewAnonClassExpression :=
	new AllocatorArguments class ClassArguments Interfaces ClassBody;
	| new AllocatorArguments class ClassArguments SuperClass ClassBody;
	| new AllocatorArguments class ClassArguments SuperClass Interfaces ClassBody;
	| new AllocatorArguments class Interfaces ClassBody;
	| new AllocatorArguments class SuperClass ClassBody;
	| new AllocatorArguments class SuperClass Interfaces ClassBody;
	| new class ClassArguments Interfaces ClassBody;
	| new class ClassArguments SuperClass ClassBody;
	| new class ClassArguments SuperClass Interfaces ClassBody;
	| new class ClassBody;
	| new class SuperClass Interfaces ClassBody;

ClassArguments :=
	lparen ArgumentList rparen;
	| lparen rparen;

InterfaceDeclaration :=
	interface identifier BaseInterfaceList InterfaceBody;
	| interface identifier InterfaceBody;
	| InterfaceTemplateDeclaration;

BaseInterfaceList :=
	colon Interfaces;

InterfaceBody :=
	lcurly DeclDefs rcurly;
	| lcurly rcurly;

EnumDeclaration :=
	enum EnumBody;
	| enum EnumTag EnumBody;
	| enum EnumTag colon EnumBaseType EnumBody;
	| enum colon EnumBaseType EnumBody;

EnumTag :=
	identifier;

EnumBaseType :=
	Type;

EnumBody :=
	semicolon;
	| lcurly EnumMembers rcurly;

EnumMembers :=
	EnumMember;
	| EnumMember comma;
	| EnumMember comma EnumMembers;

EnumMember :=
	 identifier;
	 | identifier assign AssignExpression;
	 | Type identifier assign AssignExpression;

FunctionBody :=
	 BlockStatement %prec noScopeFuncBody;
	 | BodyStatement;
	 | InStatement BodyStatement;
	 | OutStatement BodyStatement;
	 | InStatement OutStatement BodyStatement;
	 | OutStatement InStatement BodyStatement;

InStatement :=
	 in BlockStatement;

OutStatement :=
	 out BlockStatement;
	 | out lparen identifier rparen BlockStatement;

BodyStatement :=
	 body BlockStatement;

ConditionalDeclaration :=
	 Condition DeclarationBlock;
	 | Condition DeclarationBlock else DeclarationBlock;

ConditionalStatement :=
	 Condition NoScopeNonEmptyStatement;
	 | Condition NoScopeNonEmptyStatement else NoScopeNonEmptyStatement;

Condition :=
	 VersionCondition;
	 | DebugCondition;
	 | StaticIfCondition;

VersionCondition :=
	 version lparen Integer rparen;
	 | version lparen identifier rparen;
	 | version lparen unittest rparen;

VersionSpecification :=
	 version assign identifier semicolon;
	 | version assign Integer semicolon;

DebugCondition :=
	 debug;
	 | debug lparen Integer rparen;
	 | debug lparen identifier rparen;

DebugSpecification :=
	 debug assign identifier semicolon;
	 | debug assign Integer semicolon;

StaticIfCondition :=
	 static if lparen AssignExpression rparen;

StaticAssert :=
	 static assert lparen AssignExpression rparen semicolon;
	 | static assert lparen AssignExpression comma AssignExpression rparen semicolon;

TemplateDeclaration :=
	template TemplateIdentifier lparen TemplateParameterList rparen Constraint lcurly DeclDefs rcurly;
	| template TemplateIdentifier lparen TemplateParameterList rparen lcurly DeclDefs rcurly;

TemplateIdentifier :=
	identifier;

TemplateParameterList :=
	TemplateParameter;
	| TemplateParameter comma;
	| TemplateParameter comma TemplateParameterList;

TemplateParameter :=
	TemplateTypeParameter;
	| TemplateValueParameter;
	| TemplateAliasParameter;
	| TemplateTupleParameter;
	| TemplateThisParameter;

TemplateTupleParameter :=
	identifier dotdotdot;

IdentifierOrTemplateInstance :=
	identifier;
	| TemplateInstance;

TemplateInstance :=
	TemplateIdentifier bang lparen TemplateArgumentList rparen;
	| TemplateIdentifier bang TemplateSingleArgument;

TemplateThisParameter :=
    this TemplateTypeParameter;

TemplateArgumentList :=
	TemplateArgument;
	| TemplateArgument comma;
	| TemplateArgument comma TemplateArgumentList;

TemplateArgument :=
	Type;
	| AssignExpression;
	| Symbol;

Symbol :=
	SymbolTail;
	| dot SymbolTail;

SymbolTail :=
	identifier;
	| identifier dot SymbolTail;
	| TemplateInstance;
	| TemplateInstance dot SymbolTail;

TemplateSingleArgument :=
	identifier;
	| BasicTypeX;
	| CharacterLiteral;
	| StringLiteral;
	| IntegerLiteral;
	| FloatLiteral;
	| true;
	| false;
	| null;
	| file;
	| line;

TemplateTypeParameter :=
	identifier;
	| identifier TemplateTypeParameterSpecialization;
	| identifier TemplateTypeParameterDefault;
	| identifier TemplateTypeParameterSpecialization TemplateTypeParameterDefault;

TemplateTypeParameterSpecialization :=
	colon Type;

TemplateTypeParameterDefault :=
	assign Type;

TemplateValueParameter :=
    BasicType Declarator;
    | BasicType Declarator TemplateValueParameterSpecialization;
    | BasicType Declarator TemplateValueParameterDefault;
    | BasicType Declarator TemplateValueParameterSpecialization TemplateValueParameterDefault;

TemplateValueParameterSpecialization :=
    colon ConditionalExpression;

// already part of conditionalexpression
TemplateValueParameterDefault :=
	assign file;
	| assign line;

TemplateAliasParameter :=
	alias BasicType Declarator TemplateAliasParameterSpecialization TemplateAliasParameterDefault;
	| alias identifier TemplateAliasParameterSpecialization TemplateAliasParameterDefault;
	| alias identifier TemplateAliasParameterSpecialization;
	| alias identifier TemplateAliasParameterDefault;
	| alias identifier;
	| alias BasicType Declarator TemplateAliasParameterDefault;
	| alias BasicType Declarator TemplateAliasParameterSpecialization;
	| alias BasicType Declarator;

TemplateAliasParameterSpecialization :=
	colon Type;
	| colon ConditionalExpression;

TemplateAliasParameterDefault :=
	assign Type;
	| assign ConditionalExpression;

ClassTemplateDeclaration :=
	class identifier lparen TemplateParameterList rparen Constraint BaseClassList ClassBody;
	| class identifier lparen TemplateParameterList rparen BaseClassList ClassBody;
	| class identifier lparen TemplateParameterList rparen Constraint ClassBody;
	| class identifier lparen TemplateParameterList rparen ClassBody;

StructTemplateDeclaration :=
	struct identifier lparen TemplateParameterList rparen Constraint StructBody;
	| struct identifier lparen TemplateParameterList rparen StructBody;

UnionTemplateDeclaration :=
	union identifier lparen TemplateParameterList rparen Constraint StructBody;
	| union identifier lparen TemplateParameterList rparen StructBody;

InterfaceTemplateDeclaration :=
	interface identifier lparen TemplateParameterList rparen Constraint BaseInterfaceList InterfaceBody;
	| interface identifier lparen TemplateParameterList rparen Constraint InterfaceBody;
	| interface identifier lparen TemplateParameterList rparen InterfaceBody;
	| interface identifier lparen TemplateParameterList rparen BaseInterfaceList InterfaceBody;

TemplateMixinDeclaration :=
	mixin template TemplateIdentifier lparen TemplateParameterList rparen Constraint lcurly DeclDefs rcurly;
	| mixin template TemplateIdentifier lparen TemplateParameterList rparen lcurly DeclDefs rcurly;

Constraint :=
	if lparen ConstraintExpression rparen;

ConstraintExpression :=
	Expression;

TemplateMixin :=
	mixin TemplateIdentifier semicolon;
	| mixin TemplateIdentifier identifer semicolon;
	| mixin TemplateIdentifier bang lparen TemplateArgumentList rparen semicolon;
	| mixin TemplateIdentifier bang lparen TemplateArgumentList rparen semicolon identifier;

UnitTest :=
	unittest BlockStatement;

AsmInstruction :=
	stringliteral;