Changeset 2660


Ignore:
Timestamp:
Nov 19, 2012, 8:11:01 PM (6 years ago)
Author:
ksherdy
Message:

Shortened variable names for sanity.

Location:
proto/pablo
Files:
6 added
3 deleted
20 edited
2 moved

Legend:

Unmodified
Added
Removed
  • proto/pablo/input/grammar/scatter/pablo.scatter

    r2658 r2660  
    5858interfaces {
    5959//       escapable {boolean escaped = false;},
    60         intValued {int value = 0;},
     60         intValued {int value = 0;},
    6161}
    6262
    6363nodes {
    64   binaryOperator {} [expression, expression1],//, expression4],
    65   unaryOperator {} [expression2],// expression5],
    66   assignment {} [assignmentRest],
     64  binaryOperator {} [expr, expr1],//, expr4],
     65  unaryOperator {} [expr2],// expr5],
     66  Assign {} [AssignRest],
    6767  FuncCall {} [FuncCallRest],
    6868  integerConstant{intValued;} [],
     
    7070
    7171grammar {
    72         program         -> (declarations | FuncDef) *;
     72        program         -> (Decls | FuncDef) *;
    7373
    7474        //
     
    7979        // d e c l a r a t i o n s
    8080        //
    81         declarations                    -> (typeDecl | typeDef) TERMINATOR ;
    82 
    83         typeDecl                                ->  type declaratorList?;
     81        Decls                   -> (typeDecl | typeDef) TERMINATOR ;
     82
     83        typeDecl                ->  type DeclList?;
    8484               
    85         typeDef                                 ->  TYPEDEF type identifier ;
    86        
    87         declaratorList                  ->  identifier (COMMA identifier)* ; // TODO - support or support via 'source' Func definitions
     85        typeDef                 ->  TYPEDEF type identifier ;
     86       
     87        DeclList                ->  identifier (COMMA identifier)* ; // TODO - support or support via 'source' Func definitions
    8888       
    8989   
     
    9191        // f u n c t i o n   d e f i n i t i o n s                                                             
    9292        //
    93         FuncDef         -> FUNCTION type FuncName LROUND parameterList? RROUND blockStmt TERMINATOR?;                           
     93        FuncDef                 -> FUNCTION type FuncName LROUND parameterList? RROUND blockStmt TERMINATOR?;                           
    9494                                                                               
    9595        returnType              #-> type ;      // Note: Strictly not required.
     
    9797        parameterList   -> parameter (COMMA parameter)*;
    9898                                                                                                               
    99         FuncName        #-> identifier ;
     99        FuncName                #-> identifier ;
    100100                                                                                                                       
    101101        parameter               -> type parameterName ;
     
    110110        // s t a t e m e n t s
    111111        //
    112         Stmt                                                    #-> (FuncCallOrAssignmentStmt | ifStmt | whileStmt | returnStmt | localVarDecl) (TERMINATOR)? ;
     112        Stmt                                    #-> (FuncCallOrAssignStmt | ifStmt | whileStmt | returnStmt | localVarDecl) (TERMINATOR)? ;
    113113                       
    114         FuncCallOrAssignmentStmt        -> compoundVariable ((FuncCallRest _promote_) | (assignmentRest _promote_)) TERMINATOR ;
    115        
    116         FuncCallRest                            -> LROUND^ FuncCallArgList RROUND ;
    117 
    118         FuncCallArgList                         -> (expression (COMMA expression)*)? ; 
    119                
    120         assignmentOperator                              -> ASSIGN | AND_ASSIGN | OR_ASSIGN | XOR_ASSIGN ;                               
    121                                        
    122         assignmentRest                                  -> assignmentOperator^! expression ;                           
    123                                        
    124         ifStmt                                                  -> IF LROUND expression RROUND blockStmt (ELSE blockStmt)? ;                   
     114        FuncCallOrAssignStmt    -> compoundIdentifier ((FuncCallRest _promote_) | (AssignRest _promote_)) TERMINATOR ;
     115       
     116        FuncCallRest                    -> LROUND^ FuncCallArgList RROUND ;
     117
     118        FuncCallArgList                 -> (expr (COMMA expr)*)? ;     
     119               
     120        AssignOperator                  -> ASSIGN | AND_ASSIGN | OR_ASSIGN | XOR_ASSIGN ;                               
     121                                       
     122        AssignRest                              -> AssignOperator^! expr ;                             
     123                                       
     124        ifStmt                                  -> IF LROUND expr RROUND blockStmt (ELSE blockStmt)? ;                 
    125125                                                       
    126         whileStmt                                               -> WHILE LROUND expression RROUND blockStmt ;
     126        whileStmt                               -> WHILE LROUND expr RROUND blockStmt ;
    127127                       
    128         returnStmt                                              -> RETURN (expression)? TERMINATOR;
     128        returnStmt                              -> RETURN (expr)? TERMINATOR;
    129129                       
    130         localVarDecl                                    -> VAR type variableName (assignmentOperator^! expression) ?;
    131                
    132         variableName                                    #-> identifier;
    133 
    134         blockStmt                                               -> LCURLY Stmt* RCURLY ;
     130        localVarDecl                    -> VAR type VarName (AssignOperator^! expr) ?;
     131               
     132        VarName                                 #-> identifier;
     133
     134        blockStmt                               -> LCURLY Stmt* RCURLY ;
    135135       
    136136        //
    137137        // e x p r e s s i o n s
    138138        //     
    139         expression              #->     expression1 ((OR^|XOR^) expression)? ;
    140                                        
    141         expression1             #-> expression2 ((AND^) expression1)? ;
    142                                        
    143         expression2             #-> NOT^^? expression3  _leftAssoc_;
    144        
    145         expression3             #-> LROUND expression RROUND
     139        expr            #->     expr1 ((OR^|XOR^) expr)? ;
     140                                       
     141        expr1           #-> expr2 ((AND^) expr1)? ;
     142                                       
     143        expr2           #-> NOT^^? expr3  _leftAssoc_;
     144       
     145        expr3           #-> LROUND expr RROUND
    146146                                        | constant
    147                                         | compoundVariable (FuncCallRest _promote_)?
     147                                        | compoundIdentifier (FuncCallRest _promote_)?
    148148                                        ;
    149149
    150150                                        //(
    151151                                        //(FuncCallRest _promote_)?
    152                                         //| (expression4 _promote_)?
    153                                         //| (expression5 _promote_)?
     152                                        //| (expr4 _promote_)?
     153                                        //| (expr5 _promote_)?
    154154                                        //)?
    155155                                        // ;
    156                                         //expression4            -> DOT expression3 ;
    157                                         //expression5    -> (LSQUARE INTEGER_CONST^ RSQUARE) (expression5Rest)?   ;     
    158                                         //expression5Rest        -> DOT expression3 ;                                                                                           
     156                                        //expr4          -> DOT expr3 ;
     157                                        //expr5          -> (LSQUARE INTEGER_CONST^ RSQUARE) (expr5Rest)?   ;   
     158                                        //expr5Rest      -> DOT expr3 ;                                                                                         
    159159                                                                                                                                                                                                                                                                       
    160160        constant                                #-> stringConstant | signedIntegerConstant ;
     
    167167        stringConstant                  -> STRING | SQ_STRING ;
    168168       
    169         compoundVariable                #-> identifier (DOT^ identifier)*;
     169        compoundIdentifier              #-> identifier (DOT^ identifier)*;
    170170                                                       
    171171        identifier                              -> IDENTIFIER ;
  • proto/pablo/src/ast/ASTNode.java

    r2658 r2660  
    125125        }
    126126    }
    127     public void insertAfterChild(ASTNode node, ASTNode successor) {
    128             int index = children.indexOf(node);
    129             insertChildAfter(index, successor);
    130             successor.setParent(this);
    131     }
    132     private void insertChildAfter(int index, ASTNode successor) {
    133             if(index == children.size()-1) {
    134                     children.add(successor);
    135             } else {
    136                     children.add(index+1, successor);
    137             }       
    138     }   
     127       
    139128       
    140129////////////////////////////////////////////////////////////////////////////////////
     
    151140                return result;
    152141        }
     142    public void insertAfterChild(ASTNode node, ASTNode successor) {
     143        int index = children.indexOf(node);
     144        insertChildAfter(index, successor);
     145        successor.setParent(this);
     146        }
     147       
     148        private void insertChildAfter(int index, ASTNode successor) {
     149                if(index == children.size()-1) {
     150                        children.add(successor);
     151                } else {
     152                        children.add(index+1, successor);
     153                }       
     154        }               
    153155       
    154156       
  • proto/pablo/src/ast/ASTTransformer.java

    r2658 r2660  
    1212        ASTNode visit(ASTNode node);
    1313       
    14         public ASTNode visit(AssignmentNode node);
    15 
    16         public ASTNode visit(AssignmentOperatorNode node);
     14        public ASTNode visit(AssignNode node);
     15
     16        public ASTNode visit(AssignOperatorNode node);
    1717
    1818        public ASTNode visit(BinaryOperatorNode node);
     
    2020        public ASTNode visit(BlockStmtNode node);
    2121
    22         public ASTNode visit(CompoundVariableNode node);
    23 
    24         public ASTNode visit(DeclarationsNode node);
    25 
    26         public ASTNode visit(DeclaratorListNode node);
     22        public ASTNode visit(CompoundIdentifierNode node);
     23
     24        public ASTNode visit(DeclListNode node);
     25
     26        public ASTNode visit(DeclsNode node);
    2727
    2828        public ASTNode visit(EpsilonNode node);
     
    3636        public ASTNode visit(FuncCallNode node);
    3737
    38         public ASTNode visit(FuncCallOrAssignmentStmtNode node);
     38        public ASTNode visit(FuncCallOrAssignStmtNode node);
    3939
    4040        public ASTNode visit(FuncDefNode node);
     
    8787                }
    8888       
    89                 public ASTNode visit(AssignmentNode node) {
    90                         return defaultVisit(node);
    91                 }
    92 
    93                 public ASTNode visit(AssignmentOperatorNode node) {
     89                public ASTNode visit(AssignNode node) {
     90                        return defaultVisit(node);
     91                }
     92
     93                public ASTNode visit(AssignOperatorNode node) {
    9494                        return defaultVisit(node);
    9595                }
     
    103103                }
    104104
    105                 public ASTNode visit(CompoundVariableNode node) {
    106                         return defaultVisit(node);
    107                 }
    108 
    109                 public ASTNode visit(DeclarationsNode node) {
    110                         return defaultVisit(node);
    111                 }
    112 
    113                 public ASTNode visit(DeclaratorListNode node) {
     105                public ASTNode visit(CompoundIdentifierNode node) {
     106                        return defaultVisit(node);
     107                }
     108
     109                public ASTNode visit(DeclListNode node) {
     110                        return defaultVisit(node);
     111                }
     112
     113                public ASTNode visit(DeclsNode node) {
    114114                        return defaultVisit(node);
    115115                }
     
    135135                }
    136136
    137                 public ASTNode visit(FuncCallOrAssignmentStmtNode node) {
     137                public ASTNode visit(FuncCallOrAssignStmtNode node) {
    138138                        return defaultVisit(node);
    139139                }
  • proto/pablo/src/ast/ASTVisitor.java

    r2658 r2660  
    1414        T visitLeave(ASTNode node, List<T> childResults);
    1515       
    16         public void visitEnter(AssignmentNode node);
    17         public T visitLeave(AssignmentNode node, List<T> childResults);
    18 
    19         public void visitEnter(AssignmentOperatorNode node);
    20         public T visitLeave(AssignmentOperatorNode node, List<T> childResults);
     16        public void visitEnter(AssignNode node);
     17        public T visitLeave(AssignNode node, List<T> childResults);
     18
     19        public void visitEnter(AssignOperatorNode node);
     20        public T visitLeave(AssignOperatorNode node, List<T> childResults);
    2121
    2222        public void visitEnter(BinaryOperatorNode node);
     
    2626        public T visitLeave(BlockStmtNode node, List<T> childResults);
    2727
    28         public void visitEnter(CompoundVariableNode node);
    29         public T visitLeave(CompoundVariableNode node, List<T> childResults);
    30 
    31         public void visitEnter(DeclarationsNode node);
    32         public T visitLeave(DeclarationsNode node, List<T> childResults);
    33 
    34         public void visitEnter(DeclaratorListNode node);
    35         public T visitLeave(DeclaratorListNode node, List<T> childResults);
     28        public void visitEnter(CompoundIdentifierNode node);
     29        public T visitLeave(CompoundIdentifierNode node, List<T> childResults);
     30
     31        public void visitEnter(DeclListNode node);
     32        public T visitLeave(DeclListNode node, List<T> childResults);
     33
     34        public void visitEnter(DeclsNode node);
     35        public T visitLeave(DeclsNode node, List<T> childResults);
    3636
    3737        public void visitEnter(EpsilonNode node);
     
    5050        public T visitLeave(FuncCallNode node, List<T> childResults);
    5151
    52         public void visitEnter(FuncCallOrAssignmentStmtNode node);
    53         public T visitLeave(FuncCallOrAssignmentStmtNode node, List<T> childResults);
     52        public void visitEnter(FuncCallOrAssignStmtNode node);
     53        public T visitLeave(FuncCallOrAssignStmtNode node, List<T> childResults);
    5454
    5555        public void visitEnter(FuncDefNode node);
     
    134134                }
    135135               
    136                 public void visitEnter(AssignmentNode node) {
    137                         defaultVisitEnter(node);
    138                 }
    139                 public T visitLeave(AssignmentNode node, List<T> childResults) {
    140                         return defaultVisitLeave(node);
    141                 }
    142 
    143                 public void visitEnter(AssignmentOperatorNode node) {
    144                         defaultVisitEnter(node);
    145                 }
    146                 public T visitLeave(AssignmentOperatorNode node, List<T> childResults) {
     136                public void visitEnter(AssignNode node) {
     137                        defaultVisitEnter(node);
     138                }
     139                public T visitLeave(AssignNode node, List<T> childResults) {
     140                        return defaultVisitLeave(node);
     141                }
     142
     143                public void visitEnter(AssignOperatorNode node) {
     144                        defaultVisitEnter(node);
     145                }
     146                public T visitLeave(AssignOperatorNode node, List<T> childResults) {
    147147                        return defaultVisitLeave(node);
    148148                }
     
    162162                }
    163163
    164                 public void visitEnter(CompoundVariableNode node) {
    165                         defaultVisitEnter(node);
    166                 }
    167                 public T visitLeave(CompoundVariableNode node, List<T> childResults) {
    168                         return defaultVisitLeave(node);
    169                 }
    170 
    171                 public void visitEnter(DeclarationsNode node) {
    172                         defaultVisitEnter(node);
    173                 }
    174                 public T visitLeave(DeclarationsNode node, List<T> childResults) {
    175                         return defaultVisitLeave(node);
    176                 }
    177 
    178                 public void visitEnter(DeclaratorListNode node) {
    179                         defaultVisitEnter(node);
    180                 }
    181                 public T visitLeave(DeclaratorListNode node, List<T> childResults) {
     164                public void visitEnter(CompoundIdentifierNode node) {
     165                        defaultVisitEnter(node);
     166                }
     167                public T visitLeave(CompoundIdentifierNode node, List<T> childResults) {
     168                        return defaultVisitLeave(node);
     169                }
     170
     171                public void visitEnter(DeclListNode node) {
     172                        defaultVisitEnter(node);
     173                }
     174                public T visitLeave(DeclListNode node, List<T> childResults) {
     175                        return defaultVisitLeave(node);
     176                }
     177
     178                public void visitEnter(DeclsNode node) {
     179                        defaultVisitEnter(node);
     180                }
     181                public T visitLeave(DeclsNode node, List<T> childResults) {
    182182                        return defaultVisitLeave(node);
    183183                }
     
    218218                }
    219219
    220                 public void visitEnter(FuncCallOrAssignmentStmtNode node) {
    221                         defaultVisitEnter(node);
    222                 }
    223                 public T visitLeave(FuncCallOrAssignmentStmtNode node, List<T> childResults) {
     220                public void visitEnter(FuncCallOrAssignStmtNode node) {
     221                        defaultVisitEnter(node);
     222                }
     223                public T visitLeave(FuncCallOrAssignStmtNode node, List<T> childResults) {
    224224                        return defaultVisitLeave(node);
    225225                }
  • proto/pablo/src/ast/SimpleVisitor.java

    r2658 r2660  
    1313        void visit(ASTNode node);
    1414       
    15         public void visit(AssignmentNode node);
    16 
    17         public void visit(AssignmentOperatorNode node);
     15        public void visit(AssignNode node);
     16
     17        public void visit(AssignOperatorNode node);
    1818
    1919        public void visit(BinaryOperatorNode node);
     
    2121        public void visit(BlockStmtNode node);
    2222
    23         public void visit(CompoundVariableNode node);
    24 
    25         public void visit(DeclarationsNode node);
    26 
    27         public void visit(DeclaratorListNode node);
     23        public void visit(CompoundIdentifierNode node);
     24
     25        public void visit(DeclListNode node);
     26
     27        public void visit(DeclsNode node);
    2828
    2929        public void visit(EpsilonNode node);
     
    3737        public void visit(FuncCallNode node);
    3838
    39         public void visit(FuncCallOrAssignmentStmtNode node);
     39        public void visit(FuncCallOrAssignStmtNode node);
    4040
    4141        public void visit(FuncDefNode node);
     
    8888                }
    8989       
    90                 public void visit(AssignmentNode node) {
    91                         defaultVisit(node);
    92                 }
    93 
    94                 public void visit(AssignmentOperatorNode node) {
     90                public void visit(AssignNode node) {
     91                        defaultVisit(node);
     92                }
     93
     94                public void visit(AssignOperatorNode node) {
    9595                        defaultVisit(node);
    9696                }
     
    104104                }
    105105
    106                 public void visit(CompoundVariableNode node) {
    107                         defaultVisit(node);
    108                 }
    109 
    110                 public void visit(DeclarationsNode node) {
    111                         defaultVisit(node);
    112                 }
    113 
    114                 public void visit(DeclaratorListNode node) {
     106                public void visit(CompoundIdentifierNode node) {
     107                        defaultVisit(node);
     108                }
     109
     110                public void visit(DeclListNode node) {
     111                        defaultVisit(node);
     112                }
     113
     114                public void visit(DeclsNode node) {
    115115                        defaultVisit(node);
    116116                }
     
    136136                }
    137137
    138                 public void visit(FuncCallOrAssignmentStmtNode node) {
     138                public void visit(FuncCallOrAssignStmtNode node) {
    139139                        defaultVisit(node);
    140140                }
  • proto/pablo/src/ast/VoidVisitor.java

    r2658 r2660  
    1212        void visitLeave(ASTNode node);
    1313       
    14         public void visitEnter(AssignmentNode node);
    15         public void visitLeave(AssignmentNode node);
    16 
    17         public void visitEnter(AssignmentOperatorNode node);
    18         public void visitLeave(AssignmentOperatorNode node);
     14        public void visitEnter(AssignNode node);
     15        public void visitLeave(AssignNode node);
     16
     17        public void visitEnter(AssignOperatorNode node);
     18        public void visitLeave(AssignOperatorNode node);
    1919
    2020        public void visitEnter(BinaryOperatorNode node);
     
    2424        public void visitLeave(BlockStmtNode node);
    2525
    26         public void visitEnter(CompoundVariableNode node);
    27         public void visitLeave(CompoundVariableNode node);
    28 
    29         public void visitEnter(DeclarationsNode node);
    30         public void visitLeave(DeclarationsNode node);
    31 
    32         public void visitEnter(DeclaratorListNode node);
    33         public void visitLeave(DeclaratorListNode node);
     26        public void visitEnter(CompoundIdentifierNode node);
     27        public void visitLeave(CompoundIdentifierNode node);
     28
     29        public void visitEnter(DeclListNode node);
     30        public void visitLeave(DeclListNode node);
     31
     32        public void visitEnter(DeclsNode node);
     33        public void visitLeave(DeclsNode node);
    3434
    3535        public void visitEnter(EpsilonNode node);
     
    4848        public void visitLeave(FuncCallNode node);
    4949
    50         public void visitEnter(FuncCallOrAssignmentStmtNode node);
    51         public void visitLeave(FuncCallOrAssignmentStmtNode node);
     50        public void visitEnter(FuncCallOrAssignStmtNode node);
     51        public void visitLeave(FuncCallOrAssignStmtNode node);
    5252
    5353        public void visitEnter(FuncDefNode node);
     
    131131                }
    132132               
    133                 public void visitEnter(AssignmentNode node) {
    134                         defaultVisitEnter(node);
    135                 }
    136                 public void visitLeave(AssignmentNode node) {
    137                         defaultVisitLeave(node);
    138                 }
    139 
    140                 public void visitEnter(AssignmentOperatorNode node) {
    141                         defaultVisitEnter(node);
    142                 }
    143                 public void visitLeave(AssignmentOperatorNode node) {
     133                public void visitEnter(AssignNode node) {
     134                        defaultVisitEnter(node);
     135                }
     136                public void visitLeave(AssignNode node) {
     137                        defaultVisitLeave(node);
     138                }
     139
     140                public void visitEnter(AssignOperatorNode node) {
     141                        defaultVisitEnter(node);
     142                }
     143                public void visitLeave(AssignOperatorNode node) {
    144144                        defaultVisitLeave(node);
    145145                }
     
    159159                }
    160160
    161                 public void visitEnter(CompoundVariableNode node) {
    162                         defaultVisitEnter(node);
    163                 }
    164                 public void visitLeave(CompoundVariableNode node) {
    165                         defaultVisitLeave(node);
    166                 }
    167 
    168                 public void visitEnter(DeclarationsNode node) {
    169                         defaultVisitEnter(node);
    170                 }
    171                 public void visitLeave(DeclarationsNode node) {
    172                         defaultVisitLeave(node);
    173                 }
    174 
    175                 public void visitEnter(DeclaratorListNode node) {
    176                         defaultVisitEnter(node);
    177                 }
    178                 public void visitLeave(DeclaratorListNode node) {
     161                public void visitEnter(CompoundIdentifierNode node) {
     162                        defaultVisitEnter(node);
     163                }
     164                public void visitLeave(CompoundIdentifierNode node) {
     165                        defaultVisitLeave(node);
     166                }
     167
     168                public void visitEnter(DeclListNode node) {
     169                        defaultVisitEnter(node);
     170                }
     171                public void visitLeave(DeclListNode node) {
     172                        defaultVisitLeave(node);
     173                }
     174
     175                public void visitEnter(DeclsNode node) {
     176                        defaultVisitEnter(node);
     177                }
     178                public void visitLeave(DeclsNode node) {
    179179                        defaultVisitLeave(node);
    180180                }
     
    215215                }
    216216
    217                 public void visitEnter(FuncCallOrAssignmentStmtNode node) {
    218                         defaultVisitEnter(node);
    219                 }
    220                 public void visitLeave(FuncCallOrAssignmentStmtNode node) {
     217                public void visitEnter(FuncCallOrAssignStmtNode node) {
     218                        defaultVisitEnter(node);
     219                }
     220                public void visitLeave(FuncCallOrAssignStmtNode node) {
    221221                        defaultVisitLeave(node);
    222222                }
  • proto/pablo/src/compiler/PabloCompiler.java

    r2658 r2660  
    9898                        */
    9999                       
    100                     AugAssignmentXFormer AugAssignment = new AugAssignmentXFormer(value);
    101                         AugAssignment.XForm();
     100                    AugAssignXFormer AugAssign = new AugAssignXFormer(value);
     101                        AugAssign.XForm();
    102102                       
    103103                        CarryIntroXFormer carryQIntro = new CarryIntroXFormer(value, carrySet2CPP);
     
    114114
    115115                        if(PabloCompiler.addDumpStmts) {
    116                                 DumpAssignmentStmtsXFormer dumpAssignmentStmtsXFormer = new DumpAssignmentStmtsXFormer(value, builtins2CPP); 
    117                                 dumpAssignmentStmtsXFormer.XForm();
     116                                DumpAssignStmtsXFormer dumpAssignStmtsXFormer = new DumpAssignStmtsXFormer(value, builtins2CPP); 
     117                                dumpAssignStmtsXFormer.XForm();
    118118                        }
    119119                       
  • proto/pablo/src/compiler/PabloCompilerTestHarness.java

    r2658 r2660  
    3838            ADVANCECOMBINER("AdvanceCombinerXFormer", true),
    3939            ADVANCENCOUNTER("AdvanceNCounterVisitor", true),
    40             AugASSIGNMENT("AugAssignmentXFormer", true),
     40            AugAssign("AugAssignXFormer", true),
    4141            BITWISE2IDISA("Bitwise2IDISAXFormer", true),
    4242            CARRYCOUNTER("CarryCounterVisitor", true),
     
    9090                                                case ADVANCENCOUNTER:
    9191                                                        break;
    92                                                 case AugASSIGNMENT:                                     
    93                                                                 AugAssignmentTest(fileAbsolutePath);
     92                                                case AugAssign:                                 
     93                                                                AugAssignTest(fileAbsolutePath);
    9494                                                        break;
    9595                                                case BITWISE2IDISA:
     
    136136               
    137137                ASTTest astTest = new ASTTest(syntaxTree);
    138                 astTest.compareAssignmentNodes();
     138                astTest.compareAssignNodes();
    139139        }
    140140
     
    157157               
    158158                ASTTest astTest = new ASTTest(syntaxTree);
    159                 astTest.compareAssignmentNodes();
     159                astTest.compareAssignNodes();
    160160               
    161161        }
     
    165165         * @throws FileNotFoundException
    166166         */
    167         public static void AugAssignmentTest(String fileAbsolutePath) throws FileNotFoundException {
     167        public static void AugAssignTest(String fileAbsolutePath) throws FileNotFoundException {
    168168                               
    169169                LexicalController lexController = LexicalController.make(fileAbsolutePath);
     
    174174               
    175175                for (Map.Entry<String, ASTNode> entry : streamFuncMap.entrySet()) {                                                                     
    176                         AugAssignmentXFormer AugAssignment = new AugAssignmentXFormer(entry.getValue());       
    177                         AugAssignment.XForm();
     176                        AugAssignXFormer AugAssign = new AugAssignXFormer(entry.getValue());   
     177                        AugAssign.XForm();
    178178                }   
    179179               
    180180                ASTTest astTest = new ASTTest(syntaxTree);
    181                 astTest.compareAssignmentNodes();
     181                astTest.compareAssignNodes();
    182182        }
    183183       
     
    205205               
    206206                ASTTest astTest = new ASTTest(syntaxTree);
    207                 astTest.compareAssignmentNodes();
     207                astTest.compareAssignNodes();
    208208               
    209209        }       
  • proto/pablo/src/compiler/ast/Accessors.java

    r2658 r2660  
    2222
    2323        ////////////////////////////////////////////////////////////////////////////
    24         // Type declarations
     24        // Type Decls
    2525        ////////////////////////////////////////////////////////////////////////////                           
    26         public static boolean hasDeclaratorList(TypeDeclNode node) {
     26        public static boolean hasDeclList(TypeDeclNode node) {
    2727
    2828                if (node.nChildren() > 1) {
    2929                        ASTNode child = node.child(1);
    30                         assert child instanceof DeclaratorListNode;
    31                         return true;
    32                 }
    33                 return false;
    34         }
    35                
    36         ////////////////////////////////////////////////////////////////////////////
    37         // Assignment Stmts
     30                        assert child instanceof DeclListNode;
     31                        return true;
     32                }
     33                return false;
     34        }
     35               
     36        ////////////////////////////////////////////////////////////////////////////
     37        // Assign Stmts
    3838        ////////////////////////////////////////////////////////////////////////////                           
    39         public static ASTNode lhs(AssignmentNode node) {
    40                 return node.child(0);
    41         }       
    42        
    43         public static ASTNode rhs(AssignmentNode node) {
     39        public static ASTNode lhs(AssignNode node) {
     40                return node.child(0);
     41        }       
     42       
     43        public static ASTNode rhs(AssignNode node) {
    4444                return node.child(1);
    4545        }       
    4646
    47         public static String assignmentOperator(AssignmentNode node) {
     47        public static String AssignOperator(AssignNode node) {
    4848                return node.getToken().getLexeme();
    4949        }
     
    5353        ////////////////////////////////////////////////////////////////////////////                           
    5454
    55         public static String assignmentOperator(FuncCallNode node) {
    56                 return node.getToken().getLexeme();
    57         }       
    58        
    59         ////////////////////////////////////////////////////////////////////////////
    60         // Local Variable Declaration Stmts
     55        public static String AssignOperator(FuncCallNode node) {
     56                return node.getToken().getLexeme();
     57        }       
     58       
     59        ////////////////////////////////////////////////////////////////////////////
     60        // Local Var Decl Stmts
    6161        ////////////////////////////////////////////////////////////////////////////
    6262       
     
    7070        }               
    7171       
    72         public static String assignmentOperator(LocalVarDeclNode node) {
    73                 return node.getToken().getLexeme();
    74         }       
    75        
    76         public static boolean hasInitializationAssignment(LocalVarDeclNode node) {
     72        public static String AssignOperator(LocalVarDeclNode node) {
     73                return node.getToken().getLexeme();
     74        }       
     75       
     76        public static boolean hasInitializationAssign(LocalVarDeclNode node) {
    7777
    7878                if (node.nChildren() > 2) {
     
    221221            name = Accessors.identifierLexeme(node);
    222222        }
    223         else if (node instanceof CompoundVariableNode) {
     223        else if (node instanceof CompoundIdentifierNode) {
    224224            ASTNode pckage = node.child(0);
    225225            ASTNode member = node.child(1);
  • proto/pablo/src/compiler/ast/Generators.java

    r2658 r2660  
    3838        public static FuncCallNode makeFuncCallNode(String[] identifiers, Token locationToken) {
    3939               
    40                 CompoundVariableNode identifierNode = Generators.makeCompoundVariableNode(identifiers, locationToken);
     40                CompoundIdentifierNode identifierNode = Generators.makeCompoundIdentifierNode(identifiers, locationToken);
    4141                return Generators.makeFuncCallNode(identifierNode, locationToken);
    4242        }
     
    9494       
    9595        private static FuncCallNode makeFuncCallNode(ASTNode identifier, Token locationToken) {
    96                 assert identifier instanceof IdentifierNode || identifier instanceof CompoundVariableNode;
     96                assert identifier instanceof IdentifierNode || identifier instanceof CompoundIdentifierNode;
    9797
    9898                LextantToken token = Generators.makeLextantToken(Lextant.LROUND, locationToken);
     
    104104        }       
    105105               
    106         /** Makes a new CompoundVariableNode with an array of identifier strings and and the TextLocation taken from token.
     106        /** Makes a new CompoundIdentifierNode with an array of identifier strings and and the TextLocation taken from token.
    107107         * Currently, no special consideration with only one identifier in the array.
    108108         * (Maybe we can return a IdentifierNode directly in later versions.)
    109109         * @param identifiers           all identifiers
    110110         * @param locationToken         a token containing the TextLocation for this new node.
    111          * @return      the new CompoundVariableNode
    112          */
    113         public static CompoundVariableNode makeCompoundVariableNode(String[] identifiers, Token locationToken) {
     111         * @return      the new CompoundIdentifierNode
     112         */
     113        public static CompoundIdentifierNode makeCompoundIdentifierNode(String[] identifiers, Token locationToken) {
    114114                Token dotToken = Generators.makeLextantToken(Lextant.DOT, locationToken);
    115                 CompoundVariableNode compoundVariableNode = new CompoundVariableNode(dotToken);
     115                CompoundIdentifierNode CompoundIdentifierNode = new CompoundIdentifierNode(dotToken);
    116116                for (String identifier : identifiers) {
    117117                        IdentifierNode identifierNode = Generators.makeIdentifierNode(identifier, locationToken);
    118                         compoundVariableNode.appendChild(identifierNode);
     118                        CompoundIdentifierNode.appendChild(identifierNode);
    119119                }
    120                 return compoundVariableNode;
     120                return CompoundIdentifierNode;
    121121        }
    122122
  • proto/pablo/src/compiler/codeGeneration/CodeStore.java

    r2651 r2660  
    1919        public static final char INDENT  = '\t';
    2020        List<CodeLine> code = new ArrayList<CodeLine>();
    21         private String resultVariableName = "codeStoreNoVariable";
     21        private String resultVarName = "codeStoreNoVar";
    2222
    2323        public void appendToLast(String line) {
     
    5757        }
    5858       
    59         public void setResultVariableName(String name) {
    60                 this.resultVariableName  = name;
     59        public void setResultVarName(String name) {
     60                this.resultVarName  = name;
    6161        }
    6262       
    63         public String getResultVariableName() {
    64                 return resultVariableName;
     63        public String getResultVarName() {
     64                return resultVarName;
    6565        }
    6666       
  • proto/pablo/src/compiler/lang/pablo/BuiltinsUtil.java

    r2658 r2660  
    157157            return Accessors.identifierLexeme(node) == FuncName;
    158158        }
    159         else if (node instanceof CompoundVariableNode) {
     159        else if (node instanceof CompoundIdentifierNode) {
    160160            ASTNode pckage = node.child(0);
    161161            ASTNode member = node.child(1);
  • proto/pablo/src/compiler/templating/FileTemplate.java

    r2607 r2660  
    66
    77public class FileTemplate implements Template {
    8         // Template variables begin with VARIABLE_DELIMITER and followed by VARIABLE_START_CHAR.
    9         // Template variables end with (optional) whitespace and (required) VARIABLE_DELIMITER.
     8        // Template Vars begin with Var_DELIMITER and followed by Var_START_CHAR.
     9        // Template Vars end with (optional) whitespace and (required) Var_DELIMITER.
    1010       
    11         private static final String VARIABLE_DELIMITER = "%";
    12         private static final char VARIABLE_START_CHAR = '@';
     11        private static final String Var_DELIMITER = "%";
     12        private static final char Var_START_CHAR = '@';
    1313        private MemoryTemplate template;
    1414
     
    3030        private void constructTemplateFromFile(String filename) {
    3131                String rawFile = stringForFile(filename);
    32                 String[] pieces = rawFile.split(VARIABLE_DELIMITER);
     32                String[] pieces = rawFile.split(Var_DELIMITER);
    3333               
    3434                for(String piece: pieces) {
    35                         if(isAVariable(piece)) {
    36                                 String variable = getVariableName(piece);
    37                                 template.addVariable(variable);
     35                        if(isAVar(piece)) {
     36                                String Var = getVarName(piece);
     37                                template.addVar(Var);
    3838                        }
    3939                        else {
     
    4343        }
    4444       
    45         private boolean isAVariable(String piece) {
    46                 return !piece.isEmpty() && (piece.charAt(0) == VARIABLE_START_CHAR);
     45        private boolean isAVar(String piece) {
     46                return !piece.isEmpty() && (piece.charAt(0) == Var_START_CHAR);
    4747        }
    4848       
    49         private String getVariableName(String piece) {
     49        private String getVarName(String piece) {
    5050                return piece.substring(1).trim();
    5151        }
  • proto/pablo/src/compiler/templating/MemoryTemplate.java

    r2444 r2660  
    99public class MemoryTemplate implements Template {
    1010        private class Segment {
    11                 private final boolean isVariable;
     11                private final boolean isVar;
    1212                private final String value;
    13                 public Segment(boolean isVariable, String value) {
    14                         this.isVariable = isVariable;
     13                public Segment(boolean isVar, String value) {
     14                        this.isVar = isVar;
    1515                        this.value = value;
    1616                }
    17                 public boolean isVariable() {
    18                         return isVariable;
     17                public boolean isVar() {
     18                        return isVar;
    1919                }
    2020                public String value() {
     
    3030        ////////////////////////////////////////////////////////////////
    3131        // construction: use constructor,
    32         //              follow with addString and addVariable calls     
     32        //              follow with addString and addVar calls 
    3333       
    3434        public MemoryTemplate(String name) {
     
    4141                segments.add(segment);
    4242        }
    43         public void addVariable(String variable) {
    44                 Segment segment = new Segment(true, variable.intern());
     43        public void addVar(String Var) {
     44                Segment segment = new Segment(true, Var.intern());
    4545                segments.add(segment);
    4646        }
     
    4848       
    4949        ////////////////////////////////////////////////////////////////
    50         // set and clear variable values
     50        // set and clear Var values
    5151       
    5252        @Override
     
    7878        }
    7979        private String stringFor(Segment segment) {
    80                 if(segment.isVariable()) {
     80                if(segment.isVar()) {
    8181                        return substitutions.get(segment.value());
    8282                }
     
    8686       
    8787        ////////////////////////////////////////////////////////////////
    88         // check that all variables are defined.
     88        // check that all Vars are defined.
    8989
    9090        private boolean isFullyDefined() {
     
    9696        }
    9797        private boolean isDefined(Segment segment) {
    98                 if(segment.isVariable()) {
    99                         String variable = segment.value();
    100                         return isDefined(variable);
     98                if(segment.isVar()) {
     99                        String Var = segment.value();
     100                        return isDefined(Var);
    101101                }
    102102                return true;
    103103        }
    104         private boolean isDefined(String variable) {
    105                 if(!substitutions.containsKey(variable)) {
    106                         missingValueError(variable);
     104        private boolean isDefined(String Var) {
     105                if(!substitutions.containsKey(Var)) {
     106                        missingValueError(Var);
    107107                        return false;
    108108                }
     
    114114        // error reporting
    115115       
    116         private void missingValueError(String variable) {
    117                 //logError("Template error: variable " + variable + " missing value in template " + name + ".");
    118             System.err.println("Template error: variable " + variable + " missing value in template " + name + ".");
     116        private void missingValueError(String Var) {
     117                //logError("Template error: Var " + Var + " missing value in template " + name + ".");
     118            System.err.println("Template error: Var " + Var + " missing value in template " + name + ".");
    119119        }
    120120//      private void logError(String message) {
  • proto/pablo/src/compiler/test/ASTTest.java

    r2658 r2660  
    1818    }
    1919
    20     public void compareAssignmentNodes() {
    21         ASTAssignmentTestVisitor visitor = new ASTAssignmentTestVisitor();
     20    public void compareAssignNodes() {
     21        ASTAssignTestVisitor visitor = new ASTAssignTestVisitor();
    2222        ASTTree.accept(visitor);
    2323        visitor.assertComplete();
     
    6868        }
    6969       
    70         private class ASTAssignmentTestVisitor extends ASTTestVisitor {
     70        private class ASTAssignTestVisitor extends ASTTestVisitor {
    7171
    72                 ASTAssignmentTestVisitor() {
     72                ASTAssignTestVisitor() {
    7373                        super();
    7474                }
    7575               
    76                 public void visitEnter(AssignmentNode node) {
     76                public void visitEnter(AssignNode node) {
    7777                        if(ASTTree1 == null) {
    7878                                this.ASTTree1 = node;
  • proto/pablo/src/compiler/visitors/AssertBitBlockAlignStmtsXFormer.java

    r2658 r2660  
    3434                }               
    3535               
    36                 public void visitEnter(AssignmentNode node) {
     36                public void visitEnter(AssignNode node) {
    3737                        addDumpStmt(node, Accessors.lhs(node));
    3838                }
  • proto/pablo/src/compiler/visitors/AugAssignXFormer.java

    r2658 r2660  
    1111import tokens.*;
    1212
    13 public class AugAssignmentXFormer {
     13public class AugAssignXFormer {
    1414
    15         private static Map<Lextant, Lextant> AugAssignmentMap = new HashMap<Lextant, Lextant>();
     15        private static Map<Lextant, Lextant> AugAssignMap = new HashMap<Lextant, Lextant>();
    1616       
    1717        static {
    18                 AugAssignmentMap.put(Lextant.AND_ASSIGN, Lextant.AND);
    19                 AugAssignmentMap.put(Lextant.OR_ASSIGN, Lextant.OR);
    20                 AugAssignmentMap.put(Lextant.XOR_ASSIGN, Lextant.XOR);
    21                 //AugAssignmentMap.put(Lextant.NOT_ASSIGN, Lextant.NOT);
     18                AugAssignMap.put(Lextant.AND_ASSIGN, Lextant.AND);
     19                AugAssignMap.put(Lextant.OR_ASSIGN, Lextant.OR);
     20                AugAssignMap.put(Lextant.XOR_ASSIGN, Lextant.XOR);
     21                //AugAssignMap.put(Lextant.NOT_ASSIGN, Lextant.NOT);
    2222        };
    2323       
    2424        private ASTNode ASTree;
    2525       
    26         public AugAssignmentXFormer(ASTNode ASTree) {
     26        public AugAssignXFormer(ASTNode ASTree) {
    2727                this.ASTree = ASTree;
    2828        }
    2929       
    3030        public void XForm() {
    31                 VoidVisitor visitor = new AugAssignmentRemovalVisitor();
     31                VoidVisitor visitor = new AugAssignRemovalVisitor();
    3232                ASTree.accept(visitor);
    3333        }
    3434
    35         private class AugAssignmentRemovalVisitor extends VoidVisitor.Default {
     35        private class AugAssignRemovalVisitor extends VoidVisitor.Default {
    3636               
    37                 public void visitLeave(AssignmentNode node) {
    38                         XFormAugAssignment(node, Accessors.lhs(node), Accessors.rhs(node));
     37                public void visitLeave(AssignNode node) {
     38                        XFormAugAssign(node, Accessors.lhs(node), Accessors.rhs(node));
    3939                }
    4040
    4141                public void visitLeave(LocalVarDeclNode node) {
    42                         if(Accessors.hasInitializationAssignment(node)) {
    43                                 XFormAugAssignment(node, Accessors.lhs(node), Accessors.rhs(node));
     42                        if(Accessors.hasInitializationAssign(node)) {
     43                                XFormAugAssign(node, Accessors.lhs(node), Accessors.rhs(node));
    4444                        }
    4545                }
    4646                               
    47                 private void XFormAugAssignment(ASTNode node, ASTNode lhs, ASTNode rhs) {
    48                         if(isAugAssignmentLextant(node.getToken())) {
     47                private void XFormAugAssign(ASTNode node, ASTNode lhs, ASTNode rhs) {
     48                        if(isAugAssignLextant(node.getToken())) {
    4949                               
    5050                                // TODO: bug here, simply use node.child(0) as lhs may fail if side effect exists.
     
    6666                }
    6767               
    68                 private boolean isAugAssignmentLextant(Token token) {
    69                         for (Lextant key : AugAssignmentMap.keySet()) {
     68                private boolean isAugAssignLextant(Token token) {
     69                        for (Lextant key : AugAssignMap.keySet()) {
    7070                                if (token.isLextant(key)) {
    7171                                        return true;
     
    7676
    7777                private Lextant getMappedLextant(Token token) {
    78                         for (Lextant key : AugAssignmentMap.keySet()) {
     78                        for (Lextant key : AugAssignMap.keySet()) {
    7979                                if (token.isLextant(key)) {
    80                                         return AugAssignmentMap.get(key);
     80                                        return AugAssignMap.get(key);
    8181                                }
    8282                        }
  • proto/pablo/src/compiler/visitors/Bitwise2IDISAXFormer.java

    r2658 r2660  
    7373                */
    7474                public void visitLeave(LocalVarDeclNode node) {
    75                         if(Accessors.hasInitializationAssignment(node)) {
     75                        if(Accessors.hasInitializationAssign(node)) {
    7676                                ASTNode rhs = Accessors.rhs(node);
    7777                                integerConstant2IDISA(node, rhs);
     
    7979                }
    8080
    81                 public void visitLeave(AssignmentNode node) {
     81                public void visitLeave(AssignNode node) {
    8282                        ASTNode rhs = Accessors.rhs(node);
    8383                        integerConstant2IDISA(node, rhs);
  • proto/pablo/src/compiler/visitors/CPPUnparser.java

    r2658 r2660  
    99
    1010/*
    11  * Description: CodeStore get/set variables are used to pass text fragments
     11 * Description: CodeStore get/set Vars are used to pass text fragments
    1212 *                              that do not constitute output lines.
    1313 */
     
    3535        }
    3636
    37         public void visitEnter(DeclarationsNode node) {
    38 
    39         }
    40        
    41         public CodeStore visitLeave(DeclarationsNode node, List<CodeStore> childResults) {     
     37        public void visitEnter(DeclsNode node) {
     38
     39        }
     40       
     41        public CodeStore visitLeave(DeclsNode node, List<CodeStore> childResults) {     
    4242                return concatenatedChildrenCode(new CodeStore(), childResults, true);           
    4343        }       
     
    4646                CodeStore code = new CodeStore();
    4747               
    48                 String type = childResults.get(0).getResultVariableName();
    49                 String alias = childResults.get(1).getResultVariableName();
     48                String type = childResults.get(0).getResultVarName();
     49                String alias = childResults.get(1).getResultVarName();
    5050               
    5151                code.addFormattedLine("typedef %s %s;", type, alias);
     
    5656        public CodeStore visitLeave(TypeDeclNode node, List<CodeStore> childResults) {
    5757                CodeStore code = new CodeStore();
    58                 String type = childResults.get(0).getResultVariableName();
    59                 String declaratorList;
    60                 if (Accessors.hasDeclaratorList(node)) {
    61                         declaratorList = childResults.get(1).getResultVariableName();
    62                         code.addFormattedLine("%s %s;", type, declaratorList);
     58                String type = childResults.get(0).getResultVarName();
     59                String DeclList;
     60                if (Accessors.hasDeclList(node)) {
     61                        DeclList = childResults.get(1).getResultVarName();
     62                        code.addFormattedLine("%s %s;", type, DeclList);
    6363                       
    6464                } else {
     
    6868        }               
    6969
    70         public CodeStore visitLeave(DeclaratorListNode node, List<CodeStore> childResults) {
     70        public CodeStore visitLeave(DeclListNode node, List<CodeStore> childResults) {
    7171                CodeStore code = new CodeStore();
    7272                Iterator<CodeStore> iter = childResults.iterator();
    73                 code.setResultVariableName(makeDelimitedList(iter, ", "));
     73                code.setResultVarName(makeDelimitedList(iter, ", "));
    7474                return code;           
    7575        }               
     
    8787                String parameters = new String();
    8888                if(Accessors.hasParameters(node)) {
    89                         parameters = childResults.get(2).getResultVariableName();
     89                        parameters = childResults.get(2).getResultVarName();
    9090                        blockStmt = childResults.get(3);
    9191                } else {
     
    9494                               
    9595                code.addFormattedLine("%s %s(%s)",
    96                                 returnType.getResultVariableName(),
    97                                 FuncName.getResultVariableName(),
     96                                returnType.getResultVarName(),
     97                                FuncName.getResultVarName(),
    9898                                parameters);   
    9999               
     
    107107                CodeStore code = new CodeStore();               
    108108                Iterator<CodeStore> iter = childResults.iterator();
    109                 code.setResultVariableName(makeDelimitedList(iter, ", "));             
     109                code.setResultVarName(makeDelimitedList(iter, ", "));           
    110110                return code;
    111111        }
     
    115115                CodeStore code = new CodeStore();
    116116               
    117                 String type = childResults.get(0).getResultVariableName();
    118                 String identifier = childResults.get(1).getResultVariableName();
    119                 code.setResultVariableName(type + " & " + identifier);
     117                String type = childResults.get(0).getResultVarName();
     118                String identifier = childResults.get(1).getResultVarName();
     119                code.setResultVarName(type + " & " + identifier);
    120120               
    121121                return code;
     
    126126        ////////////////////////////////////////////////////////////////////////////   
    127127       
    128         // assignment Stmt
    129         public CodeStore visitLeave(AssignmentNode node, List<CodeStore> childResults) {
     128        // Assign Stmt
     129        public CodeStore visitLeave(AssignNode node, List<CodeStore> childResults) {
    130130                CodeStore code = new CodeStore();
    131131                CodeStore lhs = childResults.get(0);
    132132                CodeStore rhs = childResults.get(1);
    133                 code.addFormattedLine("%s %s %s;", lhs.getResultVariableName()
    134                                                                                  , Accessors.assignmentOperator(node)
    135                                                                                  , rhs.getResultVariableName());
     133                code.addFormattedLine("%s %s %s;", lhs.getResultVarName()
     134                                                                                 , Accessors.AssignOperator(node)
     135                                                                                 , rhs.getResultVarName());
    136136               
    137137                return code;
     
    140140        // Func invocation
    141141        //
    142         // TODO - Verify correctness, both returns variable and code line.
     142        // TODO - Verify correctness, both returns Var and code line.
    143143        //
    144144        public CodeStore visitLeave(FuncCallNode node, List<CodeStore> childResults) {
    145145                CodeStore code = new CodeStore();
    146146               
    147                 StringBuilder resultVariable = new StringBuilder();
    148                
    149                 resultVariable.append(childResults.get(0).getResultVariableName());
    150                 resultVariable.append("(");
    151                 resultVariable.append(childResults.get(1).getResultVariableName());
    152                 resultVariable.append(")");
    153                
    154                 code.setResultVariableName(resultVariable.toString());   // Func invocation as an expression   
    155                
    156                 code.addFormattedLine("%s;", resultVariable.toString()); // Func invocation as a Stmt
     147                StringBuilder resultVar = new StringBuilder();
     148               
     149                resultVar.append(childResults.get(0).getResultVarName());
     150                resultVar.append("(");
     151                resultVar.append(childResults.get(1).getResultVarName());
     152                resultVar.append(")");
     153               
     154                code.setResultVarName(resultVar.toString());   // Func invocation as an expression     
     155               
     156                code.addFormattedLine("%s;", resultVar.toString()); // Func invocation as a Stmt
    157157               
    158158                return code;
     
    162162                CodeStore code = new CodeStore();
    163163                Iterator<CodeStore> iter = childResults.iterator();
    164                 code.setResultVariableName(makeDelimitedList(iter, ", "));
     164                code.setResultVarName(makeDelimitedList(iter, ", "));
    165165                return code;
    166166        }
     
    171171                CodeStore ifTest                        = childResults.get(0);
    172172                CodeStore ifBlockStmt   = childResults.get(1);
    173                 code.addFormattedLine("if (%s)", ifTest.getResultVariableName());
     173                code.addFormattedLine("if (%s)", ifTest.getResultVarName());
    174174                code.addLine("{");
    175175                code.addAll(ifBlockStmt, 1);
     
    190190                CodeStore ifTest                        = childResults.get(0);
    191191                CodeStore blockStmt     = childResults.get(1);
    192                 code.addFormattedLine("while (%s)", ifTest.getResultVariableName());
     192                code.addFormattedLine("while (%s)", ifTest.getResultVarName());
    193193                code.addLine("{");
    194194                code.addAll(blockStmt, 1);
     
    201201                CodeStore code = new CodeStore();
    202202                CodeStore child = childResults.get(0);
    203                 code.addFormattedLine("return %s;", child.getResultVariableName());
     203                code.addFormattedLine("return %s;", child.getResultVarName());
    204204                return code;
    205205        }
    206206                               
    207         // variable declaration
     207        // Var Decl
    208208        public CodeStore visitLeave(LocalVarDeclNode node, List<CodeStore> childResults) {
    209209       
     
    213213                CodeStore identifier                    = (CodeStore)childResults.get(1);
    214214               
    215                 if(Accessors.hasInitializationAssignment(node)) {
     215                if(Accessors.hasInitializationAssign(node)) {
    216216               
    217217                        CodeStore expression                    = (CodeStore)childResults.get(2);
    218218               
    219219                        code.addFormattedLine("%s %s %s %s;",
    220                                                                 type.getResultVariableName(),
    221                                                                 identifier.getResultVariableName(),
    222                                                                 Accessors.assignmentOperator(node),
    223                                                                 expression.getResultVariableName());
     220                                                                type.getResultVarName(),
     221                                                                identifier.getResultVarName(),
     222                                                                Accessors.AssignOperator(node),
     223                                                                expression.getResultVarName());
    224224                } else {
    225225                       
    226226                        code.addFormattedLine("%s %s;",
    227                                         type.getResultVariableName(),
    228                                         identifier.getResultVariableName());
     227                                        type.getResultVarName(),
     228                                        identifier.getResultVarName());
    229229                }
    230230               
     
    232232        }       
    233233       
    234 //      public CodeStore visitLeave(AssignmentStmtNode node, List<CodeStore> childResults) {
     234//      public CodeStore visitLeave(AssignStmtNode node, List<CodeStore> childResults) {
    235235//              CodeStore code = new CodeStore();
    236 //              code.setResultVariableName(Accessors.assignmentOperator(node));
     236//              code.setResultVarName(Accessors.AssignOperator(node));
    237237//              return code;
    238238//      }
     
    262262                CodeStore lhs = childResults.get(0);
    263263                CodeStore rhs = childResults.get(1);
    264                 String lhsCode = lhs.getResultVariableName();
    265                 String rhsCode = rhs.getResultVariableName();   
    266                
    267                 StringBuffer resultVariable = new StringBuffer();
     264                String lhsCode = lhs.getResultVarName();
     265                String rhsCode = rhs.getResultVarName();       
     266               
     267                StringBuffer resultVar = new StringBuffer();
    268268               
    269269                if(!Accessors.isTerminal(Accessors.leftOperand(node))) {
    270270                        lhsCode = bracketExpressionCode(lhsCode);
    271271                }
    272                 resultVariable.append(lhsCode);
    273                
    274                 resultVariable.append(" ");
    275                 resultVariable.append(Accessors.operator(node));
    276                 resultVariable.append(" ");
     272                resultVar.append(lhsCode);
     273               
     274                resultVar.append(" ");
     275                resultVar.append(Accessors.operator(node));
     276                resultVar.append(" ");
    277277               
    278278                if(!Accessors.isTerminal(Accessors.rightOperand(node))) {
    279279                        rhsCode = bracketExpressionCode(rhsCode);
    280280                }
    281                 resultVariable.append(rhsCode);
    282                
    283                 code.setResultVariableName(resultVariable.toString());
     281                resultVar.append(rhsCode);
     282               
     283                code.setResultVarName(resultVar.toString());
    284284               
    285285                return code;
     
    292292                CodeStore code = new CodeStore();
    293293                CodeStore child = childResults.get(0);
    294                 String childCode = child.getResultVariableName();
     294                String childCode = child.getResultVarName();
    295295                       
    296                 StringBuffer resultVariable = new StringBuffer();
    297                 resultVariable.append(Accessors.operator(node));
     296                StringBuffer resultVar = new StringBuffer();
     297                resultVar.append(Accessors.operator(node));
    298298               
    299299                if(!Accessors.isTerminal(Accessors.operand(node))) {
    300300                        childCode = bracketExpressionCode(childCode);
    301301                }
    302                 resultVariable.append(childCode);
     302                resultVar.append(childCode);
    303303                               
    304                 code.setResultVariableName(resultVariable.toString());
     304                code.setResultVarName(resultVar.toString());
    305305                return code;
    306306        }       
     
    319319        public CodeStore visitLeave(StringConstantNode node, List<CodeStore> childResults) {
    320320                CodeStore code = new CodeStore();
    321                 code.setResultVariableName(Accessors.stringConstant(node));
     321                code.setResultVarName(Accessors.stringConstant(node));
    322322                return code;
    323323        }       
     
    328328        public CodeStore visitLeave(IntegerConstantNode node, List<CodeStore> childResults) {
    329329                CodeStore code = new CodeStore();
    330                 code.setResultVariableName(Accessors.integerConstant(node));
     330                code.setResultVarName(Accessors.integerConstant(node));
    331331                return code;
    332332        }
     
    346346                CodeStore code = new CodeStore();
    347347               
    348                 StringBuffer resultVariable = new StringBuffer();
     348                StringBuffer resultVar = new StringBuffer();
    349349               
    350350                CodeStore structName = (CodeStore) childResults.get(0);
    351351
    352                 resultVariable.append("struct");
    353                 resultVariable.append(" ");
    354                 resultVariable.append(structName.getResultVariableName());
     352                resultVar.append("struct");
     353                resultVar.append(" ");
     354                resultVar.append(structName.getResultVarName());
    355355               
    356356                if (Accessors.hasStructBody(node)) {                   
    357                         resultVariable.append(CodeStore.NEWLINE);
    358                         resultVariable.append("{");
    359                         resultVariable.append(CodeStore.NEWLINE);
    360                         resultVariable.append(childResults.get(1).toStringIndented(0));
    361                         resultVariable.append("}");
    362                 }
    363 
    364                 code.setResultVariableName(resultVariable.toString());
     357                        resultVar.append(CodeStore.NEWLINE);
     358                        resultVar.append("{");
     359                        resultVar.append(CodeStore.NEWLINE);
     360                        resultVar.append(childResults.get(1).toStringIndented(0));
     361                        resultVar.append("}");
     362                }
     363
     364                code.setResultVarName(resultVar.toString());
    365365
    366366                return code;
     
    385385                CodeStore type = childResults.get(0);
    386386                CodeStore memberName = childResults.get(1);
    387                 code.addFormattedLine("%s %s;", type.getResultVariableName(), memberName.getResultVariableName());             
     387                code.addFormattedLine("%s %s;", type.getResultVarName(), memberName.getResultVarName());               
    388388                return code;
    389389        }
     
    398398                CodeStore code = new CodeStore();
    399399                // TODO - Map stream --> BitBlock <-- stream, BitBlock <-- stream<1>
    400                 // code.setResultVariableName(Accessors.streamTypeName(node));
    401                 code.setResultVariableName("BitBlock");
     400                // code.setResultVarName(Accessors.streamTypeName(node));
     401                code.setResultVarName("BitBlock");
    402402               
    403403                /*
     
    407407                        CodeStore fieldWidth;
    408408                        fieldWidth = childResults.get(0);
    409                         code.setResultVariableName(code.getResultVariableName() + "<" + fieldWidth.getResultVariableName() + ">");
     409                        code.setResultVarName(code.getResultVarName() + "<" + fieldWidth.getResultVarName() + ">");
    410410                }
    411411                *
     
    419419        public CodeStore visitLeave(FieldWidthNode node, List<CodeStore> childResults) {
    420420                CodeStore code = new CodeStore();
    421                 code.setResultVariableName(Accessors.fieldWidthValue(node));           
     421                code.setResultVarName(Accessors.fieldWidthValue(node));         
    422422                return code;
    423423        }       
     
    426426        public CodeStore visitLeave(VoidNode node, List<CodeStore> childResults) {
    427427                CodeStore code = new CodeStore();
    428                 code.setResultVariableName(Accessors.voidValue(node));
     428                code.setResultVarName(Accessors.voidValue(node));
    429429                return code;
    430430        }               
    431431       
    432432        // Compound Identifiers
    433         public CodeStore visitLeave(CompoundVariableNode node, List<CodeStore> childResults) {
     433        public CodeStore visitLeave(CompoundIdentifierNode node, List<CodeStore> childResults) {
    434434                CodeStore code = new CodeStore();
    435435                Iterator<CodeStore> iter = childResults.iterator();
    436                 code.setResultVariableName(makeDelimitedList(iter, "."));
     436                code.setResultVarName(makeDelimitedList(iter, "."));
    437437                return code;
    438438        }
     
    441441        public CodeStore visitLeave(IdentifierNode node, List<CodeStore> childResults) {
    442442                CodeStore code = new CodeStore();
    443                 code.setResultVariableName(Accessors.identifierLexeme(node));
     443                code.setResultVarName(Accessors.identifierLexeme(node));
    444444                return code;
    445445        }
  • proto/pablo/src/compiler/visitors/DumpAssignStmtsXFormer.java

    r2658 r2660  
    77import compiler.lang.pablo.Builtins2Lang;
    88
    9 public class DumpAssignmentStmtsXFormer {
     9public class DumpAssignStmtsXFormer {
    1010        private ASTNode ASTree;
    1111        private Builtins2Lang builtins2Lang;
    1212       
    13         public DumpAssignmentStmtsXFormer(ASTNode ASTree, Builtins2Lang builtins2Lang) {
     13        public DumpAssignStmtsXFormer(ASTNode ASTree, Builtins2Lang builtins2Lang) {
    1414                this.ASTree = ASTree;
    1515                this.builtins2Lang = builtins2Lang;
     
    3030                }               
    3131               
    32                 public void visitEnter(AssignmentNode node) {
     32                public void visitEnter(AssignNode node) {
    3333                        addDumpStmt(node, Accessors.lhs(node));
    3434                }
  • proto/pablo/src/compiler/visitors/Unparser.java

    r2625 r2660  
    3131       
    3232        public String makeDelimitedList(Iterator<CodeStore> iter, String delimeter) {
    33                 StringBuilder resultVariable = new StringBuilder();
     33                StringBuilder resultVar = new StringBuilder();
    3434                while (iter.hasNext()) {
    35                         resultVariable.append(iter.next().getResultVariableName());
     35                        resultVar.append(iter.next().getResultVarName());
    3636                        if (iter.hasNext()) {
    37                                 resultVariable.append(delimeter);
     37                                resultVar.append(delimeter);
    3838                        }
    3939                }
    40                 return resultVariable.toString();
     40                return resultVar.toString();
    4141        }       
    4242       
  • proto/pablo/src/parser/Parser.java

    r2658 r2660  
    5151                        if( nowReading.isLextant(Lextant.STREAM, Lextant.STRUCT, Lextant.TYPEDEF, Lextant.VOID) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
    5252                                {
    53                                         ASTNode child = parseDeclarations();
     53                                        ASTNode child = parseDecls();
    5454                                        result.appendChild(child);
    5555                                        allChildren.add(child);
     
    7070        }
    7171         
    72         public ASTNode parseDeclarations() {
     72        public ASTNode parseDecls() {
    7373                if( !(nowReading.isLextant(Lextant.STREAM, Lextant.STRUCT, Lextant.TYPEDEF, Lextant.VOID) || (nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
    74                         return syntaxErrorNode("declarations² [IDENTIFIER¹, STREAM¹, STRUCT¹, TYPEDEF¹, VOID¹]");
    75                 }
    76        
    77                 boolean allowCompression = true;
    78                 ASTNode result = new DeclarationsNode(nowReading);
     74                        return syntaxErrorNode("Decls² [IDENTIFIER¹, STREAM¹, STRUCT¹, TYPEDEF¹, VOID¹]");
     75                }
     76       
     77                boolean allowCompression = true;
     78                ASTNode result = new DeclsNode(nowReading);
    7979                result.setProductionTag(2);
    8080                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     
    116116                if( (nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
    117117                        {
    118                                 ASTNode child = parseDeclaratorList();
     118                                ASTNode child = parseDeclList();
    119119                                result.appendChild(child);
    120120                                allChildren.add(child);
     
    153153        }
    154154         
    155         public ASTNode parseDeclaratorList() {
     155        public ASTNode parseDeclList() {
    156156                if( !((nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
    157                         return syntaxErrorNode("declaratorList² [IDENTIFIER¹]");
    158                 }
    159        
    160                 boolean allowCompression = true;
    161                 ASTNode result = new DeclaratorListNode(nowReading);
     157                        return syntaxErrorNode("DeclList² [IDENTIFIER¹]");
     158                }
     159       
     160                boolean allowCompression = true;
     161                ASTNode result = new DeclListNode(nowReading);
    162162                result.setProductionTag(5);
    163163                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     
    348348                if( (nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
    349349                        {
    350                                 ASTNode child = parseFuncCallOrAssignmentStmt();
     350                                ASTNode child = parseFuncCallOrAssignStmt();
    351351                                result.appendChild(child);
    352352                                allChildren.add(child);
     
    390390        }
    391391         
    392         public ASTNode parseFuncCallOrAssignmentStmt() {
     392        public ASTNode parseFuncCallOrAssignStmt() {
    393393                if( !((nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
    394                         return syntaxErrorNode("FuncCallOrAssignmentStmt² [IDENTIFIER¹]");
    395                 }
    396        
    397                 boolean allowCompression = true;
    398                 ASTNode result = new FuncCallOrAssignmentStmtNode(nowReading);
     394                        return syntaxErrorNode("FuncCallOrAssignStmt² [IDENTIFIER¹]");
     395                }
     396       
     397                boolean allowCompression = true;
     398                ASTNode result = new FuncCallOrAssignStmtNode(nowReading);
    399399                result.setProductionTag(13);
    400400                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    401401                {
    402                         ASTNode child = parseCompoundVariable();
     402                        ASTNode child = parseCompoundIdentifier();
    403403                        result.appendChild(child);
    404404                        allChildren.add(child);
     
    415415                else if( nowReading.isLextant(Lextant.AND_ASSIGN, Lextant.ASSIGN, Lextant.OR_ASSIGN, Lextant.XOR_ASSIGN) ) {
    416416                        {
    417                                 ASTNode child = parseAssignmentRest();
     417                                ASTNode child = parseAssignRest();
    418418                                result.appendChild(child);
    419419                                allChildren.add(child);
     
    459459                if( nowReading.isLextant(Lextant.LROUND, Lextant.MINUS, Lextant.NOT) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) || (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) || (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING)) ) {
    460460                        {
    461                                 ASTNode child = parseExpression();
     461                                ASTNode child = parseExpr();
    462462                                result.appendChild(child);
    463463                                allChildren.add(child);
     
    466466                                expect(Lextant.COMMA);
    467467                                {
    468                                         ASTNode child = parseExpression();
     468                                        ASTNode child = parseExpr();
    469469                                        result.appendChild(child);
    470470                                        allChildren.add(child);
     
    478478        }
    479479         
    480         public ASTNode parseAssignmentOperator() {
     480        public ASTNode parseAssignOperator() {
    481481                if( !(nowReading.isLextant(Lextant.AND_ASSIGN, Lextant.ASSIGN, Lextant.OR_ASSIGN, Lextant.XOR_ASSIGN)) ) {
    482                         return syntaxErrorNode("assignmentOperator² [AND_ASSIGN¹, ASSIGN¹, OR_ASSIGN¹, XOR_ASSIGN¹]");
    483                 }
    484        
    485                 boolean allowCompression = true;
    486                 ASTNode result = new AssignmentOperatorNode(nowReading);
     482                        return syntaxErrorNode("AssignOperator² [AND_ASSIGN¹, ASSIGN¹, OR_ASSIGN¹, XOR_ASSIGN¹]");
     483                }
     484       
     485                boolean allowCompression = true;
     486                ASTNode result = new AssignOperatorNode(nowReading);
    487487                result.setProductionTag(16);
    488488                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     
    505505        }
    506506         
    507         public ASTNode parseAssignmentRest() {
     507        public ASTNode parseAssignRest() {
    508508                if( !(nowReading.isLextant(Lextant.AND_ASSIGN, Lextant.ASSIGN, Lextant.OR_ASSIGN, Lextant.XOR_ASSIGN)) ) {
    509                         return syntaxErrorNode("assignmentRest² [AND_ASSIGN¹, ASSIGN¹, OR_ASSIGN¹, XOR_ASSIGN¹]");
    510                 }
    511        
    512                 boolean allowCompression = true;
    513                 ASTNode result = new AssignmentNode(nowReading);
     509                        return syntaxErrorNode("AssignRest² [AND_ASSIGN¹, ASSIGN¹, OR_ASSIGN¹, XOR_ASSIGN¹]");
     510                }
     511       
     512                boolean allowCompression = true;
     513                ASTNode result = new AssignNode(nowReading);
    514514                result.setProductionTag(17);
    515515                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    516516                {
    517                         ASTNode child = parseAssignmentOperator();
     517                        ASTNode child = parseAssignOperator();
    518518                        // node omitted - no result.appendChild(child);
    519519                        allChildren.add(child);
     
    521521                }
    522522                {
    523                         ASTNode child = parseExpression();
     523                        ASTNode child = parseExpr();
    524524                        result.appendChild(child);
    525525                        allChildren.add(child);
     
    543543                expect(Lextant.LROUND);
    544544                {
    545                         ASTNode child = parseExpression();
     545                        ASTNode child = parseExpr();
    546546                        result.appendChild(child);
    547547                        allChildren.add(child);
     
    579579                expect(Lextant.LROUND);
    580580                {
    581                         ASTNode child = parseExpression();
     581                        ASTNode child = parseExpr();
    582582                        result.appendChild(child);
    583583                        allChildren.add(child);
     
    607607                if( nowReading.isLextant(Lextant.LROUND, Lextant.MINUS, Lextant.NOT) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) || (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) || (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING)) ) {
    608608                        {
    609                                 ASTNode child = parseExpression();
     609                                ASTNode child = parseExpr();
    610610                                result.appendChild(child);
    611611                                allChildren.add(child);
     
    635635                }
    636636                {
    637                         ASTNode child = parseVariableName();
     637                        ASTNode child = parseVarName();
    638638                        result.appendChild(child);
    639639                        allChildren.add(child);
     
    641641                if( nowReading.isLextant(Lextant.AND_ASSIGN, Lextant.ASSIGN, Lextant.OR_ASSIGN, Lextant.XOR_ASSIGN) ) {
    642642                        {
    643                                 ASTNode child = parseAssignmentOperator();
     643                                ASTNode child = parseAssignOperator();
    644644                                // node omitted - no result.appendChild(child);
    645645                                allChildren.add(child);
     
    647647                        }
    648648                        {
    649                                 ASTNode child = parseExpression();
    650                                 result.appendChild(child);
    651                                 allChildren.add(child);
    652                         }
    653                 }
    654                 if(allowCompression) {
    655                         return result;
    656                 }
    657                 return result;
    658         }
    659          
    660         public ASTNode parseVariableName() {
     649                                ASTNode child = parseExpr();
     650                                result.appendChild(child);
     651                                allChildren.add(child);
     652                        }
     653                }
     654                if(allowCompression) {
     655                        return result;
     656                }
     657                return result;
     658        }
     659         
     660        public ASTNode parseVarName() {
    661661                if( !((nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
    662                         return syntaxErrorNode("variableName² [IDENTIFIER¹]");
     662                        return syntaxErrorNode("VarName² [IDENTIFIER¹]");
    663663                }
    664664       
     
    702702        }
    703703         
    704         public ASTNode parseExpression() {
     704        public ASTNode parseExpr() {
    705705                if( !(nowReading.isLextant(Lextant.LROUND, Lextant.MINUS, Lextant.NOT) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) || (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) || (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING))) ) {
    706                         return syntaxErrorNode("expression² [IDENTIFIER¹, INTEGER_CONST¹, LROUND¹, MINUS¹, NOT¹, SQ_STRING¹, STRING¹]");
     706                        return syntaxErrorNode("expr² [IDENTIFIER¹, INTEGER_CONST¹, LROUND¹, MINUS¹, NOT¹, SQ_STRING¹, STRING¹]");
    707707                }
    708708       
     
    712712                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    713713                {
    714                         ASTNode child = parseExpression1();
     714                        ASTNode child = parseExpr1();
    715715                        result.appendChild(child);
    716716                        allChildren.add(child);
     
    726726                        }
    727727                        {
    728                                 ASTNode child = parseExpression();
    729                                 result.appendChild(child);
    730                                 allChildren.add(child);
    731                         }
    732                 }
    733                 if(allowCompression) {
    734                         return compressIfPossible(result);
    735                 }
    736                 return result;
    737         }
    738          
    739         public ASTNode parseExpression1() {
     728                                ASTNode child = parseExpr();
     729                                result.appendChild(child);
     730                                allChildren.add(child);
     731                        }
     732                }
     733                if(allowCompression) {
     734                        return compressIfPossible(result);
     735                }
     736                return result;
     737        }
     738         
     739        public ASTNode parseExpr1() {
    740740                if( !(nowReading.isLextant(Lextant.LROUND, Lextant.MINUS, Lextant.NOT) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) || (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) || (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING))) ) {
    741                         return syntaxErrorNode("expression1² [IDENTIFIER¹, INTEGER_CONST¹, LROUND¹, MINUS¹, NOT¹, SQ_STRING¹, STRING¹]");
     741                        return syntaxErrorNode("expr1² [IDENTIFIER¹, INTEGER_CONST¹, LROUND¹, MINUS¹, NOT¹, SQ_STRING¹, STRING¹]");
    742742                }
    743743       
     
    747747                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    748748                {
    749                         ASTNode child = parseExpression2();
     749                        ASTNode child = parseExpr2();
    750750                        result.appendChild(child);
    751751                        allChildren.add(child);
     
    755755                        expect(Lextant.AND);
    756756                        {
    757                                 ASTNode child = parseExpression1();
    758                                 result.appendChild(child);
    759                                 allChildren.add(child);
    760                         }
    761                 }
    762                 if(allowCompression) {
    763                         return compressIfPossible(result);
    764                 }
    765                 return result;
    766         }
    767          
    768         public ASTNode parseExpression2() {
     757                                ASTNode child = parseExpr1();
     758                                result.appendChild(child);
     759                                allChildren.add(child);
     760                        }
     761                }
     762                if(allowCompression) {
     763                        return compressIfPossible(result);
     764                }
     765                return result;
     766        }
     767         
     768        public ASTNode parseExpr2() {
    769769                if( !(nowReading.isLextant(Lextant.LROUND, Lextant.MINUS, Lextant.NOT) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) || (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) || (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING))) ) {
    770                         return syntaxErrorNode("expression2² [IDENTIFIER¹, INTEGER_CONST¹, LROUND¹, MINUS¹, NOT¹, SQ_STRING¹, STRING¹]");
     770                        return syntaxErrorNode("expr2² [IDENTIFIER¹, INTEGER_CONST¹, LROUND¹, MINUS¹, NOT¹, SQ_STRING¹, STRING¹]");
    771771                }
    772772       
     
    781781                }
    782782                {
    783                         ASTNode child = parseExpression3();
     783                        ASTNode child = parseExpr3();
    784784                        result.appendChild(child);
    785785                        allChildren.add(child);
     
    792792        }
    793793         
    794         public ASTNode parseExpression3() {
     794        public ASTNode parseExpr3() {
    795795                if( !(nowReading.isLextant(Lextant.LROUND, Lextant.MINUS) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) || (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) || (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING))) ) {
    796                         return syntaxErrorNode("expression3² [IDENTIFIER¹, INTEGER_CONST¹, LROUND¹, MINUS¹, SQ_STRING¹, STRING¹]");
     796                        return syntaxErrorNode("expr3² [IDENTIFIER¹, INTEGER_CONST¹, LROUND¹, MINUS¹, SQ_STRING¹, STRING¹]");
    797797                }
    798798       
     
    804804                        expect(Lextant.LROUND);
    805805                        {
    806                                 ASTNode child = parseExpression();
     806                                ASTNode child = parseExpr();
    807807                                result.appendChild(child);
    808808                                allChildren.add(child);
     
    819819                else if( (nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
    820820                        {
    821                                 ASTNode child = parseCompoundVariable();
     821                                ASTNode child = parseCompoundIdentifier();
    822822                                result.appendChild(child);
    823823                                allChildren.add(child);
     
    961961        }
    962962         
    963         public ASTNode parseCompoundVariable() {
     963        public ASTNode parseCompoundIdentifier() {
    964964                if( !((nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
    965                         return syntaxErrorNode("compoundVariable² [IDENTIFIER¹]");
    966                 }
    967        
    968                 boolean allowCompression = true;
    969                 ASTNode result = new CompoundVariableNode(nowReading);
     965                        return syntaxErrorNode("compoundIdentifier² [IDENTIFIER¹]");
     966                }
     967       
     968                boolean allowCompression = true;
     969                ASTNode result = new CompoundIdentifierNode(nowReading);
    970970                result.setProductionTag(32);
    971971                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
Note: See TracChangeset for help on using the changeset viewer.