grammar.dd

Ddoc

$(SPEC_S Grammar,

$(H3 Lexical Syntax)

    $(P Refer to the page for $(LINK2 lex.html, lexical syntax).)

$(H3 $(LNAME2 type, Type))

$(GRAMMAR
$(GNAME Type):
    $(GLINK TypeCtors)$(OPT) $(GLINK BasicType) $(GLINK BasicType2)$(OPT)

$(GNAME TypeCtors):
    $(GLINK TypeCtor)
    $(GLINK TypeCtor) $(I TypeCtors)

$(GNAME TypeCtor):
    $(D const)
    $(D immutable)
    $(D inout)
    $(D shared)

$(GNAME BasicType):
    $(GLINK BasicTypeX)
    $(D .) $(GLINK IdentifierList)
    $(GLINK IdentifierList)
    $(GLINK Typeof)
    $(GLINK Typeof) $(D .) $(GLINK IdentifierList)
    $(GLINK TypeCtor) $(D $(LPAREN)) $(GLINK Type) $(D $(RPAREN))
    $(GLINK TypeVector)

$(GNAME BasicTypeX):
    $(D bool)
    $(D byte)
    $(D ubyte)
    $(D short)
    $(D ushort)
    $(D int)
    $(D uint)
    $(D long)
    $(D ulong)
    $(D char)
    $(D wchar)
    $(D dchar)
    $(D float)
    $(D double)
    $(D real)
    $(D ifloat)
    $(D idouble)
    $(D ireal)
    $(D cfloat)
    $(D cdouble)
    $(D creal)
    $(D void)

$(GNAME BasicType2):
    $(GLINK BasicType2X) $(GLINK BasicType2)$(OPT)

$(GNAME BasicType2X):
    $(D *)
    $(D [ ])
    $(D [) $(ASSIGNEXPRESSION) $(D ])
    $(D [) $(ASSIGNEXPRESSION) .. $(ASSIGNEXPRESSION) $(D ])
    $(D [) $(GLINK Type) $(D ])
    $(D delegate) $(GLINK Parameters) $(GLINK MemberFunctionAttributes)$(OPT)
    $(D function) $(GLINK Parameters) $(GLINK FunctionAttributes)$(OPT)

$(GNAME IdentifierList):
    $(I Identifier)
    $(I Identifier) $(D .) $(I IdentifierList)
    $(GLINK TemplateInstance)
    $(GLINK TemplateInstance) $(D .) $(I IdentifierList)

$(GNAME Typeof):
    $(D typeof $(LPAREN)) $(EXPRESSION) $(D $(RPAREN))
    $(D typeof $(LPAREN)) $(D return) $(D $(RPAREN))

$(GNAME TypeVector):
    $(D __vector) $(D $(LPAREN)) $(GLINK Type) $(D $(RPAREN))
)

$(H3 $(LNAME2 expression, Expression))

$(GRAMMAR
$(GNAME Expression):
    $(I CommaExpression)

$(GNAME CommaExpression):
    $(GLINK AssignExpression)
    $(GLINK AssignExpression) $(D ,) $(I CommaExpression)
)

$(GRAMMAR
$(GNAME AssignExpression):
    $(GLINK ConditionalExpression)
    $(GLINK ConditionalExpression) $(D =) $(I AssignExpression)
    $(GLINK ConditionalExpression) $(D +=) $(I AssignExpression)
    $(GLINK ConditionalExpression) $(D -=) $(I AssignExpression)
    $(GLINK ConditionalExpression) $(D *=) $(I AssignExpression)
    $(GLINK ConditionalExpression) $(D /=) $(I AssignExpression)
    $(GLINK ConditionalExpression) $(D %=) $(I AssignExpression)
    $(GLINK ConditionalExpression) $(D &=) $(I AssignExpression)
    $(GLINK ConditionalExpression) $(D |=) $(I AssignExpression)
    $(GLINK ConditionalExpression) $(D ^=) $(I AssignExpression)
    $(GLINK ConditionalExpression) $(D ~=) $(I AssignExpression)
    $(GLINK ConditionalExpression) $(D <)$(D <)$(D =) $(I AssignExpression)
    $(GLINK ConditionalExpression) $(D >>=) $(I AssignExpression)
    $(GLINK ConditionalExpression) $(D >>>=) $(I AssignExpression)
    $(GLINK ConditionalExpression) $(D ^^=) $(I AssignExpression)
)

$(GRAMMAR
$(GNAME ConditionalExpression):
    $(GLINK OrOrExpression)
    $(GLINK OrOrExpression) $(D ?) $(GLINK Expression) $(D :) $(I ConditionalExpression)
)

$(GRAMMAR
$(GNAME OrOrExpression):
    $(GLINK AndAndExpression)
    $(I OrOrExpression) $(D ||) $(GLINK AndAndExpression)
)

$(GRAMMAR
$(GNAME AndAndExpression):
    $(GLINK OrExpression)
    $(I AndAndExpression) $(CODE_AMP)$(CODE_AMP) $(GLINK OrExpression)
    $(GLINK CmpExpression)
    $(I AndAndExpression) $(CODE_AMP)$(CODE_AMP) $(GLINK CmpExpression)
)

$(GRAMMAR
$(GNAME OrExpression):
    $(GLINK XorExpression)
    $(I OrExpression) $(D |) $(GLINK XorExpression)
)

$(GRAMMAR
$(GNAME XorExpression):
    $(GLINK AndExpression)
    $(I XorExpression) $(D ^) $(GLINK AndExpression)
)

$(GRAMMAR
$(GNAME AndExpression):
    $(GLINK ShiftExpression)
    $(I AndExpression) $(D &) $(GLINK ShiftExpression)
)

$(GRAMMAR
$(GNAME CmpExpression):
    $(GLINK ShiftExpression)
    $(GLINK EqualExpression)
    $(GLINK IdentityExpression)
    $(GLINK RelExpression)
    $(GLINK InExpression)
)

$(GRAMMAR
$(GNAME EqualExpression):
    $(GLINK ShiftExpression) $(D ==) $(GLINK ShiftExpression)
    $(GLINK ShiftExpression) $(D !=) $(GLINK ShiftExpression)
)

$(GRAMMAR
$(GNAME IdentityExpression):
    $(GLINK ShiftExpression) $(D is) $(GLINK ShiftExpression)
    $(GLINK ShiftExpression) $(D !is) $(GLINK ShiftExpression)
)

$(GRAMMAR
$(GNAME RelExpression):
    $(GLINK ShiftExpression) $(D <) $(GLINK ShiftExpression)
    $(GLINK ShiftExpression) $(D <)$(D =) $(GLINK ShiftExpression)
    $(GLINK ShiftExpression) $(D >) $(GLINK ShiftExpression)
    $(GLINK ShiftExpression) $(D >=) $(GLINK ShiftExpression)
    $(GLINK ShiftExpression) $(D !<>=) $(GLINK ShiftExpression)
    $(GLINK ShiftExpression) $(D !<>) $(GLINK ShiftExpression)
    $(GLINK ShiftExpression) $(D <>) $(GLINK ShiftExpression)
    $(GLINK ShiftExpression) $(D <>=) $(GLINK ShiftExpression)
    $(GLINK ShiftExpression) $(D !>) $(GLINK ShiftExpression)
    $(GLINK ShiftExpression) $(D !>=) $(GLINK ShiftExpression)
    $(GLINK ShiftExpression) $(D !<) $(GLINK ShiftExpression)
    $(GLINK ShiftExpression) $(D !<=) $(GLINK ShiftExpression)
)

$(GRAMMAR
$(GNAME InExpression):
    $(GLINK ShiftExpression) $(D in) $(GLINK ShiftExpression)
    $(GLINK ShiftExpression) $(D !in) $(GLINK ShiftExpression)
)

$(GRAMMAR
$(GNAME ShiftExpression):
    $(GLINK AddExpression)
    $(I ShiftExpression) $(D <)$(D <) $(GLINK AddExpression)
    $(I ShiftExpression) $(D >)$(D >) $(GLINK AddExpression)
    $(I ShiftExpression) $(D >)$(D >)$(D >) $(GLINK AddExpression)
)

$(GRAMMAR
$(GNAME AddExpression):
    $(GLINK MulExpression)
    $(I AddExpression) $(D +) $(GLINK MulExpression)
    $(I AddExpression) $(D -) $(GLINK MulExpression)
    $(GLINK CatExpression)
)

$(GRAMMAR
$(GNAME CatExpression):
    $(GLINK AddExpression) $(D ~) $(GLINK MulExpression)
)

$(GRAMMAR
$(GNAME MulExpression):
    $(GLINK UnaryExpression)
    $(I MulExpression) $(D *) $(GLINK UnaryExpression)
    $(I MulExpression) $(D /) $(GLINK UnaryExpression)
    $(I MulExpression) $(D %) $(GLINK UnaryExpression)
)

$(GRAMMAR
$(GNAME UnaryExpression):
    $(CODE_AMP) $(I UnaryExpression)
    $(D ++) $(I UnaryExpression)
    $(D --) $(I UnaryExpression)
    $(D *) $(I UnaryExpression)
    $(D -) $(I UnaryExpression)
    $(D +) $(I UnaryExpression)
    $(D !) $(I UnaryExpression)
    $(GLINK ComplementExpression)
    $(D $(LPAREN)) $(GLINK Type) $(D $(RPAREN) .) $(IDENTIFIER)
    $(D $(LPAREN)) $(GLINK Type) $(D $(RPAREN) .) $(GLINK TemplateInstance)
    $(GLINK DeleteExpression)
    $(GLINK CastExpression)
    $(GLINK PowExpression)
)

$(GRAMMAR
$(GNAME ComplementExpression):
    $(D ~) $(GLINK UnaryExpression)
)

$(GRAMMAR
$(GNAME NewExpression):
    $(D new) $(I AllocatorArguments)$(OPT) $(GLINK Type)
    $(GLINK NewExpressionWithArgs)

$(GNAME NewExpressionWithArgs):
    $(D new) $(I AllocatorArguments)$(OPT) $(GLINK Type) $(D [) $(GLINK AssignExpression) $(D ])
    $(D new) $(I AllocatorArguments)$(OPT) $(GLINK Type) $(D $(LPAREN)) $(GLINK ArgumentList)$(OPT) $(D $(RPAREN))
    $(GLINK NewAnonClassExpression)

$(GNAME AllocatorArguments):
    $(D $(LPAREN)) $(GLINK ArgumentList)$(OPT) $(D $(RPAREN))

$(GNAME ArgumentList):
    $(GLINK AssignExpression)
    $(GLINK AssignExpression) $(D ,)
    $(GLINK AssignExpression) $(D ,) $(I ArgumentList)
)

$(GRAMMAR
$(GNAME NewAnonClassExpression):
    $(D new) $(GLINK AllocatorArguments)$(OPT) $(D class) $(I ClassArguments)$(OPT) $(GLINK SuperClass)$(OPT) $(GLINK Interfaces)$(OPT) $(GLINK AggregateBody)

$(GNAME ClassArguments):
    $(D $(LPAREN)) $(GLINK ArgumentList)$(OPT) $(D $(RPAREN))
)

$(GRAMMAR
$(GNAME DeleteExpression):
    $(D delete) $(GLINK UnaryExpression)
)

$(GRAMMAR
$(GNAME CastExpression):
    $(D cast $(LPAREN)) $(GLINK Type) $(D $(RPAREN)) $(GLINK UnaryExpression)
    $(D cast $(LPAREN)) $(GLINK TypeCtors)$(OPT) $(D $(RPAREN)) $(GLINK UnaryExpression)
)

$(GRAMMAR
$(GNAME PowExpression):
    $(GLINK PostfixExpression)
    $(GLINK PostfixExpression) $(D ^^) $(GLINK UnaryExpression)
)

$(GRAMMAR
$(GNAME PostfixExpression):
    $(GLINK PrimaryExpression)
    $(I PostfixExpression) $(D .) $(IDENTIFIER)
    $(I PostfixExpression) $(D .) $(GLINK TemplateInstance)
    $(I PostfixExpression) $(D .) $(GLINK NewExpression)
    $(I PostfixExpression) $(D ++)
    $(I PostfixExpression) $(D --)
    $(I PostfixExpression) $(D $(LPAREN)) $(GLINK ArgumentList)$(OPT) $(D $(RPAREN))
    $(GLINK TypeCtors)$(OPT) $(GLINK BasicType) $(D $(LPAREN)) $(GLINK ArgumentList)$(OPT) $(D $(RPAREN))
    $(GLINK IndexExpression)
    $(GLINK SliceExpression)
)

$(GRAMMAR
$(GNAME IndexExpression):
    $(GLINK PostfixExpression) $(D [) $(GLINK ArgumentList) $(D ])
)

$(GRAMMAR
$(GNAME SliceExpression):
    $(GLINK PostfixExpression) $(D [ ])
    $(GLINK PostfixExpression) $(D [) $(GLINK AssignExpression) $(D ..) $(GLINK AssignExpression) $(D ])
)

$(GRAMMAR
$(GNAME PrimaryExpression):
    $(IDENTIFIER)
    $(D .) $(IDENTIFIER)
    $(GLINK TemplateInstance)
    $(D .) $(GLINK TemplateInstance)
    $(LINK2 expression.html#this, $(D this))
    $(LINK2 expression.html#super, $(D super))
    $(LINK2 expression.html#null, $(D null))
    $(D true)
    $(D false)
    $(D $)
    $(GLINK_LEX IntegerLiteral)
    $(GLINK_LEX FloatLiteral)
    $(GLINK_LEX CharacterLiteral)
    $(GLINK StringLiterals)
    $(GLINK ArrayLiteral)
    $(GLINK AssocArrayLiteral)
    $(GLINK FunctionLiteral)
    $(GLINK AssertExpression)
    $(GLINK MixinExpression)
    $(GLINK ImportExpression)
    $(GLINK NewExpressionWithArgs)
    $(GLINK BasicTypeX) $(D .) $(IDENTIFIER)
    $(GLINK Typeof)
    $(GLINK TypeidExpression)
    $(GLINK IsExpression)
    $(D $(LPAREN)) $(GLINK Expression) $(D $(RPAREN))
    $(GLINK TraitsExpression)
    $(GLINK SpecialKeyword)
)

$(GRAMMAR
$(GNAME StringLiterals):
    $(GLINK_LEX StringLiteral)
    $(I StringLiterals) $(GLINK_LEX StringLiteral)
)

$(GRAMMAR
$(GNAME ArrayLiteral):
    $(D [) $(GLINK ArgumentList)$(OPT) $(D ])
)

$(GRAMMAR
$(GNAME AssocArrayLiteral):
    $(D [) $(GLINK KeyValuePairs) $(D ])

$(GNAME KeyValuePairs):
    $(GLINK KeyValuePair)
    $(GLINK KeyValuePair) $(D ,) $(I KeyValuePairs)

$(GNAME KeyValuePair):
    $(GLINK KeyExpression) $(D :) $(GLINK ValueExpression)

$(GNAME KeyExpression):
    $(GLINK AssignExpression)

$(GNAME ValueExpression):
    $(GLINK AssignExpression)
)

$(GRAMMAR
$(GNAME FunctionLiteral):
    $(D function) $(GLINK Type)$(OPT) $(GLINK ParameterAttributes) $(OPT) $(GLINK FunctionLiteralBody)
    $(D delegate) $(GLINK Type)$(OPT) $(GLINK ParameterAttributes) $(OPT) $(GLINK FunctionLiteralBody)
    $(GLINK ParameterAttributes) $(GLINK FunctionLiteralBody)
    $(GLINK FunctionLiteralBody)
    $(GLINK Lambda)
)

$(GRAMMAR
$(GNAME ParameterAttributes):
    $(GLINK Parameters)
    $(GLINK Parameters) $(GLINK FunctionAttributes)

$(GNAME FunctionLiteralBody):
    $(GLINK BlockStatement)
    $(GLINK FunctionContracts)$(OPT) $(GLINK BodyStatement)

$(GNAME Lambda):
    $(D function) $(GLINK Type)$(OPT) $(GLINK ParameterAttributes) $(D =>) $(GLINK AssignExpression)
    $(D delegate) $(GLINK Type)$(OPT) $(GLINK ParameterAttributes) $(D =>) $(GLINK AssignExpression)
    $(GLINK ParameterAttributes) $(D =>) $(GLINK AssignExpression)
    $(IDENTIFIER) $(D =>) $(GLINK AssignExpression)
)

$(GRAMMAR
$(GNAME AssertExpression):
    $(D assert $(LPAREN)) $(GLINK AssignExpression) $(D $(RPAREN))
    $(D assert $(LPAREN)) $(GLINK AssignExpression) $(D ,) $(GLINK AssignExpression) $(D $(RPAREN))
)

$(GRAMMAR
$(GNAME MixinExpression):
    $(D mixin $(LPAREN)) $(GLINK AssignExpression) $(D $(RPAREN))
)

$(GRAMMAR
$(GNAME ImportExpression):
    $(D import $(LPAREN)) $(GLINK AssignExpression) $(D $(RPAREN))
)

$(GRAMMAR
$(GNAME TypeidExpression):
    $(D typeid $(LPAREN)) $(GLINK Type) $(D $(RPAREN))
    $(D typeid $(LPAREN)) $(GLINK Expression) $(D $(RPAREN))
)

$(GRAMMAR
$(GNAME IsExpression):
    $(D is $(LPAREN)) $(GLINK Type) $(D $(RPAREN))
    $(D is $(LPAREN)) $(GLINK Type) $(D :) $(GLINK TypeSpecialization) $(D $(RPAREN))
    $(D is $(LPAREN)) $(GLINK Type) $(D ==) $(GLINK TypeSpecialization) $(D $(RPAREN))
    $(D is $(LPAREN)) $(GLINK Type) $(D :) $(GLINK TypeSpecialization) $(D ,) $(GLINK TemplateParameterList) $(D $(RPAREN))
    $(D is $(LPAREN)) $(GLINK Type) $(D ==) $(GLINK TypeSpecialization) $(D ,) $(GLINK TemplateParameterList) $(D $(RPAREN))
    $(D is $(LPAREN)) $(GLINK Type) $(IDENTIFIER) $(D $(RPAREN))
    $(D is $(LPAREN)) $(GLINK Type) $(IDENTIFIER) $(D :) $(GLINK TypeSpecialization) $(D $(RPAREN))
    $(D is $(LPAREN)) $(GLINK Type) $(IDENTIFIER) $(D ==) $(GLINK TypeSpecialization) $(D $(RPAREN))
    $(D is $(LPAREN)) $(GLINK Type) $(IDENTIFIER) $(D :) $(GLINK TypeSpecialization) $(D ,) $(GLINK TemplateParameterList) $(D $(RPAREN))
    $(D is $(LPAREN)) $(GLINK Type) $(IDENTIFIER) $(D ==) $(GLINK TypeSpecialization) $(D ,) $(GLINK TemplateParameterList) $(D $(RPAREN))

$(GNAME TypeSpecialization):
    $(GLINK Type)
    $(D struct)
    $(D union)
    $(D class)
    $(D interface)
    $(D enum)
    $(D function)
    $(D delegate)
    $(D super)
    $(D const)
    $(D immutable)
    $(D inout)
    $(D shared)
    $(D return)
    $(D __parameters)
)

$(GRAMMAR
$(GNAME TraitsExpression):
    $(D __traits) $(D $(LPAREN)) $(GLINK TraitsKeyword) $(D ,) $(GLINK TraitsArguments) $(D $(RPAREN))

$(GNAME TraitsKeyword):
    $(TRAITS_LINK2 isAbstractClass)
    $(TRAITS_LINK2 isArithmetic)
    $(TRAITS_LINK2 isAssociativeArray)
    $(TRAITS_LINK2 isFinalClass)
    $(TRAITS_LINK2 isPOD)
    $(TRAITS_LINK2 isNested)
    $(TRAITS_LINK2 isFloating)
    $(TRAITS_LINK2 isIntegral)
    $(TRAITS_LINK2 isScalar)
    $(TRAITS_LINK2 isStaticArray)
    $(TRAITS_LINK2 isUnsigned)
    $(TRAITS_LINK2 isVirtualFunction)
    $(TRAITS_LINK2 isVirtualMethod)
    $(TRAITS_LINK2 isAbstractFunction)
    $(TRAITS_LINK2 isFinalFunction)
    $(TRAITS_LINK2 isStaticFunction)
    $(TRAITS_LINK2 isOverrideFunction)
    $(TRAITS_LINK2 isRef)
    $(TRAITS_LINK2 isOut)
    $(TRAITS_LINK2 isLazy)
    $(TRAITS_LINK2 hasMember)
    $(TRAITS_LINK2 identifier)
    $(TRAITS_LINK2 getAliasThis)
    $(TRAITS_LINK2 getAttributes)
    $(TRAITS_LINK2 getMember)
    $(TRAITS_LINK2 getOverloads)
    $(TRAITS_LINK2 getProtection)
    $(TRAITS_LINK2 getVirtualFunctions)
    $(TRAITS_LINK2 getVirtualMethods)
    $(TRAITS_LINK2 getUnitTests)
    $(TRAITS_LINK2 parent)
    $(TRAITS_LINK2 classInstanceSize)
    $(TRAITS_LINK2 getVirtualIndex)
    $(TRAITS_LINK2 allMembers)
    $(TRAITS_LINK2 derivedMembers)
    $(TRAITS_LINK2 isSame)
    $(TRAITS_LINK2 compiles)

$(GNAME TraitsArguments):
    $(GLINK TraitsArgument)
    $(GLINK TraitsArgument) $(D ,) $(I TraitsArguments)

$(GNAME TraitsArgument):
    $(GLINK AssignExpression)
    $(GLINK Type)
)

$(GRAMMAR
$(GNAME SpecialKeyword):
    $(D $(LINK2 traits.html#specialkeywords, __FILE__))
    $(D $(LINK2 traits.html#specialkeywords, __MODULE__))
    $(D $(LINK2 traits.html#specialkeywords, __LINE__))
    $(D $(LINK2 traits.html#specialkeywords, __FUNCTION__))
    $(D $(LINK2 traits.html#specialkeywords, __PRETTY_FUNCTION__))
)

$(H3 $(LNAME2 statement, Statement))

$(GRAMMAR
$(GNAME Statement):
    $(D ;)
    $(GLINK NonEmptyStatement)
    $(GLINK ScopeBlockStatement)

$(GNAME NoScopeNonEmptyStatement):
    $(GLINK NonEmptyStatement)
    $(GLINK BlockStatement)

$(GNAME NoScopeStatement):
    $(D ;)
    $(GLINK NonEmptyStatement)
    $(GLINK BlockStatement)

$(GNAME NonEmptyOrScopeBlockStatement):
    $(GLINK NonEmptyStatement)
    $(GLINK ScopeBlockStatement)

$(GNAME NonEmptyStatement):
    $(GLINK NonEmptyStatementNoCaseNoDefault)
    $(GLINK CaseStatement)
    $(GLINK CaseRangeStatement)
    $(GLINK DefaultStatement)

$(GNAME NonEmptyStatementNoCaseNoDefault):
    $(GLINK LabeledStatement)
    $(GLINK ExpressionStatement)
    $(GLINK DeclarationStatement)
    $(GLINK IfStatement)
    $(GLINK WhileStatement)
    $(GLINK DoStatement)
    $(GLINK ForStatement)
    $(GLINK ForeachStatement)
    $(GLINK SwitchStatement)
    $(GLINK FinalSwitchStatement)
    $(GLINK ContinueStatement)
    $(GLINK BreakStatement)
    $(GLINK ReturnStatement)
    $(GLINK GotoStatement)
    $(GLINK WithStatement)
    $(GLINK SynchronizedStatement)
    $(GLINK TryStatement)
    $(GLINK ScopeGuardStatement)
    $(GLINK ThrowStatement)
    $(GLINK AsmStatement)
    $(GLINK PragmaStatement)
    $(GLINK MixinStatement)
    $(GLINK ForeachRangeStatement)
    $(GLINK ConditionalStatement)
    $(GLINK StaticAssert)
    $(GLINK TemplateMixin)
    $(GLINK ImportDeclaration)
)

$(GRAMMAR
$(GNAME ScopeStatement):
    $(GLINK NonEmptyStatement)
    $(GLINK BlockStatement)
)

$(GRAMMAR
$(GNAME ScopeBlockStatement):
    $(GLINK BlockStatement)
)

$(GRAMMAR
$(GNAME LabeledStatement):
    $(I Identifier) $(D :)
    $(I Identifier) $(D :) $(PSSEMI)
    $(I Identifier) $(D :) $(PSSEMI_PSCURLYSCOPE)
)

$(GRAMMAR
$(GNAME BlockStatement):
    $(D { })
    $(D {) $(GLINK StatementList) $(D })

$(GNAME StatementList):
    $(PSSEMI_PSCURLYSCOPE)
    $(PSSEMI_PSCURLYSCOPE) $(I StatementList)
)

$(GRAMMAR
$(GNAME ExpressionStatement):
    $(EXPRESSION) $(D ;)
)

$(GRAMMAR
$(GNAME DeclarationStatement):
    $(GLINK StorageClasses)$(OPT) $(GLINK Declaration)
)

$(GRAMMAR
$(GNAME IfStatement):
    $(D if $(LPAREN)) $(GLINK IfCondition) $(D $(RPAREN)) $(GLINK ThenStatement)
    $(D if $(LPAREN)) $(GLINK IfCondition) $(D $(RPAREN)) $(GLINK ThenStatement) $(D else) $(GLINK ElseStatement)

$(GNAME IfCondition):
    $(EXPRESSION)
    $(D auto) $(I Identifier) $(D =) $(EXPRESSION)
    $(GLINK TypeCtors) $(I Identifier) $(D =) $(EXPRESSION)
    $(GLINK TypeCtors)$(OPT) $(GLINK BasicType) $(GLINK Declarator) $(D =) $(EXPRESSION)

$(GNAME ThenStatement):
    $(PSSCOPE)

$(GNAME ElseStatement):
    $(PSSCOPE)
)

$(GRAMMAR
$(GNAME WhileStatement):
    $(D while $(LPAREN)) $(EXPRESSION) $(D $(RPAREN)) $(PSSCOPE)
)

$(GRAMMAR
$(GNAME DoStatement):
    $(D do) $(PSSCOPE) $(D  while $(LPAREN)) $(EXPRESSION) $(D $(RPAREN)) $(D ;)
)

$(GRAMMAR
$(GNAME ForStatement):
    $(D for $(LPAREN)) $(GLINK Initialize) $(I Test)$(OPT) $(D ;) $(GLINK Increment)$(OPT) $(D $(RPAREN)) $(PSSCOPE)

$(GNAME Initialize):
    $(D ;)
    $(PS0)

$(GNAME Test):
    $(EXPRESSION)

$(GNAME Increment):
    $(EXPRESSION)
)

$(GRAMMAR
$(GNAME ForeachStatement):
    $(I Foreach) $(D $(LPAREN)) $(GLINK ForeachTypeList) $(D ;) $(GLINK ForeachAggregate) $(D $(RPAREN)) $(PS0)

$(GNAME Foreach):
    $(D foreach)
    $(D foreach_reverse)

$(GNAME ForeachTypeList):
    $(GLINK ForeachType)
    $(GLINK ForeachType) , $(I ForeachTypeList)

$(GNAME ForeachType):
    $(GLINK ForeachTypeAttributes)$(OPT) $(GLINK2 declaration, BasicType) $(GLINK2 declaration, Declarator)
    $(GLINK ForeachTypeAttributes)$(OPT) $(I Identifier)

$(GNAME ForeachTypeAttributes)
    $(GLINK ForeachTypeAttribute)
    $(GLINK ForeachTypeAttribute) $(GLINK ForeachTypeAttributes)$(OPT)

$(GNAME ForeachTypeAttribute):
    $(D ref)
    $(GLINK2 declaration, TypeCtor)

$(GNAME ForeachAggregate):
    $(EXPRESSION)
)

$(GRAMMAR
$(GNAME ForeachRangeStatement):
    $(GLINK Foreach) $(D $(LPAREN)) $(GLINK ForeachType) $(D ;) $(GLINK LwrExpression) $(D ..) $(GLINK UprExpression) $(D $(RPAREN)) $(PSSCOPE)

$(GNAME LwrExpression):
    $(EXPRESSION)

$(GNAME UprExpression):
    $(EXPRESSION)
)

$(GRAMMAR
$(GNAME SwitchStatement):
    $(D switch $(LPAREN)) $(EXPRESSION) $(D $(RPAREN)) $(PSSCOPE)

$(GNAME CaseStatement):
    $(D case) $(GLINK ArgumentList) $(D :) $(PSSEMI_PSCURLYSCOPE_LIST)

$(GNAME CaseRangeStatement):
    $(D case) $(GLINK FirstExp) $(D : .. case) $(GLINK LastExp) $(D :) $(PSSEMI_PSCURLYSCOPE_LIST)

$(GNAME FirstExp):
    $(ASSIGNEXPRESSION)

$(GNAME LastExp):
    $(ASSIGNEXPRESSION)

$(GNAME DefaultStatement):
    $(D default :) $(PSSEMI_PSCURLYSCOPE_LIST)

$(GNAME ScopeStatementList):
    $(GLINK StatementListNoCaseNoDefault)

$(GNAME StatementListNoCaseNoDefault):
    $(GLINK StatementNoCaseNoDefault)
    $(GLINK StatementNoCaseNoDefault) $(I StatementListNoCaseNoDefault)

$(GNAME StatementNoCaseNoDefault):
    $(D ;)
    $(GLINK NonEmptyStatementNoCaseNoDefault)
    $(GLINK ScopeBlockStatement)
)

$(GRAMMAR
$(GNAME FinalSwitchStatement):
    $(D final switch $(LPAREN)) $(EXPRESSION) $(D $(RPAREN)) $(PSSCOPE)
)

$(GRAMMAR
$(GNAME ContinueStatement):
    $(D continue) $(I Identifier)$(OPT) $(D ;)
)

$(GRAMMAR
$(GNAME BreakStatement):
    $(D break) $(I Identifier)$(OPT) $(D ;)
)

$(GRAMMAR
$(GNAME ReturnStatement):
    $(D return) $(EXPRESSION)$(OPT) $(D ;)
)

$(GRAMMAR
$(GNAME GotoStatement):
    $(D goto) $(I Identifier) $(D ;)
    $(D goto) $(D default) $(D ;)
    $(D goto) $(D case) $(D ;)
    $(D goto) $(D case) $(EXPRESSION) $(D ;)
)

$(GRAMMAR
$(GNAME WithStatement):
    $(D with) $(D $(LPAREN)) $(EXPRESSION) $(D $(RPAREN)) $(PSSCOPE)
    $(D with) $(D $(LPAREN)) $(GLINK Symbol) $(D $(RPAREN)) $(PSSCOPE)
    $(D with) $(D $(LPAREN)) $(GLINK TemplateInstance) $(D $(RPAREN)) $(PSSCOPE)
)

$(GRAMMAR
$(GNAME SynchronizedStatement):
    $(D synchronized) $(PSSCOPE)
    $(D synchronized $(LPAREN)) $(EXPRESSION) $(D $(RPAREN)) $(PSSCOPE)
)

$(GRAMMAR
$(GNAME TryStatement):
    $(D try) $(PSSCOPE) $(GLINK Catches)
    $(D try) $(PSSCOPE) $(GLINK Catches) $(GLINK FinallyStatement)
    $(D try) $(PSSCOPE) $(GLINK FinallyStatement)

$(GNAME Catches):
    $(GLINK LastCatch)
    $(GLINK Catch)
    $(GLINK Catch) $(I Catches)

$(GNAME LastCatch):
    $(D catch) $(PS0)

$(GNAME Catch):
    $(D catch $(LPAREN)) $(GLINK CatchParameter) $(D $(RPAREN)) $(PS0)

$(GNAME CatchParameter):
    $(GLINK BasicType) $(I Identifier)

$(GNAME FinallyStatement):
    $(D finally) $(PS0)
)

$(GRAMMAR
$(GNAME ThrowStatement):
    $(D throw) $(EXPRESSION) $(D ;)
)

$(GRAMMAR
$(GNAME ScopeGuardStatement):
    $(D scope(exit)) $(PSCURLYSCOPE)
    $(D scope(success)) $(PSCURLYSCOPE)
    $(D scope(failure)) $(PSCURLYSCOPE)
)

$(GRAMMAR
$(GNAME AsmStatement):
    $(D asm) $(GLINK FunctionAttributes)$(OPT) $(D {) $(GLINK AsmInstructionList)$(OPT) $(D })

$(GNAME AsmInstructionList):
    $(GLINK AsmInstruction) $(D ;)
    $(GLINK AsmInstruction) $(D ;) $(I AsmInstructionList)
)

$(GRAMMAR
$(GNAME PragmaStatement):
    $(GLINK Pragma) $(PSSEMI)
)

$(GRAMMAR
$(GNAME MixinStatement):
    $(D mixin) $(D $(LPAREN)) $(ASSIGNEXPRESSION) $(D $(RPAREN)) $(D ;)
)

$(H3 $(LNAME2 iasm, Iasm))

$(GRAMMAR
$(GNAME AsmInstruction):
    $(I Identifier) $(D :) $(I AsmInstruction)
    $(D align) $(GLINK IntegerExpression)
    $(D even)
    $(D naked)
    $(D db) $(I Operands)
    $(D ds) $(I Operands)
    $(D di) $(I Operands)
    $(D dl) $(I Operands)
    $(D df) $(I Operands)
    $(D dd) $(I Operands)
    $(D de) $(I Operands)
    $(I Opcode)
    $(I Opcode Operands)

$(GNAME Operands):
    $(I Operand)
    $(I Operand) $(D ,) $(I Operands)
)

$(GRAMMAR
$(GNAME IntegerExpression):
    $(GLINK_LEX IntegerLiteral)
    $(I Identifier)
)

$(GRAMMAR
$(GNAME Register):
    $(D AL) $(D AH) $(D AX) $(D EAX)
    $(D BL) $(D BH) $(D BX) $(D EBX)
    $(D CL) $(D CH) $(D CX) $(D ECX)
    $(D DL) $(D DH) $(D DX) $(D EDX)
    $(D BP) $(D EBP)
    $(D SP) $(D ESP)
    $(D DI) $(D EDI)
    $(D SI) $(D ESI)
    $(D ES) $(D CS) $(D SS) $(D DS) $(D GS) $(D FS)
    $(D CR0) $(D CR2) $(D CR3) $(D CR4)
    $(D DR0) $(D DR1) $(D DR2) $(D DR3) $(D DR6) $(D DR7)
    $(D TR3) $(D TR4) $(D TR5) $(D TR6) $(D TR7)
    $(D ST)
    $(D ST(0)) $(D ST(1)) $(D ST(2)) $(D ST(3)) $(D ST(4)) $(D ST(5)) $(D ST(6)) $(D ST(7))
    $(D MM0)  $(D MM1)  $(D MM2)  $(D MM3)  $(D MM4)  $(D MM5)  $(D MM6)  $(D MM7)
    $(D XMM0) $(D XMM1) $(D XMM2) $(D XMM3) $(D XMM4) $(D XMM5) $(D XMM6) $(D XMM7)
)

$(GRAMMAR
$(GNAME Register64):
    $(D RAX)  $(D RBX)  $(D RCX)  $(D RDX)
    $(D BPL)  $(D RBP)
    $(D SPL)  $(D RSP)
    $(D DIL)  $(D RDI)
    $(D SIL)  $(D RSI)
    $(D R8B)  $(D R8W)  $(D R8D)  $(D R8)
    $(D R9B)  $(D R9W)  $(D R9D)  $(D R9)
    $(D R10B) $(D R10W) $(D R10D) $(D R10)
    $(D R11B) $(D R11W) $(D R11D) $(D R11)
    $(D R12B) $(D R12W) $(D R12D) $(D R12)
    $(D R13B) $(D R13W) $(D R13D) $(D R13)
    $(D R14B) $(D R14W) $(D R14D) $(D R14)
    $(D R15B) $(D R15W) $(D R15D) $(D R15)
    $(D XMM8) $(D XMM9) $(D XMM10) $(D XMM11) $(D XMM12) $(D XMM13) $(D XMM14) $(D XMM15)
    $(D YMM0) $(D YMM1) $(D YMM2)  $(D YMM3)  $(D YMM4)  $(D YMM5)  $(D YMM6)  $(D YMM7)
    $(D YMM8) $(D YMM9) $(D YMM10) $(D YMM11) $(D YMM12) $(D YMM13) $(D YMM14) $(D YMM15)
)

$(GRAMMAR
$(GNAME Operand):
    $(I AsmExp)

$(GNAME AsmExp):
    $(I AsmLogOrExp)
    $(I AsmLogOrExp) $(D ?) $(I AsmExp) $(D :) $(I AsmExp)

$(GNAME AsmLogOrExp):
    $(I AsmLogAndExp)
    $(I AsmLogAndExp) $(D ||) $(I AsmLogAndExp)

$(GNAME AsmLogAndExp):
    $(I AsmOrExp)
    $(I AsmOrExp) $(D &&) $(I AsmOrExp)

$(GNAME AsmOrExp):
    $(I AsmXorExp)
    $(I AsmXorExp) $(D |) $(I AsmXorExp)

$(GNAME AsmXorExp):
    $(I AsmAndExp)
    $(I AsmAndExp) $(D ^) $(I AsmAndExp)

$(GNAME AsmAndExp):
    $(I AsmEqualExp)
    $(I AsmEqualExp) $(D &) $(I AsmEqualExp)

$(GNAME AsmEqualExp):
    $(I AsmRelExp)
    $(I AsmRelExp) $(D ==) $(I AsmRelExp)
    $(I AsmRelExp) $(D !=) $(I AsmRelExp)

$(GNAME AsmRelExp):
    $(I AsmShiftExp)
    $(I AsmShiftExp) $(D <) $(I AsmShiftExp)
    $(I AsmShiftExp) $(D <)$(D =) $(I AsmShiftExp)
    $(I AsmShiftExp) $(D >) $(I AsmShiftExp)
    $(I AsmShiftExp) $(D >=) $(I AsmShiftExp)

$(GNAME AsmShiftExp):
    $(I AsmAddExp)
    $(I AsmAddExp) $(D <)$(D <) $(I AsmAddExp)
    $(I AsmAddExp) $(D >>) $(I AsmAddExp)
    $(I AsmAddExp) $(D >>>) $(I AsmAddExp)

$(GNAME AsmAddExp):
    $(I AsmMulExp)
    $(I AsmMulExp) $(D +) $(I AsmMulExp)
    $(I AsmMulExp) $(D -) $(I AsmMulExp)

$(GNAME AsmMulExp):
    $(I AsmBrExp)
    $(I AsmBrExp) $(D *) $(I AsmBrExp)
    $(I AsmBrExp) $(D /) $(I AsmBrExp)
    $(I AsmBrExp) $(D %) $(I AsmBrExp)

$(GNAME AsmBrExp):
    $(I AsmUnaExp)
    $(I AsmBrExp) $(D [) $(I AsmExp) $(D ])

$(GNAME AsmUnaExp):
    $(I AsmTypePrefix) $(I AsmExp)
    $(D offsetof) $(I AsmExp)
    $(D seg) $(I AsmExp)
    $(D +) $(I AsmUnaExp)
    $(D -) $(I AsmUnaExp)
    $(D !) $(I AsmUnaExp)
    $(D ~) $(I AsmUnaExp)
    $(I AsmPrimaryExp)

$(GNAME AsmPrimaryExp):
    $(GLINK_LEX IntegerLiteral)
    $(GLINK_LEX FloatLiteral)
    $(D __LOCAL_SIZE)
    $(D $)
    $(GLINK Register)
    $(GLINK Register) $(D :) $(I AsmExp)
    $(GLINK Register64)
    $(GLINK Register64) $(D :) $(I AsmExp)
    $(I DotIdentifier)
    $(D this)

$(GNAME DotIdentifier):
    $(I Identifier)
    $(I Identifier) $(D .) $(I DotIdentifier)
)

$(GRAMMAR
$(GNAME AsmTypePrefix):
    $(D near ptr)
    $(D far ptr)
    $(D byte ptr)
    $(D short ptr)
    $(D int ptr)
    $(D word ptr)
    $(D dword ptr)
    $(D qword ptr)
    $(D float ptr)
    $(D double ptr)
    $(D real ptr)
)

$(H3 $(LNAME2 declaration, Declaration))

$(GRAMMAR
$(GNAME Declaration):
    $(GLINK FuncDeclaration)
    $(GLINK VarDeclarations)
    $(GLINK AliasDeclaration)
    $(GLINK AggregateDeclaration)
    $(GLINK EnumDeclaration)
    $(GLINK ImportDeclaration)
)

$(GRAMMAR
$(GNAME AliasDeclaration):
    $(D alias) $(GLINK StorageClasses)$(OPT) $(GLINK BasicType) $(GLINK Declarator) $(D ;)
    $(D alias) $(GLINK StorageClasses)$(OPT) $(GLINK BasicType) $(GLINK FuncDeclarator) $(D ;)
    $(D alias) $(I AliasDeclarationX) $(D ;)

$(GNAME AliasDeclarationX):
    $(I Identifier) $(GLINK TemplateParameters)$(OPT) $(D =) $(GLINK StorageClasses)$(OPT) $(GLINK Type)
    $(I AliasDeclarationX) $(D ,) $(I Identifier) $(GLINK TemplateParameters)$(OPT) $(D =) $(GLINK StorageClasses)$(OPT) $(GLINK Type)
)

$(GRAMMAR
$(GNAME AutoDeclaration):
    $(GLINK StorageClasses) $(I AutoDeclarationX) $(D ;)

$(GNAME AutoDeclarationX):
    $(I Identifier) $(GLINK TemplateParameters)$(OPT) $(D =) $(GLINK Initializer)
    $(I AutoDeclarationX) $(D ,) $(I Identifier) $(GLINK TemplateParameters)$(OPT) $(D =) $(GLINK Initializer)
)

$(GRAMMAR
$(GNAME VarDeclarations):
    $(GLINK StorageClasses)$(OPT) $(GLINK BasicType) $(GLINK Declarators) $(D ;)
    $(GLINK AutoDeclaration)

$(GNAME Declarators):
    $(I DeclaratorInitializer)
    $(I DeclaratorInitializer) $(D ,) $(GLINK DeclaratorIdentifierList)

$(GNAME DeclaratorInitializer):
    $(GLINK VarDeclarator)
    $(GLINK VarDeclarator) $(GLINK TemplateParameters)$(OPT) $(D =) $(GLINK Initializer)
    $(GLINK AltDeclarator)
    $(GLINK AltDeclarator) $(D =) $(GLINK Initializer)

$(GNAME DeclaratorIdentifierList):
    $(GLINK DeclaratorIdentifier)
    $(GLINK DeclaratorIdentifier) $(D ,) $(I DeclaratorIdentifierList)

$(GNAME DeclaratorIdentifier):
    $(GLINK VarDeclaratorIdentifier)
    $(GLINK AltDeclaratorIdentifier)

$(GNAME VarDeclaratorIdentifier):
    $(I Identifier)
    $(I Identifier) $(GLINK TemplateParameters)$(OPT) $(D =) $(GLINK Initializer)

$(GNAME AltDeclaratorIdentifier):
    $(GLINK BasicType2) $(I Identifier) $(GLINK AltDeclaratorSuffixes)$(OPT)
    $(GLINK BasicType2) $(I Identifier) $(GLINK AltDeclaratorSuffixes)$(OPT) $(D =) $(GLINK Initializer)
    $(GLINK BasicType2)$(OPT) $(I Identifier) $(GLINK AltDeclaratorSuffixes)
    $(GLINK BasicType2)$(OPT) $(I Identifier) $(GLINK AltDeclaratorSuffixes) $(D =) $(GLINK Initializer)

$(GNAME Declarator):
    $(GLINK VarDeclarator)
    $(GLINK AltDeclarator)

$(GNAME VarDeclarator):
    $(GLINK BasicType2)$(OPT) $(I Identifier)

$(GNAME AltDeclarator):
    $(GLINK BasicType2)$(OPT) $(I Identifier) $(GLINK AltDeclaratorSuffixes)
    $(GLINK BasicType2)$(OPT) $(D $(LPAREN)) $(I AltDeclaratorX) $(D $(RPAREN))
    $(GLINK BasicType2)$(OPT) $(D $(LPAREN)) $(I AltDeclaratorX) $(D $(RPAREN)) $(GLINK AltFuncDeclaratorSuffix)
    $(GLINK BasicType2)$(OPT) $(D $(LPAREN)) $(I AltDeclaratorX) $(D $(RPAREN)) $(GLINK AltDeclaratorSuffixes)

$(GNAME AltDeclaratorX):
    $(GLINK BasicType2)$(OPT) $(I Identifier)
    $(GLINK BasicType2)$(OPT) $(I Identifier) $(GLINK AltFuncDeclaratorSuffix)
    $(GLINK AltDeclarator)

$(GNAME AltDeclaratorSuffixes):
    $(GLINK AltDeclaratorSuffix)
    $(GLINK AltDeclaratorSuffix) $(I AltDeclaratorSuffixes)

$(GNAME AltDeclaratorSuffix):
    $(D [ ])
    $(D [) $(ASSIGNEXPRESSION) $(D ])
    $(D [) $(GLINK Type) $(D ])

$(GNAME AltFuncDeclaratorSuffix):
    $(GLINK Parameters) $(GLINK MemberFunctionAttributes)$(OPT)
)

$(GRAMMAR
$(GNAME StorageClasses):
    $(GLINK StorageClass)
    $(GLINK StorageClass) $(I StorageClasses)

$(GNAME StorageClass):
    $(GLINK LinkageAttribute)
    $(GLINK AlignAttribute)
    $(D deprecated)
    $(D enum)
    $(D static)
    $(D extern)
    $(D abstract)
    $(D final)
    $(D override)
    $(D synchronized)
    $(D auto)
    $(D scope)
    $(D const)
    $(D immutable)
    $(D inout)
    $(D shared)
    $(D __gshared)
    $(GLINK Property)
    $(D nothrow)
    $(D pure)
    $(D ref)
)

$(GRAMMAR
$(GNAME Initializer):
    $(GLINK VoidInitializer)
    $(GLINK NonVoidInitializer)

$(GNAME VoidInitializer):
    $(D void)

$(GNAME NonVoidInitializer):
    $(GLINK ExpInitializer):
    $(GLINK ArrayInitializer)
    $(GLINK StructInitializer)

$(GNAME ExpInitializer):
    $(GLINK AssignExpression)

$(GNAME ArrayInitializer):
    $(D [) $(GLINK ArrayMemberInitializations)$(OPT) $(D ])

$(GNAME ArrayMemberInitializations):
    $(GLINK ArrayMemberInitialization)
    $(GLINK ArrayMemberInitialization) $(D ,)
    $(GLINK ArrayMemberInitialization) $(D ,) $(I ArrayMemberInitializations)

$(GNAME ArrayMemberInitialization):
    $(GLINK NonVoidInitializer)
    $(ASSIGNEXPRESSION) $(D :) $(GLINK NonVoidInitializer)

$(GNAME StructInitializer):
    $(D {) $(GLINK StructMemberInitializers)$(OPT) $(D })

$(GNAME StructMemberInitializers):
    $(GLINK StructMemberInitializer)
    $(GLINK StructMemberInitializer) $(D ,)
    $(GLINK StructMemberInitializer) $(D ,) $(I StructMemberInitializers)

$(GNAME StructMemberInitializer):
    $(GLINK NonVoidInitializer)
    $(I Identifier) $(D :) $(GLINK NonVoidInitializer)
)

$(H3 $(LNAME2 function, Function))

$(GRAMMAR
$(GNAME FuncDeclaration):
    $(GLINK StorageClasses)$(OPT) $(GLINK BasicType) $(GLINK FuncDeclarator) $(GLINK FunctionBody)
    $(GLINK AutoFuncDeclaration)

$(GNAME AutoFuncDeclaration):
    $(GLINK StorageClasses) $(I Identifier) $(GLINK FuncDeclaratorSuffix) $(GLINK FunctionBody)

$(GNAME FuncDeclarator):
    $(GLINK BasicType2)$(OPT) $(I Identifier) $(GLINK FuncDeclaratorSuffix)

$(GNAME FuncDeclaratorSuffix):
    $(GLINK Parameters) $(GLINK MemberFunctionAttributes)$(OPT)
    $(GLINK TemplateParameters) $(GLINK Parameters) $(GLINK MemberFunctionAttributes)$(OPT) $(GLINK Constraint)$(OPT)
)

$(GRAMMAR
$(GNAME Parameters):
    $(D $(LPAREN)) $(GLINK ParameterList)$(OPT) $(D $(RPAREN))

$(GNAME ParameterList):
    $(GLINK Parameter)
    $(GLINK Parameter) $(D ,) $(I ParameterList)
    $(D ...)

$(GNAME Parameter):
    $(I InOut)$(OPT) $(GLINK BasicType) $(GLINK Declarator)
    $(I InOut)$(OPT) $(GLINK BasicType) $(GLINK Declarator) $(D ...)
    $(I InOut)$(OPT) $(GLINK BasicType) $(GLINK Declarator) = $(ASSIGNEXPRESSION)
    $(I InOut)$(OPT) $(GLINK Type)
    $(I InOut)$(OPT) $(GLINK Type) $(D ...)

$(GNAME InOut):
    $(I InOutX)
    $(I InOut InOutX)

$(GNAME InOutX):
    $(D auto)
    $(GLINK TypeCtor)
    $(D final)
    $(D in)
    $(D lazy)
    $(D out)
    $(D ref)
    $(D scope)

$(GNAME FunctionAttributes):
    $(GLINK FunctionAttribute)
    $(GLINK FunctionAttribute) $(I FunctionAttributes)

$(GNAME FunctionAttribute):
    $(D nothrow)
    $(D pure)
    $(GLINK Property)

$(GNAME MemberFunctionAttributes):
    $(GLINK MemberFunctionAttribute)
    $(GLINK MemberFunctionAttribute) $(I MemberFunctionAttributes)

$(GNAME MemberFunctionAttribute):
    $(D const)
    $(D immutable)
    $(D inout)
    $(D shared)
    $(GLINK FunctionAttribute)
)

$(GRAMMAR
$(GNAME FunctionBody):
    $(GLINK BlockStatement)
    $(GLINK FunctionContracts)$(OPT) $(GLINK BodyStatement)
    $(GLINK FunctionContracts)

$(GNAME FunctionContracts):
    $(GLINK InStatement) $(GLINK OutStatement)$(OPT)
    $(GLINK OutStatement) $(GLINK InStatement)$(OPT)

$(GNAME InStatement):
    $(D in) $(GLINK BlockStatement)

$(GNAME OutStatement):
    $(D out) $(GLINK BlockStatement)
    $(D out) $(D $(LPAREN)) $(I Identifier) $(D $(RPAREN)) $(GLINK BlockStatement)

$(GNAME BodyStatement):
    $(D body) $(GLINK BlockStatement)
)

$(GRAMMAR
$(GNAME Constructor):
    $(D this) $(GLINK Parameters) $(GLINK MemberFunctionAttributes)$(OPT) $(D ;)
    $(D this) $(GLINK Parameters) $(GLINK MemberFunctionAttributes)$(OPT) $(GLINK FunctionBody)
    $(GLINK ConstructorTemplate)

$(GNAME ConstructorTemplate):
    $(D this) $(GLINK TemplateParameters) $(GLINK Parameters) $(GLINK MemberFunctionAttributes)$(OPT) $(GLINK Constraint)$(OPT) $(D ;)
    $(D this) $(GLINK TemplateParameters) $(GLINK Parameters) $(GLINK MemberFunctionAttributes)$(OPT) $(GLINK Constraint)$(OPT) $(GLINK FunctionBody)

$(GNAME Destructor):
    $(D ~ this ( )) $(GLINK MemberFunctionAttributes)$(OPT) $(D ;)
    $(D ~ this ( )) $(GLINK MemberFunctionAttributes)$(OPT) $(GLINK FunctionBody)

$(GNAME Postblit):
    $(D this $(LPAREN) this $(RPAREN)) $(GLINK MemberFunctionAttributes)$(OPT) $(D ;)
    $(D this $(LPAREN) this $(RPAREN)) $(GLINK MemberFunctionAttributes)$(OPT) $(GLINK FunctionBody)

$(GNAME Allocator):
    $(D new) $(GLINK Parameters) $(D ;)
    $(D new) $(GLINK Parameters) $(GLINK FunctionBody)

$(GNAME Deallocator):
    $(D delete) $(GLINK Parameters) $(D ;)
    $(D delete) $(GLINK Parameters) $(GLINK FunctionBody)

$(GNAME Invariant):
    $(D invariant ( )) $(GLINK BlockStatement)
    $(D invariant) $(GLINK BlockStatement)

$(GNAME UnitTest):
    $(D unittest) $(GLINK BlockStatement)
)

$(GRAMMAR
$(GNAME StaticConstructor):
    $(D static this ( )) $(D ;)
    $(D static this ( )) $(GLINK FunctionBody)

$(GNAME StaticDestructor):
    $(D static ~ this ( )) $(GLINK MemberFunctionAttributes)$(OPT) $(D ;)
    $(D static ~ this ( )) $(GLINK MemberFunctionAttributes)$(OPT) $(GLINK FunctionBody)

$(GNAME SharedStaticConstructor):
    $(D shared static this ( )) $(D ;)
    $(D shared static this ( )) $(GLINK FunctionBody)

$(GNAME SharedStaticDestructor):
    $(D shared static ~ this ( )) $(GLINK MemberFunctionAttributes)$(OPT) $(D ;)
    $(D shared static ~ this ( )) $(GLINK MemberFunctionAttributes)$(OPT) $(GLINK FunctionBody)
)

$(H3 $(LNAME2 aggregate, Aggregate))

$(GRAMMAR
$(GNAME AggregateDeclaration):
    $(GLINK ClassDeclaration)
    $(GLINK InterfaceDeclaration)
    $(GLINK StructDeclaration)
    $(GLINK UnionDeclaration)

$(GNAME ClassDeclaration):
    $(D class) $(I Identifier) $(D ;)
    $(D class) $(I Identifier) $(GLINK BaseClassList)$(OPT) $(GLINK AggregateBody)
    $(GLINK ClassTemplateDeclaration)

$(GNAME ClassTemplateDeclaration):
    $(D class) $(I Identifier) $(GLINK TemplateParameters) $(GLINK Constraint)$(OPT) $(GLINK BaseClassList)$(OPT) $(GLINK AggregateBody)
    $(D class) $(I Identifier) $(GLINK TemplateParameters) $(GLINK BaseClassList) $(GLINK Constraint) $(GLINK AggregateBody)

$(GNAME InterfaceDeclaration):
    $(D interface) $(I Identifier) $(D ;)
    $(D interface) $(I Identifier) $(GLINK BaseInterfaceList)$(OPT) $(GLINK AggregateBody)
    $(GLINK InterfaceTemplateDeclaration)

$(GNAME InterfaceTemplateDeclaration):
    $(D interface) $(I Identifier) $(GLINK TemplateParameters) $(GLINK Constraint)$(OPT) $(GLINK BaseInterfaceList)$(OPT) $(GLINK AggregateBody)
    $(D interface) $(I Identifier) $(GLINK TemplateParameters) $(GLINK BaseInterfaceList) $(GLINK Constraint) $(GLINK AggregateBody)

$(GNAME StructDeclaration):
    $(D struct) $(I Identifier) $(D ;)
    $(D struct) $(I Identifier) $(GLINK AggregateBody)
    $(GLINK StructTemplateDeclaration)
    $(GLINK AnonStructDeclaration)

$(GNAME StructTemplateDeclaration):
    $(D struct) $(I Identifier) $(GLINK TemplateParameters) $(GLINK Constraint)$(OPT) $(GLINK AggregateBody)

$(GNAME AnonStructDeclaration):
    $(D struct) $(GLINK AggregateBody)

$(GNAME UnionDeclaration):
    $(D union) $(I Identifier) $(D ;)
    $(D union) $(I Identifier) $(GLINK AggregateBody)
    $(GLINK UnionTemplateDeclaration)
    $(GLINK AnonUnionDeclaration)

$(GNAME UnionTemplateDeclaration):
    $(D union) $(I Identifier) $(GLINK TemplateParameters) $(GLINK Constraint)$(OPT) $(GLINK AggregateBody)

$(GNAME AnonUnionDeclaration):
    $(D union) $(GLINK AggregateBody)

$(GNAME AggregateBody):
    $(D {) $(GLINK DeclDefs)$(OPT) $(D })
)

$(GRAMMAR
$(GNAME BaseClassList):
    $(D :) $(GLINK SuperClass)
    $(D :) $(GLINK SuperClass) $(D ,) $(GLINK Interfaces)
    $(D :) $(GLINK Interfaces)

$(GNAME BaseInterfaceList):
    $(D :) $(GLINK Interfaces)

$(GNAME SuperClass):
    $(GLINK BasicType)

$(GNAME Interfaces):
    $(GLINK Interface)
    $(GLINK Interface) $(D ,) $(I Interfaces)

$(GNAME Interface):
    $(GLINK BasicType)
)

$(GRAMMAR
$(GNAME AliasThis):
    $(D alias) $(I Identifier) $(D this ;)
)

$(H3 $(LNAME2 enum, Enum))

$(GRAMMAR
$(GNAME EnumDeclaration):
    $(D enum) $(I Identifier) $(GLINK EnumBody)
    $(D enum) $(I Identifier) $(D :) $(GLINK EnumBaseType) $(GLINK EnumBody)
    $(AnonymousEnumDeclaration)

$(GNAME EnumBaseType):
    $(GLINK2 declaration, Type)

$(GNAME EnumBody):
    $(D {) $(GLINK EnumMembers) $(D })
    $(D ;)

$(GNAME EnumMembers):
    $(GLINK EnumMember)
    $(GLINK EnumMember) $(D ,)
    $(GLINK EnumMember) $(D ,) $(GLINK EnumMembers)

$(GNAME EnumMember):
    $(I Identifier)
    $(I Identifier) $(D =) $(ASSIGNEXPRESSION)

$(GNAME AnonymousEnumDeclaration):
    $(D enum) $(D :) $(GLINK EnumBaseType) $(D {) $(GLINK EnumMembers) $(D })
    $(D enum) $(D {) $(GLINK EnumMembers) $(D })
    $(D enum) $(D {) $(GLINK AnonymousEnumMembers) $(D })

$(GNAME AnonymousEnumMembers):
    $(GLINK AnonymousEnumMember)
    $(GLINK AnonymousEnumMember) $(D ,)
    $(GLINK AnonymousEnumMember) $(D ,) $(GLINK AnonymousEnumMembers)

$(GNAME AnonymousEnumMember):
    $(GLINK EnumMember)
    $(GLINK2 declaration Type) $(I Identifier) $(D =) $(ASSIGNEXPRESSION)
)

$(H3 $(LNAME2 template, Template))

$(GRAMMAR
$(GNAME TemplateDeclaration):
    $(D template) $(I Identifier) $(GLINK TemplateParameters) $(GLINK Constraint)$(OPT) $(D {) $(GLINK DeclDefs)$(OPT) $(D })

$(GNAME TemplateParameters):
    $(D $(LPAREN)) $(GLINK TemplateParameterList)$(OPT) $(D $(RPAREN))

$(GNAME TemplateParameterList):
    $(GLINK TemplateParameter)
    $(GLINK TemplateParameter) ,
    $(GLINK TemplateParameter) , $(I TemplateParameterList)

$(GNAME TemplateParameter):
    $(GLINK TemplateTypeParameter)
    $(GLINK TemplateValueParameter)
    $(GLINK TemplateAliasParameter)
    $(GLINK TemplateTupleParameter)
    $(GLINK TemplateThisParameter)

$(GNAME Constraint):
    $(D if) $(D $(LPAREN)) $(GLINK Expression) $(D $(RPAREN))
)

$(GRAMMAR
$(GNAME TemplateInstance):
    $(I Identifier) $(GLINK TemplateArguments)

$(GNAME TemplateArguments):
    $(D ! $(LPAREN)) $(GLINK TemplateArgumentList)$(OPT) $(D $(RPAREN))
    $(D !) $(GLINK TemplateSingleArgument)

$(GNAME TemplateArgumentList):
    $(GLINK TemplateArgument)
    $(GLINK TemplateArgument) ,
    $(GLINK TemplateArgument) , $(I TemplateArgumentList)

$(GNAME TemplateArgument):
    $(GLINK Type)
    $(ASSIGNEXPRESSION)
    $(GLINK Symbol)

$(GNAME Symbol):
    $(GLINK SymbolTail)
    $(D .) $(GLINK SymbolTail)

$(GNAME SymbolTail):
    $(I Identifier)
    $(I Identifier) $(D .) $(I SymbolTail)
    $(GLINK TemplateInstance)
    $(GLINK TemplateInstance) $(D .) $(I SymbolTail)

$(GNAME TemplateSingleArgument):
    $(I Identifier)
    $(GLINK BasicTypeX)
    $(GLINK_LEX CharacterLiteral)
    $(GLINK_LEX StringLiteral)
    $(GLINK_LEX IntegerLiteral)
    $(GLINK_LEX FloatLiteral)
    $(D true)
    $(D false)
    $(D null)
    $(D this)
    $(GLINK SpecialKeyword)
)

$(GRAMMAR
$(GNAME TemplateTypeParameter):
    $(I Identifier)
    $(I Identifier) $(GLINK TemplateTypeParameterSpecialization)
    $(I Identifier) $(GLINK TemplateTypeParameterDefault)
    $(I Identifier) $(GLINK TemplateTypeParameterSpecialization) $(GLINK TemplateTypeParameterDefault)

$(GNAME TemplateTypeParameterSpecialization):
    $(D :) $(GLINK Type)

$(GNAME TemplateTypeParameterDefault):
    $(D =) $(GLINK Type)
)

$(GRAMMAR
$(GNAME TemplateThisParameter):
    $(D this) $(I TemplateTypeParameter)
)

$(GRAMMAR
$(GNAME TemplateValueParameter):
    $(GLINK BasicType) $(GLINK Declarator)
    $(GLINK BasicType) $(GLINK Declarator) $(GLINK TemplateValueParameterSpecialization)
    $(GLINK BasicType) $(GLINK Declarator) $(GLINK TemplateValueParameterDefault)
    $(GLINK BasicType) $(GLINK Declarator) $(GLINK TemplateValueParameterSpecialization) $(GLINK TemplateValueParameterDefault)

$(GNAME TemplateValueParameterSpecialization):
    $(D :) $(GLINK ConditionalExpression)

$(GNAME TemplateValueParameterDefault):
    $(D =) $(ASSIGNEXPRESSION)
    $(D =) $(GLINK SpecialKeyword)
)

$(GRAMMAR
$(GNAME TemplateAliasParameter):
    $(D alias) $(I Identifier) $(GLINK TemplateAliasParameterSpecialization)$(OPT) $(GLINK TemplateAliasParameterDefault)$(OPT)
    $(D alias) $(GLINK BasicType) $(GLINK Declarator) $(GLINK TemplateAliasParameterSpecialization)$(OPT) $(GLINK TemplateAliasParameterDefault)$(OPT)

$(GNAME TemplateAliasParameterSpecialization):
    $(D :) $(GLINK Type)
    $(D :) $(GLINK ConditionalExpression)

$(GNAME TemplateAliasParameterDefault):
    $(D =) $(GLINK Type)
    $(D =) $(GLINK ConditionalExpression)
)

$(GRAMMAR
$(GNAME TemplateTupleParameter):
    $(I Identifier) $(D ...)
)

$(GRAMMAR
$(GNAME TemplateMixinDeclaration):
    $(D mixin) $(D template) $(I Identifier) $(GLINK TemplateParameters) $(GLINK Constraint)$(OPT) $(D {) $(GLINK DeclDefs)$(OPT) $(D })

$(GNAME TemplateMixin):
    $(D mixin) $(GLINK MixinTemplateName) $(GLINK TemplateArguments)$(OPT) $(I Identifier)$(OPT) $(D ;)

$(GNAME MixinTemplateName):
    $(D .) $(GLINK QualifiedIdentifierList)
    $(GLINK QualifiedIdentifierList)
    $(GLINK Typeof) $(D .) $(GLINK QualifiedIdentifierList)

$(GNAME QualifiedIdentifierList):
    $(I Identifier)
    $(I Identifier) $(D .) $(I QualifiedIdentifierList)
    $(GLINK TemplateInstance) $(D .) $(I QualifiedIdentifierList)
)

$(H3 $(LNAME2 attribute, Attribute))

$(GRAMMAR
$(GNAME AttributeSpecifier):
    $(GLINK Attribute) $(D :)
    $(GLINK Attribute) $(GLINK DeclarationBlock)

$(GNAME Attribute):
    $(GLINK LinkageAttribute)
    $(GLINK AlignAttribute)
    $(GLINK DeprecatedAttribute)
    $(GLINK ProtectionAttribute)
    $(GLINK Pragma)
    $(D static)
    $(D extern)
    $(D abstract)
    $(D final)
    $(D override)
    $(D synchronized)
    $(D auto)
    $(D scope)
    $(D const)
    $(D immutable)
    $(D inout)
    $(D shared)
    $(D __gshared)
    $(GLINK Property)
    $(D nothrow)
    $(D pure)
    $(D ref)

$(GNAME DeclarationBlock):
    $(GLINK DeclDef)
    $(D {) $(GLINK DeclDefs)$(OPT) $(D })
)

$(GRAMMAR
$(GNAME LinkageAttribute):
    $(D extern) $(D $(LPAREN)) $(GLINK LinkageType) $(D $(RPAREN))
    $(D extern) $(D $(LPAREN)) $(D C++), $(GLINK IdentifierList) $(D $(RPAREN))

$(GNAME LinkageType):
    $(D C)
    $(D C++)
    $(D D)
    $(D Windows)
    $(D Pascal)
    $(D System)
)

$(GRAMMAR
$(GNAME AlignAttribute):
    $(D align)
    $(D align) $(D $(LPAREN)) $(GLINK_LEX IntegerLiteral) $(D $(RPAREN))
)

$(GRAMMAR
$(GNAME DeprecatedAttribute):
    $(D deprecated)
    $(D deprecated $(LPAREN)) $(GLINK_LEX StringLiteral) $(D $(RPAREN))
)

$(GRAMMAR
$(GNAME ProtectionAttribute):
    $(D private)
    $(D package)
    $(D package) $(D $(LPAREN)) $(GLINK IdentifierList) $(D $(RPAREN))
    $(D protected)
    $(D public)
    $(D export)
)

$(GRAMMAR
$(GNAME Property):
    $(D @) $(GLINK PropertyIdentifier)
    $(GLINK UserDefinedAttribute)

$(GNAME PropertyIdentifier):
    $(D property)
    $(D safe)
    $(D trusted)
    $(D system)
    $(D disable)
    $(D nogc)

$(GNAME UserDefinedAttribute):
    $(D @ $(LPAREN)) $(GLINK ArgumentList) $(D $(RPAREN))
    $(D @) $(I Identifier)
    $(D @) $(I Identifier) $(D $(LPAREN)) $(GLINK ArgumentList)$(OPT) $(D $(RPAREN))
    $(D @) $(GLINK TemplateInstance)
    $(D @) $(GLINK TemplateInstance) $(D $(LPAREN)) $(GLINK ArgumentList)$(OPT) $(D $(RPAREN))
)

$(GRAMMAR
$(GNAME Pragma):
    $(D pragma) $(D $(LPAREN)) $(I Identifier) $(D $(RPAREN))
    $(D pragma) $(D $(LPAREN)) $(I Identifier) $(D ,) $(GLINK ArgumentList) $(D $(RPAREN))
)

$(H3 $(LNAME2 conditional, Conditional))

$(GRAMMAR
$(GNAME ConditionalDeclaration):
    $(GLINK Condition) $(GLINK DeclarationBlock)
    $(GLINK Condition) $(GLINK DeclarationBlock) $(D else) $(GLINK DeclarationBlock)
    $(GLINK Condition) $(D :) $(GLINK DeclDefs)$(OPT)
    $(GLINK Condition) $(GLINK DeclarationBlock) $(D else) $(D :) $(GLINK DeclDefs)$(OPT)

$(GNAME ConditionalStatement):
    $(GLINK Condition) $(GLINK NoScopeNonEmptyStatement)
    $(GLINK Condition) $(GLINK NoScopeNonEmptyStatement) $(D else) $(GLINK NoScopeNonEmptyStatement)
)

$(GRAMMAR
$(GNAME Condition):
    $(GLINK VersionCondition)
    $(GLINK DebugCondition)
    $(GLINK StaticIfCondition)

$(GNAME VersionCondition):
    $(D version $(LPAREN)) $(GLINK_LEX IntegerLiteral) $(D $(RPAREN))
    $(D version $(LPAREN)) $(I Identifier) $(D $(RPAREN))
    $(D version $(LPAREN)) $(D unittest) $(D $(RPAREN))
    $(D version $(LPAREN)) $(D assert) $(D $(RPAREN))

$(GNAME DebugCondition):
    $(D debug)
    $(D debug $(LPAREN)) $(GLINK_LEX IntegerLiteral) $(D $(RPAREN))
    $(D debug $(LPAREN)) $(I Identifier) $(D $(RPAREN))

$(GNAME StaticIfCondition):
    $(D static if $(LPAREN)) $(ASSIGNEXPRESSION) $(D $(RPAREN))
)

$(GRAMMAR
$(GNAME VersionSpecification):
    $(D version =) $(I Identifier) $(D ;)
    $(D version =) $(GLINK_LEX IntegerLiteral) $(D ;)

$(GNAME DebugSpecification):
    $(D debug =) $(I Identifier) $(D ;)
    $(D debug =) $(GLINK_LEX IntegerLiteral) $(D ;)
)

$(GRAMMAR
$(GNAME StaticAssert):
    $(D static assert $(LPAREN)) $(ASSIGNEXPRESSION) $(D $(RPAREN);)
    $(D static assert $(LPAREN)) $(ASSIGNEXPRESSION) $(D ,) $(ASSIGNEXPRESSION) $(D $(RPAREN);)
)

$(H3 $(LNAME2 module, Module))

$(GRAMMAR
$(GNAME Module):
    $(GLINK ModuleDeclaration) $(GLINK DeclDefs)
    $(GLINK DeclDefs)

$(GNAME DeclDefs):
    $(GLINK DeclDef)
    $(GLINK DeclDef) $(I DeclDefs)

$(GNAME DeclDef):
    $(GLINK AttributeSpecifier)
    $(GLINK Declaration)
    $(GLINK Constructor)
    $(GLINK Destructor)
    $(GLINK Postblit)
    $(GLINK Allocator)
    $(GLINK Deallocator)
    $(GLINK Invariant)
    $(GLINK UnitTest)
    $(GLINK AliasThis)
    $(GLINK StaticConstructor)
    $(GLINK StaticDestructor)
    $(GLINK SharedStaticConstructor)
    $(GLINK SharedStaticDestructor)
    $(GLINK ConditionalDeclaration)
    $(GLINK DebugSpecification)
    $(GLINK VersionSpecification)
    $(GLINK StaticAssert)
    $(GLINK TemplateDeclaration)
    $(GLINK TemplateMixinDeclaration)
    $(GLINK TemplateMixin)
    $(GLINK MixinDeclaration)
    $(D ;)
)

$(GRAMMAR
$(GNAME ModuleDeclaration):
    $(D module) $(I ModuleFullyQualifiedName) $(D ;)

$(GNAME ModuleFullyQualifiedName):
    $(I ModuleName)
    $(I Packages) $(D .) $(I ModuleName)

$(GNAME ModuleName):
    $(I Identifier)

$(GNAME Packages):
    $(I PackageName)
    $(I Packages) $(D .) $(I PackageName)

$(GNAME PackageName):
    $(I Identifier)
)

$(GRAMMAR
$(GNAME ImportDeclaration):
    $(D import) $(I ImportList) $(D ;)
    $(D static import) $(I ImportList) $(D ;)

$(GNAME ImportList):
    $(I Import)
    $(I ImportBindings)
    $(I Import) $(D ,) $(I ImportList)

$(GNAME Import):
    $(I ModuleFullyQualifiedName)
    $(I ModuleAliasIdentifier) $(D =) $(I ModuleFullyQualifiedName)

$(GNAME ImportBindings):
    $(I Import) $(D :) $(I ImportBindList)

$(GNAME ImportBindList):
    $(I ImportBind)
    $(I ImportBind) $(D ,) $(I ImportBindList)

$(GNAME ImportBind):
    $(I Identifier)
    $(I Identifier) = $(I Identifier)

$(GNAME ModuleAliasIdentifier):
    $(I Identifier)
)

$(GRAMMAR
$(GNAME MixinDeclaration):
    $(D mixin) $(D $(LPAREN)) $(ASSIGNEXPRESSION) $(D $(RPAREN)) $(D ;)
)

)

Macros:
        TITLE=D Grammar
        WIKI=Grammar
        IDENTIFIER=$(GLINK Identifier)
        EXPRESSION=$(GLINK Expression)
        ASSIGNEXPRESSION=$(GLINK AssignExpression)
        PSSEMI_PSCURLYSCOPE=$(GLINK Statement)
        PSSEMI_PSCURLYSCOPE_LIST=$(GLINK ScopeStatementList)
        PS0=$(GLINK NoScopeNonEmptyStatement)
        PSSCOPE=$(GLINK ScopeStatement)
        PSCURLY=$(GLINK BlockStatement)
        PSSEMI=$(GLINK NoScopeStatement)
        PSCURLY_PSSCOPE=$(GLINK ScopeBlockStatement)
        PSCURLYSCOPE=$(GLINK NonEmptyOrScopeBlockStatement)
        TRAITS_LINK2=$(LINK2 traits.html#$1, $(D $1))
        GLINK_LEX=$(GLINK2 lex, $1)
        GLINK2=$(GLINK $2)