Changeset 2608


Ignore:
Timestamp:
Nov 5, 2012, 11:26:33 AM (7 years ago)
Author:
ksherdy
Message:

Extended augmented assignment removal to a local variable initializations. Additional code generation.

Location:
proto/pablo
Files:
2 added
2 deleted
21 edited

Legend:

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

    r2607 r2608  
    3030       
    3131        IF,
    32         ELSE,
     32//      ELSE,
    3333        WHILE,
    3434        RETURN,
     
    6565  binaryOperator {} [expression, expression1],//, expression4],
    6666  unaryOperator {} [expression2,],// expression5],
    67   assignment {} [assignmentStatementRest],
    68   functionInvocation {} [functionInvocationRest],
     67  assignmentStatement {} [assignmentStatementRest],
     68  functionInvocationStatement {} [functionInvocationRest],
    6969  ASTNode [functionInvocationOrAssignmentStatement],
    7070  integerConstant{intValued;} [],
     
    106106        parameterName   #-> identifier ;
    107107       
    108         blockStatement  -> LCURLY statement* RCURLY ;
    109                
    110108        //
    111109        // f u n c t i o n - l e v e l 
     
    115113        // s t a t e m e n t s
    116114        //
    117         statement                                                       #-> ( functionInvocationOrAssignmentStatement | ifStatement | whileStatement | returnStatement | localVarDecl) (TERMINATOR)? ;
     115        statement                                                       #-> (functionInvocationOrAssignmentStatement | ifStatement | whileStatement | returnStatement | localVarDecl) (TERMINATOR)? ;
    118116                       
    119117        functionInvocationOrAssignmentStatement -> compoundVariable ((functionInvocation _promote_) | (assignmentStatementRest _promote_)) TERMINATOR ;
     
    125123        assignmentStatementRest                         -> assignmentOperator^! expression ;                           
    126124                                       
    127         ifStatement                                                     -> IF LROUND expression RROUND blockStatement (ELSE blockStatement)? ;                 
     125        ifStatement                                                     -> IF LROUND expression RROUND blockStatement ; // (ELSE blockStatement)? ; // TODO - Support else?                     
    128126                                                       
    129127        whileStatement                                          -> WHILE LROUND expression RROUND blockStatement ;
     
    133131        // localVarDeclList                                     -> localVarDecl (COMMA localVarDecl)* TERMINATOR;
    134132               
    135         localVarDecl                                            -> VAR type variableName (assignmentOperator expression) ?;
     133        localVarDecl                                            -> VAR type variableName (assignmentOperator^! expression) ?;
    136134               
    137135        variableName                                            #-> identifier;
     136
     137        blockStatement  -> LCURLY statement* RCURLY ;
    138138       
    139139        //
     
    142142        expression              #->     expression1 ((OR^|XOR^) expression)? ;
    143143                                       
    144         expression1             #-> expression2 ((AND^) expression1)?   ;
    145                                        
    146         expression2             #-> NOT^^? expression3 _leftAssoc_ ;
     144        expression1             #-> expression2 ((AND^) expression1)? ;
     145                                       
     146        expression2             #-> NOT^^? expression3  _leftAssoc_;
    147147       
    148148        expression3             #-> LROUND expression RROUND
  • proto/pablo/input/test/pablo/funcDef/funcDef1.pablo

    r2607 r2608  
    1010function struct Lex ClassifyBytes(stream<1> a, stream b) {
    1111
    12         var stream<1> a = 1;
    13         var stream<1> b = "One";
    14         var stream<1> c = 0 ^ (a | b) & c | 1;
    15         var stream d &= 1;
     12        i = 0;
     13        i &= 0;
     14        var stream j |= j;
    1615
     16        if(a) {
     17
     18        }
     19       
    1720};
  • proto/pablo/src/ast/ASTTransformer.java

    r2607 r2608  
    1212        ASTNode visit(ASTNode node);
    1313       
    14         public ASTNode visit(AssignmentNode node);
    15 
    1614        public ASTNode visit(AssignmentOperatorNode node);
    1715
     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(FunctionInvocationNode node);
     36        public ASTNode visit(FunctionInvocationStatementNode node);
    3737
    3838        public ASTNode visit(IdentifierNode node);
     
    8383                }
    8484       
    85                 public ASTNode visit(AssignmentNode node) {
    86                         return defaultVisit(node);
    87                 }
    88 
    8985                public ASTNode visit(AssignmentOperatorNode node) {
    9086                        return defaultVisit(node);
    9187                }
    9288
     89                public ASTNode visit(AssignmentStatementNode node) {
     90                        return defaultVisit(node);
     91                }
     92
    9393                public ASTNode visit(BinaryOperatorNode node) {
    9494                        return defaultVisit(node);
     
    127127                }
    128128
    129                 public ASTNode visit(FunctionInvocationNode node) {
     129                public ASTNode visit(FunctionInvocationStatementNode node) {
    130130                        return defaultVisit(node);
    131131                }
  • proto/pablo/src/ast/ASTVisitor.java

    r2607 r2608  
    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 
    1916        public void visitEnter(AssignmentOperatorNode node);
    2017        public T visitLeave(AssignmentOperatorNode node, List<T> childResults);
    2118
     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(FunctionInvocationNode node);
    50         public T visitLeave(FunctionInvocationNode node, List<T> childResults);
     49        public void visitEnter(FunctionInvocationStatementNode node);
     50        public T visitLeave(FunctionInvocationStatementNode node, List<T> childResults);
    5151
    5252        public void visitEnter(IdentifierNode node);
     
    128128                }
    129129               
    130                 public void visitEnter(AssignmentNode node) {
    131                         defaultVisitEnter(node);
    132                 }
    133                 public T visitLeave(AssignmentNode node, List<T> childResults) {
    134                         return defaultVisitLeave(node);
    135                 }
    136 
    137130                public void visitEnter(AssignmentOperatorNode node) {
    138131                        defaultVisitEnter(node);
     
    142135                }
    143136
     137                public void visitEnter(AssignmentStatementNode node) {
     138                        defaultVisitEnter(node);
     139                }
     140                public T visitLeave(AssignmentStatementNode node, List<T> childResults) {
     141                        return defaultVisitLeave(node);
     142                }
     143
    144144                public void visitEnter(BinaryOperatorNode node) {
    145145                        defaultVisitEnter(node);
     
    205205                }
    206206
    207                 public void visitEnter(FunctionInvocationNode node) {
    208                         defaultVisitEnter(node);
    209                 }
    210                 public T visitLeave(FunctionInvocationNode node, List<T> childResults) {
     207                public void visitEnter(FunctionInvocationStatementNode node) {
     208                        defaultVisitEnter(node);
     209                }
     210                public T visitLeave(FunctionInvocationStatementNode node, List<T> childResults) {
    211211                        return defaultVisitLeave(node);
    212212                }
  • proto/pablo/src/ast/SimpleVisitor.java

    r2607 r2608  
    1313        void visit(ASTNode node);
    1414       
    15         public void visit(AssignmentNode node);
    16 
    1715        public void visit(AssignmentOperatorNode node);
    1816
     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(FunctionInvocationNode node);
     37        public void visit(FunctionInvocationStatementNode node);
    3838
    3939        public void visit(IdentifierNode node);
     
    8484                }
    8585       
    86                 public void visit(AssignmentNode node) {
    87                         defaultVisit(node);
    88                 }
    89 
    9086                public void visit(AssignmentOperatorNode node) {
    9187                        defaultVisit(node);
    9288                }
    9389
     90                public void visit(AssignmentStatementNode node) {
     91                        defaultVisit(node);
     92                }
     93
    9494                public void visit(BinaryOperatorNode node) {
    9595                        defaultVisit(node);
     
    128128                }
    129129
    130                 public void visit(FunctionInvocationNode node) {
     130                public void visit(FunctionInvocationStatementNode node) {
    131131                        defaultVisit(node);
    132132                }
  • proto/pablo/src/ast/VoidVisitor.java

    r2607 r2608  
    1212        void visitLeave(ASTNode node);
    1313       
    14         public void visitEnter(AssignmentNode node);
    15         public void visitLeave(AssignmentNode node);
    16 
    1714        public void visitEnter(AssignmentOperatorNode node);
    1815        public void visitLeave(AssignmentOperatorNode node);
    1916
     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(FunctionInvocationNode node);
    48         public void visitLeave(FunctionInvocationNode node);
     47        public void visitEnter(FunctionInvocationStatementNode node);
     48        public void visitLeave(FunctionInvocationStatementNode node);
    4949
    5050        public void visitEnter(IdentifierNode node);
     
    125125                }
    126126               
    127                 public void visitEnter(AssignmentNode node) {
    128                         defaultVisitEnter(node);
    129                 }
    130                 public void visitLeave(AssignmentNode node) {
    131                         defaultVisitLeave(node);
    132                 }
    133 
    134127                public void visitEnter(AssignmentOperatorNode node) {
    135128                        defaultVisitEnter(node);
     
    139132                }
    140133
     134                public void visitEnter(AssignmentStatementNode node) {
     135                        defaultVisitEnter(node);
     136                }
     137                public void visitLeave(AssignmentStatementNode node) {
     138                        defaultVisitLeave(node);
     139                }
     140
    141141                public void visitEnter(BinaryOperatorNode node) {
    142142                        defaultVisitEnter(node);
     
    202202                }
    203203
    204                 public void visitEnter(FunctionInvocationNode node) {
    205                         defaultVisitEnter(node);
    206                 }
    207                 public void visitLeave(FunctionInvocationNode node) {
     204                public void visitEnter(FunctionInvocationStatementNode node) {
     205                        defaultVisitEnter(node);
     206                }
     207                public void visitLeave(FunctionInvocationStatementNode node) {
    208208                        defaultVisitLeave(node);
    209209                }
  • proto/pablo/src/compiler/PabloCompiler.java

    r2607 r2608  
    5050                // Quick-and-dirty. Java Map. Proceed in a similar manner as the existing Python compiler.
    5151               
    52 //              StreamFunctionVisitor streamFunctionVisitor = new StreamFunctionVisitor(syntaxTree);
    53 //              Map<String, ASTNode> streamFunctionMap = streamFunctionVisitor.makeStreamFunctionMap();
     52                StreamFunctionVisitor streamFunctionVisitor = new StreamFunctionVisitor(syntaxTree);
     53                Map<String, ASTNode> streamFunctionMap = streamFunctionVisitor.makeStreamFunctionMap();
    5454               
    55 //              for (Map.Entry<String, ASTNode> entry : streamFunctionMap.entrySet()) {
     55                for (Map.Entry<String, ASTNode> entry : streamFunctionMap.entrySet()) {
    5656                       
    5757//                  AdvanceCombiner advanceCombiner = new AdvanceCombiner(entry.getValue());
     
    6868//                      bitwiseToIDISA.transform();
    6969//
    70 //                      AugmentedAssignmentRemoval augmentedAssignmentRemoval = new AugmentedAssignmentRemoval(entry.getValue());
    71 //                      augmentedAssignmentRemoval.transform();
     70                        AugmentedAssignment augmentedAssignment = new AugmentedAssignment(entry.getValue());
     71                        augmentedAssignment.transform();
    7272
    7373//                      CarryIntro carryIntro = new CarryIntro(entry.getValue());
    7474//                      carryIntro.transform(true, false);                     
    75 //              }
     75                }
    7676
    7777                System.out.print(syntaxTree);
  • proto/pablo/src/compiler/ast/Accessors.java

    r2607 r2608  
    1616        ////////////////////////////////////////////////////////////////////////////
    1717
     18       
     19        public static boolean isTerminal(ASTNode node) {
     20                return 0 == node.nChildren();
     21        }
     22       
    1823        ////////////////////////////////////////////////////////////////////////////
    1924        // Assignment Statements
    2025        ////////////////////////////////////////////////////////////////////////////                           
    21         public static ASTNode lhs(AssignmentNode node) {
    22                 return node.child(0);
    23         }       
    24        
    25         public static ASTNode rhs(AssignmentNode node) {
     26        public static ASTNode lhs(AssignmentStatementNode node) {
     27                return node.child(0);
     28        }       
     29       
     30        public static ASTNode rhs(AssignmentStatementNode node) {
    2631                return node.child(1);
    2732        }       
    2833
    29         ////////////////////////////////////////////////////////////////////////////
    30         // Assignment Operators
     34        public static String assignmentOperator(AssignmentStatementNode node) {
     35                return node.getToken().getLexeme();
     36        }
     37       
     38        ////////////////////////////////////////////////////////////////////////////
     39        // Local Variable Declaration Statements
    3140        ////////////////////////////////////////////////////////////////////////////                           
    32         public static String assignmentOperator(AssignmentOperatorNode node) {
    33                 return node.getToken().getLexeme();
    34         }       
     41       
     42        public static ASTNode lhs(LocalVarDeclNode node) {
     43                return node.child(1);
     44        }       
     45       
     46        public static ASTNode rhs(LocalVarDeclNode node) {
     47                return node.child(2);
     48        }               
     49       
     50        public static String assignmentOperator(LocalVarDeclNode node) {
     51                return node.getToken().getLexeme();
     52        }       
     53       
     54        public static boolean hasInitializationAssignment(LocalVarDeclNode node) {
     55                return (node.nChildren() > 2);
     56        }
    3557       
    3658        ////////////////////////////////////////////////////////////////////////////
     
    4163        }
    4264
     65        public static String operator(UnaryOperatorNode node) {
     66                return node.getToken().getLexeme();
     67        }
     68       
    4369        ////////////////////////////////////////////////////////////////////////////
    4470        // Binary Operators
     
    120146        // FunctionInvocationNode helpers
    121147        ////////////////////////////////////////////////////////////////////////////
    122         public static ASTNode functionInvocationName(FunctionInvocationNode node) {
    123                 return node.child(0);
    124         }
    125 
    126         public static ASTNode functionInvocationArg(FunctionInvocationNode node, int index) {
     148        public static ASTNode functionInvocationName(FunctionInvocationStatementNode node) {
     149                return node.child(0);
     150        }
     151
     152        public static ASTNode functionInvocationArg(FunctionInvocationStatementNode node, int index) {
    127153                int argIndex = 1 + index;
    128154                if(argIndex > node.getChildren().size()) {
     
    132158        }
    133159       
    134         public static List<ASTNode> functionInvocationArgs(FunctionInvocationNode node) {
     160        public static List<ASTNode> functionInvocationArgs(FunctionInvocationStatementNode node) {
    135161                return node.getChildren().subList(1, node.nChildren());
    136162        }
     
    159185        }
    160186       
    161         public static String functionIdentifier(FunctionInvocationNode node) {
     187        public static String functionIdentifier(FunctionInvocationStatementNode node) {
    162188                ASTNode functionName = functionInvocationName(node);
    163189                String identifier = identifierLexeme(functionName);
  • proto/pablo/src/compiler/ast/Generators.java

    r2464 r2608  
    88import tokens.StringConstantToken;
    99import tokens.Token;
    10 import ast.ASTNode;
    11 import ast.BinaryOperatorNode;
    12 import ast.BlockStatementNode;
    13 import ast.CompoundVariableNode;
    14 import ast.FunctionInvocationNode;
    15 import ast.IdentifierNode;
    16 import ast.IntegerConstantNode;
    17 import ast.StringConstantNode;
     10import ast.*;
    1811
    1912public class Generators {
     
    2619        ////////////////////////////////////////////////////////////////////////////
    2720
    28         /** Makes a new FunctionInvocationNode with a function identifier string and the TextLocation taken from token.
     21        /** Makes a new FunctionInvocationStatementNode with a function identifier string and the TextLocation taken from token.
    2922         * @param identifier
    3023         * @param locationToken         a token containing the TextLocation for this new node.
    31          * @return      the new FunctionInvocationNode
     24         * @return      the new FunctionInvocationStatementNode
    3225         */
    33         public static FunctionInvocationNode makeFunctionInvocationNode(String identifier, Token locationToken) {
     26        public static FunctionInvocationStatementNode makeFunctionInvocationStatementNode(String identifier, Token locationToken) {
    3427                IdentifierNode identifierNode = Generators.makeIdentifierNode(identifier, locationToken);
    35                 return Generators.makeFunctionInvocationNode(identifierNode, locationToken);
     28                return Generators.makeFunctionInvocationStatementNode(identifierNode, locationToken);
    3629        }
    3730
    38         /** Makes a new compound FunctionInvocationNode with a array of identifiers string and the TextLocation taken from token.
     31        /** Makes a new compound FunctionInvocationStatementNode with a array of identifiers string and the TextLocation taken from token.
    3932         * @param identifiers           an array of identifiers, for example {"a", "b"} will result in function call a.b();
    4033         * @param locationToken         a token containing the TextLocation for this new node.
    41          * @return      the new FunctionInvocationNode
     34         * @return      the new FunctionInvocationStatementNode
    4235         */
    43         public static FunctionInvocationNode makeFunctionInvocationNode(String[] identifiers, Token locationToken) {
     36        public static FunctionInvocationStatementNode makeFunctionInvocationStatementNode(String[] identifiers, Token locationToken) {
    4437                CompoundVariableNode identifierNode = Generators.makeCompoundVariableNode(identifiers, locationToken);
    45                 return Generators.makeFunctionInvocationNode(identifierNode, locationToken);
     38                return Generators.makeFunctionInvocationStatementNode(identifierNode, locationToken);
    4639        }
    4740
    48         /** Makes a new compound FunctionInvocationNode with a array of identifiers string and the TextLocation taken from token.
     41        /** Makes a new compound FunctionInvocationStatementNode with a array of identifiers string and the TextLocation taken from token.
    4942         * @param identifiers           an array of identifiers, for example {"a", "b"} will result in function call a.b();
    5043         * @param locationToken         a token containing the TextLocation for this new node.
    5144         * @param children                      an array of ASTNode children
    52          * @return      the new FunctionInvocationNode
     45         * @return      the new FunctionInvocationStatementNode
    5346         */
    54         public static FunctionInvocationNode makeFunctionInvocationNode(String[] identifiers, Token locationToken, ASTNode [] children) {
     47        public static FunctionInvocationStatementNode makeFunctionInvocationStatementNode(String[] identifiers, Token locationToken, ASTNode [] children) {
    5548                CompoundVariableNode identifierNode = Generators.makeCompoundVariableNode(identifiers, locationToken);
    56                 FunctionInvocationNode functionInvocationNode = Generators.makeFunctionInvocationNode(identifierNode, locationToken);
     49                FunctionInvocationStatementNode functionInvocationNode = Generators.makeFunctionInvocationStatementNode(identifierNode, locationToken);
    5750                for(ASTNode child:children) {
    5851                        functionInvocationNode.appendChild(child);
     
    6154        }       
    6255       
    63         /** Makes a new FunctionInvocationNode with an ASTNode identifier and the TextLocation taken from token.
     56        /** Makes a new FunctionInvocationStatementNode with an ASTNode identifier and the TextLocation taken from token.
    6457         * @param identifier            an ASTNode, must be IdentifierNode or CompundVariableNode
    6558         * @param locationToken         a token containing the TextLocation for this new node.
    66          * @return      the new FunctionInvocationNode
     59         * @return      the new FunctionInvocationStatementNode
    6760         */
    68         public static FunctionInvocationNode makeFunctionInvocationNode(ASTNode identifier, Token locationToken) {
     61        public static FunctionInvocationStatementNode makeFunctionInvocationStatementNode(ASTNode identifier, Token locationToken) {
    6962                assert identifier instanceof IdentifierNode || identifier instanceof CompoundVariableNode;
    7063               
    7164                LextantToken token = Generators.makeLextantToken(Lextant.LROUND, locationToken);
    72                 FunctionInvocationNode functionInvocationNode = new FunctionInvocationNode(token);
     65                FunctionInvocationStatementNode functionInvocationNode = new FunctionInvocationStatementNode(token);
    7366                functionInvocationNode.appendChild(identifier);
    7467                return functionInvocationNode;
    7568        }
    7669
    77         /** Makes a new FunctionInvocationNode with a function identifier string, an ASTNode whose attributes
    78          * and children will be copied to the new FunctionInvocationNode and the TextLocation taken from token.
    79          * @param identifier            the identifier of FunctionInvocationNode. If toBeCopied is a FunctionInvocationNode,
     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,
    8073         *                                                      it will replace the copied identifier. Otherwise it will be inserted as the first child.
    8174         * @param toBeCopied            an ASTNode whose attributes and children will be copied.
    8275         * @param locationToken         a token containing the TextLocation for this new node.
    83          * @return      the new FunctionInvocationNode
     76         * @return      the new FunctionInvocationStatementNode
    8477         */
    85         public static FunctionInvocationNode makeFunctionInvocationNode(String identifier, ASTNode toBeCopied, Token locationToken) {
    86                 FunctionInvocationNode functionInvocationNode = new FunctionInvocationNode(toBeCopied);
     78        public static FunctionInvocationStatementNode makeFunctionInvocationStatementNode(String identifier, ASTNode toBeCopied, Token locationToken) {
     79                FunctionInvocationStatementNode functionInvocationNode = new FunctionInvocationStatementNode(toBeCopied);
    8780                for (ASTNode child : toBeCopied.getChildren()) {
    8881                        functionInvocationNode.appendChild(child);
     
    9184                IdentifierNode newIdentifier = Generators.makeIdentifierNode(identifier, locationToken);
    9285               
    93                 if(toBeCopied instanceof FunctionInvocationNode) {
     86                if(toBeCopied instanceof FunctionInvocationStatementNode) {
    9487                        ASTNode originalIdentifier = functionInvocationNode.child(0);
    9588                        functionInvocationNode.replaceChild(originalIdentifier, newIdentifier);
  • proto/pablo/src/compiler/codeGeneration/TemplateContentsGenerator.java

    r2607 r2608  
    22
    33import java.io.PrintStream;
    4 import java.util.List;
    54
    65import compiler.visitors.*;
  • proto/pablo/src/compiler/lang/pablo/builtins/BuiltinsUtil.java

    r2598 r2608  
    11package compiler.lang.pablo.builtins;
    22
    3 import ast.ASTNode;
    4 import ast.CompoundVariableNode;
    5 import ast.FunctionInvocationNode;
    6 import ast.IdentifierNode;
     3import ast.*;
    74
    85import compiler.ast.Accessors;
     
    1916     */   
    2017    public static boolean isAdvance(ASTNode node) {
    21         if(!(node instanceof FunctionInvocationNode)) {
     18        if(!(node instanceof FunctionInvocationStatementNode)) {
    2219            return false;
    2320        }
    2421       
    25         FunctionInvocationNode fNode = (FunctionInvocationNode)node;
     22        FunctionInvocationStatementNode fNode = (FunctionInvocationStatementNode)node;
    2623        ASTNode nameNode = Accessors.functionInvocationName(fNode);
    2724       
     
    7370     */
    7471    public static boolean isBuiltInCallNoArgCount(ASTNode node) {
    75         if(!(node instanceof FunctionInvocationNode)) {
     72        if(!(node instanceof FunctionInvocationStatementNode)) {
    7673            return false;
    7774        }
    7875       
    79         FunctionInvocationNode fNode = (FunctionInvocationNode)node;
     76        FunctionInvocationStatementNode fNode = (FunctionInvocationStatementNode)node;
    8077        ASTNode nameNode = Accessors.functionInvocationName(fNode);
    8178
     
    117114     */
    118115    public static boolean isCall(ASTNode node, String packageName, String functionName, int numArgs) {
    119         if(!(node instanceof FunctionInvocationNode)) {
     116        if(!(node instanceof FunctionInvocationStatementNode)) {
    120117            return false;
    121118        }
    122119       
    123         FunctionInvocationNode fNode = (FunctionInvocationNode)node;
     120        FunctionInvocationStatementNode fNode = (FunctionInvocationStatementNode)node;
    124121        ASTNode nameNode = Accessors.functionInvocationName(fNode);
    125122
  • proto/pablo/src/compiler/test/ASTTest.java

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

    r2607 r2608  
    4040                }
    4141
    42                 public void visitLeave(FunctionInvocationNode node) {
     42                public void visitLeave(FunctionInvocationStatementNode node) {
    4343                       
    4444                        if(!isAdvanceOfAdvance(node)) {
     
    4646                        }
    4747                                               
    48                         FunctionInvocationNode child = (FunctionInvocationNode)streamBeingAdvanced(node);
     48                        FunctionInvocationStatementNode child = (FunctionInvocationStatementNode)streamBeingAdvanced(node);
    4949                        ASTNode streamBeingAdvanced = streamBeingAdvanced(child);
    5050                       
     
    7878
    7979        // given that node is an advance, what is the stream being advanced?
    80         private ASTNode streamBeingAdvanced(FunctionInvocationNode node) {
     80        private ASTNode streamBeingAdvanced(FunctionInvocationStatementNode node) {
    8181                assert BuiltinsUtil.isAdvance(node);
    8282                return node.child(1);
    8383        }
    8484
    85         private int advanceAmount(FunctionInvocationNode node) {
     85        private int advanceAmount(FunctionInvocationStatementNode node) {
    8686                assert BuiltinsUtil.isAdvance(node);
    8787                if(node.nChildren()==2) {
     
    9696                        return false;
    9797       
    98                 ASTNode child = streamBeingAdvanced((FunctionInvocationNode) node);
     98                ASTNode child = streamBeingAdvanced((FunctionInvocationStatementNode) node);
    9999                return BuiltinsUtil.isAdvance(child);
    100100        }
    101101       
    102         private void translateAdvanceNode(FunctionInvocationNode node,
    103                         FunctionInvocationNode child, ASTNode streamBeingAdvanced,
     102        private void translateAdvanceNode(FunctionInvocationStatementNode node,
     103                        FunctionInvocationStatementNode child, ASTNode streamBeingAdvanced,
    104104                        int amount1, int amount2) {
    105105                node.replaceChild(child, streamBeingAdvanced);
  • proto/pablo/src/compiler/visitors/AdvanceNCounter.java

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

    r2538 r2608  
    3535        private class AugmentedAssignmentRemovalVisitor extends VoidVisitor.Default {
    3636               
    37                 public void visitLeave(AssignmentNode node) {
    38                        
     37                public void visitLeave(AssignmentStatementNode node) {
     38                        transformAugmentedAssignment(node, Accessors.lhs(node), Accessors.rhs(node));
     39                }
     40
     41                public void visitLeave(LocalVarDeclNode node) {
     42                        if(Accessors.hasInitializationAssignment(node)) {
     43                                transformAugmentedAssignment(node, Accessors.lhs(node), Accessors.rhs(node));
     44                        }
     45                }
     46                               
     47                private void transformAugmentedAssignment(ASTNode node, ASTNode lhs, ASTNode rhs) {
    3948                        if(isAugmentedAssignmentLextant(node.getToken())) {
    4049                               
     
    4554                                LextantToken binaryOperatorToken = LextantToken.make(node.getToken().getLocation(), lexeme, binaryOperatorLextant);
    4655                               
    47                                 BinaryOperatorNode binaryOperatorNode = Generators.makeBinaryOperatorNode(Accessors.lhs(node),
    48                                                                                                                                         Accessors.rhs(node),
    49                                                                                                                                         binaryOperatorToken);
     56                                BinaryOperatorNode binaryOperatorNode = Generators.makeBinaryOperatorNode(lhs, rhs, binaryOperatorToken);
    5057                               
    5158                                LextantToken assign = LextantToken.make(node.getToken().getLocation(),
     
    5562                                                               
    5663                                //Accessors.rhs(node).updateSelf(binaryOperatorNode);
    57                                 node.replaceChild(Accessors.rhs(node), binaryOperatorNode);
    58                         } 
     64                                node.replaceChild(rhs, binaryOperatorNode);
     65                        }
    5966                }
    60 
     67               
    6168                private boolean isAugmentedAssignmentLextant(Token token) {
    6269                        for (Lextant key : augmentedAssignmentMap.keySet()) {
  • proto/pablo/src/compiler/visitors/Bitwise2IDISA.java

    r2607 r2608  
    2626                        if(op.isLextant(Lextant.NOT)) {
    2727                               
    28                                 FunctionInvocationNode functionInvocationNode = Generators.makeFunctionInvocationNode(SIMD.NOT.idisaName(), op);
     28                                FunctionInvocationStatementNode functionInvocationNode = Generators.makeFunctionInvocationStatementNode(SIMD.NOT.idisaName(), op);
    2929                                functionInvocationNode.appendChild(Accessors.operand(node));
    3030                                node.updateSelf(functionInvocationNode);
     
    4444                                }
    4545                               
    46                                 FunctionInvocationNode functioninvocationNode = Generators.makeFunctionInvocationNode(functionName, op);
     46                                FunctionInvocationStatementNode functioninvocationNode = Generators.makeFunctionInvocationStatementNode(functionName, op);
    4747                                functioninvocationNode.appendChild(Accessors.leftOperand(node));
    4848                                functioninvocationNode.appendChild(Accessors.rightOperand(node));
     
    6161                               
    6262                                name = SIMD.CONSTANT.idisaConstantName(fieldWidth, constant);
    63                                 FunctionInvocationNode functionInvocationNode = Generators.makeFunctionInvocationNode(name, node.getToken());
     63                                FunctionInvocationStatementNode functionInvocationNode = Generators.makeFunctionInvocationStatementNode(name, node.getToken());
    6464                                node.updateSelf(functionInvocationNode);
    6565                        }
     
    7373                        ASTNode ifTest = Accessors.ifTest(node);                       
    7474                        String functionName = BITBLOCK.ANY.getFunctionName();
    75                         FunctionInvocationNode functionInvocationNode = Generators.makeFunctionInvocationNode(functionName, ifTest.getToken());
     75                        FunctionInvocationStatementNode functionInvocationNode = Generators.makeFunctionInvocationStatementNode(functionName, ifTest.getToken());
    7676                        functionInvocationNode.appendChild(ifTest);
    7777                        node.replaceChild(ifTest, functionInvocationNode);
     
    8686                        ASTNode whileTest = Accessors.whileCondition(node);
    8787                        String functionName = BITBLOCK.ANY.getFunctionName();
    88                         FunctionInvocationNode functionInvocationNode = Generators.makeFunctionInvocationNode(functionName, whileTest.getToken());
     88                        FunctionInvocationStatementNode functionInvocationNode = Generators.makeFunctionInvocationStatementNode(functionName, whileTest.getToken());
    8989                        functionInvocationNode.appendChild(whileTest);
    9090                        node.replaceChild(whileTest, functionInvocationNode);
  • proto/pablo/src/compiler/visitors/CPPCodeGenerator.java

    r2607 r2608  
    88import compiler.codeGeneration.*;
    99
     10// ASTNode w/o code generation code: constant,
     11
    1012public class CPPCodeGenerator extends CodeGenerator {
    1113
    12 //      TODO - Labeller Stack? 
    1314//      private Labeller labeller = new Labeller();
    1415
    1516        private boolean inTypeDecl = false;
    16        
    17         // private boolean inStreamFunctionDefinitions = false;
    18                
     17                       
    1918        public CPPCodeGenerator(ASTNode astTree) {
    2019                this.astTree = astTree;
     
    4746        // Stream Functions
    4847        ////////////////////////////////////////////////////////////////////////////
    49 
    5048        public CodeStore visitLeave(FunctionDefNode node, List<CodeStore> childResults) {
    5149                CodeStore code = new CodeStore();
     
    6563               
    6664                CodeStore blockStatement = childResults.get(3);
    67                 code.addAll(blockStatement, 0);
    68                
     65                code.addLine("{");
     66                code.addAll(blockStatement, 1);
     67                code.dedentedLine("}");
    6968                return code;
    7069        }
     
    8988        }
    9089       
    91         // Parameter (type identifier)
     90        // Parameter
    9291        public CodeStore visitLeave(ParameterNode node, List<CodeStore> childResults) { // a variable, not a line of code
    9392                CodeStore code = new CodeStore();
     
    103102        // Statements
    104103        ////////////////////////////////////////////////////////////////////////////   
    105        
    106         // block statements
    107         public CodeStore visitLeave(BlockStatementNode node, List<CodeStore> childResults) {
    108                 CodeStore code = new CodeStore();
     104        public CodeStore visitLeave(AssignmentStatementNode node, List<CodeStore> childResults) {
     105                CodeStore code = new CodeStore();
     106                CodeStore lhs = childResults.get(0);
     107                CodeStore rhs = childResults.get(1);
     108                code.addFormattedLine("%s %s %s;",lhs.getResultVariableName()
     109                                                                                 ,node.getToken().getLexeme()
     110                                                                                 ,rhs.getResultVariableName());
     111               
     112                return code;
     113        }
     114       
     115       
     116
     117        // if statement
     118        public CodeStore visitLeave(IfStatementNode node, List<CodeStore> childResults) {
     119                CodeStore code = new CodeStore();
     120                CodeStore ifTest                        = childResults.get(0);
     121                CodeStore blockStatement        = childResults.get(1);
     122                code.addFormattedLine("if (%s)", ifTest.getResultVariableName());
    109123                code.addLine("{");
    110                
    111                 for (CodeStore child: childResults.subList(0, 1)) {
    112                         code.addAll(child, 1);
    113                 }
    114                
    115                 for (CodeStore child: childResults.subList(1, childResults.size())) {
    116                         code.addAll(child, 0);         
    117                 }
    118                 code.dedentedLine("};");
    119                
    120                 return code;
    121         }       
    122        
    123         // local var declarations list
     124                code.addAll(blockStatement, 1);
     125                code.dedentedLine("}");
     126                return code;
     127        }
     128       
     129        // while statement
     130       
     131        // return statement
     132        public CodeStore visitLeave(ReturnStatementNode node, List<CodeStore> childResults) {
     133                CodeStore code = new CodeStore();
     134                CodeStore child = childResults.get(0);
     135                code.addFormattedLine("return %s;", child.getResultVariableName());
     136                return code;
     137        }
     138                       
     139        // variable declarations list
    124140        public CodeStore visitLeave(LocalVarDeclListNode node, List<CodeStore> childResults) {
    125141                // TODO
     
    127143        }       
    128144
     145        // variable declaration
    129146        public CodeStore visitLeave(LocalVarDeclNode node, List<CodeStore> childResults) {
    130147       
     
    133150                CodeStore type                                  = (CodeStore)childResults.get(0);
    134151                CodeStore identifier                    = (CodeStore)childResults.get(1);
    135                 CodeStore assignmentOperator    = (CodeStore)childResults.get(2);
    136                 CodeStore expression                    = (CodeStore)childResults.get(3);
     152                //CodeStore assignmentOperator  = //(CodeStore)childResults.get(2);
     153                CodeStore expression                    = (CodeStore)childResults.get(2);
    137154               
    138155                code.addFormattedLine("%s %s %s %s;",
    139156                                                                type.getResultVariableName(),
    140157                                                                identifier.getResultVariableName(),
    141                                                                 assignmentOperator.getResultVariableName(),
     158                                                                Accessors.assignmentOperator(node),
    142159                                                                expression.getResultVariableName());
    143160                return code;           
     
    145162        }       
    146163       
    147         public CodeStore visitLeave(AssignmentOperatorNode node, List<CodeStore> childResults) {
    148                 CodeStore code = new CodeStore();
    149                 code.setResultVariableName(Accessors.assignmentOperator(node));
    150                 return code;
    151         }
    152        
     164//      public CodeStore visitLeave(AssignmentStatementNode node, List<CodeStore> childResults) {
     165//              CodeStore code = new CodeStore();
     166//              code.setResultVariableName(Accessors.assignmentOperator(node));
     167//              return code;
     168//      }
     169
     170        // block statements
     171        public CodeStore visitLeave(BlockStatementNode node, List<CodeStore> childResults) {
     172                CodeStore code = new CodeStore();
     173               
     174                if (childResults.isEmpty()) {
     175                        code.addLine(""); // empty if / while
     176                }
     177               
     178                for (CodeStore child: childResults) {
     179                        code.addAll(child, 0);
     180                }
     181                               
     182                return code;
     183        }       
     184               
     185        ////////////////////////////////////////////////////////////////////////////   
    153186        // Expressions
    154 
    155        
    156         ////////////////////////////////////////////////////////////////////////////
     187        ////////////////////////////////////////////////////////////////////////////
     188       
    157189        // BinaryOperator
    158         ////////////////////////////////////////////////////////////////////////////
    159190        public CodeStore visitLeave(BinaryOperatorNode node, List<CodeStore> childResults) {
    160191                CodeStore code = new CodeStore();
    161192                CodeStore lhs = childResults.get(0);
    162193                CodeStore rhs = childResults.get(1);
     194                String lhsCode = lhs.getResultVariableName();
     195                String rhsCode = rhs.getResultVariableName();   
    163196               
    164197                StringBuffer resultVariable = new StringBuffer();
    165                 resultVariable.append(lhs.getResultVariableName());
     198
     199                if(!Accessors.isTerminal(Accessors.leftOperand(node))) {
     200                        lhsCode = bracketExpressionCode(lhsCode);
     201                }
     202                resultVariable.append(lhsCode);
     203               
    166204                resultVariable.append(" ");
    167205                resultVariable.append(Accessors.operator(node));
    168206                resultVariable.append(" ");
    169                 resultVariable.append(rhs.getResultVariableName());
     207               
     208                if(!Accessors.isTerminal(Accessors.rightOperand(node))) {
     209                        rhsCode = bracketExpressionCode(rhsCode);
     210                }
     211                resultVariable.append(rhsCode);
    170212               
    171213                code.setResultVariableName(resultVariable.toString());
    172214               
    173215                return code;
     216        }
     217
     218        ////////////////////////////////////////////////////////////////////////////
     219        // UnaryOperator
     220        ////////////////////////////////////////////////////////////////////////////
     221        public CodeStore visitLeave(UnaryOperatorNode node, List<CodeStore> childResults) {
     222                CodeStore code = new CodeStore();
     223                CodeStore child = childResults.get(0);
     224                String childCode = child.getResultVariableName();
     225                       
     226                StringBuffer resultVariable = new StringBuffer();
     227                resultVariable.append(Accessors.operator(node));
     228               
     229                if(!Accessors.isTerminal(Accessors.operand(node))) {
     230                        childCode = bracketExpressionCode(childCode);
     231                }
     232                resultVariable.append(childCode);
     233                               
     234                code.setResultVariableName(resultVariable.toString());
     235                return code;
     236        }       
     237       
     238        private String bracketExpressionCode(String code) {
     239                StringBuffer buffer = new StringBuffer();
     240                buffer.append("(");
     241                buffer.append(code);
     242                buffer.append(")");
     243                return buffer.toString();
    174244        }               
    175 
     245       
    176246        ////////////////////////////////////////////////////////////////////////////
    177247        // Operator
  • proto/pablo/src/compiler/visitors/CarryCounter.java

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

    r2603 r2608  
    4040        private class CarryIntroVisitor extends VoidVisitor.Default {
    4141
    42                 private final String ciSuffix = "_ci";
    43                 private final String coSuffix = "_co";
    44                 private String [] pendindCarryQName = {CarryQ.CarryQ_PACKAGE_NAME, CarryQ.GETCARRYIN.cPPCode()};
    45                 private String [] pending64QName = {CarryQ.CarryQ_PACKAGE_NAME, CarryQ.GETPENDING64.cPPCode()};
     42                //private final String ciSuffix = "_ci";
     43                //private final String coSuffix = "_co";
     44                //private String [] pendindCarryQName = {CarryQ.CarryQ_PACKAGE_NAME, CarryQ.GETCARRYIN.cPPCode()};
     45                //private String [] pending64QName = {CarryQ.CarryQ_PACKAGE_NAME, CarryQ.GETPENDING64.cPPCode()};
    4646               
    4747                private boolean ciMode;
     
    6060                }
    6161
    62                 void setCiMode(boolean ciMode) {
    63                         this.ciMode = ciMode;
    64                 }
    65                
    66                 void setCoMode(boolean coMode) {
    67                         this.coMode = coMode;
    68                 }
     62                //void setCiMode(boolean ciMode) {
     63                //      this.ciMode = ciMode;
     64                //}
     65               
     66                //void setCoMode(boolean coMode) {
     67                //      this.coMode = coMode;
     68                //}
    6969               
    7070                //              def xfrm_fndef(self, fndef):
     
    8383                }               
    8484               
    85                 public void visitLeave(FunctionInvocationNode node) {
     85                public void visitLeave(FunctionInvocationStatementNode node) {
    8686                       
    8787                        ASTNode replacementNode;
     
    100100//              adv_n_args = [mkCall('simd<1>::constant<0>', []), ast.Num(self.current_adv_n)]
    101101                        if(ciMode) {
    102                                 carryCall = Generators.makeFunctionInvocationNode(new String [] {CarryQ.CarryQ_PACKAGE_NAME, CarryQ.GETCARRYIN.cPPCode()}, node.getToken());
     102                                carryCall = Generators.makeFunctionInvocationStatementNode(new String [] {CarryQ.CarryQ_PACKAGE_NAME, CarryQ.GETCARRYIN.cPPCode()}, node.getToken());
    103103                                carryCall.appendChild(currentCarry);
    104104                               
    105                                 advNCall = Generators.makeFunctionInvocationNode(new String [] {CarryQ.CarryQ_PACKAGE_NAME, CarryQ.GETPENDING64.cPPCode()}, node.getToken());
     105                                advNCall = Generators.makeFunctionInvocationStatementNode(new String [] {CarryQ.CarryQ_PACKAGE_NAME, CarryQ.GETPENDING64.cPPCode()}, node.getToken());
    106106                                advNCall.appendChild(currentAdvN);
    107107                               
     
    118118        //                    return c                 
    119119                        if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, BuiltinOperations.ADVANCE.pabloName(), BuiltinOperations.ADVANCE.argCount())) {               
    120                                 replaceFunctionInvocationNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.ADVANCE.cPPCode(), carryCall, currentCarry);
     120                                replaceFunctionInvocationStatementNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.ADVANCE.cPPCode(), carryCall, currentCarry);
    121121                                this.currentCarry += 1;
    122122                        }
     
    129129        //            return c         
    130130                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, BuiltinOperations.SCANTHRU.pabloName(), BuiltinOperations.SCANTHRU.argCount())) {                         
    131                                 replaceFunctionInvocationNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.SCANTHRU.cPPCode(), carryCall, currentCarry);
     131                                replaceFunctionInvocationStatementNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.SCANTHRU.cPPCode(), carryCall, currentCarry);
    132132                                this.currentCarry += 1;
    133133                        }
     
    140140        //            return c         
    141141                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, BuiltinOperations.ADVANCETHENSCANTHRU.pabloName(), BuiltinOperations.ADVANCETHENSCANTHRU.argCount())) {
    142                                 replaceFunctionInvocationNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.ADVANCETHENSCANTHRU.cPPCode(), carryCall, currentCarry);
     142                                replaceFunctionInvocationStatementNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.ADVANCETHENSCANTHRU.cPPCode(), carryCall, currentCarry);
    143143                                this.currentCarry += 1;
    144144                        }               
     
    151151        //            return c         
    152152                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, BuiltinOperations.SPANUPTO.pabloName(), BuiltinOperations.SPANUPTO.argCount())) {
    153                                 replaceFunctionInvocationNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.SPANUPTO.cPPCode(), carryCall, currentCarry);                         
     153                                replaceFunctionInvocationStatementNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.SPANUPTO.cPPCode(), carryCall, currentCarry);                               
    154154                                this.currentCarry += 1;
    155155                        }               
     
    164164        //            return c
    165165                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, BuiltinOperations.ADVANCETHENSCANTO.pabloName(), BuiltinOperations.ADVANCETHENSCANTO.argCount())) {
    166                                 replaceFunctionInvocationNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.ADVANCETHENSCANTO.cPPCode(), carryCall, currentCarry);
     166                                replaceFunctionInvocationStatementNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.ADVANCETHENSCANTO.cPPCode(), carryCall, currentCarry);
    167167                                this.currentCarry += 1;
    168168                        }               
     
    178178       
    179179                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, BuiltinOperations.INCLUSIVESPAN.pabloName(), BuiltinOperations.INCLUSIVESPAN.argCount())) {
    180                                 replaceFunctionInvocationNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.INCLUSIVESPAN.cPPCode(), carryCall, currentCarry);
     180                                replaceFunctionInvocationStatementNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.INCLUSIVESPAN.cPPCode(), carryCall, currentCarry);
    181181                                this.currentCarry += 1;
    182182                        }                               
     
    192192       
    193193                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, BuiltinOperations.EXCLUSIVESPAN.pabloName(), BuiltinOperations.EXCLUSIVESPAN.argCount())) {
    194                                 replaceFunctionInvocationNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.EXCLUSIVESPAN.cPPCode(), carryCall, currentCarry);
     194                                replaceFunctionInvocationStatementNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.EXCLUSIVESPAN.cPPCode(), carryCall, currentCarry);
    195195                                this.currentCarry += 1;
    196196                        }                                               
     
    208208       
    209209                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, BuiltinOperations.SCANTO.pabloName(), BuiltinOperations.SCANTO.argCount())) {
    210                                 replaceFunctionInvocationNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.SCANTO.cPPCode(), carryCall, currentCarry);
     210                                replaceFunctionInvocationStatementNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.SCANTO.cPPCode(), carryCall, currentCarry);
    211211                                this.currentCarry += 1;
    212212                        }                                                               
     
    221221       
    222222                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, BuiltinOperations.SCANTOFIRST.pabloName(), BuiltinOperations.SCANTOFIRST.argCount())) {
    223                                 replaceFunctionInvocationNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.SCANTOFIRST.cPPCode(), carryCall, currentCarry);
     223                                replaceFunctionInvocationStatementNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.SCANTOFIRST.cPPCode(), carryCall, currentCarry);
    224224                                this.currentCarry += 1;
    225225                        }                                                                               
     
    232232        //            return c
    233233                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, BuiltinOperations.ADVANCE32.pabloName(), BuiltinOperations.ADVANCE32.argCount())) {
    234                                 replaceFunctionInvocationNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.ADVANCE32.cPPCode(), carryCall, currentAdvN);
     234                                replaceFunctionInvocationStatementNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.ADVANCE32.cPPCode(), carryCall, currentAdvN);
    235235                                this.currentAdvN += 1;
    236236                        }                       
     
    243243        //            return c         
    244244                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, BuiltinOperations.ADVANCEN.pabloName(), BuiltinOperations.ADVANCEN.argCount())) {
    245                                 replaceFunctionInvocationNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.ADVANCEN.cPPCode(), carryCall, currentAdvN);                                 
     245                                replaceFunctionInvocationStatementNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.ADVANCEN.cPPCode(), carryCall, currentAdvN);                                 
    246246                                this.currentAdvN += 1;                 
    247247                        }                                       
     
    256256                                         
    257257                                if(!this.coMode) { // if not final block
    258                                         replacementNode = Generators.makeFunctionInvocationNode(SIMD.ANDC.idisaName(), node.getToken());
     258                                        replacementNode = Generators.makeFunctionInvocationStatementNode(SIMD.ANDC.idisaName(), node.getToken());
    259259                                        for(ASTNode arg : Accessors.functionInvocationArgs(node)) {
    260260                                                replacementNode.appendChild(arg);
     
    262262                                        replacementNode.appendChild(Generators.makeIdentifierNode(Keywords.EOFMASK.cPPName(), node.getToken()));
    263263                                } else {
    264                                         replacementNode = Generators.makeFunctionInvocationNode(SIMD.CONSTANT.idisaConstantName(1, 0), node.getToken());                                       
     264                                        replacementNode = Generators.makeFunctionInvocationStatementNode(SIMD.CONSTANT.idisaConstantName(1, 0), node.getToken());                                       
    265265                                }
    266266                                node.updateSelf(replacementNode);
     
    276276                               
    277277                                if(!this.coMode) {  // if not final block
    278                                         replacementNode = Generators.makeFunctionInvocationNode(SIMD.AND.idisaName(), node.getToken());
     278                                        replacementNode = Generators.makeFunctionInvocationStatementNode(SIMD.AND.idisaName(), node.getToken());
    279279                                        for(ASTNode arg : Accessors.functionInvocationArgs(node)) {
    280280                                                replacementNode.appendChild(arg);
     
    297297//
    298298//                      else if (Builtins.isCall(node, Builtins.BUILTIN_PACKAGE_NAME, NoCarry.STREAMSCAN.pabloName(), NoCarry.STREAMSCAN.argCount())) {
    299 //                              replacementNode = Generators.makeFunctionInvocationNode(NoCarry.STREAMSCAN.cPPCode(), node.getToken());
     299//                              replacementNode = Generators.makeFunctionInvocationStatementNode(NoCarry.STREAMSCAN.cPPCode(), node.getToken());
    300300//                             
    301301//                              ASTNode arg0 = Generators.makeIdentifierNode("(ScanBlock *) &" + Accessors.identifierLexeme(Accessors.functionInvocationArg(node, 0)), node.getToken());
     
    343343                               
    344344                                ASTNode lhs = Accessors.ifTest(node);
    345                                 FunctionInvocationNode rhs = (FunctionInvocationNode) Generators.makeFunctionInvocationNode(
     345                                FunctionInvocationStatementNode rhs = (FunctionInvocationStatementNode) Generators.makeFunctionInvocationStatementNode(
    346346                                                                                                        new String [] {CarryQ.CarryQ_PACKAGE_NAME, CarryQ.CARRYTEST.cPPCode()},
    347347                                                                                                        node.getToken());
     
    360360                               
    361361                                // else part, append CarryDequeueEnqueue call
    362                                 FunctionInvocationNode carryDequeueEnqueue = (FunctionInvocationNode) Generators.makeFunctionInvocationNode(
     362                                FunctionInvocationStatementNode carryDequeueEnqueue = (FunctionInvocationStatementNode) Generators.makeFunctionInvocationStatementNode(
    363363                                                                                                                                new String [] {CarryQ.CarryQ_PACKAGE_NAME, CarryQ.CARRYDEQUEUEENQUEUE.cPPCode()},
    364364                                                                                                                                node.getToken());
     
    379379                                       
    380380                // Helpers             
    381                 private void replaceFunctionInvocationNode(FunctionInvocationNode node, String targetPackage, String targetName,
     381                private void replaceFunctionInvocationStatementNode(FunctionInvocationStatementNode node, String targetPackage, String targetName,
    382382                                ASTNode call, IntegerConstantNode carry) {
    383                         FunctionInvocationNode replacementNode;
     383                        FunctionInvocationStatementNode replacementNode;
    384384                        String [] compoundName = new String [2];
    385385                        compoundName[0] = targetPackage;
    386386                        compoundName[1] = targetName;
    387                         replacementNode = Generators.makeFunctionInvocationNode(compoundName, node.getToken());
     387                        replacementNode = Generators.makeFunctionInvocationStatementNode(compoundName, node.getToken());
    388388                        for(ASTNode arg : Accessors.functionInvocationArgs(node)) {
    389389                                replacementNode.appendChild(arg);
  • proto/pablo/src/lexicalAnalyzer/Lextant.java

    r2461 r2608  
    3434        WHILE("while", "main"),
    3535        RETURN("return", "main"),
    36         ELSE("else", "main"),
    3736        FUNCTION("function", "main"),
    3837        LCURLY("{", "main"),
  • proto/pablo/src/parser/Parser.java

    r2607 r2608  
    328328        }
    329329         
     330        public ASTNode parseStatement() {
     331                if( !(nowReading.isLextant(Lextant.IF, Lextant.RETURN, Lextant.VAR, Lextant.WHILE) || (nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
     332                        return syntaxErrorNode("statement² [IDENTIFIER¹, IF¹, RETURN¹, VAR¹, WHILE¹]");
     333                }
     334       
     335                boolean allowCompression = true;
     336                ASTNode result = new ASTNode(nowReading);
     337                result.setProductionTag(12);
     338                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     339                if( (nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
     340                        {
     341                                ASTNode child = parseFunctionInvocationOrAssignmentStatement();
     342                                result.appendChild(child);
     343                                allChildren.add(child);
     344                        }
     345                }
     346                else if( nowReading.isLextant(Lextant.IF) ) {
     347                        {
     348                                ASTNode child = parseIfStatement();
     349                                result.appendChild(child);
     350                                allChildren.add(child);
     351                        }
     352                }
     353                else if( nowReading.isLextant(Lextant.WHILE) ) {
     354                        {
     355                                ASTNode child = parseWhileStatement();
     356                                result.appendChild(child);
     357                                allChildren.add(child);
     358                        }
     359                }
     360                else if( nowReading.isLextant(Lextant.RETURN) ) {
     361                        {
     362                                ASTNode child = parseReturnStatement();
     363                                result.appendChild(child);
     364                                allChildren.add(child);
     365                        }
     366                }
     367                else if( nowReading.isLextant(Lextant.VAR) ) {
     368                        {
     369                                ASTNode child = parseLocalVarDecl();
     370                                result.appendChild(child);
     371                                allChildren.add(child);
     372                        }
     373                }
     374                if( nowReading.isLextant(Lextant.TERMINATOR) ) {
     375                        expect(Lextant.TERMINATOR);
     376                }
     377                if(allowCompression) {
     378                        return compressIfPossible(result);
     379                }
     380                return result;
     381        }
     382         
     383        public ASTNode parseFunctionInvocationOrAssignmentStatement() {
     384                if( !((nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
     385                        return syntaxErrorNode("functionInvocationOrAssignmentStatement² [IDENTIFIER¹]");
     386                }
     387       
     388                boolean allowCompression = true;
     389                ASTNode result = new ASTNode(nowReading);
     390                result.setProductionTag(13);
     391                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     392                {
     393                        ASTNode child = parseCompoundVariable();
     394                        result.appendChild(child);
     395                        allChildren.add(child);
     396                }
     397                if( nowReading.isLextant(Lextant.LROUND) ) {
     398                        {
     399                                ASTNode child = parseFunctionInvocation();
     400                                result.appendChild(child);
     401                                allChildren.add(child);
     402                        }
     403                        result = promoteLastChild(result);
     404                        allowCompression = false;
     405                }
     406                else if( nowReading.isLextant(Lextant.AND_ASSIGN, Lextant.ASSIGN, Lextant.OR_ASSIGN, Lextant.XOR_ASSIGN) ) {
     407                        {
     408                                ASTNode child = parseAssignmentStatementRest();
     409                                result.appendChild(child);
     410                                allChildren.add(child);
     411                        }
     412                        result = promoteLastChild(result);
     413                        allowCompression = false;
     414                }
     415                expect(Lextant.TERMINATOR);
     416                if(allowCompression) {
     417                        return result;
     418                }
     419                return result;
     420        }
     421         
     422        public ASTNode parseFunctionInvocation() {
     423                if( !(nowReading.isLextant(Lextant.LROUND)) ) {
     424                        return syntaxErrorNode("functionInvocation² [LROUND¹]");
     425                }
     426       
     427                boolean allowCompression = true;
     428                ASTNode result = new ASTNode(nowReading);
     429                result.setProductionTag(14);
     430                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     431                {
     432                        ASTNode child = parseFunctionInvocationRest();
     433                        result.appendChild(child);
     434                        allChildren.add(child);
     435                }
     436                if(allowCompression) {
     437                        return compressIfPossible(result);
     438                }
     439                return result;
     440        }
     441         
     442        public ASTNode parseAssignmentOperator() {
     443                if( !(nowReading.isLextant(Lextant.AND_ASSIGN, Lextant.ASSIGN, Lextant.OR_ASSIGN, Lextant.XOR_ASSIGN)) ) {
     444                        return syntaxErrorNode("assignmentOperator² [AND_ASSIGN¹, ASSIGN¹, OR_ASSIGN¹, XOR_ASSIGN¹]");
     445                }
     446       
     447                boolean allowCompression = true;
     448                ASTNode result = new AssignmentOperatorNode(nowReading);
     449                result.setProductionTag(15);
     450                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     451                if( nowReading.isLextant(Lextant.ASSIGN) ) {
     452                        expect(Lextant.ASSIGN);
     453                }
     454                else if( nowReading.isLextant(Lextant.AND_ASSIGN) ) {
     455                        expect(Lextant.AND_ASSIGN);
     456                }
     457                else if( nowReading.isLextant(Lextant.OR_ASSIGN) ) {
     458                        expect(Lextant.OR_ASSIGN);
     459                }
     460                else if( nowReading.isLextant(Lextant.XOR_ASSIGN) ) {
     461                        expect(Lextant.XOR_ASSIGN);
     462                }
     463                if(allowCompression) {
     464                        return result;
     465                }
     466                return result;
     467        }
     468         
     469        public ASTNode parseAssignmentStatementRest() {
     470                if( !(nowReading.isLextant(Lextant.AND_ASSIGN, Lextant.ASSIGN, Lextant.OR_ASSIGN, Lextant.XOR_ASSIGN)) ) {
     471                        return syntaxErrorNode("assignmentStatementRest² [AND_ASSIGN¹, ASSIGN¹, OR_ASSIGN¹, XOR_ASSIGN¹]");
     472                }
     473       
     474                boolean allowCompression = true;
     475                ASTNode result = new AssignmentStatementNode(nowReading);
     476                result.setProductionTag(16);
     477                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     478                {
     479                        ASTNode child = parseAssignmentOperator();
     480                        // node omitted - no result.appendChild(child);
     481                        allChildren.add(child);
     482                        result.setToken( child.getToken() );
     483                }
     484                {
     485                        ASTNode child = parseExpression();
     486                        result.appendChild(child);
     487                        allChildren.add(child);
     488                }
     489                if(allowCompression) {
     490                        return result;
     491                }
     492                return result;
     493        }
     494         
     495        public ASTNode parseIfStatement() {
     496                if( !(nowReading.isLextant(Lextant.IF)) ) {
     497                        return syntaxErrorNode("ifStatement² [IF¹]");
     498                }
     499       
     500                boolean allowCompression = true;
     501                ASTNode result = new IfStatementNode(nowReading);
     502                result.setProductionTag(17);
     503                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     504                expect(Lextant.IF);
     505                expect(Lextant.LROUND);
     506                {
     507                        ASTNode child = parseExpression();
     508                        result.appendChild(child);
     509                        allChildren.add(child);
     510                }
     511                expect(Lextant.RROUND);
     512                {
     513                        ASTNode child = parseBlockStatement();
     514                        result.appendChild(child);
     515                        allChildren.add(child);
     516                }
     517                if(allowCompression) {
     518                        return result;
     519                }
     520                return result;
     521        }
     522         
     523        public ASTNode parseWhileStatement() {
     524                if( !(nowReading.isLextant(Lextant.WHILE)) ) {
     525                        return syntaxErrorNode("whileStatement² [WHILE¹]");
     526                }
     527       
     528                boolean allowCompression = true;
     529                ASTNode result = new WhileStatementNode(nowReading);
     530                result.setProductionTag(18);
     531                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     532                expect(Lextant.WHILE);
     533                expect(Lextant.LROUND);
     534                {
     535                        ASTNode child = parseExpression();
     536                        result.appendChild(child);
     537                        allChildren.add(child);
     538                }
     539                expect(Lextant.RROUND);
     540                {
     541                        ASTNode child = parseBlockStatement();
     542                        result.appendChild(child);
     543                        allChildren.add(child);
     544                }
     545                if(allowCompression) {
     546                        return result;
     547                }
     548                return result;
     549        }
     550         
     551        public ASTNode parseReturnStatement() {
     552                if( !(nowReading.isLextant(Lextant.RETURN)) ) {
     553                        return syntaxErrorNode("returnStatement² [RETURN¹]");
     554                }
     555       
     556                boolean allowCompression = true;
     557                ASTNode result = new ReturnStatementNode(nowReading);
     558                result.setProductionTag(19);
     559                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     560                expect(Lextant.RETURN);
     561                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)) ) {
     562                        {
     563                                ASTNode child = parseExpression();
     564                                result.appendChild(child);
     565                                allChildren.add(child);
     566                        }
     567                }
     568                expect(Lextant.TERMINATOR);
     569                if(allowCompression) {
     570                        return result;
     571                }
     572                return result;
     573        }
     574         
     575        public ASTNode parseLocalVarDecl() {
     576                if( !(nowReading.isLextant(Lextant.VAR)) ) {
     577                        return syntaxErrorNode("localVarDecl² [VAR¹]");
     578                }
     579       
     580                boolean allowCompression = true;
     581                ASTNode result = new LocalVarDeclNode(nowReading);
     582                result.setProductionTag(20);
     583                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     584                expect(Lextant.VAR);
     585                {
     586                        ASTNode child = parseType();
     587                        result.appendChild(child);
     588                        allChildren.add(child);
     589                }
     590                {
     591                        ASTNode child = parseVariableName();
     592                        result.appendChild(child);
     593                        allChildren.add(child);
     594                }
     595                if( nowReading.isLextant(Lextant.AND_ASSIGN, Lextant.ASSIGN, Lextant.OR_ASSIGN, Lextant.XOR_ASSIGN) ) {
     596                        {
     597                                ASTNode child = parseAssignmentOperator();
     598                                // node omitted - no result.appendChild(child);
     599                                allChildren.add(child);
     600                                result.setToken( child.getToken() );
     601                        }
     602                        {
     603                                ASTNode child = parseExpression();
     604                                result.appendChild(child);
     605                                allChildren.add(child);
     606                        }
     607                }
     608                if(allowCompression) {
     609                        return result;
     610                }
     611                return result;
     612        }
     613         
     614        public ASTNode parseVariableName() {
     615                if( !((nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
     616                        return syntaxErrorNode("variableName² [IDENTIFIER¹]");
     617                }
     618       
     619                boolean allowCompression = true;
     620                ASTNode result = new ASTNode(nowReading);
     621                result.setProductionTag(21);
     622                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     623                {
     624                        ASTNode child = parseIdentifier();
     625                        result.appendChild(child);
     626                        allChildren.add(child);
     627                }
     628                if(allowCompression) {
     629                        return compressIfPossible(result);
     630                }
     631                return result;
     632        }
     633         
    330634        public ASTNode parseBlockStatement() {
    331635                if( !(nowReading.isLextant(Lextant.LCURLY)) ) {
     
    335639                boolean allowCompression = true;
    336640                ASTNode result = new BlockStatementNode(nowReading);
    337                 result.setProductionTag(12);
     641                result.setProductionTag(22);
    338642                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    339643                expect(Lextant.LCURLY);
     
    348652                if(allowCompression) {
    349653                        return result;
    350                 }
    351                 return result;
    352         }
    353          
    354         public ASTNode parseStatement() {
    355                 if( !(nowReading.isLextant(Lextant.IF, Lextant.RETURN, Lextant.VAR, Lextant.WHILE) || (nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
    356                         return syntaxErrorNode("statement² [IDENTIFIER¹, IF¹, RETURN¹, VAR¹, WHILE¹]");
    357                 }
    358        
    359                 boolean allowCompression = true;
    360                 ASTNode result = new ASTNode(nowReading);
    361                 result.setProductionTag(13);
    362                 RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    363                 if( (nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
    364                         {
    365                                 ASTNode child = parseFunctionInvocationOrAssignmentStatement();
    366                                 result.appendChild(child);
    367                                 allChildren.add(child);
    368                         }
    369                 }
    370                 else if( nowReading.isLextant(Lextant.IF) ) {
    371                         {
    372                                 ASTNode child = parseIfStatement();
    373                                 result.appendChild(child);
    374                                 allChildren.add(child);
    375                         }
    376                 }
    377                 else if( nowReading.isLextant(Lextant.WHILE) ) {
    378                         {
    379                                 ASTNode child = parseWhileStatement();
    380                                 result.appendChild(child);
    381                                 allChildren.add(child);
    382                         }
    383                 }
    384                 else if( nowReading.isLextant(Lextant.RETURN) ) {
    385                         {
    386                                 ASTNode child = parseReturnStatement();
    387                                 result.appendChild(child);
    388                                 allChildren.add(child);
    389                         }
    390                 }
    391                 else if( nowReading.isLextant(Lextant.VAR) ) {
    392                         {
    393                                 ASTNode child = parseLocalVarDecl();
    394                                 result.appendChild(child);
    395                                 allChildren.add(child);
    396                         }
    397                 }
    398                 if( nowReading.isLextant(Lextant.TERMINATOR) ) {
    399                         expect(Lextant.TERMINATOR);
    400                 }
    401                 if(allowCompression) {
    402                         return compressIfPossible(result);
    403                 }
    404                 return result;
    405         }
    406          
    407         public ASTNode parseFunctionInvocationOrAssignmentStatement() {
    408                 if( !((nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
    409                         return syntaxErrorNode("functionInvocationOrAssignmentStatement² [IDENTIFIER¹]");
    410                 }
    411        
    412                 boolean allowCompression = true;
    413                 ASTNode result = new ASTNode(nowReading);
    414                 result.setProductionTag(14);
    415                 RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    416                 {
    417                         ASTNode child = parseCompoundVariable();
    418                         result.appendChild(child);
    419                         allChildren.add(child);
    420                 }
    421                 if( nowReading.isLextant(Lextant.LROUND) ) {
    422                         {
    423                                 ASTNode child = parseFunctionInvocation();
    424                                 result.appendChild(child);
    425                                 allChildren.add(child);
    426                         }
    427                         result = promoteLastChild(result);
    428                         allowCompression = false;
    429                 }
    430                 else if( nowReading.isLextant(Lextant.AND_ASSIGN, Lextant.ASSIGN, Lextant.OR_ASSIGN, Lextant.XOR_ASSIGN) ) {
    431                         {
    432                                 ASTNode child = parseAssignmentStatementRest();
    433                                 result.appendChild(child);
    434                                 allChildren.add(child);
    435                         }
    436                         result = promoteLastChild(result);
    437                         allowCompression = false;
    438                 }
    439                 expect(Lextant.TERMINATOR);
    440                 if(allowCompression) {
    441                         return result;
    442                 }
    443                 return result;
    444         }
    445          
    446         public ASTNode parseFunctionInvocation() {
    447                 if( !(nowReading.isLextant(Lextant.LROUND)) ) {
    448                         return syntaxErrorNode("functionInvocation² [LROUND¹]");
    449                 }
    450        
    451                 boolean allowCompression = true;
    452                 ASTNode result = new ASTNode(nowReading);
    453                 result.setProductionTag(15);
    454                 RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    455                 {
    456                         ASTNode child = parseFunctionInvocationRest();
    457                         result.appendChild(child);
    458                         allChildren.add(child);
    459                 }
    460                 if(allowCompression) {
    461                         return compressIfPossible(result);
    462                 }
    463                 return result;
    464         }
    465          
    466         public ASTNode parseAssignmentOperator() {
    467                 if( !(nowReading.isLextant(Lextant.AND_ASSIGN, Lextant.ASSIGN, Lextant.OR_ASSIGN, Lextant.XOR_ASSIGN)) ) {
    468                         return syntaxErrorNode("assignmentOperator² [AND_ASSIGN¹, ASSIGN¹, OR_ASSIGN¹, XOR_ASSIGN¹]");
    469                 }
    470        
    471                 boolean allowCompression = true;
    472                 ASTNode result = new AssignmentOperatorNode(nowReading);
    473                 result.setProductionTag(16);
    474                 RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    475                 if( nowReading.isLextant(Lextant.ASSIGN) ) {
    476                         expect(Lextant.ASSIGN);
    477                 }
    478                 else if( nowReading.isLextant(Lextant.AND_ASSIGN) ) {
    479                         expect(Lextant.AND_ASSIGN);
    480                 }
    481                 else if( nowReading.isLextant(Lextant.OR_ASSIGN) ) {
    482                         expect(Lextant.OR_ASSIGN);
    483                 }
    484                 else if( nowReading.isLextant(Lextant.XOR_ASSIGN) ) {
    485                         expect(Lextant.XOR_ASSIGN);
    486                 }
    487                 if(allowCompression) {
    488                         return result;
    489                 }
    490                 return result;
    491         }
    492          
    493         public ASTNode parseAssignmentStatementRest() {
    494                 if( !(nowReading.isLextant(Lextant.AND_ASSIGN, Lextant.ASSIGN, Lextant.OR_ASSIGN, Lextant.XOR_ASSIGN)) ) {
    495                         return syntaxErrorNode("assignmentStatementRest² [AND_ASSIGN¹, ASSIGN¹, OR_ASSIGN¹, XOR_ASSIGN¹]");
    496                 }
    497        
    498                 boolean allowCompression = true;
    499                 ASTNode result = new AssignmentNode(nowReading);
    500                 result.setProductionTag(17);
    501                 RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    502                 {
    503                         ASTNode child = parseAssignmentOperator();
    504                         // node omitted - no result.appendChild(child);
    505                         allChildren.add(child);
    506                         result.setToken( child.getToken() );
    507                 }
    508                 {
    509                         ASTNode child = parseExpression();
    510                         result.appendChild(child);
    511                         allChildren.add(child);
    512                 }
    513                 if(allowCompression) {
    514                         return result;
    515                 }
    516                 return result;
    517         }
    518          
    519         public ASTNode parseIfStatement() {
    520                 if( !(nowReading.isLextant(Lextant.IF)) ) {
    521                         return syntaxErrorNode("ifStatement² [IF¹]");
    522                 }
    523        
    524                 boolean allowCompression = true;
    525                 ASTNode result = new IfStatementNode(nowReading);
    526                 result.setProductionTag(18);
    527                 RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    528                 expect(Lextant.IF);
    529                 expect(Lextant.LROUND);
    530                 {
    531                         ASTNode child = parseExpression();
    532                         result.appendChild(child);
    533                         allChildren.add(child);
    534                 }
    535                 expect(Lextant.RROUND);
    536                 {
    537                         ASTNode child = parseBlockStatement();
    538                         result.appendChild(child);
    539                         allChildren.add(child);
    540                 }
    541                 if( nowReading.isLextant(Lextant.ELSE) ) {
    542                         expect(Lextant.ELSE);
    543                         {
    544                                 ASTNode child = parseBlockStatement();
    545                                 result.appendChild(child);
    546                                 allChildren.add(child);
    547                         }
    548                 }
    549                 if(allowCompression) {
    550                         return result;
    551                 }
    552                 return result;
    553         }
    554          
    555         public ASTNode parseWhileStatement() {
    556                 if( !(nowReading.isLextant(Lextant.WHILE)) ) {
    557                         return syntaxErrorNode("whileStatement² [WHILE¹]");
    558                 }
    559        
    560                 boolean allowCompression = true;
    561                 ASTNode result = new WhileStatementNode(nowReading);
    562                 result.setProductionTag(19);
    563                 RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    564                 expect(Lextant.WHILE);
    565                 expect(Lextant.LROUND);
    566                 {
    567                         ASTNode child = parseExpression();
    568                         result.appendChild(child);
    569                         allChildren.add(child);
    570                 }
    571                 expect(Lextant.RROUND);
    572                 {
    573                         ASTNode child = parseBlockStatement();
    574                         result.appendChild(child);
    575                         allChildren.add(child);
    576                 }
    577                 if(allowCompression) {
    578                         return result;
    579                 }
    580                 return result;
    581         }
    582          
    583         public ASTNode parseReturnStatement() {
    584                 if( !(nowReading.isLextant(Lextant.RETURN)) ) {
    585                         return syntaxErrorNode("returnStatement² [RETURN¹]");
    586                 }
    587        
    588                 boolean allowCompression = true;
    589                 ASTNode result = new ReturnStatementNode(nowReading);
    590                 result.setProductionTag(20);
    591                 RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    592                 expect(Lextant.RETURN);
    593                 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)) ) {
    594                         {
    595                                 ASTNode child = parseExpression();
    596                                 result.appendChild(child);
    597                                 allChildren.add(child);
    598                         }
    599                 }
    600                 expect(Lextant.TERMINATOR);
    601                 if(allowCompression) {
    602                         return result;
    603                 }
    604                 return result;
    605         }
    606          
    607         public ASTNode parseLocalVarDecl() {
    608                 if( !(nowReading.isLextant(Lextant.VAR)) ) {
    609                         return syntaxErrorNode("localVarDecl² [VAR¹]");
    610                 }
    611        
    612                 boolean allowCompression = true;
    613                 ASTNode result = new LocalVarDeclNode(nowReading);
    614                 result.setProductionTag(21);
    615                 RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    616                 expect(Lextant.VAR);
    617                 {
    618                         ASTNode child = parseType();
    619                         result.appendChild(child);
    620                         allChildren.add(child);
    621                 }
    622                 {
    623                         ASTNode child = parseVariableName();
    624                         result.appendChild(child);
    625                         allChildren.add(child);
    626                 }
    627                 if( nowReading.isLextant(Lextant.AND_ASSIGN, Lextant.ASSIGN, Lextant.OR_ASSIGN, Lextant.XOR_ASSIGN) ) {
    628                         {
    629                                 ASTNode child = parseAssignmentOperator();
    630                                 result.appendChild(child);
    631                                 allChildren.add(child);
    632                         }
    633                         {
    634                                 ASTNode child = parseExpression();
    635                                 result.appendChild(child);
    636                                 allChildren.add(child);
    637                         }
    638                 }
    639                 if(allowCompression) {
    640                         return result;
    641                 }
    642                 return result;
    643         }
    644          
    645         public ASTNode parseVariableName() {
    646                 if( !((nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
    647                         return syntaxErrorNode("variableName² [IDENTIFIER¹]");
    648                 }
    649        
    650                 boolean allowCompression = true;
    651                 ASTNode result = new ASTNode(nowReading);
    652                 result.setProductionTag(22);
    653                 RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    654                 {
    655                         ASTNode child = parseIdentifier();
    656                         result.appendChild(child);
    657                         allChildren.add(child);
    658                 }
    659                 if(allowCompression) {
    660                         return compressIfPossible(result);
    661654                }
    662655                return result;
     
    806799       
    807800                boolean allowCompression = true;
    808                 ASTNode result = new FunctionInvocationNode(nowReading);
     801                ASTNode result = new FunctionInvocationStatementNode(nowReading);
    809802                result.setProductionTag(27);
    810803                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
Note: See TracChangeset for help on using the changeset viewer.