root/toys/v3d/parsed.g

// BSD license
/*
Copyright (c) 2009 Ellery Newcomer
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
   notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
   notice, this list of conditions and the following disclaimer in the
   documentation and/or other materials provided with the distribution.
3. The name of the author may not be used to endorse or promote products
   derived from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

/**
  * Alright people, stop looking at this and thinking it actually works.
  * It doesn't. It never did because ANLTR3 is a heck of a lot more neurotic
  * than ANTLR2.
  * The ANLTR2 grammars, on the other hand, work pretty well.
  * Have a peek at https://bitbucket.org/ariovistus/d-jvm-cc/src/
  * for them and lots of unfinished cruft
  */

parser grammar parsed;
// manually converted from a v2 grammar. (I might make this one pretty)
options{
    tokenVocab = lexd;
    output=AST;
}
@members{
    boolean catch_ambig = false;
}
module_:
    (moduleDeclaration)? declDefs
    ;
moduleDeclaration:
    Module moduleName Semicolon 
    ;
moduleName:
    Identifier (Dot Identifier )* 
    ;
declDefs :
    ((( alignmentAttribute 
    |protection 
        |pragma_
    |versionCondition
    |debugCondition
    //note seeing else else is erroneous
    |Else
    |staticIfCondition)
    
    (Lcurly declDefs Rcurly
    | Colon)?)
    | (attributes 
    (autoDeclaration 
    |Lcurly declDefs Rcurly
    |Colon)?)
    |declDef
    )*
    ;
declDef:
    enumDeclaration 
    |classDeclaration 
    |interfaceDeclaration 
    |structDecl 
    |unionDecl 
    |importDeclaration //need to bind static for static import
    |templateDeclaration 
    |mixinDeclaration 
    |templateMixin 
    //|staticConstructor 
    //|staticDestructor 
    |staticAssert 
    //|staticIfDeclaration 
    |declaration
    |constructor //need to bind static for static ctor (and check params)
    |destructor //need to bind static for static dtor
    |invariant_ 
    |unitTest 
    |classAllocator 
    |classDeallocator 
    |debugSpecification 
    //|debugDeclaration 
    |versionSpecification 
    //|versionDeclaration 
    //|pragma_ Semicolon
    |Semicolon
    ;
atrAuto:
    attributes autoDeclaration 
    ;
mixinDeclaration:
    Mixin Lparth asgExp Rparth Semicolon 
    ;
attributes:
    (attribute )+ 
    ;

attribute:
    Extern Lparth linkageType Rparth 
    |storageClass
    ;
storageClass:
    Abstract 
    |Deprecated 
    |Override 
    |Synchronized 
    |sStorageClass 
    ;
sStorageClass:
    Auto 
    |Const 
    |Extern 
    |Final 
    | Static 
    |Scope 
    ;
linkageType:
    Identifier (Plusplus )? 
    ;
alignmentAttribute:
    Align (Lparth IntegerLiteral Rparth )? 
    ;
pragma_:
    Pragma Lparth Identifier (Comma expressionList )? Rparth 
    ;
importDeclaration:
    /*(Static )?*/ Import importSegment (Comma importSegment )* (Colon importBindList )? Semicolon 
    ;
importSegment:
    (Identifier Assign moduleName 
        |moduleName ) 
    ;
importBindList:
    importBind (Comma importBind )* 
    ;
importBind:
    Identifier (Assign Identifier )? 
    ;
enumDeclaration :
    Enum (
    Identifier (Colon enumBaseType)?  (enumBody|Semicolon)
    |(Colon enumBaseType)? enumBody)
    ;
enumBaseType:
    type 
    ;
enumBody:
    Lcurly (enumMembers )? Rcurly 
    ;
enumMembers:
    enumMember ((Comma Rcurly )=> Comma 
        |Comma enumMember )* 
    ;
enumMember:
    Identifier (Assign asgExp )? 
    ;
atrClassDecl:
    storageClasses classDeclaration 
    ;
classDeclaration:
    Class Identifier (templateParameterList )? (baseClassList )? (classBody 
        |Semicolon ) 
    ;
baseClassList:
    Colon baseClass (Comma baseClass )* 
    ;
baseClass:
    (protection )? identifierList 
    ;
protection:
    (Private 
        |Package 
        |Public 
        |Protected 
        |Export ) 
    ;
classBody:
    Lcurly declDefs Rcurly 
    ;
declaration:
    typedefDecl 
    |aliasDecl 
    |decl 
    ;
typedefDecl:
    Typedef (storageClasses )? basicType declarator declaratorSuffix Semicolon 
    ;
aliasDecl:
    Alias (storageClasses )? basicType declarator (aliasDeclList )? Semicolon 
    ;
aliasDeclList:
    (Comma Identifier )+ 
    ;
decl:
    (basicType declarator ( functionBody  
            |declaratorSuffix Semicolon ) ) 
    ;
storageClasses:
    (storageClass )+ 
    ;
declaratorSuffix:
    (declaratorInitializer )? (Comma declaratorIdentifierList )? 
    ;
declaratorInitializer:
    Assign initializer 
    ;
declaratorIdentifierList:
    declaratorIdentifier (Comma declaratorIdentifier )* 
    ;
declaratorIdentifier:
    Identifier (Assign initializer )? 
    ;
/*
staticIfDeclaration:
    staticIfCondition ccThenBlock ((Else)=> Else ccElseBlock )? 
    ;
versionDeclaration:
    versionCondition ccThenBlock ((Else)=> Else ccElseBlock )? 
    ;
debugDeclaration:
    debugCondition ccThenBlock ((Else)=> Else ccElseBlock )? 
    ;
ccThenBlock:
    block 
    ;
ccElseBlock:
    block 
    ;
block:
    ((Semicolon)=>Semicolon //error consumption
    |Colon (declDefs )?
        | Lcurly declDefs Rcurly 
        declDef 
        ) 
    ;
    */
basicType:
    (baseType 
        |userType ) 
    ;
userType:
    Dot identifierList 
    |identifierList 
    |typeof_ ((Dot)=> Dot identifierList )? 
    ;
baseType:
    Bool 
    |Byte 
    |Ubyte 
    |Short 
    |Ushort 
    |Int 
    |Uint 
    |Long 
    |Ulong 
    |Char 
    |Wchar 
    |Dchar 
    |Float 
    |Double 
    |Real 
    |Ifloat 
    |Idouble 
    |Ireal 
    |Cfloat 
    |Cdouble 
    |Creal 
    |Void 
    ;
basicType2:
    (basicType2_x )+ 
    ;
basicType2_x:
    (Mul 
        |Delegate parameters2 
        |Function parameters2 
        |(Lbracket Rbracket )=> Lbracket Rbracket
        |(Lbracket type Rbracket )=> Lbracket type Rbracket 
        |Lbracket exp (Slice exp )? Rbracket ) 
    ;
declarator:
    (basicType2 )?  (Identifier 
    |Lparth declarator Rparth) 
    ((Lparth |Lbracket )=> declaratorSuffixes )?
    
    ;
declaratorSuffixes:
    (declaratorSuffixes_bracket ((Lparth)=> declaratorSuffixes_parenth )? 
        |declaratorSuffixes_parenth ) 
    ;
declaratorSuffixes_bracket:
    (basicType2_bracket )+ 
    ;
basicType2_bracket:
    Lbracket (Rbracket 
        |(type Rbracket )=> type Rbracket 
        |exp Rbracket ) 
    ;
declaratorSuffixes_parenth:
    ((templateParameterList Lparth )=> templateParameterList parameters 
        |parameters ) 
    ;
identifierList:
    identifier ((Dot)=> Dot identifier )* 
    ;
identifier:
    (Identifier Not )=> templateInstance 
    |Identifier 
    ;
typeof_:
    Typeof Lparth (exp 
        |Return ) Rparth 
    ;

type:
    basicType declarator2
    ;
declarator2:
    (basicType2 )? 
    (((Lparth Rparth)=> Lparth Rparth
    |Lparth declarator2 Rparth)
    (declaratorSuffixes)?)?
    ;
parameters:
        Lparth (parameter (Comma parameter )*)? Rparth
    ;
parameters2:
    parameters 
    ;
parameter:
    Vararg 
    |(inOut )? basicType ((declarator )=> (declarator (Assign asgExp 
                |Vararg )? ) 
        |declarator2 (Vararg )? ) 
    ;
inOut:
    (In 
        |Out 
        |Inout 
        |Lazy 
        |Ref ) 
    ;
initializer:
    ((Void )=> Void 
        |nonVoidInitializer ) 
    ;
nonVoidInitializer:
    (asgExp )=> asgExp 
    |arrayInitializer 
    |structInitializer 
    ;
arrayInitializer:
    (Lbracket ((asgExp Colon )=> assocMemInits 
            |arrayMemInits )? Rbracket ) 
    ;
arrayMemInits:
    arrayMemInit ((Comma Rbracket )=> Comma 
        |Comma arrayMemInit )* 
    ;
assocMemInits:
    assocMemInit ((Comma Rbracket )=> Comma 
        |Comma assocMemInit )* 
    ;
arrayMemInit:
    nonVoidInitializer 
    ;
assocMemInit:
    asgExp Colon nonVoidInitializer 
    ;
structInitializer:
    ((Lcurly Rcurly )=> Lcurly Rcurly 
        |Lcurly structMemberInitializers Rcurly ) 
    ;
structMemberInitializers:
    structMemberInitializer ((Comma Rcurly )=> Comma 
        |Comma structMemberInitializer )* 
    ;
structMemberInitializer:
    (Identifier Colon )=> Identifier Colon nonVoidInitializer 
    |nonVoidInitializer 
    ;
autoDeclaration:
    autoAsg (Comma autoAsg )* Semicolon 
    ;
autoAsg:
    Identifier Assign initializer 
    ;
constructor:
    This parameters (Semicolon 
        |functionBody ) 
    ;
destructor:
    Cat This Lparth Rparth (Semicolon 
        |functionBody ) 
    ;
/*
staticConstructor:
    Static This Lparth Rparth (Semicolon 
        |functionBody ) 
    ;
staticDestructor:
    Static Cat This Lparth Rparth (Semicolon 
        |functionBody ) 
    ;
    */
invariant_:
    Invariant (Lparth Rparth )? blockStatement 
    ;
blockStatement:
    Lcurly ((statement )* Rcurly ) 
    ;
unitTest:
    Unittest functionBody 
    ;
classAllocator:
    New parameters functionBody 
    ;
classDeallocator:
    Delete parameters functionBody 
    ;
interfaceDeclaration:
    Interface Identifier (templateParameterList )? (baseClassList )? (classBody 
        |Semicolon ) 
    ;
structDecl:
    Struct structBody 
    ;
unionDecl:
    Union structBody 
    ;
structBody:
    classBody
    |Identifier templateParameterList? (classBody|Semicolon)
    ;
debugSpecification:
    Debug Assign (IntegerLiteral 
        |Identifier ) Semicolon 
    ;
versionSpecification:
    Version Assign (IntegerLiteral 
        |Identifier ) Semicolon 
    ;
exp:
    asgExp (comma asgExp )* 
    ;
comma:
    Comma 
    ;
asgExp:
    condExp (asg condExp )* 
    ;
asg:
    (Assign 
        |Add_assign 
        |Minus_assign 
        |Mul_assign 
        |Div_assign 
        |Mod_assign 
        |And_bitwise_assign 
        |Or_bitwise_assign 
        |Xor_assign 
        |Cat_assign 
        |Lshift_assign 
        |Rshift_assign 
        |Urshift_assign ) 
    ;
condExp:
    orExp (Ternary exp Colon condExp )? 
    ;
orExp:
    andExp (Or andExp )* 
    ;
andExp:
    orBitExp (And orBitExp )* 
    ;
orBitExp:
    xorExp (Or_bitwise xorExp )* 
    ;
xorExp:
    andBitExp (Xor andBitExp )* 
    ;
andBitExp:
    cmpExp (And_bitwise cmpExp )* 
    ;
cmpExp:
    shiftExp (cmp shiftExp )? 
    ;
cmp:
    (Eq 
        |Ne 
        |Is 
        |(Not Is ) 
        |Lt 
        |Le 
        |Gt 
        |Ge 
        |Yes_nan 
        |Eq_or_nan 
        |Ne_no_nan 
        |No_nan 
        |Le_or_nan 
        |Lt_or_nan 
        |Ge_or_nan 
        |Gt_or_nan 
        |In ) 
    ;
shiftExp:
    addExp (shift addExp )* 
    ;
shift:
    (Lshift 
        |Rshift 
        |Urshift ) 
    ;
addExp:
    mulExp (add mulExp )* 
    ;
add:
    (Add 
        |Minus 
        |Cat ) 
    ;
mulExp:
    unExp (mul unExp )* 
    ;
mul:
    (Mul 
        |Div 
        |Mod ) 
    ;
unExp:
    unary unExp 
    |newExpression 
    |deleteExp 
    |castExp 
    |primExp 
    ;
unary:
    (And_bitwise 
        |Plusplus 
        |Minusminus 
        |Mul 
        |Minus 
        |Add 
        |Not 
        |Cat ) 
    ;
newExpression:
    (newArguments Class )=> anonClassExp 
    |newExp 
    ;
newExp:
    newArguments basicType ((basicType2_noAA)=> basicType2_noAA )? ((Lparth)=> Lparth argumentList Rparth )? 
    ;
anonClassExp:
    newArguments classArguments (anonBaseClassList )? classBody 
    ;
anonBaseClassList:
    baseClass (Comma baseClass )* 
    ;
basicType2_noAA:
    ((basicType2_noAA_x)=> basicType2_noAA_x )+ 
    ;
basicType2_noAA_x:
    (Mul 
        |Lbracket (Rbracket 
            |exp (Slice exp )? Rbracket ) 
        |Delegate parameters2 
        |Function parameters2 ) 
    ;
newArguments:
    New (Lparth argumentList Rparth )? 
    ;
classArguments:
    Class (Lparth argumentList Rparth )? 
    ;
argumentList:
    (arguments )? 
    ;
arguments:
    asgExp (Comma asgExp )* 
    ;
deleteExp:
    Delete unExp 
    ;
castExp:
    Cast Lparth type Rparth unExp 
    ;
indexExpression:
    Lbracket argumentList Rbracket 
    ;
primExp:
    ((Identifier Not Lparth )=> templateInstanceExp 
        |(basicType Dot )=> basicType Dot identifierExp 
        |(functionLiteral )=> functionLiteral 
        |(Dot Identifier Not Lparth )=> Dot templateInstanceExp 
        |Dot identifierExp 
        |(Lparth type Rparth Dot )=> Lparth type Rparth Dot identifierExp 
        |identifierExp 
        |literal 
        |stringLiteral 
        |arrayLiteral 
        |assertExp 
        |mixinExpression 
        |importExpression 
        |typeidExp 
        |isExp 
        |typeofExp 
        |Lparth exp Rparth ) 

     ((Dot Identifier Not Lparth )=> Dot templateInstanceExp 
        |(Dot New )=> Dot newExpression 
        |Dot identifierExp 
        |Lparth argumentList Rparth 
        |(Lbracket asgExp Slice )=> Lbracket asgExp Slice asgExp Rbracket 
        |indexExpression )* 
    
    (post )? 
    ;
post:
    (Plusplus 
        |Minusminus ) 
    ;
identifierExp:
    Identifier 
    ;
templateInstanceExp:
    identifierExp templateArgumentList 
    ;
stringLiteral:
    strLit (strLit )* 
    ;
strLit:
    StringLiteral 
    ;
literal:
    (This 
        |Super 
        |Null 
        |True 
        |False 
        |Dollar 
        |IntegerLiteral 
        |IntegerLiteralSuffixed 
        |FloatLiteral 
        |CharacterLiteral ) 
    ;
typeofExp:
    typeofp Lparth exp Rparth 
    ;
typeofp:
    Typeof 
    ;
arrayLiteral:
    Lbracket ((Rbracket )=> Rbracket 
        |(asgExp Colon )=> keyValuePairs Rbracket 
        |argumentList Rbracket ) 
    ;
keyValuePairs:
    keyValuePair (Comma keyValuePair )* 
    ;
keyValuePair:
    keyExpression Colon valueExpression 
    ;
keyExpression:
    asgExp 
    ;
valueExpression:
    asgExp 
    ;
functionLiteral:
    (Function (type )? (parameterAttributes )? functionBody 
        |Delegate (type )? (parameterAttributes )? functionBody 
        |parameterAttributes functionBody 
        |functionBody ) 
    ;
parameterAttributes:
    parameters 
    ;
assertExp:
    Assert Lparth asgExp (Comma asgExp )? Rparth 
    ;
mixinExpression:
    Mixin Lparth asgExp Rparth 
    ;
importExpression:
    Import Lparth asgExp Rparth 
    ;
typeidExp:
    Typeid Lparth type Rparth 
    ;
isExp:
    Is Lparth type (Identifier )? (Colon typeSpec Rparth 
        |Eq typeSpec Rparth 
        |Rparth ) 
    ;
typeSpec:
    (type 
        |Typedef 
        |Struct 
        |Union 
        |Class 
        |Interface 
        |Enum 
        |Function 
        |Delegate 
        |Super 
        |Return ) 
    ;
statement:
    Semicolon 
    |(Lcurly )=> scopeBlockStatement 
    |nonEmptyStatement 
    ;
noScopeNonEmptyStatement:
    (Lcurly )=> blockStatement 
    |nonEmptyStatement 
    ;
noScopeStatement:
    Semicolon 
    |(Lcurly )=> blockStatement 
    |nonEmptyStatement 
    ;
nonEmptyOrScopeBlockStatement:
    (Lcurly )=> scopeBlockStatement 
    |nonEmptyStatement 
    ;
nonEmptyStatement:
    nonEmptyStatement_case 
    |nonEmptyStatement_nocase 
    ;
nonEmptyStatement_case:
    caseStatement 
    |defaultStatement 
    ;
nonEmptyStatement_nocase :
    (Identifier Colon )=> labeledStatement 
    |(Mixin ~(Lparth ) )=> templateMixin 
    |(Static Assert )=> Static staticAssert 
    |versionStatement 
    |debugStatement 
    |(Static If )=> staticIfStatement 
    |(Class )=> classDeclaration 
    |interfaceDeclaration 
    |structDecl 
    |unionDecl 
    |enumDeclaration 
    |whileStatement 
    |doStatement 
    |forStatement 
    |foreachStatement 
    |ifStatement 
    |(Scope Lparth )=> scopeGuardStatement 
    |pragmaStatement 
    |switchStatement 
    |returnStatement 
    |breakStatement 
    |continueStatement 
    |gotoStatement 
    |(Synchronized )=> synchronizedStatement 
    |withStatement 
    |tryStatement 
    |throwStatement 
    |volatileStatement 
    |asmStatement 
    |{catch_ambig}?=>declarationExpressionStatement 
    |{!catch_ambig}?=>declarationExpressionStatement_noambig
    ;
declarator_ambig:
    (basicType2 )? ((Lparth Identifier ~(Rparth ) )=> Lparth declarator_ambig Rparth declaratorSuffixes 
        |(Lparth basicType2 )=> Lparth declarator_ambig Rparth declaratorSuffixes 
        |(Identifier (Lparth 
                |Lbracket ) )=> Identifier declaratorSuffixes 
        |Identifier ) 
    ;
declarationExpressionStatement:
    (storageClass)+ (autoDeclaration|declaration)
    |(Alias |Typedef )=> declaration 
    |(mixinStatement )=> mixinStatement 
    |(Mixin Lparth )=> ambigExpression Semicolon 
    |(basicType Dot )=> exp Semicolon 
    |(baseType )=> declaration 
    |(userType declarator_ambig )=> ((exp )=> ambigDeclaration 
        |declaration ) 
    |(declaration )=> ambigExpression Semicolon 
    |exp Semicolon 
    ;
declarationExpressionStatement_noambig:
    (storageClass)+ (autoDeclaration|declaration)
    |mixinStatement 
    |(declaration)=> declaration
    |exp Semicolon 
    ;

ambigExpression:
    exp 
    ;
ambigDeclaration:
    basicType declarator declaratorSuffix Semicolon 
    ;
scopeStatement:
    ((Lcurly )=> blockStatement 
        |nonEmptyStatement ) 
    ;
scopeBlockStatement:
    blockStatement 
    ;
labeledStatement:
    Identifier Colon noScopeStatement 
    ;
ifStatement:
    If Lparth ifCondition Rparth thenStatement ((Else)=> Else elseStatement )? 
    ;
ifCondition:
    ((basicType declarator Assign )=> basicType declarator Assign exp 
        |Auto Identifier Assign exp 
        |exp ) 
    ;
thenStatement:
    ((Lcurly )=> blockStatement 
        |nonEmptyStatement ) 
    ;
elseStatement:
    scopeStatement 
    ;
whileStatement:
    While Lparth exp Rparth scopeStatement 
    ;
doStatement:
    Do scopeStatement While Lparth exp Rparth 
    ;
forStatement:
    For Lparth forInitializer fortest Semicolon forincrement Rparth scopeStatement 
    ;
forInitializer:
    (Semicolon 
        |noScopeNonEmptyStatement ) 
    ;
fortest:
    (exp )? 
    ;
forincrement:
    (exp )? 
    ;
foreachStatement:
    (Foreach 
        |Foreach_reverse ) Lparth foreachTypeList Semicolon aggregate Rparth noScopeNonEmptyStatement 
    ;
foreachTypeList:
    foreachType (Comma foreachType )* 
    ;
foreachType:
    (Inout 
        |Ref )? ((Identifier (Comma 
                |Semicolon ) )=> Identifier 
        |basicType declarator ) 
    ;
aggregate:
    exp 
    ;
switchStatement:
    Switch Lparth exp Rparth scopeStatement 
    ;
caseStatement:
    Case expressionList Colon caseStatement_s 
    ;
caseStatement_s:
    ((statement_nocase)=>statement_nocase )* 
    ;
statement_nocase:
    Semicolon 
    |(Lcurly )=> scopeBlockStatement 
    |nonEmptyStatement_nocase 
    ;
expressionList:
    asgExp (Comma asgExp )* 
    ;
defaultStatement:
    Default Colon caseStatement_s 
    ;
continueStatement:
    Continue (Identifier )? Semicolon 
    ;
breakStatement:
    Break (Identifier )? Semicolon 
    ;
returnStatement:
    Return (exp )? Semicolon 
    ;
gotoStatement:
    (Goto Identifier )=> Goto Identifier Semicolon 
    |(Goto Default )=> Goto Default Semicolon 
    |Goto gotoCase 
    ;
gotoCase:
    (Case Semicolon )=> Case Semicolon 
    |Case exp Semicolon 
    ;
withStatement:
    With Lparth exp Rparth scopeStatement 
    ;
synchronizedStatement:
    Synchronized ((Lparth)=> Lparth syncexpr Rparth )? scopeStatement 
    ;
syncexpr:
    exp 
    ;
tryStatement:
    Try scopeStatement ((Catch )=> ((catches finallySegment )=> catches finallySegment 
            |catches ) 
        |finallySegment ) 
    ;
catches:
    (Catch Lparth )=> ((catcha Catch )=> catcha catches 
        |catcha ) 
    |lastCatch 
    ;
lastCatch:
    Catch noScopeNonEmptyStatement 
    ;
catcha:
    Catch Lparth catchParameter Rparth noScopeNonEmptyStatement 
    ;
catchParameter:
    basicType (Identifier )? 
    ;
finallySegment:
    Finally noScopeNonEmptyStatement 
    ;
throwStatement:
    Throw exp Semicolon 
    ;
scopeGuardStatement:
    Scope Lparth Identifier Rparth nonEmptyOrScopeBlockStatement 
    ;
volatileStatement:
    (Volatile Semicolon )=> Volatile Semicolon 
    |Volatile statement 
    ;
asmStatement:
    Asm Lcurly (asmInstruction Semicolon )* Rcurly 
    ;
asmInstruction:
    (~(Semicolon 
            |Rcurly 
            |Lcurly ) )* 
    ;
pragmaStatement:
    pragma_ noScopeStatement 
    ;
mixinStatement:
    Mixin Lparth asgExp Rparth Semicolon 
    ;
functionBody:
    (inStatement (outStatement )? bodyStatement 
        |outStatement (inStatement )? bodyStatement 
        |bodyStatement 
        |bodyBlockStatement ) 
    ;
inStatement:
    In blockStatement 
    ;
outStatement:
    Out (Lparth Identifier Rparth )? blockStatement 
    ;
bodyStatement:
    Body blockStatement 
    ;
bodyBlockStatement:
    blockStatement 
    ;
templateDeclaration:
    Template Identifier templateParameterList classBody 
    ;
templateParameterList:
    ((Lparth Rparth )=> Lparth Rparth 
        |Lparth templateParameter (Comma templateParameter )* Rparth ) 
    ;
templateInstance:
    Identifier templateArgumentList 
    ;
templateArgumentList:
    Not Lparth ((Rparth )=> Rparth 
        |templateArgument (Comma templateArgument )* Rparth ) 
    ;
templateArgument:
    ((type (Comma 
                |Rparth ) )=> type 
        |asgExp ) 
    ;
templateParameter:
    ((Identifier (Colon 
                |Assign 
                |Comma 
                |Rparth ) )=> templateTypeParameter 
        |(Identifier Vararg )=> templateTupleParameter 
        |templateValueParameter 
        |templateAliasParameter ) 
    ;
templateTypeParameter:
    Identifier (Colon type )? (Assign type )? 
    ;
templateValueParameter:
    basicType declarator (Colon condExp )? (Assign condExp )? 
    ;
templateAliasParameter:
    Alias Identifier (Colon type )? (Assign type )? 
    ;
templateTupleParameter:
    Identifier Vararg 
    ;
templateMixin:
    (Mixin (mixinIdentifier )+ (Identifier )? Semicolon 
        |Mixin mixinIdentifier1 (mixinIdentifier )* (Identifier )? Semicolon ) 
    ;
mixinIdentifier1:
    (mixinTypeof Dot Identifier (templateArgumentList )? 
        |Identifier (templateArgumentList )? ) 
    ;
mixinTypeof:
    Typeof Lparth exp Rparth 
    ;
mixinIdentifier:
    Dot Identifier (templateArgumentList )? 
    ;
versionStatement:
    versionCondition ccThenStatement ((Else)=> Else ccElseStatement )? 
    ;
debugStatement:
    debugCondition ccThenStatement ((Else)=> Else ccElseStatement )? 
    ;
staticIfStatement:
    staticIfCondition ccThenStatement ((Else)=> Else ccElseStatement )? 
    ;
ccThenStatement:
    noScopeNonEmptyStatement 
    ;
ccElseStatement:
    noScopeNonEmptyStatement 
    ;
versionCondition:
    Version Lparth (IntegerLiteral |Identifier ) Rparth 
    ;
debugCondition:
    Debug ((Lparth)=> Lparth (IntegerLiteral |Identifier ) Rparth )?
    ;
staticIfCondition:
    Static If Lparth asgExp Rparth 
    ;
staticAssert:
    /*Static*/ Assert Lparth asgExp (Comma asgExp )? Rparth Semicolon 
    ;