Changeset 245

Show
Ignore:
Timestamp:
08/16/06 16:00:34 (6 years ago)
Author:
pragma
Message:

Updated D Parser

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/enki/BaseParser.d

    r241 r245  
    4848     
    4949    protected String data; 
    50   protected uint pos; 
     50//    protected uint pos; 
    5151    protected ErrorData[] errors; 
    5252     
    …… 
    6161        pos = 0; 
    6262    } 
    63      
     63    /* 
    6464    protected uint position(){ 
    6565        return this.pos; 
    …… 
    6868    protected void position(uint  newPos){ 
    6969        this.pos = newPos; 
    70     } 
     70    }*/ 
     71     
     72    uint position; 
     73    alias position pos; 
    7174     
    7275    protected String sliceData(uint start,uint end){ 

  • trunk/enki/Expression.d

    r240 r245  
    739739        else{ 
    740740            return "terminal(convert!(String," ~ type ~ ")(bind_" ~ bindingName ~ ")).success"; 
    741         }           
     741        } 
    742742    } 
    743743     

  • trunk/enki/IParser.d

    r235 r245  
    4444    protected ResultString regexp(String str); 
    4545    protected ResultString terminal(String str); 
    46     protected uint position(); 
    47     protected void position(uint newPos); 
     46    //protected uint position(); 
     47    //protected void position(uint newPos); 
    4848    protected String sliceData(uint start,uint end); 
    4949    public ResultString terminal(uint ch); 

  • trunk/enki/codegen/d/CodeGenerator.d

    r244 r245  
    374374        renderProductionTestInternal(test,pass,fail); 
    375375    } 
    376      
    377     /*       
    378     assignSliceToBinding(Binding bind,positionHandle sliceFrom); // slices up to current position 
    379     assignLoopSliceToBinding(Binding bind); // slices all parts parsed by loop 
    380      
    381     renderIfTest(ProductionCall test,Statment pass,Statement fail); 
    382     render(Statement stmt); 
    383     render(Binding bind); 
    384                  
    385     regexpTest(String regexp,Binding bind,Statement pass,Statement fail); 
     376         
     377    void assignSlice(String type,String varName,PositionHandle sliceFrom,PositionHandle sliceTo=null){ 
     378        emit( 
     379    } 
     380     
     381    /* terminal expressions */ 
     382                     
     383    void regexpTest(String regexp,Binding bind,Statement pass,Statement fail){ 
     384    }    
    386385    stringTerminalTest(String value,Binding bind,Statement pass,Statement fail); 
    387386    terminalTest(String value,Binding bind,Statement pass,Statement fail); 
    388387    rangeTest(String start,String end); 
    389          
    390     render(Scope scope); // requests statement placement (or call) at a particular place in the output 
    391      
    392      
     388 
     389    /*   
    393390    unwind(positionHandle unwindTo); 
    394391 

  • trunk/enki/enki_bn.d

    r237 r245  
    22// This file is automatically maintained by the BUILD utility, 
    33// Please refrain from manually editing it. 
    4 long auto_build_number = 184; 
     4long auto_build_number = 185; 

  • trunk/enki/library/d/Parser.bnf

    r235 r245  
    2828 
    2929.parsetype(Token); 
     30.utf("32"); 
    3031 
    31 .include("./parser/Asm.bnf"); 
    32 .include("./parser/Attribute.bnf"); 
    33 .include("./parser/Class.bnf"); 
    34 .include("./parser/Conditional.bnf"); 
     32.import(enki.library.d.Token); 
     33.import(enki.library.d.ParserBackend); 
     34 
     35.baseclass(ParserBackend); 
     36.classname(Parser); 
     37 
     38.include("enki/library/d/parser/Asm.bnf"); 
     39.include("enki/library/d/parser/Attribute.bnf"); 
     40.include("enki/library/d/parser/Class.bnf"); 
     41.include("enki/library/d/parser/Conditional.bnf"); 
     42.include("enki/library/d/parser/Declaration.bnf"); 
     43.include("enki/library/d/parser/Enum.bnf"); 
     44.include("enki/library/d/parser/Expression.bnf"); 
     45.include("enki/library/d/parser/Function.bnf"); 
     46.include("enki/library/d/parser/Import.bnf"); 
     47.include("enki/library/d/parser/Interface.bnf"); 
     48.include("enki/library/d/parser/Mixin.bnf"); 
     49.include("enki/library/d/parser/Module.bnf"); 
     50.include("enki/library/d/parser/Struct.bnf"); 
     51.include("enki/library/d/parser/Statements.bnf"); 
     52.include("enki/library/d/parser/Template.bnf"); 
    3553 
    3654Syntax = Module mod ::= Module:mod; 
    …… 
    3957# where a fully qualified namespace versus a single Identifier is allowed. 
    4058 
    41 Namespace  
     59Namespace 
    4260    ::= &Tok.Identifier { &Tok.Period &Tok.Identifier }; 
    4361     
    …… 
    4866    ::= &Tok.Identifier;     
    4967     
    50 Symbol ::= ??? 
     68//TODO: define me - Symbol for SymbolTemplateArgument 
     69Symbol ::= ""; 

  • trunk/enki/library/d/ParserBackend.d

    r235 r245  
    2424 
    2525// using a token type of 'Token' 
    26 class ParserBackend : enki.BaseParser{ 
     26class ParserBackend{ 
    2727    struct ErrorData{ 
    2828        uint pos; 
    …… 
    3131     
    3232    private Token[] data; 
    33     private uint pos; 
     33    private uint position; 
     34    alias pos position; 
    3435    private ErrorData[] errors; 
    3536     
    …… 
    3738    } 
    3839     
    39     public void initalize(String input){ 
     40    public void initialize(String input){ 
    4041        data = input; 
    4142        pos = 0; 
    4243    } 
    43      
    44     protected uint position(){ 
    45         return this.pos; 
    46     } 
    47      
    48     protected void position(uint newPos){ 
    49         this.pos = newPos; 
    50     } 
    51      
     44         
    5245    protected uint nextToken(){ 
    5346        return (this.pos++); 
    …… 
    139132        ResultString(); 
    140133    } 
    141      
    142     public  
    143      
     134         
    144135    // overrides left unused: 
    145136    public ResultString terminal(uint ch){ 

  • trunk/enki/library/d/Tokenizer.bnf

    r241 r245  
    9191        SpecialToken:~tokens |  
    9292        SpecialTokenSequence:~tokens |       
     93        //Keyword:~tokens | 
    9394        Identifier:~tokens | 
    9495        CharacterLiteral:~tokens |  
    95         Keyword:~tokens | 
    9696        Operator:~tokens | 
    9797        FloatLiteral:~tokens |  

  • trunk/enki/library/d/parser/Asm.bnf

    r235 r245  
    2424+/}}} 
    2525 
     26.import(enki.library.d.Asm); 
     27.import(enki.library.d.x86.Opcode); 
     28.import(enki.library.d.x86.Register); 
     29 
     30.include("enki/library/d/parser/x86/Register.bnf"); 
     31.include("enki/library/d/parser/x86/Opcode.bnf"); 
     32 
    2633AsmInstruction 
    2734    ::= "align" IntegerExpression | 
    …… 
    3946        &Token.Identifier &Tok.Colon AsmInstruction; 
    4047 
     48IntegerExpression ::= &Token.Integer; 
     49         
    4150Operands 
    4251    ::= Operand [ &Tok.Comma Operands ]; 
    …… 
    5261 
    5362AsmLogAndExp 
    54     ::= AsmOrExp [ Tok.AndAnd AsmOrExp ]; 
     63    ::= AsmOrExp [ &Tok.AndAnd AsmOrExp ]; 
    5564 
    56 AsmOrExp: 
    57     AsmXorExp 
    58     AsmXorExp | AsmXorExp 
     65AsmOrExp 
     66    ::= AsmXorExp [ &Tok.Or AsmXorExp ]; 
    5967 
    60 AsmXorExp: 
    61     AsmAndExp 
    62     AsmAndExp ^ AsmAndExp 
     68AsmXorExp 
     69    ::= AsmAndExp [ &Tok.Inverse AsmAndExp ]; 
    6370 
    64 AsmAndExp: 
    65     AsmEqualExp 
    66     AsmEqualExp & AsmEqualExp 
     71AsmAndExp 
     72    ::= AsmEqualExp [ &Tok.And AsmEqualExp ]; 
    6773 
    68 AsmEqualExp: 
    69     AsmRelExp 
    70     AsmRelExp == AsmRelExp 
    71     AsmRelExp != AsmRelExp 
     74AsmEqualExp 
     75    ::= AsmRelExp [ (&Tok.EqualsEquals | &Tok.NotEquals) AsmRelExp ]; 
    7276 
    73 AsmRelExp: 
    74     AsmShiftExp 
    75     AsmShiftExp < AsmShiftExp 
    76     AsmShiftExp <= AsmShiftExp 
    77     AsmShiftExp > AsmShiftExp 
    78     AsmShiftExp >= AsmShiftExp 
     77AsmRelExp 
     78    ::= AsmShiftExp [ 
     79        &Tok.Less | 
     80        &Tok.LessEquals | 
     81        &Tok.Greater | 
     82        &Tok.GreaterEquals 
     83    ] AsmShiftExp; 
    7984 
    80 AsmShiftExp: 
    81     AsmAddExp 
    82     AsmAddExp << AsmAddExp 
    83     AsmAddExp >> AsmAddExp 
    84     AsmAddExp >>> AsmAddExp 
     85AsmShiftExp 
     86    ::= AsmAddExp [ 
     87        &Tok.LessLess | 
     88        &Tok.GreaterGreater | 
     89        &Tok.GreaterGreaterGreater  
     90    ] AsmAddExp; 
    8591 
    86 AsmAddExp: 
    87     AsmMulExp 
    88     AsmMulExp + AsmMulExp 
    89     AsmMulExp - AsmMulExp 
     92AsmAddExp 
     93    ::= AsmMulExp [ 
     94        &Tok.Add | 
     95        &Tok.Minus 
     96    ] AsmMulExp; 
    9097 
    91 AsmMulExp: 
    92     AsmBrExp 
    93     AsmBrExp * AsmBrExp 
    94     AsmBrExp / AsmBrExp 
    95     AsmBrExp % AsmBrExp 
     98AsmMulExp 
     99    ::= AsmBrExp [ 
     100        &Tok.Star | 
     101        &Tok.Div | 
     102        &Tok.Mod 
     103    ] AsmBrExp; 
     104     
     105AsmBrExp 
     106    ::= AsmUnaExp | 
     107    AsmBrExp &Tok.OpenBracket AsmExp &Tok.CloseBracket; 
    96108 
    97 AsmBrExp: 
    98     AsmUnaExp 
    99     AsmBrExp [ AsmExp ] 
    100  
    101 AsmUnaExp: 
    102     AsmTypePrefix AsmExp 
    103     offset AsmExp 
    104     seg AsmExp 
    105     + AsmUnaExp 
    106     - AsmUnaExp 
    107     ! AsmUnaExp 
    108     ~ AsmUnaExp 
    109     AsmPrimaryExp 
     109AsmUnaExp 
     110    ::=  
     111    AsmTypePrefix AsmExp | 
     112    "offset" AsmExp | 
     113    "seg" AsmExp | 
     114    &Tok.Plus AsmUnaExp | 
     115    &Tok.Minus AsmUnaExp | 
     116    &Tok.Not AsmUnaExp | 
     117    &Tok.Cat AsmUnaExp | 
     118    AsmPrimaryExp; 
    110119 
    111120AsmPrimaryExp 
    112     ::= IntegerConstant | 
    113         FloatConstant | 
     121    ::= &Token.Integer | 
     122        &Token.FloatingPoint | 
    114123        "__LOCAL_SIZE" | 
    115124        &Tok.Dollar | 

  • trunk/enki/library/d/parser/Attribute.bnf

    r235 r245  
    2424+/}}} 
    2525 
     26.import(enki.library.d.Attribute); 
     27 
    2628AttributeSpecifier 
    2729    = Declaration[] decls 
    …… 
    2931 
    3032Attribute 
    31     = void setAttrib(attr) 
     33    = void setAttrib(Attribute attr) 
    3234    ::= LinkageAttribute:attr | 
    3335        AlignAttribute:attr | 
    …… 
    3638 
    3739BasicAttribute 
    38     = new BasicAttribute(type) 
     40    = new BasicAttribute(uint type) 
    3941    ::= &Tok.Deprecated @BasicAttribute.Deprecated:type | 
    4042        &Tok.Private    @BasicAttribute.Private:type | 

  • trunk/enki/library/d/parser/Class.bnf

    r235 r245  
    2424+/}}} 
    2525 
     26.import(enki.library.d.Class); 
     27 
    2628ClassDeclaration 
    2729    = new Class(String name,InterfaceRef[] interfaces,Declaration[] classBody) 
    28     ::= &Tok.Class Token.Identifier:name [&Tok.Colon BaseClasslist:interfaces] ClassBody:classBody; 
     30    ::= &Tok.Class &Token.Identifier:name [&Tok.Colon InterfaceClasses:interfaces] ClassBody:classBody; 
    2931 
    30 BaseClasslist 
     32InterfaceClasses 
    3133    = InterfaceRef[] interfaces 
    32     ::= IntefaceClass:~interfaces { InterfaceClass:~interfaces }; 
     34    ::= InterfaceRef:~interfaces { InterfaceRef:~interfaces }; 
    3335 
    3436InterfaceRef 
    3537    = InterfaceRef InterfaceRef(uint type,String name) 
    36     :: = [Protection:type] Identifier:name; 
     38    ::= [Protection:type] Identifier:name; 
    3739 
    3840Protection 
    …… 
    4446         
    4547ClassBody 
    46     = Declaration[] decls; 
    47     ::= &Tok.OpenCurly @pushAttribs { ClassBodyDeclaration;decls } @popAttribs &Tok.CloseCurly; 
     48    = Declaration[] decls 
     49    ::= &Tok.OpenCurly @pushAttribs { ClassBodyDeclaration:decls } @popAttribs &Tok.CloseCurly; 
    4850 
    4951ClassBodyDeclaration 
    50     = Declaration[] decls; 
     52    = Declaration[] decls 
    5153    ::= Declaration:~decls | 
    5254        Constructor:~decls | 
    …… 
    7577    ::= &Tok.Static &Tok.Cat &Tok.This &Tok.OpenParen &Tok.CloseParen FunctionBody:functionBody; 
    7678     
    77 ClassInvariant 
    78     = new ClassInvariant(FunctionBody functionBody) 
     79Invariant 
     80    = new Invariant(FunctionBody functionBody) 
    7981    ::= &Tok.Invariant FunctionBody:functionBody; 
    8082     
    …… 
    9698        &Tok.Class [&Tok.OpenParen ArgumentList:classArgs &Tok.CloseParen] 
    9799        [SuperClass:superClass] [InterfaceClasses:interfaces] ClassBody:classBody; 
     100         
     101//TODO: allow for templated namespace references as well 
     102SuperClass 
     103    ::= NamespaceRef; 

  • trunk/enki/library/d/parser/Class.d

    r235 r245  
    5959    } 
    6060} 
    61 class ClassInvariant : Declaration{ 
     61class Invariant : Declaration{ 
    6262    public this(FunctionBody functionBody){ 
    6363    } 

  • trunk/enki/library/d/parser/Conditional.bnf

    r235 r245  
    2424+/}}} 
    2525 
     26.import(enki.library.d.Conditional); 
     27 
    2628ConditionalDeclaration 
    2729    = new ConditionalDeclaration(Condition cond,Declaration[] trueBranch,Declaration[] falseBranch)  
    …… 
    4042     
    4143VersionCondition 
    42     = new VersionCondition(VersionValue:value) 
     44    = new VersionCondition(VersionValue value) 
    4345    ::= &Tok.Version &Tok.OpenParen VersionValue:value &Tok.CloseParen; 
    4446        
    …… 
    4850     
    4951DebugCondition 
    50     = new DebugCondition(VersionValue:value) 
     52    = new DebugCondition(VersionValue value) 
    5153    ::= &Tok.Debug [ &Tok.OpenParen VersionValue:value &Tok.CloseParen ]; 
    5254     
    …… 
    6567IntegerVersionValue 
    6668    = new IntegerVersionValue(Integer value)  
    67     ::= Integer:value; 
     69    ::= &Token.Integer:value; 
    6870 
    6971     

  • trunk/enki/library/d/parser/Declaration.bnf

    r235 r245  
    2424+/}}} 
    2525 
     26.import(enki.library.d.Declaration); 
     27 
    2628##### Declaration ##### 
    2729 
    …… 
    3436    ::= MemberDecl:decl &Tok.Semi | 
    3537        MethodDecl:decl | 
    36         AutoDeclaration:decl &Tok.Semi 
    37     ); 
     38        AutoDeclaration:decl &Tok.Semi; 
    3839         
    3940MemberDecl 
    …… 
    5354    ::= Declarator:decl [ &Tok.Equals Initializer:init ]; 
    5455 
    55 DeclaratorIdentifierList: 
     56DeclaratorIdentifierList 
    5657    = DeclaratorIdentifier[] decls 
    5758    ::= DeclaratorIdentifier:~decls { &Tok.Comma DeclaratorIdentifier:~decls }; 
    …… 
    5960DeclaratorIdentifier 
    6061    = new DeclaratorIdentifier(String name,Initializer[] init) 
    61     ::= Identifier:name [ %Tok.Equals Initializer:init ]; 
     62    ::= Identifier:name [ &Tok.Equals Initializer:init ]; 
    6263 
    6364BasicType 
    64     = BasicType(type,ident) 
     65    = BasicType BasicType(type,ident) 
    6566    ::= ( 
    6667        &Tok.Bool       @BasicType.Bool:type    | 
    …… 
    8586        &Tok.CDouble    @BasicType.CDouble:type | 
    8687        &Tok.CReal      @BasicType.CReal:type   | 
    87         &Tok.Void       @BasicType.Void:type   | 
     88        &Tok.Void       @BasicType.Void:type 
    8889    ) | ( 
    8990        ([&Tok.Period] IdentifierList):ident @BasicType.User:type 
    …… 
    107108 
    108109DeclaratorSuffix 
    109     ::= &tok.OpenBracket [ Expression | Type ] &tok.CloseBracket [Parameters] 
     110    ::= &tok.OpenBracket [ Expression | Type ] &tok.CloseBracket [Parameters]; 
    110111 
    111112IdentifierList 
    …… 
    115116        TemplateInstance &tok.Period IdentifierList; 
    116117 
    117 Typeof: 
    118         &Tok.Typeof ( Expression ) 
     118Typeof  
     119    ::= &Tok.Typeof ( Expression ); 
    119120 
    120121#NOTE: StorageClass is merged with StorageClasses from the original spec for efficency 

  • trunk/enki/library/d/parser/Enum.bnf

    r235 r245  
    2424+/}}} 
    2525 
     26.import(enki.library.d.Enum); 
     27 
    2628EnumDeclaration 
    2729    = new EnumDeclaration(String name,Type baseType,EnumMember[] members) 
    2830    ::= &Tok.Enum (  
    29             [Identifier:name] [ &Tok.Colon Type:baseType ] EnumBody:members; 
     31            [Identifier:name] [ &Tok.Colon Type:baseType ] EnumBody:members 
    3032        ); 
    3133 
    …… 
    3941 
    4042EnumMember 
    41     = EnumMember(String name,AssignExpression expr) 
     43    = EnumMember EnumMember(String name,AssignExpression expr) 
    4244    ::= Identifier [ &Tok.Equals AssignExpression ]; 

  • trunk/enki/library/d/parser/Expression.bnf

    r235 r245  
    2323    OTHER DEALINGS IN THE SOFTWARE. 
    2424+/}}} 
     25 
     26.import(enki.library.d.Expression); 
    2527 
    2628Expression 
    …… 
    108110        ]; 
    109111 
    110 AddExpression: 
     112AddExpression 
    111113    ::= MulExpression | 
    112114        AddExpression [ 
    …… 
    117119        ];   
    118120 
    119 MulExpression: 
     121MulExpression 
    120122    ::= UnaryExpression | 
    121123        MulExpression [ 
    …… 
    126128        ];       
    127129 
    128 UnaryExpression: 
     130UnaryExpression 
    129131    ::= PostfixExpression | 
    130132        (   &Tok.And | 
    …… 
    171173        &Tok.True | 
    172174        &Tok.False | 
    173         NumericLiteral | 
    174         CharacterLiteral | 
    175         StringLiterals | 
     175        &Token.Integer | 
     176        &Token.FloatingPoint |       
     177        &Token.CharLiteral | 
     178        &Token.StringLiteral | 
    176179        FunctionLiteral | 
    177180        AssertExpression | 
    …… 
    190193StringLiteral 
    191194    = new StringLiteral(Token tok) 
    192     ::= &Token.StringLiteral:tok 
     195    ::= &Token.StringLiteral:tok; 
    193196 
    194197AssertExpression 
    …… 
    216219NewInlineAnonClassExpression 
    217220    = new NewInlineAnonClassExpression(Expression[] newArgs,Expression[] classArgs,InterfaceRef[] interfaces,Declaration[] decls) 
    218     ::= NewArguments:newArgs ClassArguments:classArgs [BaseClasslist:interfaces] &Tok.OpenCurly DeclDefs:decls &Tok.CloseCurly; 
     221    ::= NewArguments:newArgs ClassArguments:classArgs [InterfaceClasses:interfaces] &Tok.OpenCurly DeclDefs:decls &Tok.CloseCurly; 
    219222 
    220223NewArguments 
    …… 
    225228    = Expression[] expressions 
    226229    ::= &Tok.Class [ &TokOpenParen [ ArgumentList:~expressions ] &TokCloseParen ]; 
     230 
     231//TODO: finish the following 
     232FunctionLiteral 
     233    ::= 
     234    &Tok.Function [Type] [ &Tok.OpenParen ArgumentList &Tok.CloseParen ] FunctionBody | 
     235    &Tok.Delegate [Type] [ &Tok.OpenParen ArgumentList &Tok.CloseParen ] FunctionBody | 
     236    [ &Tok.OpenParen ArgumentList &Tok.CloseParen ] FunctionBody | 
     237    FunctionBody; 
     238 
     239     
     240AssertExpression 
     241    ::= &Tok.Assert &Tok.OpenParen Expression [ &Tok.Comma Expression ] &Tok.CloseParen; 
     242     
     243TypeidExpression 
     244    ::= &Tok.Typeid  &Tok.OpenParen Type &Tok.CloseParen; 
     245 
     246IsExpression 
     247    ::= &Tok.Is &TokOpenParen Type [Identifier] [ 
     248        &Tok.Colon TypeSpecialization | 
     249        &Tok.EqualsEquals TypeSpecialization 
     250    ] &Tok.CloseParen; 
     251 
     252TypeSpecialization 
     253    ::= Type | 
     254        &Tok.Typedef | 
     255        &Tok.Struct | 
     256        &Tok.Union | 
     257        &Tok.Class | 
     258        &Tok.Interface | 
     259        &Tok.Enum |  
     260        &Tok.Function | 
     261        &Tok.Delegate; 

  • trunk/enki/library/d/parser/Function.bnf

    r235 r245  
    2424+/}}} 
    2525 
     26.import(enki.library.d.Function); 
     27 
    2628FunctionBody 
    2729    = FunctionBody FunctionBody(Statement[] bodyBlock,Statement[] inBlock,OutStatement outBlock) 

  • trunk/enki/library/d/parser/Import.bnf

    r235 r245  
    2323    OTHER DEALINGS IN THE SOFTWARE. 
    2424+/}}} 
     25 
     26.import(enki.library.d.Import); 
    2527 
    2628##### Import ##### 
    …… 
    5355     
    5456# shim to help stay compliant 
    55 .alias(ModuleAliasIdentifier,ModuleName); 
     57.alias(ModuleName,ModuleAliasIdentifier); 

  • trunk/enki/library/d/parser/Interface.bnf

    r235 r245  
    2424+/}}} 
    2525 
    26 InterfaceDeclaration: 
     26.import(enki.library.d.Interface); 
     27 
     28InterfaceDeclaration 
    2729    = new InterfaceDeclaration(String[] interfaces,Declaration[] decls) 
    2830    ::= &Tok.Interface Identifier [ &Tok.Colon SuperInterfaces ] InterfaceBody:decls; 

  • trunk/enki/library/d/parser/Mixin.bnf

    r235 r245  
    2424+/}}} 
    2525 
     26.import(enki.library.d.Mixin); 
     27 
    2628TemplateMixin 
    2729    = new TemplateMixin(String name,TemplateArgument[] args,String scopeName) 
    …… 
    3234        &Tok.Semi; 
    3335 
    34 .alias(MixinIdentifier,Identifier); 
     36.alias(Identifier,MixinIdentifier); 

  • trunk/enki/library/d/parser/Module.bnf

    r235 r245  
    2424+/}}} 
    2525 
     26.import(enki.library.d.Module); 
     27 
    2628##### Module ##### 
    2729     
    2830ModuleDeclaration 
    29     = String name; 
     31    = String name 
    3032    ::= &Tok.Module ModuleName:name; 
    3133 
    …… 
    5355        Constructor:~decls | 
    5456        Destructor:~decls | 
    55       Invariant:~decls | 
     57          Invariant:~decls | 
    5658        UnitTest:~decls | 
    5759        StaticConstructor:~decls | 

  • trunk/enki/library/d/parser/Statement.d

    r235 r245  
    2727} 
    2828 
    29 class LabelledStatement{ 
     29class LabeledStatement{ 
    3030    public this(String name,Statement stmt){ 
    3131    } 
    …… 
    3838 
    3939 
    40 class DeclarationStatment{ 
     40class DeclarationStatement{ 
    4141    public this(Variable[] vars){ 
    4242    } 
    …… 
    4545 
    4646class Variable{ 
    47     public this(Type type,String name,Initalizer init){ 
     47    public this(Type type,String name,Initializer init){ 
    4848    } 
    4949} 
    …… 
    158158} 
    159159 
    160 class WithExpressionStatment{ 
     160class WithExpressionStatement{ 
    161161    public this(Expression expr){ 
    162162    } 
    …… 
    218218} 
    219219 
    220 class VolatileStatement{ 
     220class VolatileStatement : Statement{ 
    221221    public this(Statement stmt){ 
    222222    } 
    223223} 
    224224 
    225 class AsmStatement{ 
     225class AsmStatement : Statement{ 
    226226    public this(AsmInstruction[] instructions){ 
    227227    } 
    228228} 
     229 
     230class PragmaStatement : Statement{ 
     231    public this(Pragma prag,Statement stmt){ 
     232    } 
     233} 

  • trunk/enki/library/d/parser/Statements.bnf

    r235 r245  
    2424+/}}} 
    2525 
     26.import(enki.library.d.Statements); 
     27 
    2628Statement 
    2729    = Statement stmt 
    …… 
    3133        DeclarationStatement:stmt | 
    3234        IfStatement:stmt | 
    33         DebugStatement:stmt | 
    34         VersionStatement:stmt | 
     35        ConditionalStatement:stmt | 
    3536        WhileStatement:stmt | 
    36         DoWhileStatement:stmt | 
     37        DoStatement:stmt | 
    3738        ForStatement:stmt | 
    3839        ForeachStatement:stmt | 
    …… 
    5354        PragmaStatement:stmt; 
    5455  
    55 LabelledStatement 
    56     = new LabelledStatement(String name,Statement stmt) 
     56LabeledStatement 
     57    = new LabeledStatement(String name,Statement stmt) 
    5758    ::= Identifier:name &Tok.Colon Statement:stmt; 
    5859     
    …… 
    6667     
    6768DeclarationStatement 
    68     ::= new DeclarationStatment(Variable[] vars) 
     69    = new DeclarationStatement(Variable[] vars) 
    6970    ::= Type:type IdentifierList!(type):vars &Tok.Semi; 
    7071 
    …… 
    7475 
    7576Variable(Type type) 
    76     = new Variable(Type type,String name,Initalizer init) 
    77     ::= Identifier:name [ &Tok.Equals Initalizer:init ]; 
     77    = new Variable(Type type,String name,Initializer init) 
     78    ::= Identifier:name [ &Tok.Equals Initializer:init ]; 
    7879 
    7980IfStatement 
    …… 
    114115        [ Expression:startExpr | Declaration:startDecl ] &Tok.Semi 
    115116        [ Expression:test ] &Tok.Semi 
    116         [ Expression:increment [ &Tok.Semi 
     117        [ Expression:increment ] 
    117118        &Tok.CloseParen Statement:stmt; 
    118119     
    119120ForeachStatement 
    120121    = new ForeachStatement(ForeachType[] types,Expression expr,Statement stmt) 
    121     ::= &Tok.Foreach &Tok.OpenParen ForeachTypeList:types &Tok.Semi Expression;expr &Tok.CloseParen Statement:stmt; 
     122    ::= &Tok.Foreach &Tok.OpenParen ForeachTypeList:types &Tok.Semi Expression:expr &Tok.CloseParen Statement:stmt; 
    122123 
    123124ForeachTypeList  
    …… 
    183184    ); 
    184185     
    185 WithExpressionStatment 
    186     = new WithExpressionStatment(Expression expr) 
     186WithExpressionStatement 
     187    = new WithExpressionStatement(Expression expr) 
    187188    ::= &Tok.OpenParen Expression:expr &Tok.CloseParen BlockStatement; 
    188189     
    …… 
    196197     
    197198SynchronizeStatement 
    198     = new SynchronizeStatement(Statment stmt,Expression expr) 
     199    = new SynchronizeStatement(Statement stmt,Expression expr) 
    199200    ::= &Tok.Synchronized (  
    200201            Statement:stmt |  
    201             &Tok.OpenParen Expression:expr &Tok.CloseParen Statment:stmt 
     202            &Tok.OpenParen Expression:expr &Tok.CloseParen Statement:stmt 
    202203        ); 
    203204     
    204205TryStatement 
    205     = new TryStatement(BlockStatment stmt,Catch[] catches,FinallyStatement fin) 
     206    = new TryStatement(BlockStatement stmt,Catch[] catches,FinallyStatement fin) 
    206207    ::= &Tok.Try BlockStatement:stmt (FinallyStatement:fin | Catches:catches [FinallyStatement:fin]); 
    207208 
    …… 
    217218 
    218219Catch 
    219     = new Catch(Declarator decl,BlockStatment stmt) 
    220     &Tok.Catch &Tok.OpenParen Declarator:decl &Tok.CloseParen BlockStatement:stmt; 
     220    = new Catch(Declarator decl,BlockStatement stmt) 
     221    ::= &Tok.Catch &Tok.OpenParen Declarator:decl &Tok.CloseParen BlockStatement:stmt; 
    221222         
    222223FinallyStatement 
    …… 
    240241    = new VolatileStatement(Statement stmt) 
    241242    ::= &Tok.Volatile Statement:stmt; 
    242  
    243243     
    244244AsmStatement 
    …… 
    246246    ::= &Tok.Asm [ &Tok.OpenCurly { AsmInstruction:~instructions } &Tok.CloseCurly ]; 
    247247 
     248PragmaStatement 
     249    = new PragmaStatement(Pragma prag,Statement stmt) 
     250    ::= Pragma:prag [ Statement:stmt ]; 

  • trunk/enki/library/d/parser/Struct.bnf

    r236 r245  
    4444StructBody 
    4545    = Declaration[] decls 
    46     &Tok.OpenCurly { StructBodyDeclaration:~decls } &Tok.CloseCurly; 
     46    ::= &Tok.OpenCurly { StructBodyDeclaration:~decls } &Tok.CloseCurly; 
    4747 
    4848StructBodyDeclaration 
    49     = Declaration: decl 
     49    = Declaration decl 
    5050    ::= Declaration:decl | 
    5151        Invariant:decl | 

  • trunk/enki/library/d/parser/Template.bnf

    r235 r245  
    2424+/}}} 
    2525 
     26.import(enki.library.d.Template); 
     27 
    2628TemplateDeclaration 
    2729    = new TemplateDeclaration(String name,TemplateParameter[] params,Declaration[] decls) 
    …… 
    4042TemplateParameter 
    4143    = TemplateParameter param 
    42     ::= TypeParameter:param | 
    43         ValueParameter:param | 
    44         AliasParameter:param; 
     44    ::= TemplateTypeParameter:param | 
     45        TemplateValueParameter:param | 
     46        TemplateAliasParameter:param; 
    4547 
    4648TemplateTypeParameter 
    …… 
    6264TemplateValueParameterSpecialization 
    6365    = Expression expr 
    64     ::= ConditionalExpression:expr 
     66    ::= ConditionalExpression:expr; 
    6567 
    6668TemplateValueParameterDefault 
    6769    = Expression expr 
    68     ::= ConditionalExpression:expr 
     70    ::= ConditionalExpression:expr; 
    6971 
    7072TemplateAliasParameter 
    …… 
    8183 
    8284TemplateInstance 
    83     = new TemplateInstance(String name,TemplateArgument[] args); 
    84     ::= TemplateIdentifer &Tok.Not &Tok.OpenParen TemplateArgumentList &Tok.CloseParen; 
     85    = new TemplateInstance(String name,TemplateArgument[] args) 
     86    ::= TemplateIdentifier &Tok.Not &Tok.OpenParen TemplateArgumentList &Tok.CloseParen; 
    8587 
    8688TemplateArgumentList 
    …… 
    108110ClassTemplateDeclaration 
    109111    = new ClassTemplateDeclaration(TemplateParameter[] params,String name,InterfaceRef[] interfaces,Declaration[] classBody) 
    110     ::= &Tok.Class Token.Identifier:name  
     112    ::= &Tok.Class &Token.Identifier:name  
    111113        &Tok.OpenParen TemplateParameterList:params &Tok.CloseParen  
    112         [&Tok.Colon BaseClasslist:interfaces] ClassBody:classBody; 
     114        [&Tok.Colon InterfaceClasses:interfaces] ClassBody:classBody; 
    113115 
    114116FunctionTemplateDeclaration 
    …… 
    116118    ::= Type Identifier &Tok.OpenParen TemplateParameterList &Tok.CloseParen  
    117119        &Tok.OpenParen FunctionParameterList &Tok.CloseParen FunctionBody; 
     120     
     121//TODO: fix me!  
     122FunctionParameterList 
     123    ::= "";