Changeset 2621


Ignore:
Timestamp:
Nov 7, 2012, 3:50:54 PM (6 years ago)
Author:
ksherdy
Message:

Updated grammar, code generation, ...

Location:
proto/pablo
Files:
7 added
27 deleted
22 edited

Legend:

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

    r2609 r2621  
    11//
    22// Ken Herdy
    3 // Sept. 8 2012
     3// 8-September-2012
    44//
    55context main {
     
    2121 
    2222        TYPEDEF,
    23 //      CALL,
    2423        VAR,
    2524        FUNCTION,       
     
    6564  binaryOperator {} [expression, expression1],//, expression4],
    6665  unaryOperator {} [expression2,],// expression5],
    67   assignmentStatement {} [assignmentStatementRest],
    68   functionInvocationStatement {} [functionInvocationRest],
    69   ASTNode [functionInvocationOrAssignmentStatement],
     66  assignment {} [assignmentRest],
     67  functionInvocation {} [functionInvocationRest],
    7068  integerConstant{intValued;} [],
    71  
    7269}
    7370
     
    8481        declarations                    -> (typeDecl | typeDef) TERMINATOR ;
    8582
    86         typeDecl                                ->  type ;
     83        typeDecl                                ->  type declaratorList ?;
    8784               
    88         typeDef                                 ->  TYPEDEF type declaratorList ? ;
     85        typeDef                                 ->  TYPEDEF type identifier ;
    8986       
    9087        declaratorList                  ->  identifier (COMMA identifier)? ;
     
    9693        functionDef             -> FUNCTION type functionName LROUND parameterList RROUND blockStatement TERMINATOR?;                           
    9794                                                                               
    98         returnType              #-> type ;      // Note: Not strictly required.
     95        returnType              #-> type ;      // Note: Strictly not required.
    9996       
    10097        parameterList   -> (parameter (COMMA parameter)*)?;
     
    115112        statement                                                       #-> (functionInvocationOrAssignmentStatement | ifStatement | whileStatement | returnStatement | localVarDecl) (TERMINATOR)? ;
    116113                       
    117         functionInvocationOrAssignmentStatement -> compoundVariable ((functionInvocationRest _promote_) | (assignmentStatementRest _promote_)) TERMINATOR ;
    118        
    119 //      functionInvocationRest                          -> LROUND^ functionInvocationArgumentsList RROUND ;
    120        
    121         functionInvocationRest                          -> LROUND^ (expression (COMMA expression)*)? RROUND ;
    122 
    123         functionInvocationArgumentsList         -> (expression (COMMA expression)*)? ; 
     114        functionInvocationOrAssignmentStatement -> compoundVariable ((functionInvocationRest _promote_) | (assignmentRest _promote_)) TERMINATOR ;
     115       
     116        functionInvocationRest                          -> LROUND^ functionInvocationArgumentList RROUND ;
     117       
     118//      functionInvocationRest                          -> LROUND^ (expression (COMMA expression)*)? RROUND ;
     119
     120        functionInvocationArgumentList          -> (expression (COMMA expression)*)? ; 
    124121               
    125122        assignmentOperator                                      -> ASSIGN | AND_ASSIGN | OR_ASSIGN | XOR_ASSIGN ;                               
    126123                                       
    127         assignmentStatementRest                         -> assignmentOperator^! expression ;                           
     124        assignmentRest                          -> assignmentOperator^! expression ;                           
    128125                                       
    129126        ifStatement                                                     -> IF LROUND expression RROUND blockStatement ; // (ELSE blockStatement)?                       
  • proto/pablo/input/test/pablo/funcDef/funcDef1.pablo

    r2609 r2621  
    1 function struct Lex ClassifyBytes(stream<1> a, stream b) {
     1struct B
     2{
     3        stream a;
     4        stream a;
     5        stream a;
     6        stream a;
     7};
    28
    3         i = foo(a);     
    4 };
     9function struct B Foo() { }
  • proto/pablo/input/test/visitors/AdvanceCombiner/advance.pablo

    r2600 r2621  
    88        temp = Advance(X,2);                            // Expected
    99        temp = Advance(Advance(X));             // Translated to Expected
    10        
     10
    1111        temp = Advance(X,2);                            // Expected
    1212        temp = Advance(pablo.Advance(X));       // Translated to Expected
  • proto/pablo/src/ast/ASTTransformer.java

    r2609 r2621  
    1212        ASTNode visit(ASTNode node);
    1313       
     14        public ASTNode visit(AssignmentNode node);
     15
    1416        public ASTNode visit(AssignmentOperatorNode node);
    1517
    16         public ASTNode visit(AssignmentStatementNode node);
    17 
    1818        public ASTNode visit(BinaryOperatorNode node);
    1919
     
    3434        public ASTNode visit(FunctionDefNode node);
    3535
    36         public ASTNode visit(FunctionInvocationArgumentsListNode node);
    37 
    38         public ASTNode visit(FunctionInvocationStatementNode node);
     36        public ASTNode visit(FunctionInvocationArgumentListNode node);
     37
     38        public ASTNode visit(FunctionInvocationNode node);
     39
     40        public ASTNode visit(FunctionInvocationOrAssignmentStatementNode node);
    3941
    4042        public ASTNode visit(IdentifierNode node);
     
    8587                }
    8688       
     89                public ASTNode visit(AssignmentNode node) {
     90                        return defaultVisit(node);
     91                }
     92
    8793                public ASTNode visit(AssignmentOperatorNode node) {
    8894                        return defaultVisit(node);
    8995                }
    9096
    91                 public ASTNode visit(AssignmentStatementNode node) {
    92                         return defaultVisit(node);
    93                 }
    94 
    9597                public ASTNode visit(BinaryOperatorNode node) {
    9698                        return defaultVisit(node);
     
    129131                }
    130132
    131                 public ASTNode visit(FunctionInvocationArgumentsListNode node) {
    132                         return defaultVisit(node);
    133                 }
    134 
    135                 public ASTNode visit(FunctionInvocationStatementNode node) {
     133                public ASTNode visit(FunctionInvocationArgumentListNode node) {
     134                        return defaultVisit(node);
     135                }
     136
     137                public ASTNode visit(FunctionInvocationNode node) {
     138                        return defaultVisit(node);
     139                }
     140
     141                public ASTNode visit(FunctionInvocationOrAssignmentStatementNode node) {
    136142                        return defaultVisit(node);
    137143                }
  • proto/pablo/src/ast/ASTVisitor.java

    r2609 r2621  
    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
    1619        public void visitEnter(AssignmentOperatorNode node);
    1720        public T visitLeave(AssignmentOperatorNode node, List<T> childResults);
    1821
    19         public void visitEnter(AssignmentStatementNode node);
    20         public T visitLeave(AssignmentStatementNode node, List<T> childResults);
    21 
    2222        public void visitEnter(BinaryOperatorNode node);
    2323        public T visitLeave(BinaryOperatorNode node, List<T> childResults);
     
    4747        public T visitLeave(FunctionDefNode node, List<T> childResults);
    4848
    49         public void visitEnter(FunctionInvocationArgumentsListNode node);
    50         public T visitLeave(FunctionInvocationArgumentsListNode node, List<T> childResults);
    51 
    52         public void visitEnter(FunctionInvocationStatementNode node);
    53         public T visitLeave(FunctionInvocationStatementNode node, List<T> childResults);
     49        public void visitEnter(FunctionInvocationArgumentListNode node);
     50        public T visitLeave(FunctionInvocationArgumentListNode node, List<T> childResults);
     51
     52        public void visitEnter(FunctionInvocationNode node);
     53        public T visitLeave(FunctionInvocationNode node, List<T> childResults);
     54
     55        public void visitEnter(FunctionInvocationOrAssignmentStatementNode node);
     56        public T visitLeave(FunctionInvocationOrAssignmentStatementNode node, List<T> childResults);
    5457
    5558        public void visitEnter(IdentifierNode node);
     
    131134                }
    132135               
     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
    133143                public void visitEnter(AssignmentOperatorNode node) {
    134144                        defaultVisitEnter(node);
     
    138148                }
    139149
    140                 public void visitEnter(AssignmentStatementNode node) {
    141                         defaultVisitEnter(node);
    142                 }
    143                 public T visitLeave(AssignmentStatementNode node, List<T> childResults) {
    144                         return defaultVisitLeave(node);
    145                 }
    146 
    147150                public void visitEnter(BinaryOperatorNode node) {
    148151                        defaultVisitEnter(node);
     
    208211                }
    209212
    210                 public void visitEnter(FunctionInvocationArgumentsListNode node) {
    211                         defaultVisitEnter(node);
    212                 }
    213                 public T visitLeave(FunctionInvocationArgumentsListNode node, List<T> childResults) {
    214                         return defaultVisitLeave(node);
    215                 }
    216 
    217                 public void visitEnter(FunctionInvocationStatementNode node) {
    218                         defaultVisitEnter(node);
    219                 }
    220                 public T visitLeave(FunctionInvocationStatementNode node, List<T> childResults) {
     213                public void visitEnter(FunctionInvocationArgumentListNode node) {
     214                        defaultVisitEnter(node);
     215                }
     216                public T visitLeave(FunctionInvocationArgumentListNode node, List<T> childResults) {
     217                        return defaultVisitLeave(node);
     218                }
     219
     220                public void visitEnter(FunctionInvocationNode node) {
     221                        defaultVisitEnter(node);
     222                }
     223                public T visitLeave(FunctionInvocationNode node, List<T> childResults) {
     224                        return defaultVisitLeave(node);
     225                }
     226
     227                public void visitEnter(FunctionInvocationOrAssignmentStatementNode node) {
     228                        defaultVisitEnter(node);
     229                }
     230                public T visitLeave(FunctionInvocationOrAssignmentStatementNode node, List<T> childResults) {
    221231                        return defaultVisitLeave(node);
    222232                }
  • proto/pablo/src/ast/SimpleVisitor.java

    r2609 r2621  
    1313        void visit(ASTNode node);
    1414       
     15        public void visit(AssignmentNode node);
     16
    1517        public void visit(AssignmentOperatorNode node);
    1618
    17         public void visit(AssignmentStatementNode node);
    18 
    1919        public void visit(BinaryOperatorNode node);
    2020
     
    3535        public void visit(FunctionDefNode node);
    3636
    37         public void visit(FunctionInvocationArgumentsListNode node);
    38 
    39         public void visit(FunctionInvocationStatementNode node);
     37        public void visit(FunctionInvocationArgumentListNode node);
     38
     39        public void visit(FunctionInvocationNode node);
     40
     41        public void visit(FunctionInvocationOrAssignmentStatementNode node);
    4042
    4143        public void visit(IdentifierNode node);
     
    8688                }
    8789       
     90                public void visit(AssignmentNode node) {
     91                        defaultVisit(node);
     92                }
     93
    8894                public void visit(AssignmentOperatorNode node) {
    8995                        defaultVisit(node);
    9096                }
    9197
    92                 public void visit(AssignmentStatementNode node) {
    93                         defaultVisit(node);
    94                 }
    95 
    9698                public void visit(BinaryOperatorNode node) {
    9799                        defaultVisit(node);
     
    130132                }
    131133
    132                 public void visit(FunctionInvocationArgumentsListNode node) {
    133                         defaultVisit(node);
    134                 }
    135 
    136                 public void visit(FunctionInvocationStatementNode node) {
     134                public void visit(FunctionInvocationArgumentListNode node) {
     135                        defaultVisit(node);
     136                }
     137
     138                public void visit(FunctionInvocationNode node) {
     139                        defaultVisit(node);
     140                }
     141
     142                public void visit(FunctionInvocationOrAssignmentStatementNode node) {
    137143                        defaultVisit(node);
    138144                }
  • proto/pablo/src/ast/VoidVisitor.java

    r2609 r2621  
    1212        void visitLeave(ASTNode node);
    1313       
     14        public void visitEnter(AssignmentNode node);
     15        public void visitLeave(AssignmentNode node);
     16
    1417        public void visitEnter(AssignmentOperatorNode node);
    1518        public void visitLeave(AssignmentOperatorNode node);
    1619
    17         public void visitEnter(AssignmentStatementNode node);
    18         public void visitLeave(AssignmentStatementNode node);
    19 
    2020        public void visitEnter(BinaryOperatorNode node);
    2121        public void visitLeave(BinaryOperatorNode node);
     
    4545        public void visitLeave(FunctionDefNode node);
    4646
    47         public void visitEnter(FunctionInvocationArgumentsListNode node);
    48         public void visitLeave(FunctionInvocationArgumentsListNode node);
    49 
    50         public void visitEnter(FunctionInvocationStatementNode node);
    51         public void visitLeave(FunctionInvocationStatementNode node);
     47        public void visitEnter(FunctionInvocationArgumentListNode node);
     48        public void visitLeave(FunctionInvocationArgumentListNode node);
     49
     50        public void visitEnter(FunctionInvocationNode node);
     51        public void visitLeave(FunctionInvocationNode node);
     52
     53        public void visitEnter(FunctionInvocationOrAssignmentStatementNode node);
     54        public void visitLeave(FunctionInvocationOrAssignmentStatementNode node);
    5255
    5356        public void visitEnter(IdentifierNode node);
     
    128131                }
    129132               
     133                public void visitEnter(AssignmentNode node) {
     134                        defaultVisitEnter(node);
     135                }
     136                public void visitLeave(AssignmentNode node) {
     137                        defaultVisitLeave(node);
     138                }
     139
    130140                public void visitEnter(AssignmentOperatorNode node) {
    131141                        defaultVisitEnter(node);
     
    135145                }
    136146
    137                 public void visitEnter(AssignmentStatementNode node) {
    138                         defaultVisitEnter(node);
    139                 }
    140                 public void visitLeave(AssignmentStatementNode node) {
    141                         defaultVisitLeave(node);
    142                 }
    143 
    144147                public void visitEnter(BinaryOperatorNode node) {
    145148                        defaultVisitEnter(node);
     
    205208                }
    206209
    207                 public void visitEnter(FunctionInvocationArgumentsListNode node) {
    208                         defaultVisitEnter(node);
    209                 }
    210                 public void visitLeave(FunctionInvocationArgumentsListNode node) {
    211                         defaultVisitLeave(node);
    212                 }
    213 
    214                 public void visitEnter(FunctionInvocationStatementNode node) {
    215                         defaultVisitEnter(node);
    216                 }
    217                 public void visitLeave(FunctionInvocationStatementNode node) {
     210                public void visitEnter(FunctionInvocationArgumentListNode node) {
     211                        defaultVisitEnter(node);
     212                }
     213                public void visitLeave(FunctionInvocationArgumentListNode node) {
     214                        defaultVisitLeave(node);
     215                }
     216
     217                public void visitEnter(FunctionInvocationNode node) {
     218                        defaultVisitEnter(node);
     219                }
     220                public void visitLeave(FunctionInvocationNode node) {
     221                        defaultVisitLeave(node);
     222                }
     223
     224                public void visitEnter(FunctionInvocationOrAssignmentStatementNode node) {
     225                        defaultVisitEnter(node);
     226                }
     227                public void visitLeave(FunctionInvocationOrAssignmentStatementNode node) {
    218228                        defaultVisitLeave(node);
    219229                }
  • proto/pablo/src/compiler/PabloCompilerTestHarness.java

    r2579 r2621  
    3030        protected static String testDirectoryName = null;
    3131       
     32       
    3233        public enum Test {
    33             ADVANCECOMBINER("AdvanceCombiner"),
    34             ADVANCENCOUNTER("AdvanceNCounter"),
    35             AUGMENTEDASSIGNMENT("AugmentedAssignment"),
    36             BITWISE2IDISA("Bitwise2IDISA"),
    37             CARRYCOUNTER("CarryCounter"),
    38             CARRYINTROCICO("CarryIntroCiCo"),
    39             CARRYINTROCI("CarryIntroCi"),
    40             CARRYINITTOONELIST("CarryInitToOneList"),
    41             STREAMFUNCTIONVISITOR("StreamFunctionVisitor");
     34            ADVANCECOMBINER("AdvanceCombiner", true),
     35            ADVANCENCOUNTER("AdvanceNCounter", true),
     36            AUGMENTEDASSIGNMENT("AugmentedAssignment", true),
     37            BITWISE2IDISA("Bitwise2IDISA", true),
     38            CARRYCOUNTER("CarryCounter", true),
     39            CARRYINTROCICO("CarryIntroCiCo", true),
     40            CARRYINTROCI("CarryIntroCi", true),
     41            CARRYINITTOONELIST("CarryInitToOneList", true),
     42            STREAMFUNCTIONVISITOR("StreamFunctionVisitor", true);
    4243           
    4344            private final String directoryName;
     45            private boolean addTest = false;
    4446           
    45             Test(String directoryName) {
     47            Test(String directoryName, boolean addTest) {
    4648                this.directoryName = directoryName;
     49                this.addTest = addTest;
    4750            }
    4851           
    4952            public String directory() { return directoryName; }
     53            public boolean addTest() { return addTest; }
    5054        }
    5155       
     
    6266
    6367                for(Test test: Test.values()) {
    64                         String dir = new String();
    65                         ArrayList<File> files = new ArrayList<File>();
    66                         dir = testBase.getAbsolutePath() + File.separator + test.directory();
    67                         files = matchFiles(new File (dir), ".pablo");
    68                        
    69                         for(File file: files) {
    70                                 String fileAbsolutePath = file.getAbsolutePath();
    71                                 System.out.println("Running: " + fileAbsolutePath);
    72                                
    73                                 switch(test) {
    74                                         case ADVANCECOMBINER:
    75                                                 advanceCombinerTest(fileAbsolutePath);
    76                                         break;
    77                                 case ADVANCENCOUNTER:
    78                                         break;
    79                                 case AUGMENTEDASSIGNMENT:                                       
    80                                                 augmentedAssignmentTest(fileAbsolutePath);
    81                                         break;
    82                                 case BITWISE2IDISA:
    83                                                 bitwise2IDISATest(fileAbsolutePath);
    84                                         break;                                 
    85                                 case CARRYCOUNTER:
    86                                         break;                                 
    87                                 case CARRYINTROCICO:
    88                                                 carryIntroTest(fileAbsolutePath, true, true);
    89                                         break;
    90                                 case CARRYINTROCI:
    91                                                 carryIntroTest(fileAbsolutePath, true, false);
    92                                         break; 
    93                                 case CARRYINITTOONELIST:
    94                                         break;                                 
    95                                 case STREAMFUNCTIONVISITOR:
    96                                         break;
    97                                 default:
    98                                         break;
     68                       
     69                        if (test.addTest()) {
     70                       
     71                                String dir = new String();
     72                                ArrayList<File> files = new ArrayList<File>();
     73                                dir = testBase.getAbsolutePath() + File.separator + test.directory();
     74                                files = matchFiles(new File (dir), ".pablo");
     75                               
     76                                for(File file: files) {
     77                                        String fileAbsolutePath = file.getAbsolutePath();
     78                                        System.out.println("Running: " + fileAbsolutePath);
     79                                       
     80                                        switch(test) {
     81                                                case ADVANCECOMBINER:
     82                                                        advanceCombinerTest(fileAbsolutePath);
     83                                                        break;
     84                                                case ADVANCENCOUNTER:
     85                                                        break;
     86                                                case AUGMENTEDASSIGNMENT:                                       
     87                                                                augmentedAssignmentTest(fileAbsolutePath);
     88                                                        break;
     89                                                case BITWISE2IDISA:
     90                                                                bitwise2IDISATest(fileAbsolutePath);
     91                                                        break;                                 
     92                                                case CARRYCOUNTER:
     93                                                        break;                                 
     94                                                case CARRYINTROCICO:
     95                                                                carryIntroTest(fileAbsolutePath, true, true);
     96                                                        break;
     97                                                case CARRYINTROCI:
     98                                                                carryIntroTest(fileAbsolutePath, true, false);
     99                                                        break; 
     100                                                case CARRYINITTOONELIST:
     101                                                        break;                                 
     102                                                case STREAMFUNCTIONVISITOR:
     103                                                        break;
     104                                                default:
     105                                                        break;
     106                                        }
    99107                                }
    100108                        }
    101                 }               
    102                         System.out.print("Tests complete.");
     109                }
     110               
     111                System.out.print("Tests complete.");
    103112        }
    104113       
  • proto/pablo/src/compiler/ast/Accessors.java

    r2609 r2621  
    2424        // Assignment Statements
    2525        ////////////////////////////////////////////////////////////////////////////                           
    26         public static ASTNode lhs(AssignmentStatementNode node) {
    27                 return node.child(0);
    28         }       
    29        
    30         public static ASTNode rhs(AssignmentStatementNode node) {
    31                 return node.child(1);
    32         }       
    33 
    34         public static String assignmentOperator(AssignmentStatementNode node) {
     26        public static ASTNode lhs(AssignmentNode node) {
     27                return node.child(0);
     28        }       
     29       
     30        public static ASTNode rhs(AssignmentNode node) {
     31                return node.child(1);
     32        }       
     33
     34        public static String assignmentOperator(AssignmentNode node) {
    3535                return node.getToken().getLexeme();
    3636        }
     
    4040        ////////////////////////////////////////////////////////////////////////////                           
    4141
    42         public static String assignmentOperator(FunctionInvocationStatementNode node) {
     42        public static String assignmentOperator(FunctionInvocationNode node) {
    4343                return node.getToken().getLexeme();
    4444        }       
     
    153153        // FunctionInvocationNode helpers
    154154        ////////////////////////////////////////////////////////////////////////////
    155         public static ASTNode functionInvocationName(FunctionInvocationStatementNode node) {
    156                 return node.child(0);
    157         }
    158 
    159         public static ASTNode functionInvocationArg(FunctionInvocationStatementNode node, int index) {
    160                 int argIndex = 1 + index;
    161                 if(argIndex > node.getChildren().size()) {
     155        public static ASTNode functionInvocationName(FunctionInvocationNode node) {
     156                return node.child(0);
     157        }
     158
     159        public static ASTNode functionInvocationArgumentsListNode(FunctionInvocationNode node) {
     160                return node.child(1);
     161        }
     162       
     163        public static ASTNode functionInvocationArgument(FunctionInvocationNode node, int index) {
     164               
     165                if((index + 1) > Accessors.functionInvocationArgumentsList(node).getChildren().size()) {
    162166                        throw new RuntimeException("Function invocation argument out of range.");
    163167                }
    164                 return node.getChildren().get(argIndex);
    165         }
    166        
    167         public static List<ASTNode> functionInvocationArgs(FunctionInvocationStatementNode node) {
    168                 return node.getChildren().subList(1, node.nChildren());
     168                return Accessors.functionInvocationArgumentsList(node).child(index);
     169        }
     170       
     171        public static List<ASTNode> functionInvocationArgList(FunctionInvocationNode node) {
     172                return Accessors.functionInvocationArgumentsList(node).getChildren();
     173        }
     174       
     175        public static ASTNode functionInvocationArgumentsList(FunctionInvocationNode node) {
     176                return node.child(1);
    169177        }
    170178       
     
    191199                return identifier.getToken().getLexeme();
    192200        }
    193        
    194         public static String functionIdentifier(FunctionInvocationStatementNode node) {
    195                 ASTNode functionName = functionInvocationName(node);
    196                 String identifier = identifierLexeme(functionName);
    197                 return identifier;
    198         }
    199201
    200202        ////////////////////////////////////////////////////////////////////////////
  • proto/pablo/src/compiler/ast/Generators.java

    r2608 r2621  
    11package compiler.ast;
     2
     3import java.util.ArrayList;
     4import java.util.List;
    25
    36import lexicalAnalyzer.LexicalType;
     
    1619        // Static factories for various nodes
    1720        //
    18         // (some planned, some implemented)
    19         ////////////////////////////////////////////////////////////////////////////
    20 
    21         /** Makes a new FunctionInvocationStatementNode with a function identifier string and the TextLocation taken from token.
     21        // TODO - refactor makeFunctionInvocationNode code
     22        ////////////////////////////////////////////////////////////////////////////
     23
     24        /** Makes a new FunctionInvocationNode with a function identifier string and the TextLocation taken from token.
    2225         * @param identifier
    23          * @param locationToken         a token containing the TextLocation for this new node.
    24          * @return      the new FunctionInvocationStatementNode
    25          */
    26         public static FunctionInvocationStatementNode makeFunctionInvocationStatementNode(String identifier, Token locationToken) {
    27                 IdentifierNode identifierNode = Generators.makeIdentifierNode(identifier, locationToken);
    28                 return Generators.makeFunctionInvocationStatementNode(identifierNode, locationToken);
    29         }
    30 
    31         /** Makes a new compound FunctionInvocationStatementNode with a array of identifiers string and the TextLocation taken from token.
    32          * @param identifiers           an array of identifiers, for example {"a", "b"} will result in function call a.b();
    33          * @param locationToken         a token containing the TextLocation for this new node.
    34          * @return      the new FunctionInvocationStatementNode
    35          */
    36         public static FunctionInvocationStatementNode makeFunctionInvocationStatementNode(String[] identifiers, Token locationToken) {
     26         * @param locationToken
     27         * @return FunctionInvocationNode
     28         */
     29        public static FunctionInvocationNode makeFunctionInvocationNode(String identifier, Token locationToken) {
     30                IdentifierNode identifierNode = Generators.makeIdentifierNode(identifier, locationToken);       
     31                return Generators.makeFunctionInvocationNode(identifierNode, locationToken);
     32        }
     33
     34        /** Makes a new compound FunctionInvocationNode with a array of identifiers string and the TextLocation taken from token.
     35         * @param identifiers - a compound identifier a.b()     
     36         * @param locationToken
     37         * @return
     38         */
     39        public static FunctionInvocationNode makeFunctionInvocationNode(String[] identifiers, Token locationToken) {
     40               
    3741                CompoundVariableNode identifierNode = Generators.makeCompoundVariableNode(identifiers, locationToken);
    38                 return Generators.makeFunctionInvocationStatementNode(identifierNode, locationToken);
    39         }
    40 
    41         /** Makes a new compound FunctionInvocationStatementNode with a array of identifiers string and the TextLocation taken from token.
    42          * @param identifiers           an array of identifiers, for example {"a", "b"} will result in function call a.b();
    43          * @param locationToken         a token containing the TextLocation for this new node.
    44          * @param children                      an array of ASTNode children
    45          * @return      the new FunctionInvocationStatementNode
    46          */
    47         public static FunctionInvocationStatementNode makeFunctionInvocationStatementNode(String[] identifiers, Token locationToken, ASTNode [] children) {
    48                 CompoundVariableNode identifierNode = Generators.makeCompoundVariableNode(identifiers, locationToken);
    49                 FunctionInvocationStatementNode functionInvocationNode = Generators.makeFunctionInvocationStatementNode(identifierNode, locationToken);
    50                 for(ASTNode child:children) {
    51                         functionInvocationNode.appendChild(child);
     42                return Generators.makeFunctionInvocationNode(identifierNode, locationToken);
     43        }
     44
     45        public static FunctionInvocationNode makeFunctionInvocationNode(String identifier, Token locationToken, ASTNode[] arguments) {
     46               
     47                FunctionInvocationNode node = Generators.makeFunctionInvocationNode(identifier, locationToken);
     48                Generators.addFunctionInvocationArguments(node, arguments);
     49                return node;
     50        }       
     51
     52        public static FunctionInvocationNode makeFunctionInvocationNode(String identifier, Token locationToken, List<ASTNode> arguments) {
     53               
     54                FunctionInvocationNode node = Generators.makeFunctionInvocationNode(identifier, locationToken);
     55                Generators.addFunctionInvocationsArguments(node, arguments);
     56                return node;
     57        }       
     58       
     59        private static void addFunctionInvocationArguments(FunctionInvocationNode node, ASTNode[] arguments) {
     60                if(arguments.length > 0) {
     61                        for(ASTNode child: arguments) {
     62                                Accessors.functionInvocationArgumentsListNode(node).appendChild(child);
     63                        }
     64                        Accessors.functionInvocationArgumentsListNode(node).setToken(arguments[0].getToken());
     65                }       
     66        }
     67
     68        public static FunctionInvocationNode makeFunctionInvocationNode(String[] identifiers, Token locationToken, ASTNode[] arguments) {
     69       
     70                FunctionInvocationNode node = Generators.makeFunctionInvocationNode(identifiers, locationToken);
     71                List<ASTNode> list = new ArrayList<ASTNode>();
     72                for(ASTNode arg: arguments) {
     73                        list.add(arg);
    5274                }
     75                Generators.addFunctionInvocationsArguments(node, list);
     76                return node;
     77        }
     78
     79        public static FunctionInvocationNode makeFunctionInvocationNode(String[] identifiers, Token locationToken,  List<ASTNode> arguments) {
     80               
     81                FunctionInvocationNode node = Generators.makeFunctionInvocationNode(identifiers, locationToken);
     82                Generators.addFunctionInvocationsArguments(node, arguments);
     83                return node;
     84        }       
     85       
     86        private static void addFunctionInvocationsArguments(FunctionInvocationNode node, List<ASTNode> arguments) {
     87               
     88                if(arguments.size() > 0) {
     89                        for(ASTNode child: arguments) {
     90                                Accessors.functionInvocationArgumentsListNode(node).appendChild(child);
     91                        }
     92                        Accessors.functionInvocationArgumentsListNode(node).setToken(arguments.get(0).getToken());
     93                }               
     94        }
     95       
     96        private static FunctionInvocationNode makeFunctionInvocationNode(ASTNode identifier, Token locationToken) {
     97                assert identifier instanceof IdentifierNode || identifier instanceof CompoundVariableNode;
     98
     99                LextantToken token = Generators.makeLextantToken(Lextant.LROUND, locationToken);
     100                FunctionInvocationNode functionInvocationNode = new FunctionInvocationNode(token);
     101                functionInvocationNode.appendChild(identifier);
     102                functionInvocationNode.appendChild(new FunctionInvocationArgumentListNode(locationToken));
     103
    53104                return functionInvocationNode;
    54105        }       
    55        
    56         /** Makes a new FunctionInvocationStatementNode with an ASTNode identifier and the TextLocation taken from token.
    57          * @param identifier            an ASTNode, must be IdentifierNode or CompundVariableNode
    58          * @param locationToken         a token containing the TextLocation for this new node.
    59          * @return      the new FunctionInvocationStatementNode
    60          */
    61         public static FunctionInvocationStatementNode makeFunctionInvocationStatementNode(ASTNode identifier, Token locationToken) {
    62                 assert identifier instanceof IdentifierNode || identifier instanceof CompoundVariableNode;
    63                
    64                 LextantToken token = Generators.makeLextantToken(Lextant.LROUND, locationToken);
    65                 FunctionInvocationStatementNode functionInvocationNode = new FunctionInvocationStatementNode(token);
    66                 functionInvocationNode.appendChild(identifier);
    67                 return functionInvocationNode;
    68         }
    69 
    70         /** Makes a new FunctionInvocationStatementNode with a function identifier string, an ASTNode whose attributes
    71          * and children will be copied to the new FunctionInvocationStatementNode and the TextLocation taken from token.
    72          * @param identifier            the identifier of FunctionInvocationStatementNode. If toBeCopied is a FunctionInvocationStatementNode,
    73          *                                                      it will replace the copied identifier. Otherwise it will be inserted as the first child.
    74          * @param toBeCopied            an ASTNode whose attributes and children will be copied.
    75          * @param locationToken         a token containing the TextLocation for this new node.
    76          * @return      the new FunctionInvocationStatementNode
    77          */
    78         public static FunctionInvocationStatementNode makeFunctionInvocationStatementNode(String identifier, ASTNode toBeCopied, Token locationToken) {
    79                 FunctionInvocationStatementNode functionInvocationNode = new FunctionInvocationStatementNode(toBeCopied);
    80                 for (ASTNode child : toBeCopied.getChildren()) {
    81                         functionInvocationNode.appendChild(child);
    82                 }
    83                
    84                 IdentifierNode newIdentifier = Generators.makeIdentifierNode(identifier, locationToken);
    85                
    86                 if(toBeCopied instanceof FunctionInvocationStatementNode) {
    87                         ASTNode originalIdentifier = functionInvocationNode.child(0);
    88                         functionInvocationNode.replaceChild(originalIdentifier, newIdentifier);
    89                 } else {
    90                         functionInvocationNode.insertChild(newIdentifier);
    91                 }
    92                 return functionInvocationNode;
    93         }
    94106               
    95107        /** Makes a new CompoundVariableNode with an array of identifier strings and and the TextLocation taken from token.
  • proto/pablo/src/compiler/codeGeneration/CodeStore.java

    r2607 r2621  
    77       
    88        private class CodeLine {
    9                 public final String line;
     9                public String line;
    1010                public final int relativeIndent;         // compared to previous line.
    1111                public CodeLine(String line, int relativeIndent) {
     
    2020        List<CodeLine> code = new ArrayList<CodeLine>();
    2121        private String resultVariableName = "codeStoreNoVariable";
     22
     23        public void appendToLast(String line) {
     24                if (code.isEmpty()) {
     25                        addLine(line);
     26                } else {
     27                        CodeLine codeLine = code.get(code.size()-1);
     28                        codeLine.line += line;
     29                }
     30        }
    2231       
    2332        public void addLine(String line, int relativeIndent) {
  • proto/pablo/src/compiler/lang/pablo/builtins/BuiltinsUtil.java

    r2608 r2621  
    1616     */   
    1717    public static boolean isAdvance(ASTNode node) {
    18         if(!(node instanceof FunctionInvocationStatementNode)) {
     18        if(!(node instanceof FunctionInvocationNode)) {
    1919            return false;
    2020        }
    2121       
    22         FunctionInvocationStatementNode fNode = (FunctionInvocationStatementNode)node;
     22        FunctionInvocationNode fNode = (FunctionInvocationNode)node;
    2323        ASTNode nameNode = Accessors.functionInvocationName(fNode);
    2424       
     
    7070     */
    7171    public static boolean isBuiltInCallNoArgCount(ASTNode node) {
    72         if(!(node instanceof FunctionInvocationStatementNode)) {
     72        if(!(node instanceof FunctionInvocationNode)) {
    7373            return false;
    7474        }
    7575       
    76         FunctionInvocationStatementNode fNode = (FunctionInvocationStatementNode)node;
     76        FunctionInvocationNode fNode = (FunctionInvocationNode)node;
    7777        ASTNode nameNode = Accessors.functionInvocationName(fNode);
    7878
     
    114114     */
    115115    public static boolean isCall(ASTNode node, String packageName, String functionName, int numArgs) {
    116         if(!(node instanceof FunctionInvocationStatementNode)) {
     116        if(!(node instanceof FunctionInvocationNode)) {
    117117            return false;
    118118        }
    119119       
    120         FunctionInvocationStatementNode fNode = (FunctionInvocationStatementNode)node;
     120        FunctionInvocationNode fNode = (FunctionInvocationNode)node;
    121121        ASTNode nameNode = Accessors.functionInvocationName(fNode);
    122122
    123123        boolean nameMatches = isQualifiedName(nameNode, packageName, functionName);
    124         boolean numArgsMatches = Accessors.functionInvocationArgs(fNode).size() == numArgs;
     124        boolean numArgsMatches = Accessors.functionInvocationArgumentsListNode(fNode).nChildren() == numArgs;
    125125       
    126126        return nameMatches && numArgsMatches;
  • proto/pablo/src/compiler/test/ASTTest.java

    r2608 r2621  
    5656                }
    5757               
    58                 public void visitEnter(FunctionInvocationStatementNode node) {
     58                public void visitEnter(FunctionInvocationNode node) {
    5959                       
    6060                        if(this.ASTTree1 == null) {
     
    7474                }
    7575               
    76                 public void visitEnter(AssignmentStatementNode node) {
     76                public void visitEnter(AssignmentNode node) {
    7777                        if(ASTTree1 == null) {
    7878                                this.ASTTree1 = node;
  • proto/pablo/src/compiler/visitors/AdvanceCombiner.java

    r2608 r2621  
    22
    33
     4import compiler.ast.Accessors;
    45import compiler.ast.Generators;
    56import compiler.lang.pablo.builtins.BuiltinsUtil;
     
    4041                }
    4142
    42                 public void visitLeave(FunctionInvocationStatementNode node) {
     43                public void visitLeave(FunctionInvocationNode node) {
    4344                       
    44                         if(!isAdvanceOfAdvance(node)) {
     45                        if(!isAdvanceOfAdvance(node)) { 
    4546                                return;
    4647                        }
    47                                                
    48                         FunctionInvocationStatementNode child = (FunctionInvocationStatementNode)streamBeingAdvanced(node);
    49                         ASTNode streamBeingAdvanced = streamBeingAdvanced(child);
    50                        
     48                               
     49                        FunctionInvocationNode child = (FunctionInvocationNode)streamBeingAdvanced(node);
    5150                       
    5251                        int amount1 = advanceAmount(node);
    5352                        int amount2 = advanceAmount(child);
    5453                       
     54                        /*
     55                        System.out.println("---");
     56                        System.out.println(node);
     57                        System.out.println("---");
     58                        System.out.println(child);
     59                        System.out.println("---");
     60                        System.out.println(streamBeingAdvanced);
     61                        System.out.println("---");
     62                        */
    5563
    56                         translateAdvanceNode(node, child, streamBeingAdvanced, amount1,
    57                                         amount2);
    58                        
    59                 }
    60                
     64                        translateAdvanceNode(node, child, amount1, amount2);
     65                }               
    6166        }
    6267       
     
    7883
    7984        // given that node is an advance, what is the stream being advanced?
    80         private ASTNode streamBeingAdvanced(FunctionInvocationStatementNode node) {
     85        private ASTNode streamBeingAdvanced(FunctionInvocationNode node) {
    8186                assert BuiltinsUtil.isAdvance(node);
    82                 return node.child(1);
     87                return Accessors.functionInvocationArgumentsList(node).child(0);
    8388        }
    8489
    85         private int advanceAmount(FunctionInvocationStatementNode node) {
     90        private int advanceAmount(FunctionInvocationNode node) {
    8691                assert BuiltinsUtil.isAdvance(node);
    87                 if(node.nChildren()==2) {
     92                if(Accessors.functionInvocationArgumentsList(node).nChildren()==1) {
    8893                        return 1;
    8994                }
    90                 assert node.nChildren()==3;
    91                 return valueOf(node.child(2));
     95                assert Accessors.functionInvocationArgumentsList(node).nChildren()==2;
     96                return valueOf(Accessors.functionInvocationArgumentsList(node).child(1));
    9297        }       
    9398       
    9499        private boolean isAdvanceOfAdvance(ASTNode node) {
    95                 if(!BuiltinsUtil.isAdvance(node))
     100                if(!BuiltinsUtil.isAdvance(node)) {
    96101                        return false;
    97        
    98                 ASTNode child = streamBeingAdvanced((FunctionInvocationStatementNode) node);
     102                }
     103                ASTNode child = streamBeingAdvanced((FunctionInvocationNode) node);             
    99104                return BuiltinsUtil.isAdvance(child);
    100105        }
    101106       
    102         private void translateAdvanceNode(FunctionInvocationStatementNode node,
    103                         FunctionInvocationStatementNode child, ASTNode streamBeingAdvanced,
     107        private void translateAdvanceNode(
     108                        FunctionInvocationNode node,
     109                        FunctionInvocationNode child,
    104110                        int amount1, int amount2) {
    105                 node.replaceChild(child, streamBeingAdvanced);
     111               
     112                node.replaceChild(      Accessors.functionInvocationArgumentsList(node),
     113                                                        Accessors.functionInvocationArgumentsList(child));
     114               
    106115                IntegerConstantNode integerConstantNode = Generators.makeIntegerConstantNode(amount1+amount2, node.getToken());
    107                 if(node.nChildren()==2) {
    108                         node.appendChild(integerConstantNode);
     116                if(Accessors.functionInvocationArgumentsList(node).nChildren()==1) {
     117                        Accessors.functionInvocationArgumentsList(child).appendChild(integerConstantNode);
    109118                }
    110                 assert node.nChildren()==3;
    111                 node.replaceChild(node.child(2), integerConstantNode);
     119                assert Accessors.functionInvocationArgumentsList(node).nChildren()==2;
     120                Accessors.functionInvocationArgumentsList(node).replaceChild(
     121                                Accessors.functionInvocationArgumentsList(node).child(1),
     122                                integerConstantNode);
    112123        }
    113        
    114124}
  • proto/pablo/src/compiler/visitors/AdvanceNCounter.java

    r2608 r2621  
    2424                }
    2525
    26                 public void visitLeave(FunctionInvocationStatementNode node) {
     26                public void visitLeave(FunctionInvocationNode node) {
    2727                        if(BuiltinsUtil.isCarryN(node)) {
    2828                            this.advNCount += 1;
  • proto/pablo/src/compiler/visitors/AugmentedAssignment.java

    r2608 r2621  
    3535        private class AugmentedAssignmentRemovalVisitor extends VoidVisitor.Default {
    3636               
    37                 public void visitLeave(AssignmentStatementNode node) {
     37                public void visitLeave(AssignmentNode node) {
    3838                        transformAugmentedAssignment(node, Accessors.lhs(node), Accessors.rhs(node));
    3939                }
  • proto/pablo/src/compiler/visitors/Bitwise2IDISA.java

    r2608 r2621  
    2525                        Token op = node.getToken();
    2626                        if(op.isLextant(Lextant.NOT)) {
    27                                
    28                                 FunctionInvocationStatementNode functionInvocationNode = Generators.makeFunctionInvocationStatementNode(SIMD.NOT.idisaName(), op);
    29                                 functionInvocationNode.appendChild(Accessors.operand(node));
     27
     28                                FunctionInvocationNode functionInvocationNode =
     29                                                Generators.makeFunctionInvocationNode(SIMD.NOT.idisaName(),
     30                                                                                                                                op,
     31                                                                                                                                new ASTNode [] {Accessors.operand(node)});                     
    3032                                node.updateSelf(functionInvocationNode);
    3133                        }
     
    4446                                }
    4547                               
    46                                 FunctionInvocationStatementNode functioninvocationNode = Generators.makeFunctionInvocationStatementNode(functionName, op);
    47                                 functioninvocationNode.appendChild(Accessors.leftOperand(node));
    48                                 functioninvocationNode.appendChild(Accessors.rightOperand(node));
    49                                 node.updateSelf(functioninvocationNode);
     48                                FunctionInvocationNode functionInvocationNode =
     49                                                Generators.makeFunctionInvocationNode(functionName,
     50                                                                                                                                op,
     51                                                                                                                                new ASTNode [] {Accessors.leftOperand(node), Accessors.rightOperand(node)});
     52                                node.updateSelf(functionInvocationNode);
    5053                        }
    5154                }
     
    6164                               
    6265                                name = SIMD.CONSTANT.idisaConstantName(fieldWidth, constant);
    63                                 FunctionInvocationStatementNode functionInvocationNode = Generators.makeFunctionInvocationStatementNode(name, node.getToken());
     66                                FunctionInvocationNode functionInvocationNode = Generators.makeFunctionInvocationNode(name, node.getToken());
    6467                                node.updateSelf(functionInvocationNode);
    6568                        }
     
    7376                        ASTNode ifTest = Accessors.ifTest(node);                       
    7477                        String functionName = BITBLOCK.ANY.getFunctionName();
    75                         FunctionInvocationStatementNode functionInvocationNode = Generators.makeFunctionInvocationStatementNode(functionName, ifTest.getToken());
    76                         functionInvocationNode.appendChild(ifTest);
     78                        FunctionInvocationNode functionInvocationNode = Generators.makeFunctionInvocationNode(functionName, node.getToken());
    7779                        node.replaceChild(ifTest, functionInvocationNode);
    78                         //ifTest.updateSelf(functionCallNode);
    7980                }
    8081               
     
    8687                        ASTNode whileTest = Accessors.whileCondition(node);
    8788                        String functionName = BITBLOCK.ANY.getFunctionName();
    88                         FunctionInvocationStatementNode functionInvocationNode = Generators.makeFunctionInvocationStatementNode(functionName, whileTest.getToken());
    89                         functionInvocationNode.appendChild(whileTest);
    90                         node.replaceChild(whileTest, functionInvocationNode);
    91                         //whileTest.updateSelf(functionCallNode);
     89                       
     90                        FunctionInvocationNode functionInvocationNode = Generators.makeFunctionInvocationNode(
     91                                                                                                                                functionName,
     92                                                                                                                                whileTest.getToken(),                                                                                                                                                                     new ASTNode [] {whileTest});
     93                                                                                                                                node.replaceChild(whileTest, functionInvocationNode);
     94                        }
    9295                }
    93                
    94         }
    9596}
    9697
  • proto/pablo/src/compiler/visitors/CPPCodeGenerator.java

    r2609 r2621  
    88import compiler.codeGeneration.*;
    99
    10 // ASTNode w/o code generation code: constant,
     10/*
     11 * Description: CodeStore get/set variables are used to pass text fragments
     12 *                              that do not constitute output lines.
     13 */
    1114
    1215public class CPPCodeGenerator extends CodeGenerator {
     
    4043        public CodeStore visitLeave(DeclarationsNode node, List<CodeStore> childResults) {
    4144                inTypeDecl = false;
     45               
    4246                return concatenatedChildrenCode(new CodeStore(), childResults, false);         
    4347        }       
    44                
     48
     49        public CodeStore visitLeave(TypeDeclNode node, List<CodeStore> childResults) {
     50                CodeStore code = new CodeStore();
     51                code.addFormattedLine("%s;", childResults.get(0).getResultVariableName());
     52                return code;           
     53        }               
     54       
    4555        ////////////////////////////////////////////////////////////////////////////
    4656        // Stream Functions
     
    5666                        parameters = childResults.get(2).getResultVariableName();
    5767                }
    58                
     68                               
    5969                code.addFormattedLine("%s %s (%s)",
    6070                                returnType.getResultVariableName(),
    6171                                functionName.getResultVariableName(),
    62                                 parameters);
     72                                parameters);   
    6373               
    6474                CodeStore blockStatement = childResults.get(3);
     
    104114       
    105115        // assignment statement
    106         public CodeStore visitLeave(AssignmentStatementNode node, List<CodeStore> childResults) {
     116        public CodeStore visitLeave(AssignmentNode node, List<CodeStore> childResults) {
    107117                CodeStore code = new CodeStore();
    108118                CodeStore lhs = childResults.get(0);
     
    115125        }
    116126
    117         // function invocation statement
    118         public CodeStore visitLeave(FunctionInvocationStatementNode node, List<CodeStore> childResults) {
    119                 CodeStore code = new CodeStore();
    120                 CodeStore lhs = childResults.get(0);
    121                 CodeStore rhs = childResults.get(1);
    122                 code.addFormattedLine("%s %s %s;", lhs.getResultVariableName()
    123                                                                                  , Accessors.assignmentOperator(node)
    124                                                                                  ,"rhs.getResultVariableName()");
     127        // function invocation
     128        public CodeStore visitLeave(FunctionInvocationNode node, List<CodeStore> childResults) {
     129                CodeStore code = new CodeStore();
     130               
     131                StringBuilder resultVariable = new StringBuilder();
     132               
     133                resultVariable.append(childResults.get(0).getResultVariableName());
     134                resultVariable.append("(");
     135                resultVariable.append(childResults.get(1).getResultVariableName());
     136                resultVariable.append(")");
     137               
     138                code.setResultVariableName(resultVariable.toString());
    125139               
    126140                return code;
    127141        }       
    128142       
     143        public CodeStore visitLeave(FunctionInvocationArgumentListNode node, List<CodeStore> childResults) { // a variable, not a line of code
     144                CodeStore code = new CodeStore();
     145               
     146                StringBuilder resultVariable = new StringBuilder();
     147               
     148                Iterator<CodeStore> iter = childResults.iterator();
     149               
     150                while (iter.hasNext()) {
     151                        resultVariable.append(iter.next().getResultVariableName());
     152                        if (iter.hasNext()) {
     153                                resultVariable.append(", ");
     154                        }
     155                }
     156               
     157                code.setResultVariableName(resultVariable.toString());
     158               
     159                return code;
     160        }       
     161               
    129162        // if statement
    130163        public CodeStore visitLeave(IfStatementNode node, List<CodeStore> childResults) {
     
    140173       
    141174        // while statement
     175        public CodeStore visitLeave(WhileStatementNode node, List<CodeStore> childResults) {
     176                CodeStore code = new CodeStore();
     177                CodeStore ifTest                        = childResults.get(0);
     178                CodeStore blockStatement        = childResults.get(1);
     179                code.addFormattedLine("while (%s)", ifTest.getResultVariableName());
     180                code.addLine("{");
     181                code.addAll(blockStatement, 1);
     182                code.dedentedLine("}");
     183                return code;
     184        }       
    142185       
    143186        // return statement
     
    150193                       
    151194        // variable declarations list
    152         public CodeStore visitLeave(LocalVarDeclListNode node, List<CodeStore> childResults) {
     195        //public CodeStore visitLeave(LocalVarDeclListNode node, List<CodeStore> childResults) {
    153196                // TODO - implement
    154                 return concatenatedChildrenCode(new CodeStore(), childResults, true);
    155         }       
     197        //      return concatenatedChildrenCode(new CodeStore(), childResults, true);
     198        //}     
    156199
    157200        // variable declaration
     
    285328        // Stream Structures
    286329        ////////////////////////////////////////////////////////////////////////////
    287         public CodeStore visitLeave(TypeDeclNode node, List<CodeStore> childResults) {
    288                 return concatenatedChildrenCode(new CodeStore(), childResults, false);
    289         }       
    290        
     330
    291331        // Struct Type
    292332        public CodeStore visitLeave(StructTypeNode node, List<CodeStore> childResults) {
    293333
    294334                CodeStore code = new CodeStore();
     335               
     336                StringBuffer resultVariable = new StringBuffer();
     337               
    295338                CodeStore structName = (CodeStore) childResults.get(0);
    296                 String structTypeName = "struct " + structName.getResultVariableName();
    297                
    298                 if (inTypeDecl) {                                                                       // if 'type definition', not a variable, a line of code
    299                         code.addLine(structTypeName);
    300                         code.addAll((CodeStore)childResults.get(1), 0);
    301                 } else {                                                                                        // else 'type', a variable, not a line of code
    302                         code.setResultVariableName(structTypeName);
    303                 }
    304                 return code;
    305                        
     339
     340                resultVariable.append("struct");
     341                resultVariable.append(" ");
     342                resultVariable.append(structName.getResultVariableName());
     343               
     344                if (Accessors.hasStructBody(node)) {                   
     345                        resultVariable.append(CodeStore.NEWLINE);
     346                        resultVariable.append("{");
     347                        resultVariable.append(CodeStore.NEWLINE);
     348                        resultVariable.append(childResults.get(1).toStringIndented(0));
     349                        resultVariable.append("}");
     350                }
     351
     352                code.setResultVariableName(resultVariable.toString());
     353
     354                return code;
     355               
    306356        }
    307357       
     
    309359        public CodeStore visitLeave(StructTypeBodyNode node, List<CodeStore> childResults) {
    310360                CodeStore code = new CodeStore();
    311                 code.addLine("{");
     361                StringBuffer resultVariable = new StringBuffer();
    312362               
    313363                for (CodeStore child: childResults.subList(0, 1)) {
     
    318368                        code.addAll(child, 0);         
    319369                }
    320                 code.dedentedLine("};");
     370               
    321371               
    322372                return code;
     
    333383               
    334384        // Type
    335         public CodeStore visitLeave(TypeNode node, List<CodeStore> childResults) {
    336                 return concatenatedChildrenCode(new CodeStore(), childResults, false);
    337         }
     385        //public CodeStore visitLeave(TypeNode node, List<CodeStore> childResults) {
     386        //      return concatenatedChildrenCode(new CodeStore(), childResults, false);
     387        //}
    338388       
    339389        // Stream
  • proto/pablo/src/compiler/visitors/CarryCounter.java

    r2608 r2621  
    2525                }
    2626               
    27                 public void visitLeave(FunctionInvocationStatementNode node) {
     27                public void visitLeave(FunctionInvocationNode node) {
    2828
    2929                        if(BuiltinsUtil.isCarryOne(node)) {
  • proto/pablo/src/compiler/visitors/CarryIntro.java

    r2608 r2621  
    11package compiler.visitors;
     2
     3import java.util.ArrayList;
     4import java.util.List;
    25
    36import tokens.LextantToken;
     
    8386                }               
    8487               
    85                 public void visitLeave(FunctionInvocationStatementNode node) {
     88                public void visitLeave(FunctionInvocationNode node) {
    8689                       
    8790                        ASTNode replacementNode;
     
    100103//              adv_n_args = [mkCall('simd<1>::constant<0>', []), ast.Num(self.current_adv_n)]
    101104                        if(ciMode) {
    102                                 carryCall = Generators.makeFunctionInvocationStatementNode(new String [] {CarryQ.CarryQ_PACKAGE_NAME, CarryQ.GETCARRYIN.cPPCode()}, node.getToken());
    103                                 carryCall.appendChild(currentCarry);
    104                                
    105                                 advNCall = Generators.makeFunctionInvocationStatementNode(new String [] {CarryQ.CarryQ_PACKAGE_NAME, CarryQ.GETPENDING64.cPPCode()}, node.getToken());
    106                                 advNCall.appendChild(currentAdvN);
     105                                carryCall = Generators.makeFunctionInvocationNode(
     106                                                new String [] {CarryQ.CarryQ_PACKAGE_NAME, CarryQ.GETCARRYIN.cPPCode()},
     107                                                node.getToken(),
     108                                                new ASTNode [] {currentCarry});
     109                               
     110                                advNCall = Generators.makeFunctionInvocationNode(
     111                                                new String [] {CarryQ.CarryQ_PACKAGE_NAME, CarryQ.GETPENDING64.cPPCode()},
     112                                                node.getToken(),
     113                                                new ASTNode [] {currentAdvN});
    107114                               
    108115                        } else {
     
    118125        //                    return c                 
    119126                        if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, BuiltinOperations.ADVANCE.pabloName(), BuiltinOperations.ADVANCE.argCount())) {               
    120                                 replaceFunctionInvocationStatementNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.ADVANCE.cPPCode(), carryCall, currentCarry);
     127                                replaceFunctionInvocationNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.ADVANCE.cPPCode(), carryCall, currentCarry);
    121128                                this.currentCarry += 1;
    122129                        }
     
    129136        //            return c         
    130137                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, BuiltinOperations.SCANTHRU.pabloName(), BuiltinOperations.SCANTHRU.argCount())) {                         
    131                                 replaceFunctionInvocationStatementNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.SCANTHRU.cPPCode(), carryCall, currentCarry);
     138                                replaceFunctionInvocationNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.SCANTHRU.cPPCode(), carryCall, currentCarry);
    132139                                this.currentCarry += 1;
    133140                        }
     
    140147        //            return c         
    141148                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, BuiltinOperations.ADVANCETHENSCANTHRU.pabloName(), BuiltinOperations.ADVANCETHENSCANTHRU.argCount())) {
    142                                 replaceFunctionInvocationStatementNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.ADVANCETHENSCANTHRU.cPPCode(), carryCall, currentCarry);
     149                                replaceFunctionInvocationNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.ADVANCETHENSCANTHRU.cPPCode(), carryCall, currentCarry);
    143150                                this.currentCarry += 1;
    144151                        }               
     
    151158        //            return c         
    152159                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, BuiltinOperations.SPANUPTO.pabloName(), BuiltinOperations.SPANUPTO.argCount())) {
    153                                 replaceFunctionInvocationStatementNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.SPANUPTO.cPPCode(), carryCall, currentCarry);                               
     160                                replaceFunctionInvocationNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.SPANUPTO.cPPCode(), carryCall, currentCarry);                         
    154161                                this.currentCarry += 1;
    155162                        }               
     
    164171        //            return c
    165172                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, BuiltinOperations.ADVANCETHENSCANTO.pabloName(), BuiltinOperations.ADVANCETHENSCANTO.argCount())) {
    166                                 replaceFunctionInvocationStatementNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.ADVANCETHENSCANTO.cPPCode(), carryCall, currentCarry);
     173                                replaceFunctionInvocationNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.ADVANCETHENSCANTO.cPPCode(), carryCall, currentCarry);
    167174                                this.currentCarry += 1;
    168175                        }               
     
    178185       
    179186                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, BuiltinOperations.INCLUSIVESPAN.pabloName(), BuiltinOperations.INCLUSIVESPAN.argCount())) {
    180                                 replaceFunctionInvocationStatementNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.INCLUSIVESPAN.cPPCode(), carryCall, currentCarry);
     187                                replaceFunctionInvocationNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.INCLUSIVESPAN.cPPCode(), carryCall, currentCarry);
    181188                                this.currentCarry += 1;
    182189                        }                               
     
    192199       
    193200                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, BuiltinOperations.EXCLUSIVESPAN.pabloName(), BuiltinOperations.EXCLUSIVESPAN.argCount())) {
    194                                 replaceFunctionInvocationStatementNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.EXCLUSIVESPAN.cPPCode(), carryCall, currentCarry);
     201                                replaceFunctionInvocationNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.EXCLUSIVESPAN.cPPCode(), carryCall, currentCarry);
    195202                                this.currentCarry += 1;
    196203                        }                                               
     
    208215       
    209216                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, BuiltinOperations.SCANTO.pabloName(), BuiltinOperations.SCANTO.argCount())) {
    210                                 replaceFunctionInvocationStatementNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.SCANTO.cPPCode(), carryCall, currentCarry);
     217                                replaceFunctionInvocationNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.SCANTO.cPPCode(), carryCall, currentCarry);
    211218                                this.currentCarry += 1;
    212219                        }                                                               
     
    221228       
    222229                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, BuiltinOperations.SCANTOFIRST.pabloName(), BuiltinOperations.SCANTOFIRST.argCount())) {
    223                                 replaceFunctionInvocationStatementNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.SCANTOFIRST.cPPCode(), carryCall, currentCarry);
     230                                replaceFunctionInvocationNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.SCANTOFIRST.cPPCode(), carryCall, currentCarry);
    224231                                this.currentCarry += 1;
    225232                        }                                                                               
     
    232239        //            return c
    233240                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, BuiltinOperations.ADVANCE32.pabloName(), BuiltinOperations.ADVANCE32.argCount())) {
    234                                 replaceFunctionInvocationStatementNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.ADVANCE32.cPPCode(), carryCall, currentAdvN);
     241                                //replaceFunctionInvocationNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.ADVANCE32.cPPCode(), carryCall, currentAdvN);
     242                                // TODO ==> verify advNCall
     243                                replaceFunctionInvocationNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.ADVANCE32.cPPCode(), advNCall, currentAdvN);
    235244                                this.currentAdvN += 1;
    236245                        }                       
     
    243252        //            return c         
    244253                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, BuiltinOperations.ADVANCEN.pabloName(), BuiltinOperations.ADVANCEN.argCount())) {
    245                                 replaceFunctionInvocationStatementNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.ADVANCEN.cPPCode(), carryCall, currentAdvN);                                 
     254                                //replaceFunctionInvocationNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.ADVANCEN.cPPCode(), carryCall, currentAdvN);                                       
     255                                // TODO ==> verify advNCall
     256                                replaceFunctionInvocationNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.ADVANCE32.cPPCode(), advNCall, currentAdvN);         
    246257                                this.currentAdvN += 1;                 
    247258                        }                                       
     
    256267                                         
    257268                                if(!this.coMode) { // if not final block
    258                                         replacementNode = Generators.makeFunctionInvocationStatementNode(SIMD.ANDC.idisaName(), node.getToken());
    259                                         for(ASTNode arg : Accessors.functionInvocationArgs(node)) {
    260                                                 replacementNode.appendChild(arg);
    261                                         }                                                                       
    262                                         replacementNode.appendChild(Generators.makeIdentifierNode(Keywords.EOFMASK.cPPName(), node.getToken()));
     269                                        List<ASTNode> args = new ArrayList<ASTNode>();
     270                                        for(ASTNode arg : Accessors.functionInvocationArgumentsListNode(node).getChildren()) {
     271                                                args.add(arg);
     272                                        }       
     273                                        args.add(Generators.makeIdentifierNode(Keywords.EOFMASK.cPPName(), node.getToken()));
     274                                        replacementNode = Generators.makeFunctionInvocationNode(SIMD.ANDC.idisaName(), node.getToken(), args);
     275                                       
    263276                                } else {
    264                                         replacementNode = Generators.makeFunctionInvocationStatementNode(SIMD.CONSTANT.idisaConstantName(1, 0), node.getToken());                                       
     277                                        replacementNode = Generators.makeFunctionInvocationNode(SIMD.CONSTANT.idisaConstantName(1, 0), node.getToken());                                       
    265278                                }
    266279                                node.updateSelf(replacementNode);
     
    276289                               
    277290                                if(!this.coMode) {  // if not final block
    278                                         replacementNode = Generators.makeFunctionInvocationStatementNode(SIMD.AND.idisaName(), node.getToken());
    279                                         for(ASTNode arg : Accessors.functionInvocationArgs(node)) {
    280                                                 replacementNode.appendChild(arg);
    281                                         }                                                                       
    282                                         replacementNode.appendChild(Generators.makeIdentifierNode(Keywords.EOFMASK.cPPName(), node.getToken()));
     291                                        List<ASTNode> args = new ArrayList<ASTNode>();
     292                                       
     293                                        for(ASTNode arg : Accessors.functionInvocationArgumentsListNode(node).getChildren()) {
     294                                                args.add(arg);
     295                                        }
     296                                        args.add(Generators.makeIdentifierNode(Keywords.EOFMASK.cPPName(), node.getToken()));
     297                                        replacementNode = Generators.makeFunctionInvocationNode(SIMD.AND.idisaName(), node.getToken(), args);
     298                                       
    283299                                } else {
    284                                         replacementNode = Accessors.functionInvocationArg(node,0);
     300                                        replacementNode = Accessors.functionInvocationArgument(node,0);
    285301                                }
    286302                                node.updateSelf(replacementNode);
     
    297313//
    298314//                      else if (Builtins.isCall(node, Builtins.BUILTIN_PACKAGE_NAME, NoCarry.STREAMSCAN.pabloName(), NoCarry.STREAMSCAN.argCount())) {
    299 //                              replacementNode = Generators.makeFunctionInvocationStatementNode(NoCarry.STREAMSCAN.cPPCode(), node.getToken());
     315//                              replacementNode = Generators.makeFunctionInvocationNode(NoCarry.STREAMSCAN.cPPCode(), node.getToken());
    300316//                             
    301317//                              ASTNode arg0 = Generators.makeIdentifierNode("(ScanBlock *) &" + Accessors.identifierLexeme(Accessors.functionInvocationArg(node, 0)), node.getToken());
     
    343359                               
    344360                                ASTNode lhs = Accessors.ifTest(node);
    345                                 FunctionInvocationStatementNode rhs = (FunctionInvocationStatementNode) Generators.makeFunctionInvocationStatementNode(
    346                                                                                                         new String [] {CarryQ.CarryQ_PACKAGE_NAME, CarryQ.CARRYTEST.cPPCode()},
    347                                                                                                         node.getToken());
    348                                
     361       
    349362                                IntegerConstantNode lowerBound = Generators.makeIntegerConstantNode(carryBase, node.getToken());
    350363                                IntegerConstantNode upperBound =  Generators.makeIntegerConstantNode(carryCount, node.getToken());
    351                                
    352                                 rhs.appendChild(lowerBound);
    353                                 rhs.appendChild(upperBound);
     364                       
     365                                FunctionInvocationNode rhs = (FunctionInvocationNode) Generators.makeFunctionInvocationNode(
     366                                                new String [] {CarryQ.CarryQ_PACKAGE_NAME, CarryQ.CARRYTEST.cPPCode()},
     367                                                node.getToken(),
     368                                                new ASTNode [] {lowerBound, upperBound});
    354369                               
    355370                                BinaryOperatorNode replacementIfTestNode = Generators.makeBinaryOperatorNode(lhs,
     
    360375                               
    361376                                // else part, append CarryDequeueEnqueue call
    362                                 FunctionInvocationStatementNode carryDequeueEnqueue = (FunctionInvocationStatementNode) Generators.makeFunctionInvocationStatementNode(
    363                                                                                                                                 new String [] {CarryQ.CarryQ_PACKAGE_NAME, CarryQ.CARRYDEQUEUEENQUEUE.cPPCode()},
    364                                                                                                                                 node.getToken());
    365                                
    366                                 carryDequeueEnqueue.appendChild(lowerBound);
    367                                 carryDequeueEnqueue.appendChild(upperBound);                           
     377                               
     378                                FunctionInvocationNode carryDequeueEnqueue = (FunctionInvocationNode) Generators.makeFunctionInvocationNode(
     379                                                new String [] {CarryQ.CarryQ_PACKAGE_NAME, CarryQ.CARRYDEQUEUEENQUEUE.cPPCode()},
     380                                                node.getToken(),
     381                                                new ASTNode [] {lowerBound, upperBound});
     382
    368383                               
    369384                                if (Accessors.hasElseBlockStatement(node)) {   
     
    379394                                       
    380395                // Helpers             
    381                 private void replaceFunctionInvocationStatementNode(FunctionInvocationStatementNode node, String targetPackage, String targetName,
     396                private void replaceFunctionInvocationNode(FunctionInvocationNode node, String targetPackage, String targetName,
    382397                                ASTNode call, IntegerConstantNode carry) {
    383                         FunctionInvocationStatementNode replacementNode;
    384                         String [] compoundName = new String [2];
    385                         compoundName[0] = targetPackage;
    386                         compoundName[1] = targetName;
    387                         replacementNode = Generators.makeFunctionInvocationStatementNode(compoundName, node.getToken());
    388                         for(ASTNode arg : Accessors.functionInvocationArgs(node)) {
    389                                 replacementNode.appendChild(arg);
    390                         }                               
    391                         replacementNode.appendChild(call);
    392                         replacementNode.appendChild(carry);
    393 
     398                        FunctionInvocationNode replacementNode;
     399
     400                        List<ASTNode> args = new ArrayList<ASTNode>();
     401                                               
     402                        for(ASTNode arg : Accessors.functionInvocationArgumentsListNode(node).getChildren()) {
     403                                args.add(arg);
     404                        }       
     405                        args.add(call);
     406                        args.add(carry);
     407                       
     408                        replacementNode = Generators.makeFunctionInvocationNode(
     409                                        new String [] {targetPackage, targetName},
     410                                        node.getToken(),
     411                                        args);
     412                       
    394413                        node.updateSelf(replacementNode);
    395414                }
  • proto/pablo/src/compiler/visitors/StreamFunctionVisitor.java

    r2415 r2621  
    22
    33import lexicalAnalyzer.LexicalType;
     4import tokens.IdentifierToken;
    45import tokens.StringConstantToken;
    56import ast.*;
     
    5152                        String functionName = functionNameNode.getToken().getLexeme();
    5253                        functionName = capitalize(functionName);
    53                         StringConstantToken newNameToken = StringConstantToken.make(LexicalType.STRING, functionNameNode.getToken().getLocation(), functionName);
     54                        IdentifierToken newNameToken = IdentifierToken.make(LexicalType.IDENTIFIER, functionNameNode.getToken().getLocation(), functionName);
     55                       
    5456                        functionNameNode.setToken(newNameToken);
    5557                        streamFunctionMap.put(functionName, node);                                     
  • proto/pablo/src/parser/Parser.java

    r2609 r2621  
    114114                        allChildren.add(child);
    115115                }
     116                if( (nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
     117                        {
     118                                ASTNode child = parseDeclaratorList();
     119                                result.appendChild(child);
     120                                allChildren.add(child);
     121                        }
     122                }
    116123                if(allowCompression) {
    117124                        return result;
     
    135142                        allChildren.add(child);
    136143                }
    137                 if( (nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
    138                         {
    139                                 ASTNode child = parseDeclaratorList();
    140                                 result.appendChild(child);
    141                                 allChildren.add(child);
    142                         }
     144                {
     145                        ASTNode child = parseIdentifier();
     146                        result.appendChild(child);
     147                        allChildren.add(child);
    143148                }
    144149                if(allowCompression) {
     
    387392       
    388393                boolean allowCompression = true;
    389                 ASTNode result = new ASTNode(nowReading);
     394                ASTNode result = new FunctionInvocationOrAssignmentStatementNode(nowReading);
    390395                result.setProductionTag(13);
    391396                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     
    406411                else if( nowReading.isLextant(Lextant.AND_ASSIGN, Lextant.ASSIGN, Lextant.OR_ASSIGN, Lextant.XOR_ASSIGN) ) {
    407412                        {
    408                                 ASTNode child = parseAssignmentStatementRest();
     413                                ASTNode child = parseAssignmentRest();
    409414                                result.appendChild(child);
    410415                                allChildren.add(child);
     
    426431       
    427432                boolean allowCompression = true;
    428                 ASTNode result = new FunctionInvocationStatementNode(nowReading);
     433                ASTNode result = new FunctionInvocationNode(nowReading);
    429434                result.setProductionTag(14);
    430435                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    431436                result.setToken(nowReading);
    432437                expect(Lextant.LROUND);
     438                {
     439                        ASTNode child = parseFunctionInvocationArgumentList();
     440                        result.appendChild(child);
     441                        allChildren.add(child);
     442                }
     443                expect(Lextant.RROUND);
     444                if(allowCompression) {
     445                        return result;
     446                }
     447                return result;
     448        }
     449         
     450        public ASTNode parseFunctionInvocationArgumentList() {
     451                boolean allowCompression = true;
     452                ASTNode result = new FunctionInvocationArgumentListNode(nowReading);
     453                result.setProductionTag(15);
     454                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    433455                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)) ) {
    434456                        {
     
    446468                        }
    447469                }
    448                 expect(Lextant.RROUND);
    449                 if(allowCompression) {
    450                         return result;
    451                 }
    452                 return result;
    453         }
    454          
    455         public ASTNode parseFunctionInvocationArgumentsList() {
    456                 boolean allowCompression = true;
    457                 ASTNode result = new FunctionInvocationArgumentsListNode(nowReading);
    458                 result.setProductionTag(15);
    459                 RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    460                 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)) ) {
    461                         {
    462                                 ASTNode child = parseExpression();
    463                                 result.appendChild(child);
    464                                 allChildren.add(child);
    465                         }
    466                         while( nowReading.isLextant(Lextant.COMMA) ) {
    467                                 expect(Lextant.COMMA);
    468                                 {
    469                                         ASTNode child = parseExpression();
    470                                         result.appendChild(child);
    471                                         allChildren.add(child);
    472                                 }
    473                         }
    474                 }
    475470                if(allowCompression) {
    476471                        return result;
     
    506501        }
    507502         
    508         public ASTNode parseAssignmentStatementRest() {
     503        public ASTNode parseAssignmentRest() {
    509504                if( !(nowReading.isLextant(Lextant.AND_ASSIGN, Lextant.ASSIGN, Lextant.OR_ASSIGN, Lextant.XOR_ASSIGN)) ) {
    510                         return syntaxErrorNode("assignmentStatementRest² [AND_ASSIGN¹, ASSIGN¹, OR_ASSIGN¹, XOR_ASSIGN¹]");
    511                 }
    512        
    513                 boolean allowCompression = true;
    514                 ASTNode result = new AssignmentStatementNode(nowReading);
     505                        return syntaxErrorNode("assignmentRest² [AND_ASSIGN¹, ASSIGN¹, OR_ASSIGN¹, XOR_ASSIGN¹]");
     506                }
     507       
     508                boolean allowCompression = true;
     509                ASTNode result = new AssignmentNode(nowReading);
    515510                result.setProductionTag(17);
    516511                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
Note: See TracChangeset for help on using the changeset viewer.