Changeset 3147


Ignore:
Timestamp:
May 15, 2013, 6:16:57 PM (6 years ago)
Author:
shermer
Message:

fixed child replacement bug in ExpandAugmentedAssignments?.
exploratory improvements to pabloS grammar.

Location:
proto/pabloj/branches/refactor-experimental
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • proto/pabloj/branches/refactor-experimental/input/grammar/scatter/pabloS.scatter

    r3141 r3147  
    3535  // t o k e n s
    3636  tokens {
    37  
    38 //      TYPEDEF,
    39         VAR,
     37//      VAR,
    4038        FUNCTION,       
    4139        STREAM,
     
    5553        NOT   "~",
    5654        XOR   "^",
     55        MULTIPLY        "*",
     56        DIVIDE          "/",
     57        ADD                     "+",
     58        SUBTRACT        "-",
    5759        ASSIGN      "=",
    5860        AND_ASSIGN  "&=",
    5961        OR_ASSIGN   "|=",
    6062        XOR_ASSIGN  "^=",
     63        MULTIPLY_ASSIGN         "*=",
     64        DIVIDE_ASSIGN           "/=",
     65        ADD_ASSIGN                      "+=",
     66        SUBTRACT_ASSIGN         "-=",
    6167        LANGLE          "<",
    6268        RANGLE          ">",
     
    7076        TERMINATOR  ";",
    7177        DOT                     ".",
    72 //      MINUS           "-",
    7378  }
    7479}
     
    8085
    8186nodes {
    82   ASTNode {Type type = null;} [],
     87  ASTNode {Type type = null;} [assignOperator],
    8388  binaryOperator {} [expr expr1],       //, expr4],
    8489  unaryOperator {} [expr2],                     // expr5],
     
    8691  funcCall {} [funcCallRest],
    8792  // streamCall {} [streamCallRest],
    88   integerConstant{intValued;} [],
     93  integerConstant{intValued;} [fieldWidthSpec],
    8994  primitiveType{} [intType voidType],
    9095  streamType{int fieldWidth = 1;} [],
     
    9297
    9398grammar {
    94         program         -> (typeDecl | funcDef) *; // | typeDef // not implemented
     99        program         -> (structDecl | funcDef) *;                   
    95100
    96101        //
     
    98103        //
    99104       
    100         // typeDecl             
    101 
    102         typeDecl                ->  type TERMINATOR ;
    103                
    104         // typeDef                      ->  TYPEDEF type identifier TERMINATOR ; // not implemented
    105        
    106         // DeclList             ->  identifier (COMMA identifier)* ; 
    107        
     105        // structDecl           
     106
     107        structDecl                      ->  STRUCT structName structTypeBody ;
     108                                               
     109        structTypeBody          ->      LCURLY (structMember TERMINATOR)+ RCURLY ;
     110                                       
     111        structMember            ->      structMemberType structMemberName ;
     112       
     113        structMemberType        #-> structType | streamType ;
     114       
     115        structMemberName        #-> identifier ;
    108116   
    109117    //
     
    129137        // s t a t e m e n t s
    130138        //
    131         stmt                                    #-> (funcCallOrAssignStmt | ifStmt | whileStmt | returnStmt | localVarDecl) (TERMINATOR)? ;
    132                                
    133         funcCallOrAssignStmt    # -> expr (assignRest _promote_)? TERMINATOR ;
    134        
    135         funcCallRest                    -> LROUND^ funcCallArgList RROUND ;
    136 
    137         funcCallArgList                 -> (expr (COMMA expr)*) ? ;     
    138                
    139         // streamCallRest                       -> LANGLE^ fieldWidth RANGLE LROUND idisaCallArgList RROUND;
    140 
    141         // streamCallArgList            -> (expr (COMMA expr)*)? ;             
    142                
    143         assignOperator                  -> ASSIGN | AND_ASSIGN | OR_ASSIGN | XOR_ASSIGN ;                               
    144                                        
    145         assignRest                              -> assignOperator^! expr ;                             
    146                                        
    147         ifStmt                                  -> IF LROUND expr RROUND blockStmt (ELSE blockStmt)? ;                 
    148                                                        
     139        stmt                                    #->     funcCallOrAssignStmt | ifStmt | whileStmt | returnStmt | localVarDecl ;
     140               
     141        funcCallOrAssignStmt    #-> expr (assignRest _promote_)? TERMINATOR ;
     142       
     143        assignRest                              -> assignOperator^! expr ;
     144        assignOperator                  -> ASSIGN | AND_ASSIGN | OR_ASSIGN | XOR_ASSIGN |
     145                                                           MULTIPLY_ASSIGN | DIVIDE_ASSIGN | ADD_ASSIGN | SUBTRACT_ASSIGN ;             
     146                                       
     147        ifStmt                                  -> IF LROUND expr RROUND blockStmt (ELSE blockStmt)? ;                                         
    149148        whileStmt                               -> WHILE LROUND expr RROUND blockStmt ;
     149        returnStmt                              -> RETURN (expr)? TERMINATOR;
     150        blockStmt                               -> LCURLY stmt* RCURLY ;
    150151                       
    151         returnStmt                              -> RETURN (expr)? TERMINATOR;
    152                        
    153         localVarDecl                    -> VAR type varName (localVarAssignOperator^! expr) ?;
    154        
    155         localVarAssignOperator  -> ASSIGN ;
    156                
    157         varName                                 #-> identifier; // compoundIdentifier ?
    158 
    159         blockStmt                               -> LCURLY stmt* RCURLY ;
     152        localVarDecl                    -> type varName (ASSIGN^ expr) ?;
     153               
     154        varName                                 #-> identifier;                         // compoundIdentifier ?
     155
    160156       
    161157        //
    162158        // e x p r e s s i o n s
    163159        //     
    164         expr            #->     expr1 ((OR^|XOR^) expr)?  _leftAssoc_ ;
    165                                        
    166         expr1           #-> expr2 ((AND^) expr1)?  _leftAssoc_ ;
    167                                        
    168         expr2           #-> NOT^^? expr3;
    169        
    170         expr3           #-> LROUND expr RROUND
     160        expr    #->     expr1 ((OR^|XOR^) expr)?  _leftAssoc_ ;
     161                                       
     162        expr1   #-> expr2 ((AND^) expr1)?  _leftAssoc_ ;
     163                                       
     164        expr2   #-> NOT^^? expr3;
     165       
     166        expr3   #-> expr4 ((MULTIPLY^ | DIVIDE^) expr3)? _leftAssoc_ ;
     167        expr4   #-> expr4 ((ADD^ | SUBTRACT^) expr3)? _leftAssoc_ ;
     168       
     169        expr3   #-> LROUND expr RROUND
    171170                                        | stringConstant
    172171                                        | integerConstant
     
    193192                                                       
    194193        identifier                              -> IDENTIFIER ;
    195      
     194   
     195    funcCallRest                        -> LROUND^ funcCallArgList RROUND ;
     196
     197        funcCallArgList                 -> (expr (COMMA expr)*) ? ;     
     198               
     199        // streamCallRest                       -> LANGLE^ fieldWidth RANGLE LROUND idisaCallArgList RROUND;
     200
     201        // streamCallArgList            -> (expr (COMMA expr)*)? ;             
    196202     
    197203           
     
    200206        //
    201207
    202         type                    #->     typeName                |
    203                                                         primitiveType   |
     208        type                    #->     primitiveType   |
    204209                                                        streamType              |
    205210                                                        structType              ;                       // | tupleType;
    206                                                        
    207         typeName                #->  identifier ;
    208211       
    209212       
     
    212215        primitiveType   #-> ( intType | voidType ) ;
    213216       
    214         intType                  -> INT    { @type = {{PrimitiveType.INT}};  } ;
     217        intType                  -> INT    { @type = {{PrimitiveType.INTEGER}};  } ;
    215218        voidType                 -> VOID   { @type = {{PrimitiveType.VOID}}; } ;
    216219       
     
    218221        // s t r e a m
    219222       
    220         streamType              ->      STREAM fieldWidthSpec!  {  @fieldWidth = @:value;
    221                                                                                            @type = {{ new StreamType(%?) }} , @fieldWidth ;
    222                                                                                         } ;
    223                                        
    224         fieldWidthSpec  #->  LANGLE integerConstant RANGLE ;   
    225                                        
    226        
    227        
     223        streamType              ->      STREAM fieldWidthSpec!  {       @fieldWidth = @:value;
     224                                                                                                        @type = {{ new StreamType(%?) }} , @fieldWidth ;
     225                                                                                       } ;
     226                                       
     227        fieldWidthSpec  #->  (LANGLE integerConstant RANGLE ) |
     228                                                 (epsilon {@value = 1;}) ;     
     229                                       
    228230       
    229231        // c o m p o u n d   t y p e s
     
    231233        // s t r u c t 
    232234               
    233         structType                              ->      STRUCT structName (structTypeBody)? ;           
     235        structType                              ->      STRUCT structName ;             
    234236                                       
    235237        structName                              #->  identifier ;                               
    236                                        
    237         structTypeBody                  ->      LCURLY structMember TERMINATOR (structMember TERMINATOR)* RCURLY;
    238                                        
    239         structMember                    ->      type structMemberName ; // (structMemberAssignOperator^! expr) ?; // TODO
    240        
    241         structMemberName                #-> identifier ;
     238
    242239       
    243240       
  • proto/pabloj/branches/refactor-experimental/src/toolchain/pabloS/lang/type/PrimitiveType.java

    r3137 r3147  
    1111
    1212        VOID,
    13         INTEGERCONSTANT,
     13        INTEGER,
    1414        STRINGCONSTANT,
    1515        STREAM1,
  • proto/pabloj/branches/refactor-experimental/src/toolchain/pabloS/semanticAnalyzer/visitors/ExpandAugmentedAssignments.java

    r3115 r3147  
    4646                        if(isAugmentedAssignment(token)) {
    4747                                LextantToken binaryOperatorToken = includedOperatorToken(token);
    48                                 BinaryOperatorNode binaryOperatorNode = Generators.makeBinaryOperatorNode(lhs.deepCopy(), rhs, binaryOperatorToken);
     48                                BinaryOperatorNode binaryOperatorNode = Generators.makeBinaryOperatorNode(lhs.deepCopy(), rhs.deepCopy(), binaryOperatorToken);
    4949                               
    5050                                changeTokenToAssign(node);                                     
Note: See TracChangeset for help on using the changeset viewer.