Changeset 2658


Ignore:
Timestamp:
Nov 19, 2012, 7:51:17 PM (6 years ago)
Author:
ksherdy
Message:

Shortened variable names for sanity.

Location:
proto/pablo
Files:
9 added
11 deleted
28 edited
3 copied
12 moved

Legend:

Unmodified
Added
Removed
  • proto/pablo/input/grammar/antlr/pablo.g

    r2583 r2658  
    3434// f u n c t i o n   d e f i n i t i o n                                                               
    3535functionDef
    36                                 : FUNCTION functionReturnTypeSpecifier functionName LROUND parameterList? RROUND blockStatemen
     36                                : FUNCTION functionReturnTypeSpecifier functionName LROUND parameterList? RROUND blockStm
    3737                                ;                               
    3838                                                                       
     
    5757                                ;
    5858
    59 blockStatement
    60                                 : LCURLY statementList RCURLY
    61                                 ;
    62 
    63 statementList
    64                                 : statement*
     59blockStmt
     60                                : LCURLY StmtList RCURLY
     61                                ;
     62
     63StmtList
     64                                : Stmt*
    6565                                ;
    6666
    6767// s t a t e m e n t s
    68 statement       
    69                                 : (variableDefinition | assignmentStatement | ifStatement | functionCall | whileStatement | returnStatement) (TERMINATOR)?
     68Stmt   
     69                                : (variableDefinition | assignmentStmt | ifStmt | functionCall | whileStmt | returnStmt) (TERMINATOR)?
    7070                                ;
    7171                                       
     
    7878                                ;
    7979                                       
    80 assignmentStatement
     80assignmentStmt
    8181                                : compoundVariable assignmentOperator expression
    8282                                ;
     
    9090                                ;
    9191                               
    92 ifStatement
    93                                 : IF LROUND expression RROUND blockStatement (ELSE blockStatement)?
     92ifStmt
     93                                : IF LROUND expression RROUND blockStmt (ELSE blockStmt)?
    9494                                ;
    9595
     
    9898                                ;
    9999                               
    100 whileStatement
    101                                 : WHILE LROUND expression RROUND DO blockStatement     
    102                                 ;
    103 
    104 returnStatement
     100whileStmt
     101                                : WHILE LROUND expression RROUND DO blockStmt   
     102                                ;
     103
     104returnStmt
    105105                                : RETURN identifier // expression ?
    106106                                ;
  • proto/pablo/input/grammar/scatter/pablo.scatter

    r2641 r2658  
    6565  unaryOperator {} [expression2],// expression5],
    6666  assignment {} [assignmentRest],
    67   functionInvocation {} [functionInvocationRest],
     67  FuncCall {} [FuncCallRest],
    6868  integerConstant{intValued;} [],
    6969}
    7070
    7171grammar {
    72         program         -> (declarations | functionDef) *;
     72        program         -> (declarations | FuncDef) *;
    7373
    7474        //
     
    8585        typeDef                                 ->  TYPEDEF type identifier ;
    8686       
    87         declaratorList                  ->  identifier (COMMA identifier)* ; // TODO - support or support via 'source' function definitions
     87        declaratorList                  ->  identifier (COMMA identifier)* ; // TODO - support or support via 'source' Func definitions
    8888       
    8989   
     
    9191        // f u n c t i o n   d e f i n i t i o n s                                                             
    9292        //
    93         functionDef             -> FUNCTION type functionName LROUND parameterList? RROUND blockStatement TERMINATOR?;                         
     93        FuncDef         -> FUNCTION type FuncName LROUND parameterList? RROUND blockStmt TERMINATOR?;                           
    9494                                                                               
    9595        returnType              #-> type ;      // Note: Strictly not required.
     
    9797        parameterList   -> parameter (COMMA parameter)*;
    9898                                                                                                               
    99         functionName    #-> identifier ;
     99        FuncName        #-> identifier ;
    100100                                                                                                                       
    101101        parameter               -> type parameterName ;
     
    110110        // s t a t e m e n t s
    111111        //
    112         statement                                                       #-> (functionInvocationOrAssignmentStatement | ifStatement | whileStatement | returnStatement | localVarDecl) (TERMINATOR)? ;
     112        Stmt                                                    #-> (FuncCallOrAssignmentStmt | ifStmt | whileStmt | returnStmt | localVarDecl) (TERMINATOR)? ;
    113113                       
    114         functionInvocationOrAssignmentStatement -> compoundVariable ((functionInvocationRest _promote_) | (assignmentRest _promote_)) TERMINATOR ;
    115        
    116         functionInvocationRest                          -> LROUND^ functionInvocationArgumentList RROUND ;
    117 
    118         functionInvocationArgumentList          -> (expression (COMMA expression)*)? ; 
    119                
    120         assignmentOperator                                      -> ASSIGN | AND_ASSIGN | OR_ASSIGN | XOR_ASSIGN ;                               
    121                                        
    122         assignmentRest                                          -> assignmentOperator^! expression ;                           
    123                                        
    124         ifStatement                                                     -> IF LROUND expression RROUND blockStatement (ELSE blockStatement)? ;                 
     114        FuncCallOrAssignmentStmt        -> compoundVariable ((FuncCallRest _promote_) | (assignmentRest _promote_)) TERMINATOR ;
     115       
     116        FuncCallRest                            -> LROUND^ FuncCallArgList RROUND ;
     117
     118        FuncCallArgList                         -> (expression (COMMA expression)*)? ; 
     119               
     120        assignmentOperator                              -> ASSIGN | AND_ASSIGN | OR_ASSIGN | XOR_ASSIGN ;                               
     121                                       
     122        assignmentRest                                  -> assignmentOperator^! expression ;                           
     123                                       
     124        ifStmt                                                  -> IF LROUND expression RROUND blockStmt (ELSE blockStmt)? ;                   
    125125                                                       
    126         whileStatement                                          -> WHILE LROUND expression RROUND blockStatement ;
     126        whileStmt                                               -> WHILE LROUND expression RROUND blockStmt ;
    127127                       
    128         returnStatement                                         -> RETURN (expression)? TERMINATOR;
     128        returnStmt                                              -> RETURN (expression)? TERMINATOR;
    129129                       
    130         localVarDecl                                            -> VAR type variableName (assignmentOperator^! expression) ?;
    131                
    132         variableName                                            #-> identifier;
    133 
    134         blockStatement                                          -> LCURLY statement* RCURLY ;
     130        localVarDecl                                    -> VAR type variableName (assignmentOperator^! expression) ?;
     131               
     132        variableName                                    #-> identifier;
     133
     134        blockStmt                                               -> LCURLY Stmt* RCURLY ;
    135135       
    136136        //
     
    145145        expression3             #-> LROUND expression RROUND
    146146                                        | constant
    147                                         | compoundVariable (functionInvocationRest _promote_)?
     147                                        | compoundVariable (FuncCallRest _promote_)?
    148148                                        ;
    149149
    150                                                 //(
    151                                                 //(functionInvocationRest _promote_)?
    152                                                 //| (expression4 _promote_)?
    153                                                 //| (expression5 _promote_)?
    154                                                 //)?
    155                                                 // ;
    156                                                 //expression4            -> DOT expression3 ;
    157                                                 //expression5    -> (LSQUARE INTEGER_CONST^ RSQUARE) (expression5Rest)?   ;     
    158                                                 //expression5Rest        -> DOT expression3 ;                                                                                           
     150                                        //(
     151                                        //(FuncCallRest _promote_)?
     152                                        //| (expression4 _promote_)?
     153                                        //| (expression5 _promote_)?
     154                                        //)?
     155                                        // ;
     156                                        //expression4            -> DOT expression3 ;
     157                                        //expression5    -> (LSQUARE INTEGER_CONST^ RSQUARE) (expression5Rest)?   ;     
     158                                        //expression5Rest        -> DOT expression3 ;                                                                                           
    159159                                                                                                                                                                                                                                                                       
    160160        constant                                #-> stringConstant | signedIntegerConstant ;
  • proto/pablo/input/grammar/scatter/pablo.scatter.alpha

    r2387 r2658  
    6666  binaryOperator {} [expression, expression1, expression3],
    6767  unaryOperator {} [expression2],
    68   assignment {} [assignmentStatementTail],
    69 //  ifStatement {} [ifStatementBulk],
     68  assignment {} [assignmentStmtTail],
     69//  ifStmt {} [ifStmtBulk],
    7070  functionCall {} [functionCallTail],
    7171  tupleIdentifier {} [tupleTail],
    72 //  ASTNode [variableFunctionCall], //[assignmentOrFunctionInvocation, variableOrFunctionInvocation],
     72//  ASTNode [variableFunctionCall], //[assignmentOrFunctionCall, variableOrFunctionCall],
    7373}
    7474
     
    9191        // f u n c t i o n   d e f i n i t i o n s                                                             
    9292        //
    93         functionDef             -> FUNCTION functionReturnType functionName LROUND (parameter (COMMA parameter)*)? RROUND blockStatement TERMINATOR ?;                         
     93        functionDef             -> FUNCTION functionReturnType functionName LROUND (parameter (COMMA parameter)*)? RROUND blockStmt TERMINATOR ?;                               
    9494                                                                               
    9595        functionReturnType      -> typeSpecifier | VOID ;
     
    101101        parameterName   #-> identifier ;
    102102       
    103         blockStatement  -> LCURLY statement* RCURLY ;
     103        blockStmt       -> LCURLY Stmt* RCURLY ;
    104104               
    105105        //
    106106        // s t a t e m e n t s
    107107        //
    108         statement                       #-> (assignmentStatementOrFunctionCall | ifStatement | whileStatement | returnStatement) (TERMINATOR)?  ;
     108        Stmt                    #-> (assignmentStmtOrFunctionCall | ifStmt | whileStmt | returnStmt) (TERMINATOR)?      ;
    109109                       
    110110        //variableDefinition           
     
    112112        //variableName          #-> identifier ;
    113113       
    114         assignmentStatementOrFunctionCall -> compoundVariable (assignmentStatementTail _promote_ | functionCallTail _promote_) ;
    115        
    116         assignmentStatementTail -> assignmentOperator^! expression ;
     114        assignmentStmtOrFunctionCall -> compoundVariable (assignmentStmtTail _promote_ | functionCallTail _promote_) ;
     115       
     116        assignmentStmtTail      -> assignmentOperator^! expression ;
    117117       
    118118        functionCallTail        -> LROUND (argumentList)? RROUND ;
     
    131131        assignmentOperator      -> ASSIGN | AND_ASSIGN | OR_ASSIGN | NOT_ASSIGN | XOR_ASSIGN ;
    132132                                       
    133         ifStatement             -> IF LROUND ifCondition RROUND ifBlock (ELSE elseBlock)? ;
     133        ifStmt          -> IF LROUND ifCondition RROUND ifBlock (ELSE elseBlock)? ;
    134134       
    135135        ifCondition             -> expression ;
    136136       
    137         ifBlock                 -> blockStatement ;
    138        
    139         elseBlock               -> blockStatement ; // TODO - dangling else problems?
     137        ifBlock                 -> blockStmt ;
     138       
     139        elseBlock               -> blockStmt ; // TODO - dangling else problems?
    140140                                               
    141         whileStatement  -> WHILE LROUND whileCondition RROUND blockStatement ;
     141        whileStmt       -> WHILE LROUND whileCondition RROUND blockStmt ;
    142142       
    143143        whileCondition  -> expression ;
    144144       
    145         returnStatement -> RETURN (identifier)? ; // TODO - return an expression
     145        returnStmt      -> RETURN (identifier)? ; // TODO - return an expression
    146146       
    147147        //
  • proto/pablo/input/grammar/scatter/pablo.scatter.beta

    r2370 r2658  
    5454 binaryOperator {} [expression, expression1, expression3],
    5555 unaryOperator {} [expression2],
    56  assignment {} [assignmentStatementRest],
    57  ifStatement {} [ifStatementBulk],
    58  functionInvocation {} [functionInvocationRest],
    59  ASTNode [assignmentOrFunctionInvocation, variableOrFunctionInvocation],
     56 assignment {} [assignmentStmtRest],
     57 ifStmt {} [ifStmtBulk],
     58 FunctionCall {} [FunctionCallRest],
     59 ASTNode [assignmentOrFunctionCall, variableOrFunctionCall],
    6060}
    6161
     
    7070 // We need to put curly braces {} around body of class delcaration.
    7171 // this grammar only allows simple initialization of fields as class
    72  // body statements. Verfiy this as a property of the input.
     72 // body Stmts. Verfiy this as a property of the input.
    7373 ////////////////////////////////////////////////////////////////////////
    7474 
    7575 structDeclaration → CLASS structName LEFTROUND RIGHTROUND COLON structBody ;
    76  structBody → LEFTCURLY structBodyStatement* RIGHTCURLY ;
    77  structBodyStatement ʉ → variableName ASSIGN value TERMINATOR? ;
     76 structBody → LEFTCURLY structBodyStmt* RIGHTCURLY ;
     77 structBodyStmt ʉ → variableName ASSIGN value TERMINATOR? ;
    7878 value → INTEGER_CONST ;
    7979 
     
    8787 ////////////////////////////////////////////////////////////////////////
    8888 
    89  functionDef → DEF functionName LEFTROUND parameterList RIGHTROUND COLON blockStatement ;
     89 functionDef → DEF functionName LEFTROUND parameterList RIGHTROUND COLON blockStmt ;
    9090 parameterList → identifier ( COMMA identifier )* ;
    9191 
    92  statement ʉ → (assignmentOrFunctionInvocation | ifStatement | whileStatement | blockStatement) TERMINATOR?;
    93  blockStatement → LEFTCURLY statement* RIGHTCURLY ;
     92 Stmt ʉ → (assignmentOrFunctionCall | ifStmt | whileStmt | blockStmt) TERMINATOR?;
     93 blockStmt → LEFTCURLY Stmt* RIGHTCURLY ;
    9494 
    95  assignmentOrFunctionInvocation → compoundVariable ( assignmentStatementRest ▲ | functionInvocationRest ▲ ) ;
    96  assignmentStatementRest → assignOp^! expression ;
     95 assignmentOrFunctionCall → compoundVariable ( assignmentStmtRest ▲ | FunctionCallRest ▲ ) ;
     96 assignmentStmtRest → assignOp^! expression ;
    9797 assignOp -> AND_EQUAL | OR_EQUAL | XOR_EQUAL | ASSIGN ;
    9898 
    99  ifStatement ʉ → IF ifStatementBulk ;
    100  ifStatementBulk → expression COLON? blockStatement (ELIF COLON? ifStatementBulk | ELSE COLON? blockStatement)? ;
    101  whileStatement → WHILE expression COLON? blockStatement ;
    102  expressionStatement → expression;
     99 ifStmt ʉ → IF ifStmtBulk ;
     100 ifStmtBulk → expression COLON? blockStmt (ELIF COLON? ifStmtBulk | ELSE COLON? blockStmt)? ;
     101 whileStmt → WHILE expression COLON? blockStmt ;
     102 expressionStmt → expression;
    103103 
    104104 expression ʉ → expression1 ( (OR^ | XOR^) expression )? ;    // lowest precedence: OR, XOR
     
    108108 expression4 ʉ → LEFTROUND expression RIGHTROUND
    109109 
    110               | variableOrFunctionInvocation
     110              | variableOrFunctionCall
    111111 
    112112              | constant ;
    113113 
    114  variableOrFunctionInvocation ʉ → compoundVariable (functionInvocationRest ▲)? ;
    115  functionInvocationRest → LEFTROUND^ expression (COMMA expression)* RIGHTROUND ;
     114 variableOrFunctionCall ʉ → compoundVariable (FunctionCallRest ▲)? ;
     115 FunctionCallRest → LEFTROUND^ expression (COMMA expression)* RIGHTROUND ;
    116116 
    117117 compoundVariable ʉ → identifier (DOT^ identifier)* ;
  • proto/pablo/input/test/visitors/Bitwise2IDISAXFormer/bitwise2IDISA.pablo

    r2600 r2658  
    2828        r = ~x;                                 // Actual       
    2929
    30         /*       Additional transformations not under test.
     30        /*       Additional XFormations not under test.
    3131       
    3232       
  • proto/pablo/src/ast/ASTNode.java

    r2641 r2658  
    125125        }
    126126    }
    127         public void insertAfterChild(ASTNode node, ASTNode successor) {
    128                 int index = children.indexOf(node);
    129                 insertChildAfter(index, successor);
    130                 successor.setParent(this);
    131         }
    132        
    133         private void insertChildAfter(int index, ASTNode successor) {
    134                 if(index == children.size()-1) {
    135                         children.add(successor);
    136                 } else {
    137                         children.add(index+1, successor);
    138                 }       
    139         }               
     127    public void insertAfterChild(ASTNode node, ASTNode successor) {
     128            int index = children.indexOf(node);
     129            insertChildAfter(index, successor);
     130            successor.setParent(this);
     131    }
     132    private void insertChildAfter(int index, ASTNode successor) {
     133            if(index == children.size()-1) {
     134                    children.add(successor);
     135            } else {
     136                    children.add(index+1, successor);
     137            }       
     138    }   
    140139       
    141140////////////////////////////////////////////////////////////////////////////////////
  • proto/pablo/src/ast/ASTTransformer.java

    r2621 r2658  
    1818        public ASTNode visit(BinaryOperatorNode node);
    1919
    20         public ASTNode visit(BlockStatementNode node);
     20        public ASTNode visit(BlockStmtNode node);
    2121
    2222        public ASTNode visit(CompoundVariableNode node);
     
    3232        public ASTNode visit(FieldWidthNode node);
    3333
    34         public ASTNode visit(FunctionDefNode node);
    35 
    36         public ASTNode visit(FunctionInvocationArgumentListNode node);
    37 
    38         public ASTNode visit(FunctionInvocationNode node);
    39 
    40         public ASTNode visit(FunctionInvocationOrAssignmentStatementNode node);
     34        public ASTNode visit(FuncCallArgListNode node);
     35
     36        public ASTNode visit(FuncCallNode node);
     37
     38        public ASTNode visit(FuncCallOrAssignmentStmtNode node);
     39
     40        public ASTNode visit(FuncDefNode node);
    4141
    4242        public ASTNode visit(IdentifierNode node);
    4343
    44         public ASTNode visit(IfStatementNode node);
     44        public ASTNode visit(IfStmtNode node);
    4545
    4646        public ASTNode visit(IntegerConstantNode node);
     
    5454        public ASTNode visit(ProgramNode node);
    5555
    56         public ASTNode visit(ReturnStatementNode node);
     56        public ASTNode visit(ReturnStmtNode node);
    5757
    5858        public ASTNode visit(StreamTypeNode node);
     
    7474        public ASTNode visit(VoidNode node);
    7575
    76         public ASTNode visit(WhileStatementNode node);
     76        public ASTNode visit(WhileStmtNode node);
    7777
    7878
     
    9999                }
    100100
    101                 public ASTNode visit(BlockStatementNode node) {
     101                public ASTNode visit(BlockStmtNode node) {
    102102                        return defaultVisit(node);
    103103                }
     
    127127                }
    128128
    129                 public ASTNode visit(FunctionDefNode node) {
    130                         return defaultVisit(node);
    131                 }
    132 
    133                 public ASTNode visit(FunctionInvocationArgumentListNode node) {
    134                         return defaultVisit(node);
    135                 }
    136 
    137                 public ASTNode visit(FunctionInvocationNode node) {
    138                         return defaultVisit(node);
    139                 }
    140 
    141                 public ASTNode visit(FunctionInvocationOrAssignmentStatementNode node) {
     129                public ASTNode visit(FuncCallArgListNode node) {
     130                        return defaultVisit(node);
     131                }
     132
     133                public ASTNode visit(FuncCallNode node) {
     134                        return defaultVisit(node);
     135                }
     136
     137                public ASTNode visit(FuncCallOrAssignmentStmtNode node) {
     138                        return defaultVisit(node);
     139                }
     140
     141                public ASTNode visit(FuncDefNode node) {
    142142                        return defaultVisit(node);
    143143                }
     
    147147                }
    148148
    149                 public ASTNode visit(IfStatementNode node) {
     149                public ASTNode visit(IfStmtNode node) {
    150150                        return defaultVisit(node);
    151151                }
     
    171171                }
    172172
    173                 public ASTNode visit(ReturnStatementNode node) {
     173                public ASTNode visit(ReturnStmtNode node) {
    174174                        return defaultVisit(node);
    175175                }
     
    211211                }
    212212
    213                 public ASTNode visit(WhileStatementNode node) {
     213                public ASTNode visit(WhileStmtNode node) {
    214214                        return defaultVisit(node);
    215215                }
  • proto/pablo/src/ast/ASTVisitor.java

    r2621 r2658  
    2323        public T visitLeave(BinaryOperatorNode node, List<T> childResults);
    2424
    25         public void visitEnter(BlockStatementNode node);
    26         public T visitLeave(BlockStatementNode node, List<T> childResults);
     25        public void visitEnter(BlockStmtNode node);
     26        public T visitLeave(BlockStmtNode node, List<T> childResults);
    2727
    2828        public void visitEnter(CompoundVariableNode node);
     
    4444        public T visitLeave(FieldWidthNode node, List<T> childResults);
    4545
    46         public void visitEnter(FunctionDefNode node);
    47         public T visitLeave(FunctionDefNode node, List<T> childResults);
    48 
    49         public void visitEnter(FunctionInvocationArgumentListNode node);
    50         public T visitLeave(FunctionInvocationArgumentListNode node, List<T> childResults);
    51 
    52         public void visitEnter(FunctionInvocationNode node);
    53         public T visitLeave(FunctionInvocationNode node, List<T> childResults);
    54 
    55         public void visitEnter(FunctionInvocationOrAssignmentStatementNode node);
    56         public T visitLeave(FunctionInvocationOrAssignmentStatementNode node, List<T> childResults);
     46        public void visitEnter(FuncCallArgListNode node);
     47        public T visitLeave(FuncCallArgListNode node, List<T> childResults);
     48
     49        public void visitEnter(FuncCallNode node);
     50        public T visitLeave(FuncCallNode node, List<T> childResults);
     51
     52        public void visitEnter(FuncCallOrAssignmentStmtNode node);
     53        public T visitLeave(FuncCallOrAssignmentStmtNode node, List<T> childResults);
     54
     55        public void visitEnter(FuncDefNode node);
     56        public T visitLeave(FuncDefNode node, List<T> childResults);
    5757
    5858        public void visitEnter(IdentifierNode node);
    5959        public T visitLeave(IdentifierNode node, List<T> childResults);
    6060
    61         public void visitEnter(IfStatementNode node);
    62         public T visitLeave(IfStatementNode node, List<T> childResults);
     61        public void visitEnter(IfStmtNode node);
     62        public T visitLeave(IfStmtNode node, List<T> childResults);
    6363
    6464        public void visitEnter(IntegerConstantNode node);
     
    7777        public T visitLeave(ProgramNode node, List<T> childResults);
    7878
    79         public void visitEnter(ReturnStatementNode node);
    80         public T visitLeave(ReturnStatementNode node, List<T> childResults);
     79        public void visitEnter(ReturnStmtNode node);
     80        public T visitLeave(ReturnStmtNode node, List<T> childResults);
    8181
    8282        public void visitEnter(StreamTypeNode node);
     
    107107        public T visitLeave(VoidNode node, List<T> childResults);
    108108
    109         public void visitEnter(WhileStatementNode node);
    110         public T visitLeave(WhileStatementNode node, List<T> childResults);
     109        public void visitEnter(WhileStmtNode node);
     110        public T visitLeave(WhileStmtNode node, List<T> childResults);
    111111
    112112
     
    155155                }
    156156
    157                 public void visitEnter(BlockStatementNode node) {
    158                         defaultVisitEnter(node);
    159                 }
    160                 public T visitLeave(BlockStatementNode node, List<T> childResults) {
     157                public void visitEnter(BlockStmtNode node) {
     158                        defaultVisitEnter(node);
     159                }
     160                public T visitLeave(BlockStmtNode node, List<T> childResults) {
    161161                        return defaultVisitLeave(node);
    162162                }
     
    204204                }
    205205
    206                 public void visitEnter(FunctionDefNode node) {
    207                         defaultVisitEnter(node);
    208                 }
    209                 public T visitLeave(FunctionDefNode node, List<T> childResults) {
    210                         return defaultVisitLeave(node);
    211                 }
    212 
    213                 public void visitEnter(FunctionInvocationArgumentListNode node) {
    214                         defaultVisitEnter(node);
    215                 }
    216                 public T visitLeave(FunctionInvocationArgumentListNode node, List<T> childResults) {
    217                         return defaultVisitLeave(node);
    218                 }
    219 
    220                 public void visitEnter(FunctionInvocationNode node) {
    221                         defaultVisitEnter(node);
    222                 }
    223                 public T visitLeave(FunctionInvocationNode node, List<T> childResults) {
    224                         return defaultVisitLeave(node);
    225                 }
    226 
    227                 public void visitEnter(FunctionInvocationOrAssignmentStatementNode node) {
    228                         defaultVisitEnter(node);
    229                 }
    230                 public T visitLeave(FunctionInvocationOrAssignmentStatementNode node, List<T> childResults) {
     206                public void visitEnter(FuncCallArgListNode node) {
     207                        defaultVisitEnter(node);
     208                }
     209                public T visitLeave(FuncCallArgListNode node, List<T> childResults) {
     210                        return defaultVisitLeave(node);
     211                }
     212
     213                public void visitEnter(FuncCallNode node) {
     214                        defaultVisitEnter(node);
     215                }
     216                public T visitLeave(FuncCallNode node, List<T> childResults) {
     217                        return defaultVisitLeave(node);
     218                }
     219
     220                public void visitEnter(FuncCallOrAssignmentStmtNode node) {
     221                        defaultVisitEnter(node);
     222                }
     223                public T visitLeave(FuncCallOrAssignmentStmtNode node, List<T> childResults) {
     224                        return defaultVisitLeave(node);
     225                }
     226
     227                public void visitEnter(FuncDefNode node) {
     228                        defaultVisitEnter(node);
     229                }
     230                public T visitLeave(FuncDefNode node, List<T> childResults) {
    231231                        return defaultVisitLeave(node);
    232232                }
     
    239239                }
    240240
    241                 public void visitEnter(IfStatementNode node) {
    242                         defaultVisitEnter(node);
    243                 }
    244                 public T visitLeave(IfStatementNode node, List<T> childResults) {
     241                public void visitEnter(IfStmtNode node) {
     242                        defaultVisitEnter(node);
     243                }
     244                public T visitLeave(IfStmtNode node, List<T> childResults) {
    245245                        return defaultVisitLeave(node);
    246246                }
     
    281281                }
    282282
    283                 public void visitEnter(ReturnStatementNode node) {
    284                         defaultVisitEnter(node);
    285                 }
    286                 public T visitLeave(ReturnStatementNode node, List<T> childResults) {
     283                public void visitEnter(ReturnStmtNode node) {
     284                        defaultVisitEnter(node);
     285                }
     286                public T visitLeave(ReturnStmtNode node, List<T> childResults) {
    287287                        return defaultVisitLeave(node);
    288288                }
     
    351351                }
    352352
    353                 public void visitEnter(WhileStatementNode node) {
    354                         defaultVisitEnter(node);
    355                 }
    356                 public T visitLeave(WhileStatementNode node, List<T> childResults) {
     353                public void visitEnter(WhileStmtNode node) {
     354                        defaultVisitEnter(node);
     355                }
     356                public T visitLeave(WhileStmtNode node, List<T> childResults) {
    357357                        return defaultVisitLeave(node);
    358358                }
  • proto/pablo/src/ast/SimpleVisitor.java

    r2621 r2658  
    1919        public void visit(BinaryOperatorNode node);
    2020
    21         public void visit(BlockStatementNode node);
     21        public void visit(BlockStmtNode node);
    2222
    2323        public void visit(CompoundVariableNode node);
     
    3333        public void visit(FieldWidthNode node);
    3434
    35         public void visit(FunctionDefNode node);
    36 
    37         public void visit(FunctionInvocationArgumentListNode node);
    38 
    39         public void visit(FunctionInvocationNode node);
    40 
    41         public void visit(FunctionInvocationOrAssignmentStatementNode node);
     35        public void visit(FuncCallArgListNode node);
     36
     37        public void visit(FuncCallNode node);
     38
     39        public void visit(FuncCallOrAssignmentStmtNode node);
     40
     41        public void visit(FuncDefNode node);
    4242
    4343        public void visit(IdentifierNode node);
    4444
    45         public void visit(IfStatementNode node);
     45        public void visit(IfStmtNode node);
    4646
    4747        public void visit(IntegerConstantNode node);
     
    5555        public void visit(ProgramNode node);
    5656
    57         public void visit(ReturnStatementNode node);
     57        public void visit(ReturnStmtNode node);
    5858
    5959        public void visit(StreamTypeNode node);
     
    7575        public void visit(VoidNode node);
    7676
    77         public void visit(WhileStatementNode node);
     77        public void visit(WhileStmtNode node);
    7878
    7979
     
    100100                }
    101101
    102                 public void visit(BlockStatementNode node) {
     102                public void visit(BlockStmtNode node) {
    103103                        defaultVisit(node);
    104104                }
     
    128128                }
    129129
    130                 public void visit(FunctionDefNode node) {
    131                         defaultVisit(node);
    132                 }
    133 
    134                 public void visit(FunctionInvocationArgumentListNode node) {
    135                         defaultVisit(node);
    136                 }
    137 
    138                 public void visit(FunctionInvocationNode node) {
    139                         defaultVisit(node);
    140                 }
    141 
    142                 public void visit(FunctionInvocationOrAssignmentStatementNode node) {
     130                public void visit(FuncCallArgListNode node) {
     131                        defaultVisit(node);
     132                }
     133
     134                public void visit(FuncCallNode node) {
     135                        defaultVisit(node);
     136                }
     137
     138                public void visit(FuncCallOrAssignmentStmtNode node) {
     139                        defaultVisit(node);
     140                }
     141
     142                public void visit(FuncDefNode node) {
    143143                        defaultVisit(node);
    144144                }
     
    148148                }
    149149
    150                 public void visit(IfStatementNode node) {
     150                public void visit(IfStmtNode node) {
    151151                        defaultVisit(node);
    152152                }
     
    172172                }
    173173
    174                 public void visit(ReturnStatementNode node) {
     174                public void visit(ReturnStmtNode node) {
    175175                        defaultVisit(node);
    176176                }
     
    212212                }
    213213
    214                 public void visit(WhileStatementNode node) {
     214                public void visit(WhileStmtNode node) {
    215215                        defaultVisit(node);
    216216                }
  • proto/pablo/src/ast/VoidVisitor.java

    r2621 r2658  
    2121        public void visitLeave(BinaryOperatorNode node);
    2222
    23         public void visitEnter(BlockStatementNode node);
    24         public void visitLeave(BlockStatementNode node);
     23        public void visitEnter(BlockStmtNode node);
     24        public void visitLeave(BlockStmtNode node);
    2525
    2626        public void visitEnter(CompoundVariableNode node);
     
    4242        public void visitLeave(FieldWidthNode node);
    4343
    44         public void visitEnter(FunctionDefNode node);
    45         public void visitLeave(FunctionDefNode node);
    46 
    47         public void visitEnter(FunctionInvocationArgumentListNode node);
    48         public void visitLeave(FunctionInvocationArgumentListNode node);
    49 
    50         public void visitEnter(FunctionInvocationNode node);
    51         public void visitLeave(FunctionInvocationNode node);
    52 
    53         public void visitEnter(FunctionInvocationOrAssignmentStatementNode node);
    54         public void visitLeave(FunctionInvocationOrAssignmentStatementNode node);
     44        public void visitEnter(FuncCallArgListNode node);
     45        public void visitLeave(FuncCallArgListNode node);
     46
     47        public void visitEnter(FuncCallNode node);
     48        public void visitLeave(FuncCallNode node);
     49
     50        public void visitEnter(FuncCallOrAssignmentStmtNode node);
     51        public void visitLeave(FuncCallOrAssignmentStmtNode node);
     52
     53        public void visitEnter(FuncDefNode node);
     54        public void visitLeave(FuncDefNode node);
    5555
    5656        public void visitEnter(IdentifierNode node);
    5757        public void visitLeave(IdentifierNode node);
    5858
    59         public void visitEnter(IfStatementNode node);
    60         public void visitLeave(IfStatementNode node);
     59        public void visitEnter(IfStmtNode node);
     60        public void visitLeave(IfStmtNode node);
    6161
    6262        public void visitEnter(IntegerConstantNode node);
     
    7575        public void visitLeave(ProgramNode node);
    7676
    77         public void visitEnter(ReturnStatementNode node);
    78         public void visitLeave(ReturnStatementNode node);
     77        public void visitEnter(ReturnStmtNode node);
     78        public void visitLeave(ReturnStmtNode node);
    7979
    8080        public void visitEnter(StreamTypeNode node);
     
    105105        public void visitLeave(VoidNode node);
    106106
    107         public void visitEnter(WhileStatementNode node);
    108         public void visitLeave(WhileStatementNode node);
     107        public void visitEnter(WhileStmtNode node);
     108        public void visitLeave(WhileStmtNode node);
    109109
    110110
     
    152152                }
    153153
    154                 public void visitEnter(BlockStatementNode node) {
    155                         defaultVisitEnter(node);
    156                 }
    157                 public void visitLeave(BlockStatementNode node) {
     154                public void visitEnter(BlockStmtNode node) {
     155                        defaultVisitEnter(node);
     156                }
     157                public void visitLeave(BlockStmtNode node) {
    158158                        defaultVisitLeave(node);
    159159                }
     
    201201                }
    202202
    203                 public void visitEnter(FunctionDefNode node) {
    204                         defaultVisitEnter(node);
    205                 }
    206                 public void visitLeave(FunctionDefNode node) {
    207                         defaultVisitLeave(node);
    208                 }
    209 
    210                 public void visitEnter(FunctionInvocationArgumentListNode node) {
    211                         defaultVisitEnter(node);
    212                 }
    213                 public void visitLeave(FunctionInvocationArgumentListNode node) {
    214                         defaultVisitLeave(node);
    215                 }
    216 
    217                 public void visitEnter(FunctionInvocationNode node) {
    218                         defaultVisitEnter(node);
    219                 }
    220                 public void visitLeave(FunctionInvocationNode node) {
    221                         defaultVisitLeave(node);
    222                 }
    223 
    224                 public void visitEnter(FunctionInvocationOrAssignmentStatementNode node) {
    225                         defaultVisitEnter(node);
    226                 }
    227                 public void visitLeave(FunctionInvocationOrAssignmentStatementNode node) {
     203                public void visitEnter(FuncCallArgListNode node) {
     204                        defaultVisitEnter(node);
     205                }
     206                public void visitLeave(FuncCallArgListNode node) {
     207                        defaultVisitLeave(node);
     208                }
     209
     210                public void visitEnter(FuncCallNode node) {
     211                        defaultVisitEnter(node);
     212                }
     213                public void visitLeave(FuncCallNode node) {
     214                        defaultVisitLeave(node);
     215                }
     216
     217                public void visitEnter(FuncCallOrAssignmentStmtNode node) {
     218                        defaultVisitEnter(node);
     219                }
     220                public void visitLeave(FuncCallOrAssignmentStmtNode node) {
     221                        defaultVisitLeave(node);
     222                }
     223
     224                public void visitEnter(FuncDefNode node) {
     225                        defaultVisitEnter(node);
     226                }
     227                public void visitLeave(FuncDefNode node) {
    228228                        defaultVisitLeave(node);
    229229                }
     
    236236                }
    237237
    238                 public void visitEnter(IfStatementNode node) {
    239                         defaultVisitEnter(node);
    240                 }
    241                 public void visitLeave(IfStatementNode node) {
     238                public void visitEnter(IfStmtNode node) {
     239                        defaultVisitEnter(node);
     240                }
     241                public void visitLeave(IfStmtNode node) {
    242242                        defaultVisitLeave(node);
    243243                }
     
    278278                }
    279279
    280                 public void visitEnter(ReturnStatementNode node) {
    281                         defaultVisitEnter(node);
    282                 }
    283                 public void visitLeave(ReturnStatementNode node) {
     280                public void visitEnter(ReturnStmtNode node) {
     281                        defaultVisitEnter(node);
     282                }
     283                public void visitLeave(ReturnStmtNode node) {
    284284                        defaultVisitLeave(node);
    285285                }
     
    348348                }
    349349
    350                 public void visitEnter(WhileStatementNode node) {
    351                         defaultVisitEnter(node);
    352                 }
    353                 public void visitLeave(WhileStatementNode node) {
     350                public void visitEnter(WhileStmtNode node) {
     351                        defaultVisitEnter(node);
     352                }
     353                public void visitLeave(WhileStmtNode node) {
    354354                        defaultVisitLeave(node);
    355355                }
  • proto/pablo/src/compiler/OptionsConfig.java

    r2655 r2658  
    5252                    OptionBuilder.isRequired(false);
    5353                    OptionBuilder.withLongOpt("dump");
    54                     OptionBuilder.withDescription("Add SIMD register dump statements.");
     54                    OptionBuilder.withDescription("Add SIMD register dump Stmts.");
    5555                        option = OptionBuilder.create("d");
    5656                        options.addOption(option);                     
     
    5959                    OptionBuilder.isRequired(false);
    6060                    OptionBuilder.withLongOpt("align");
    61                     OptionBuilder.withDescription("Add ASSERT_BITBLOCK_ALIGN statements.");
     61                    OptionBuilder.withDescription("Add ASSERT_BITBLOCK_ALIGN Stmts.");
    6262                        option = OptionBuilder.create("a");
    6363                        options.addOption(option);                     
  • proto/pablo/src/compiler/PabloCompiler.java

    r2657 r2658  
    3939        private static String errorRoutine;
    4040       
    41         private static boolean addDumpStatements = false;
    42         private static boolean addAssertBitBlockAlignStatements = false;
     41        private static boolean addDumpStmts = false;
     42        private static boolean addAssertBitBlockAlignStmts = false;
    4343               
    4444        public static void main(String[] args) throws FileNotFoundException {
     
    5454                    errorRoutine = cmd.getOptionValue("e", "assert_0_error");
    5555                   
    56                     if(cmd.hasOption("d")) { addDumpStatements = true; }
    57                     if(cmd.hasOption("a")) { addAssertBitBlockAlignStatements = true; }
     56                    if(cmd.hasOption("d")) { addDumpStmts = true; }
     57                    if(cmd.hasOption("a")) { addAssertBitBlockAlignStmts = true; }
    5858                       
    5959                } catch (Exception e) {
     
    7575                ASTNode syntaxTree = Parser.parse(lexController);
    7676                               
    77                 StreamFunctionVisitor streamFunctionVisitor = new StreamFunctionVisitor(syntaxTree);
    78                 Map<String, ASTNode> streamFunctionMap = streamFunctionVisitor.makeStreamFunctionMap();
     77                StreamFuncVisitor streamFuncVisitor = new StreamFuncVisitor(syntaxTree);
     78                Map<String, ASTNode> streamFuncMap = streamFuncVisitor.makeStreamFuncMap();
    7979               
    8080                Builtins2Lang builtins2CPP = new Builtins2CPP();
    8181                CarrySet2Lang carrySet2CPP = new CarrySet2CPP();
    8282               
    83                 for (Map.Entry<String, ASTNode> entry : streamFunctionMap.entrySet()) {
     83                for (Map.Entry<String, ASTNode> entry : streamFuncMap.entrySet()) {
    8484                       
    8585                    ASTNode value = entry.getValue();
    8686                       
    87                     AdvanceCombinerTransformer advanceCombiner = new AdvanceCombinerTransformer(value);
    88                     advanceCombiner.transform();
     87                    AdvanceCombinerXFormer advanceCombiner = new AdvanceCombinerXFormer(value);
     88                    advanceCombiner.XForm();
    8989                   
    9090                    /*
     
    9898                        */
    9999                       
    100                     AugmentedAssignmentTransformer augmentedAssignment = new AugmentedAssignmentTransformer(value);
    101                         augmentedAssignment.transform();
     100                    AugAssignmentXFormer AugAssignment = new AugAssignmentXFormer(value);
     101                        AugAssignment.XForm();
    102102                       
    103                         CarryIntroTransformer carryQIntro = new CarryIntroTransformer(value, carrySet2CPP);
    104                         carryQIntro.transform(true, false);
     103                        CarryIntroXFormer carryQIntro = new CarryIntroXFormer(value, carrySet2CPP);
     104                        carryQIntro.XForm(true, false);
    105105                       
    106                         Pablo2CarryTransformer pablo2CarryQ = new Pablo2CarryTransformer(value, builtins2CPP, carrySet2CPP);
    107                         pablo2CarryQ.transform(true, false);               
     106                        Pablo2CarryXFormer pablo2CarryQ = new Pablo2CarryXFormer(value, builtins2CPP, carrySet2CPP);
     107                        pablo2CarryQ.XForm(true, false);                   
    108108                   
    109                         Bitwise2IDISATransformer bitwiseToIDISA = new Bitwise2IDISATransformer(value);
    110                         bitwiseToIDISA.transform();
     109                        AssertZeroXFormer assertZeroXFormer = new AssertZeroXFormer(value, builtins2CPP);
     110                        assertZeroXFormer.XForm();
     111                       
     112                        Bitwise2IDISAXFormer bitwiseToIDISA = new Bitwise2IDISAXFormer(value);
     113                        bitwiseToIDISA.XForm();
    111114
    112                         if(PabloCompiler.addDumpStatements) {
    113                                 DumpAssignmentStatementsTransformer dumpAssignmentStatementsTransformer
    114                                         = new DumpAssignmentStatementsTransformer(value, builtins2CPP); 
    115                                 dumpAssignmentStatementsTransformer.transform();
     115                        if(PabloCompiler.addDumpStmts) {
     116                                DumpAssignmentStmtsXFormer dumpAssignmentStmtsXFormer = new DumpAssignmentStmtsXFormer(value, builtins2CPP); 
     117                                dumpAssignmentStmtsXFormer.XForm();
    116118                        }
    117119                       
    118                         if(PabloCompiler.addAssertBitBlockAlignStatements) {
    119                                 AssertBitBlockAlignStatementsTransformer assertBitBlockAlignStatementsTransformer
    120                                         = new AssertBitBlockAlignStatementsTransformer(value, builtins2CPP, carrySet2CPP); 
    121                                 assertBitBlockAlignStatementsTransformer.transform();
     120                        if(PabloCompiler.addAssertBitBlockAlignStmts) {
     121                                AssertBitBlockAlignStmtsXFormer assertBitBlockAlignStmtsXFormer = new AssertBitBlockAlignStmtsXFormer(value, builtins2CPP, carrySet2CPP); 
     122                                assertBitBlockAlignStmtsXFormer.XForm();
    122123                        }                       
    123124                       
  • proto/pablo/src/compiler/PabloCompilerTestHarness.java

    r2657 r2658  
    3636       
    3737        public enum Test {
    38             ADVANCECOMBINER("AdvanceCombinerTransformer", true),
     38            ADVANCECOMBINER("AdvanceCombinerXFormer", true),
    3939            ADVANCENCOUNTER("AdvanceNCounterVisitor", true),
    40             AUGMENTEDASSIGNMENT("AugmentedAssignmentTransformer", true),
    41             BITWISE2IDISA("Bitwise2IDISATransformer", true),
     40            AugASSIGNMENT("AugAssignmentXFormer", true),
     41            BITWISE2IDISA("Bitwise2IDISAXFormer", true),
    4242            CARRYCOUNTER("CarryCounterVisitor", true),
    43             PABLO2CARRYQCICO("Pablo2CarryQCiCoTransformer", true),
    44             PABLO2CARRYQCI("Pablo2CarryQCiTransformer", true),
     43            PABLO2CARRYQCICO("Pablo2CarryQCiCoXFormer", true),
     44            PABLO2CARRYQCI("Pablo2CarryQCiXFormer", true),
    4545            CARRYINITTOONELIST("CarryInitToOneListVisitor", true),
    46             STREAMFUNCTIONVISITOR("StreamFunctionVisitor", true);
    47             //CARRYQINTROTRANSFORMER("",true); // TODO
     46            STREAMFuncVISITOR("StreamFuncVisitor", true);
     47            //CARRYQINTROXFORMER("",true); // TODO
     48            //ASSERTZERO("",true);// TODO
    4849           
    4950            private final String directoryName;
     
    6667        public static void main(String[] args) throws FileNotFoundException {
    6768                               
    68                 checkArguments(args, "PabloCompilerTestHarness");
     69                checkArgs(args, "PabloCompilerTestHarness");
    6970                Tokens.setPrintLevel(Tokens.Level.FULL);       
    7071                File testBase = new File(testDirectoryName);
     
    8990                                                case ADVANCENCOUNTER:
    9091                                                        break;
    91                                                 case AUGMENTEDASSIGNMENT:                                       
    92                                                                 augmentedAssignmentTest(fileAbsolutePath);
     92                                                case AugASSIGNMENT:                                     
     93                                                                AugAssignmentTest(fileAbsolutePath);
    9394                                                        break;
    9495                                                case BITWISE2IDISA:
     
    105106                                                case CARRYINITTOONELIST:
    106107                                                        break;                                 
    107                                                 case STREAMFUNCTIONVISITOR:
     108                                                case STREAMFuncVISITOR:
    108109                                                        break;
    109110                                                default:
     
    126127                ASTNode syntaxTree = Parser.parse(lexController);
    127128               
    128                 StreamFunctionVisitor streamFunctionVisitor = new StreamFunctionVisitor(syntaxTree);
    129                 Map<String, ASTNode> streamFunctionMap = streamFunctionVisitor.makeStreamFunctionMap();
    130                
    131                 for (Map.Entry<String, ASTNode> entry : streamFunctionMap.entrySet()) {                                         
    132                     AdvanceCombinerTransformer advanceCombiner = new AdvanceCombinerTransformer(entry.getValue());
    133                     advanceCombiner.transform();                           
     129                StreamFuncVisitor streamFuncVisitor = new StreamFuncVisitor(syntaxTree);
     130                Map<String, ASTNode> streamFuncMap = streamFuncVisitor.makeStreamFuncMap();
     131               
     132                for (Map.Entry<String, ASTNode> entry : streamFuncMap.entrySet()) {                                             
     133                    AdvanceCombinerXFormer advanceCombiner = new AdvanceCombinerXFormer(entry.getValue());
     134                    advanceCombiner.XForm();                       
    134135                }   
    135136               
     
    147148                ASTNode syntaxTree = Parser.parse(lexController);
    148149               
    149                 StreamFunctionVisitor streamFunctionVisitor = new StreamFunctionVisitor(syntaxTree);
    150                 Map<String, ASTNode> streamFunctionMap = streamFunctionVisitor.makeStreamFunctionMap();
    151                
    152                 for (Map.Entry<String, ASTNode> entry : streamFunctionMap.entrySet()) {                                         
    153                         Bitwise2IDISATransformer bitwiseToIDISA = new Bitwise2IDISATransformer(entry.getValue());
    154                         bitwiseToIDISA.transform();                         
     150                StreamFuncVisitor streamFuncVisitor = new StreamFuncVisitor(syntaxTree);
     151                Map<String, ASTNode> streamFuncMap = streamFuncVisitor.makeStreamFuncMap();
     152               
     153                for (Map.Entry<String, ASTNode> entry : streamFuncMap.entrySet()) {                                             
     154                        Bitwise2IDISAXFormer bitwiseToIDISA = new Bitwise2IDISAXFormer(entry.getValue());
     155                        bitwiseToIDISA.XForm();                     
    155156                }
    156157               
     
    164165         * @throws FileNotFoundException
    165166         */
    166         public static void augmentedAssignmentTest(String fileAbsolutePath) throws FileNotFoundException {
     167        public static void AugAssignmentTest(String fileAbsolutePath) throws FileNotFoundException {
    167168                               
    168169                LexicalController lexController = LexicalController.make(fileAbsolutePath);
    169170                ASTNode syntaxTree = Parser.parse(lexController);
    170171               
    171                 StreamFunctionVisitor streamFunctionVisitor = new StreamFunctionVisitor(syntaxTree);
    172                 Map<String, ASTNode> streamFunctionMap = streamFunctionVisitor.makeStreamFunctionMap();
    173                
    174                 for (Map.Entry<String, ASTNode> entry : streamFunctionMap.entrySet()) {                                                                 
    175                         AugmentedAssignmentTransformer augmentedAssignment = new AugmentedAssignmentTransformer(entry.getValue());     
    176                         augmentedAssignment.transform();
     172                StreamFuncVisitor streamFuncVisitor = new StreamFuncVisitor(syntaxTree);
     173                Map<String, ASTNode> streamFuncMap = streamFuncVisitor.makeStreamFuncMap();
     174               
     175                for (Map.Entry<String, ASTNode> entry : streamFuncMap.entrySet()) {                                                                     
     176                        AugAssignmentXFormer AugAssignment = new AugAssignmentXFormer(entry.getValue());       
     177                        AugAssignment.XForm();
    177178                }   
    178179               
     
    190191               
    191192               
    192                 StreamFunctionVisitor streamFunctionVisitor = new StreamFunctionVisitor(syntaxTree);
    193                 Map<String, ASTNode> streamFunctionMap = streamFunctionVisitor.makeStreamFunctionMap();
     193                StreamFuncVisitor streamFuncVisitor = new StreamFuncVisitor(syntaxTree);
     194                Map<String, ASTNode> streamFuncMap = streamFuncVisitor.makeStreamFuncMap();
    194195               
    195196                Builtins2Lang builtins2CPP = new Builtins2CPP();
    196197               
    197                 for (Map.Entry<String, ASTNode> entry : streamFunctionMap.entrySet()) {
     198                for (Map.Entry<String, ASTNode> entry : streamFuncMap.entrySet()) {     
    198199                        ASTNode value = entry.getValue();                               
    199200                        CarrySet2Lang carrySet2CPP = new CarrySet2CPP();
    200                         Pablo2CarryTransformer pablo2CarryQ = new Pablo2CarryTransformer(value, builtins2CPP, carrySet2CPP);
    201                         pablo2CarryQ.transform(ciMode, coMode);                 
     201                        Pablo2CarryXFormer pablo2CarryQ = new Pablo2CarryXFormer(value, builtins2CPP, carrySet2CPP);
     202                        pablo2CarryQ.XForm(ciMode, coMode);                     
    202203                       
    203204                }   
     
    246247        }
    247248
    248         protected static void checkArguments(String[] args, String applicationName) {
     249        protected static void checkArgs(String[] args, String applicationName) {
    249250                int length = args.length;
    250251                boolean inputDirectoryFound = false;
  • proto/pablo/src/compiler/ReadMe.txt

    r2657 r2658  
    5454   (c) Code generation phases. Dependent on the target language and hardware.
    5555
    56    (d) Name Visitors SomeNameVisitor, InnerSomeNameVisitor; and Name SomeNameTransformer, InnerSomeNameTransformer.
     56   (d) Name Visitors SomeNameVisitor, InnerSomeNameVisitor; and Name SomeNameXFormer, InnerSomeNameXFormer.
    5757
    5858   Work in progress.
    5959   
    60 3. Visitor dependency. Tree transformation, e.g. carry counter depends on
     603. Visitor dependency. Tree XFormation, e.g. carry counter depends on
    6161   'Advance(x)' function name and argument count.
    6262   
     
    8080   Done.
    8181
    82 5. Verify function call expressions versus function call statements. Go over code
     825. Verify function call expressions versus function call Stmts. Go over code
    8383   generation scheme.
    8484         
  • proto/pablo/src/compiler/ast/Accessors.java

    r2641 r2658  
    3535               
    3636        ////////////////////////////////////////////////////////////////////////////
    37         // Assignment Statements
     37        // Assignment Stmts
    3838        ////////////////////////////////////////////////////////////////////////////                           
    3939        public static ASTNode lhs(AssignmentNode node) {
     
    5050       
    5151        ////////////////////////////////////////////////////////////////////////////
    52         // Function Invocation Statements
     52        // Func Invocation Stmts
    5353        ////////////////////////////////////////////////////////////////////////////                           
    5454
    55         public static String assignmentOperator(FunctionInvocationNode node) {
    56                 return node.getToken().getLexeme();
    57         }       
    58        
    59         ////////////////////////////////////////////////////////////////////////////
    60         // Local Variable Declaration Statements
     55        public static String assignmentOperator(FuncCallNode node) {
     56                return node.getToken().getLexeme();
     57        }       
     58       
     59        ////////////////////////////////////////////////////////////////////////////
     60        // Local Variable Declaration Stmts
    6161        ////////////////////////////////////////////////////////////////////////////
    6262       
     
    123123       
    124124        ////////////////////////////////////////////////////////////////////////////
    125         // IfStatementNode helpers
     125        // IfStmtNode helpers
    126126        ////////////////////////////////////////////////////////////////////////////   
    127         public static ASTNode ifTest(IfStatementNode node) {
     127        public static ASTNode ifTest(IfStmtNode node) {
    128128                return (ASTNode) node.child(0);
    129129        }
    130130
    131         public static BlockStatementNode ifBlockStatement(IfStatementNode node) {
    132                 return (BlockStatementNode) node.child(1);
    133         }       
    134        
    135         public static boolean hasElseBlockStatement(IfStatementNode node) {
     131        public static BlockStmtNode ifBlockStmt(IfStmtNode node) {
     132                return (BlockStmtNode) node.child(1);
     133        }       
     134       
     135        public static boolean hasElseBlockStmt(IfStmtNode node) {
    136136                return node.nChildren() > 2;
    137137        }
    138138       
    139         public static BlockStatementNode elseBlockStatement(IfStatementNode node) {
    140                 return (BlockStatementNode) node.child(2);
    141         }
    142 
    143         ////////////////////////////////////////////////////////////////////////////
    144         // WhileStatementNode helpers
     139        public static BlockStmtNode elseBlockStmt(IfStmtNode node) {
     140                return (BlockStmtNode) node.child(2);
     141        }
     142
     143        ////////////////////////////////////////////////////////////////////////////
     144        // WhileStmtNode helpers
    145145        ////////////////////////////////////////////////////////////////////////////           
    146         public static ASTNode whileCondition(WhileStatementNode node) {
    147                 return node.child(0);
    148         }       
    149                
    150         ////////////////////////////////////////////////////////////////////////////
    151         // FunctionDefinitionNode helpers
    152         ////////////////////////////////////////////////////////////////////////////
    153         public static IdentifierNode functionName(FunctionDefNode node) {
     146        public static ASTNode whileCondition(WhileStmtNode node) {
     147                return node.child(0);
     148        }       
     149               
     150        ////////////////////////////////////////////////////////////////////////////
     151        // FuncDefinitionNode helpers
     152        ////////////////////////////////////////////////////////////////////////////
     153        public static IdentifierNode FuncName(FuncDefNode node) {
    154154                return (IdentifierNode) node.child(1);
    155155        }
    156156       
    157         public static boolean hasParameters(FunctionDefNode node) {
     157        public static boolean hasParameters(FuncDefNode node) {
    158158                ASTNode child2 = node.child(2);
    159159               
     
    164164        }
    165165       
    166         public static BlockStatementNode blockStatementNode(FunctionDefNode node) {
    167                 int blockStatementNodeIndex;
     166        public static BlockStmtNode blockStmtNode(FuncDefNode node) {
     167                int blockStmtNodeIndex;
    168168               
    169169                if(Accessors.hasParameters(node)) {
    170                         blockStatementNodeIndex = 3;
     170                        blockStmtNodeIndex = 3;
    171171                } else {
    172                         blockStatementNodeIndex = 2;
    173                 }
    174                
    175                 ASTNode child = node.child(blockStatementNodeIndex);
    176                 assert child instanceof BlockStatementNode;
    177         return (BlockStatementNode) child;
    178         }       
    179        
    180         ////////////////////////////////////////////////////////////////////////////
    181         // WhileStatement helpers
    182         ////////////////////////////////////////////////////////////////////////////
    183         public static ASTNode whileTest(WhileStatementNode node) {
    184                 return node.child(0);
    185         }
    186        
    187         ////////////////////////////////////////////////////////////////////////////
    188         // FunctionInvocationNode helpers
    189         ////////////////////////////////////////////////////////////////////////////
    190         public static ASTNode functionInvocationName(FunctionInvocationNode node) {
    191                 return node.child(0);
    192         }
    193 
    194         public static ASTNode functionInvocationArgumentsListNode(FunctionInvocationNode node) {
     172                        blockStmtNodeIndex = 2;
     173                }
     174               
     175                ASTNode child = node.child(blockStmtNodeIndex);
     176                assert child instanceof BlockStmtNode;
     177        return (BlockStmtNode) child;
     178        }       
     179       
     180        ////////////////////////////////////////////////////////////////////////////
     181        // WhileStmt helpers
     182        ////////////////////////////////////////////////////////////////////////////
     183        public static ASTNode whileTest(WhileStmtNode node) {
     184                return node.child(0);
     185        }
     186       
     187        ////////////////////////////////////////////////////////////////////////////
     188        // FuncCallNode helpers
     189        ////////////////////////////////////////////////////////////////////////////
     190        public static ASTNode FuncCallName(FuncCallNode node) {
     191                return node.child(0);
     192        }
     193
     194        public static ASTNode FuncCallArgsListNode(FuncCallNode node) {
    195195                return node.child(1);
    196196        }
    197197       
    198         public static int functionInvocationArgumentCount(FunctionInvocationNode node) {
    199                 ASTNode argList = Accessors.functionInvocationArgumentsListNode(node);
     198        public static int FuncCallArgCount(FuncCallNode node) {
     199                ASTNode argList = Accessors.FuncCallArgsListNode(node);
    200200                if (argList == null) {
    201201                        return 0;
     
    204204        }
    205205       
    206         public static ASTNode functionInvocationArgument(FunctionInvocationNode node, int index) {
    207                
    208                 if((index + 1) > Accessors.functionInvocationArgumentsList(node).getChildren().size()) {
    209                         throw new RuntimeException("Function invocation argument out of range.");
    210                 }
    211                 return Accessors.functionInvocationArgumentsList(node).child(index);
    212         }
    213        
    214         public static List<ASTNode> functionInvocationArgList(FunctionInvocationNode node) {
    215                 return Accessors.functionInvocationArgumentsList(node).getChildren();
    216         }
    217        
    218         public static ASTNode functionInvocationArgumentsList(FunctionInvocationNode node) {
    219                 return node.child(1);
    220         }
    221        
    222     public static String functionInvocationName(ASTNode node) {
     206        public static ASTNode FuncCallArg(FuncCallNode node, int index) {
     207               
     208                if((index + 1) > Accessors.FuncCallArgsListNode(node).getChildren().size()) {
     209                        throw new RuntimeException("Func invocation Arg out of range.");
     210                }
     211                return Accessors.FuncCallArgsListNode(node).child(index);
     212        }
     213       
     214        public static List<ASTNode> FuncCallArgsList(FuncCallNode node) {
     215                return Accessors.FuncCallArgsListNode(node).getChildren();
     216        }
     217               
     218    public static String FuncCallName(ASTNode node) {
    223219        String name = new String();
    224220        if(node instanceof IdentifierNode) {
  • proto/pablo/src/compiler/ast/Generators.java

    r2621 r2658  
    1919        // Static factories for various nodes
    2020        //
    21         // TODO - refactor makeFunctionInvocationNode code
    22         ////////////////////////////////////////////////////////////////////////////
    23 
    24         /** Makes a new FunctionInvocationNode with a function identifier string and the TextLocation taken from token.
     21        ////////////////////////////////////////////////////////////////////////////
     22
     23        /** Makes a new FuncCallNode with a Func identifier string and the TextLocation taken from token.
    2524         * @param identifier
    2625         * @param locationToken
    27          * @return FunctionInvocationNode
    28          */
    29         public static FunctionInvocationNode makeFunctionInvocationNode(String identifier, Token locationToken) {
     26         * @return FuncCallNode
     27         */
     28        public static FuncCallNode makeFuncCallNode(String identifier, Token locationToken) {
    3029                IdentifierNode identifierNode = Generators.makeIdentifierNode(identifier, locationToken);       
    31                 return Generators.makeFunctionInvocationNode(identifierNode, locationToken);
    32         }
    33 
    34         /** Makes a new compound FunctionInvocationNode with a array of identifiers string and the TextLocation taken from token.
     30                return Generators.makeFuncCallNode(identifierNode, locationToken);
     31        }
     32
     33        /** Makes a new compound FuncCallNode with a array of identifiers string and the TextLocation taken from token.
    3534         * @param identifiers - a compound identifier a.b()     
    3635         * @param locationToken
    3736         * @return
    3837         */
    39         public static FunctionInvocationNode makeFunctionInvocationNode(String[] identifiers, Token locationToken) {
     38        public static FuncCallNode makeFuncCallNode(String[] identifiers, Token locationToken) {
    4039               
    4140                CompoundVariableNode identifierNode = Generators.makeCompoundVariableNode(identifiers, locationToken);
    42                 return Generators.makeFunctionInvocationNode(identifierNode, locationToken);
    43         }
    44 
    45         public static FunctionInvocationNode makeFunctionInvocationNode(String identifier, Token locationToken, ASTNode[] arguments) {
    46                
    47                 FunctionInvocationNode node = Generators.makeFunctionInvocationNode(identifier, locationToken);
    48                 Generators.addFunctionInvocationArguments(node, arguments);
    49                 return node;
    50         }       
    51 
    52         public static FunctionInvocationNode makeFunctionInvocationNode(String identifier, Token locationToken, List<ASTNode> arguments) {
    53                
    54                 FunctionInvocationNode node = Generators.makeFunctionInvocationNode(identifier, locationToken);
    55                 Generators.addFunctionInvocationsArguments(node, arguments);
    56                 return node;
    57         }       
    58        
    59         private static void addFunctionInvocationArguments(FunctionInvocationNode node, ASTNode[] arguments) {
    60                 if(arguments.length > 0) {
    61                         for(ASTNode child: arguments) {
    62                                 Accessors.functionInvocationArgumentsListNode(node).appendChild(child);
     41                return Generators.makeFuncCallNode(identifierNode, locationToken);
     42        }
     43
     44        public static FuncCallNode makeFuncCallNode(String identifier, Token locationToken, ASTNode[] Args) {
     45               
     46                FuncCallNode node = Generators.makeFuncCallNode(identifier, locationToken);
     47                Generators.addFuncCallArgs(node, Args);
     48                return node;
     49        }       
     50
     51        public static FuncCallNode makeFuncCallNode(String identifier, Token locationToken, List<ASTNode> Args) {
     52               
     53                FuncCallNode node = Generators.makeFuncCallNode(identifier, locationToken);
     54                Generators.addFuncCallsArgs(node, Args);
     55                return node;
     56        }       
     57       
     58        private static void addFuncCallArgs(FuncCallNode node, ASTNode[] Args) {
     59                if(Args.length > 0) {
     60                        for(ASTNode child: Args) {
     61                                Accessors.FuncCallArgsListNode(node).appendChild(child);
    6362                        }
    64                         Accessors.functionInvocationArgumentsListNode(node).setToken(arguments[0].getToken());
     63                        Accessors.FuncCallArgsListNode(node).setToken(Args[0].getToken());
    6564                }       
    6665        }
    6766
    68         public static FunctionInvocationNode makeFunctionInvocationNode(String[] identifiers, Token locationToken, ASTNode[] arguments) {
    69        
    70                 FunctionInvocationNode node = Generators.makeFunctionInvocationNode(identifiers, locationToken);
     67        public static FuncCallNode makeFuncCallNode(String[] identifiers, Token locationToken, ASTNode[] Args) {
     68       
     69                FuncCallNode node = Generators.makeFuncCallNode(identifiers, locationToken);
    7170                List<ASTNode> list = new ArrayList<ASTNode>();
    72                 for(ASTNode arg: arguments) {
     71                for(ASTNode arg: Args) {
    7372                        list.add(arg);
    7473                }
    75                 Generators.addFunctionInvocationsArguments(node, list);
    76                 return node;
    77         }
    78 
    79         public static FunctionInvocationNode makeFunctionInvocationNode(String[] identifiers, Token locationToken,  List<ASTNode> arguments) {
    80                
    81                 FunctionInvocationNode node = Generators.makeFunctionInvocationNode(identifiers, locationToken);
    82                 Generators.addFunctionInvocationsArguments(node, arguments);
    83                 return node;
    84         }       
    85        
    86         private static void addFunctionInvocationsArguments(FunctionInvocationNode node, List<ASTNode> arguments) {
    87                
    88                 if(arguments.size() > 0) {
    89                         for(ASTNode child: arguments) {
    90                                 Accessors.functionInvocationArgumentsListNode(node).appendChild(child);
     74                Generators.addFuncCallsArgs(node, list);
     75                return node;
     76        }
     77
     78        public static FuncCallNode makeFuncCallNode(String[] identifiers, Token locationToken,  List<ASTNode> Args) {
     79               
     80                FuncCallNode node = Generators.makeFuncCallNode(identifiers, locationToken);
     81                Generators.addFuncCallsArgs(node, Args);
     82                return node;
     83        }       
     84       
     85        private static void addFuncCallsArgs(FuncCallNode node, List<ASTNode> Args) {
     86               
     87                if(Args.size() > 0) {
     88                        for(ASTNode child: Args) {
     89                                Accessors.FuncCallArgsListNode(node).appendChild(child);
    9190                        }
    92                         Accessors.functionInvocationArgumentsListNode(node).setToken(arguments.get(0).getToken());
     91                        Accessors.FuncCallArgsListNode(node).setToken(Args.get(0).getToken());
    9392                }               
    9493        }
    9594       
    96         private static FunctionInvocationNode makeFunctionInvocationNode(ASTNode identifier, Token locationToken) {
     95        private static FuncCallNode makeFuncCallNode(ASTNode identifier, Token locationToken) {
    9796                assert identifier instanceof IdentifierNode || identifier instanceof CompoundVariableNode;
    9897
    9998                LextantToken token = Generators.makeLextantToken(Lextant.LROUND, locationToken);
    100                 FunctionInvocationNode functionInvocationNode = new FunctionInvocationNode(token);
    101                 functionInvocationNode.appendChild(identifier);
    102                 functionInvocationNode.appendChild(new FunctionInvocationArgumentListNode(locationToken));
    103 
    104                 return functionInvocationNode;
     99                FuncCallNode FuncCallNode = new FuncCallNode(token);
     100                FuncCallNode.appendChild(identifier);
     101                FuncCallNode.appendChild(new FuncCallArgListNode(locationToken));
     102
     103                return FuncCallNode;
    105104        }       
    106105               
     
    199198        }       
    200199       
    201         public static BlockStatementNode makeBlockStatementNode(Token tokenLocation) {
    202                 LextantToken token = Generators.makeLextantToken(Lextant.WHILE, tokenLocation);
    203                 return new BlockStatementNode(token);
     200        public static BlockStmtNode makeBlockStmtNode(Token tokenLocation) {
     201                LextantToken token = Generators.makeLextantToken(Lextant.LCURLY, tokenLocation);
     202                return new BlockStmtNode(token);
     203        }
     204       
     205        public static IfStmtNode makeIfStmtNode(Token tokenLocation, ASTNode expression, BlockStmtNode blockStmt) {
     206                LextantToken token = Generators.makeLextantToken(Lextant.LCURLY, tokenLocation);
     207                IfStmtNode ifStmtNode = new IfStmtNode(token);
     208                ifStmtNode.appendChild(expression);
     209                ifStmtNode.appendChild((ASTNode)blockStmt);
     210                return ifStmtNode;
    204211        }
    205212}
  • proto/pablo/src/compiler/codeGeneration/templates/applications/pablo_dummy.template

    r2422 r2658  
    77@decl
    88
    9 // Stream Statements
     9// Stream Stmts
    1010@stream_stmts
    1111
    12 // Block Statements
     12// Block Stmts
    1313@block_stmts
    1414
    15 // Final Block Statements
     15// Final Block Stmts
    1616@final_block_stmts
    1717
  • proto/pablo/src/compiler/lang/idisa/BITBLOCK.java

    r2657 r2658  
    1010        private int argCount;
    1111       
    12         private BITBLOCK(String functionName, int argCount) {
    13                 this.name = functionName;
     12        private BITBLOCK(String FuncName, int argCount) {
     13                this.name = FuncName;
    1414                this.argCount = argCount;
    1515        }
  • proto/pablo/src/compiler/lang/pablo/Builtins.java

    r2657 r2658  
    2121    ATEOF(Carry.None, "atEOF", 1),
    2222    INFILE(Carry.None, "inFile", 1),
     23    ASSERTZERO(Carry.None, "assert_0", 2),     
    2324    EOFMASK(Carry.None, "EOF_mask", 0), // deprecated
    2425       
  • proto/pablo/src/compiler/lang/pablo/Builtins2CPP.java

    r2657 r2658  
    33import java.util.HashMap;
    44import java.util.Map;
     5
     6import compiler.lang.pablo.Builtins.Carry;
    57
    68public class Builtins2CPP extends Builtins2Lang {
     
    2729        pablo2CPPCode.put(Builtins.ATEOF, "atEOF");
    2830        pablo2CPPCode.put(Builtins.INFILE, "inFile");
     31        pablo2CPPCode.put(Builtins.ASSERTZERO, "assert_0_error");       
    2932        pablo2CPPCode.put(Builtins.EOFMASK, "EOF_mask");
    3033       
  • proto/pablo/src/compiler/lang/pablo/BuiltinsUtil.java

    r2657 r2658  
    1414        }
    1515       
    16         if (!(node instanceof FunctionInvocationNode)) {
     16        if (!(node instanceof FuncCallNode)) {
    1717            return false;
    1818        }
    1919       
    20         FunctionInvocationNode fNode = (FunctionInvocationNode)node;
    21         ASTNode nameNode = Accessors.functionInvocationName(fNode);
    22         ASTNode argumentsListNode = (ASTNode)Accessors.functionInvocationArgumentsListNode(fNode);
     20        FuncCallNode fNode = (FuncCallNode)node;
     21        ASTNode nameNode = Accessors.FuncCallName(fNode);
     22        ASTNode ArgsListNode = (ASTNode)Accessors.FuncCallArgsListNode(fNode);
    2323   
    2424        // Advance(X)
    2525        if (isQualifiedName(nameNode, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.ADVANCE.pabloName())
    26                 && argumentsListNode.nChildren() == 1) {
     26                && ArgsListNode.nChildren() == 1) {
    2727            return true;
    2828        }
     
    3030        // Advance(X,n)
    3131        if (isQualifiedName(nameNode, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.ADVANCE.pabloName())
    32                 && argumentsListNode.nChildren() == 2) {       
     32                && ArgsListNode.nChildren() == 2) {     
    3333                        return true;
    3434        }
     
    5252                for (Builtins carryOneOperation : Builtins.carryOneOperations()) {                     
    5353                               
    54                         ASTNode identifier = Accessors.functionInvocationName((FunctionInvocationNode) node);
    55                         int argCount = Accessors.functionInvocationArgumentCount((FunctionInvocationNode)node);
     54                        ASTNode identifier = Accessors.FuncCallName((FuncCallNode) node);
     55                        int argCount = Accessors.FuncCallArgCount((FuncCallNode)node);
    5656                       
    5757                        if (isQualifiedName(identifier, BuiltinsUtil.BUILTIN_PACKAGE_NAME, carryOneOperation.pabloName())
     
    6666               
    6767                for (Builtins carryNOperation : Builtins.carryNOperations()) {
    68                         ASTNode identifier = Accessors.functionInvocationName((FunctionInvocationNode) node);
    69                         int argCount = Accessors.functionInvocationArgumentCount((FunctionInvocationNode) node);
     68                        ASTNode identifier = Accessors.FuncCallName((FuncCallNode) node);
     69                        int argCount = Accessors.FuncCallArgCount((FuncCallNode) node);
    7070                       
    7171                if (isQualifiedName(identifier, BuiltinsUtil.BUILTIN_PACKAGE_NAME, carryNOperation.pabloName())
     
    8080   
    8181    /** Returns true if the node represents a call to the
    82      *  given built-in function.
     82     *  given built-in Func.
    8383     * 
    8484     * @param node                  node to be checked
    85      * @return                      whether the node is a call of the function
     85     * @return                      whether the node is a call of the Func
    8686     */
    8787    public static boolean isBuiltInCallNoArgCount(ASTNode node) {
    88         if(!(node instanceof FunctionInvocationNode)) {
     88        if(!(node instanceof FuncCallNode)) {
    8989            return false;
    9090        }
    9191       
    92         FunctionInvocationNode fNode = (FunctionInvocationNode)node;
    93         ASTNode nameNode = Accessors.functionInvocationName(fNode);
     92        FuncCallNode fNode = (FuncCallNode)node;
     93        ASTNode nameNode = Accessors.FuncCallName(fNode);
    9494
    9595        for (Builtins builtin : Builtins.values()) {
     
    103103   
    104104    /** Returns true if the node represents a call to the
    105      *  given built-in function with the given number of arguments.
     105     *  given built-in Func with the given number of Args.
    106106     * 
    107107     * @param node                  node to be checked
    108      * @return                      whether the node is a call of the function with argNumToMatch arguments
     108     * @return                      whether the node is a call of the Func with argNumToMatch Args
    109109     */
    110110    public static boolean isBuiltInCall(ASTNode node) {
     
    120120   
    121121    /** Returns true if the node represents a call to the
    122      *  given function with the given number of arguments.
     122     *  given Func with the given number of Args.
    123123     *  If node does not have a packageName attached, it is assumed to match the given packageName.
    124124     * 
    125125     * @param node                  node to be checked
    126126     * @param packageName           package name that must be matched.
    127      * @param functionName          name of function to be matched
    128      * @param numArgs               number of arguments to be matched
    129      * @return                      whether the node is a call of the function with argNumToMatch arguments
     127     * @param FuncName          name of Func to be matched
     128     * @param numArgs               number of Args to be matched
     129     * @return                      whether the node is a call of the Func with argNumToMatch Args
    130130     */
    131     public static boolean isCall(ASTNode node, String packageName, String functionName, int numArgs) {
    132         if(!(node instanceof FunctionInvocationNode)) {
     131    public static boolean isCall(ASTNode node, String packageName, String FuncName, int numArgs) {
     132        if(!(node instanceof FuncCallNode)) {
    133133            return false;
    134134        }
    135135       
    136         FunctionInvocationNode fNode = (FunctionInvocationNode)node;
    137         ASTNode nameNode = Accessors.functionInvocationName(fNode);
     136        FuncCallNode fNode = (FuncCallNode)node;
     137        ASTNode nameNode = Accessors.FuncCallName(fNode);
    138138
    139         boolean nameMatches = isQualifiedName(nameNode, packageName, functionName);
    140         boolean numArgsMatches = Accessors.functionInvocationArgumentsListNode(fNode).nChildren() == numArgs;
     139        boolean nameMatches = isQualifiedName(nameNode, packageName, FuncName);
     140        boolean numArgsMatches = Accessors.FuncCallArgsListNode(fNode).nChildren() == numArgs;
    141141       
    142142        return nameMatches && numArgsMatches;
    143143    }
    144144   
    145     /** Determines if node represents the name of the function described by packageName, functionName.
    146      *  In particular, if node represents a simple (non-qualified) name, then it is compared with functionName.
     145    /** Determines if node represents the name of the Func described by packageName, FuncName.
     146     *  In particular, if node represents a simple (non-qualified) name, then it is compared with FuncName.
    147147     *  (Essentially, this assumes that the packageName is correct.)
    148      *  If node represents a compound (qualified) name, then it is compared with 'packageName.functionName'.
     148     *  If node represents a compound (qualified) name, then it is compared with 'packageName.FuncName'.
    149149     * 
    150150     * @param node
    151151     * @param packageName
    152      * @param functionName
    153      * @return True if the node matches packageName.functionName.
     152     * @param FuncName
     153     * @return True if the node matches packageName.FuncName.
    154154     */
    155     public static boolean isQualifiedName(ASTNode node, String packageName, String functionName) {
     155    public static boolean isQualifiedName(ASTNode node, String packageName, String FuncName) {
    156156        if(node instanceof IdentifierNode) {           
    157             return Accessors.identifierLexeme(node) == functionName;
     157            return Accessors.identifierLexeme(node) == FuncName;
    158158        }
    159159        else if (node instanceof CompoundVariableNode) {
     
    162162           
    163163            return   (Accessors.identifierLexeme(pckage) == packageName) &&
    164                      (Accessors.identifierLexeme(member) == functionName);
     164                     (Accessors.identifierLexeme(member) == FuncName);
    165165        }
    166166        return false;
  • proto/pablo/src/compiler/test/ASTTest.java

    r2621 r2658  
    1212    }
    1313   
    14     public void compareFunctionInvocationNodes() {
    15         ASTFunctionInvocationTestVisitor visitor = new ASTFunctionInvocationTestVisitor();
     14    public void compareFuncCallNodes() {
     15        ASTFuncCallTestVisitor visitor = new ASTFuncCallTestVisitor();
    1616        ASTTree.accept(visitor);
    1717        visitor.assertComplete();
     
    5050    }
    5151   
    52         private class ASTFunctionInvocationTestVisitor extends ASTTestVisitor {
     52        private class ASTFuncCallTestVisitor extends ASTTestVisitor {
    5353
    54                 ASTFunctionInvocationTestVisitor() {
     54                ASTFuncCallTestVisitor() {
    5555                        super();
    5656                }
    5757               
    58                 public void visitEnter(FunctionInvocationNode node) {
     58                public void visitEnter(FuncCallNode node) {
    5959                       
    6060                        if(this.ASTTree1 == null) {
  • proto/pablo/src/compiler/visitors/AdvanceCombinerXFormer.java

    r2657 r2658  
    99import ast.*;
    1010
    11 public class AdvanceCombinerTransformer {
     11public class AdvanceCombinerXFormer {
    1212       
    1313    private ASTNode ASTTree;
    1414   
    15     public AdvanceCombinerTransformer(ASTNode astTree) {
     15    public AdvanceCombinerXFormer(ASTNode astTree) {
    1616        this.ASTTree = astTree;
    1717    }
    1818   
    19     public void transform() {
     19    public void XForm() {
    2020        AdvanceCombinerVisitor visitor = new AdvanceCombinerVisitor();
    2121        ASTTree.accept(visitor);
     
    3232        private class AdvanceCombinerVisitor extends VoidVisitor.Default {
    3333
    34                 public void visitEnter(IfStatementNode node) {
    35                     // Additional carry logic req'd to support carry combine within If statements
     34                public void visitEnter(IfStmtNode node) {
     35                    // Additional carry logic req'd to support carry combine within If Stmts
    3636                        node.skipChildren();
    3737                }
    38                 public void visitEnter(WhileStatementNode node) {
    39                     // Additional carry logic req'd to support carry combine within While statements
     38                public void visitEnter(WhileStmtNode node) {
     39                    // Additional carry logic req'd to support carry combine within While Stmts
    4040                        node.skipChildren();
    4141                }
    4242
    43                 public void visitLeave(FunctionInvocationNode node) {
     43                public void visitLeave(FuncCallNode node) {
    4444                       
    4545                        if(!isAdvanceOfAdvance(node)) {
     
    4747                        }
    4848                                                       
    49                         ASTNode argumentsList = Accessors.functionInvocationArgumentsList((FunctionInvocationNode) node);
    50                         FunctionInvocationNode child = (FunctionInvocationNode)argumentsList.child(0);
     49                        ASTNode ArgsList = Accessors.FuncCallArgsListNode((FuncCallNode) node);
     50                        FuncCallNode child = (FuncCallNode)ArgsList.child(0);
    5151                       
    5252                        int amount1 = advanceAmount(node);
     
    6363        }
    6464
    65         private int advanceAmount(FunctionInvocationNode node) {
     65        private int advanceAmount(FuncCallNode node) {
    6666                assert BuiltinsUtil.isAdvance(node);
    67                 if(Accessors.functionInvocationArgumentsList(node).nChildren()==1) {
     67                if(Accessors.FuncCallArgsListNode(node).nChildren()==1) {
    6868                        return 1;
    6969                }
    70                 assert Accessors.functionInvocationArgumentsList(node).nChildren()==2;
    71                 return valueOf(Accessors.functionInvocationArgumentsList(node).child(1));
     70                assert Accessors.FuncCallArgsListNode(node).nChildren()==2;
     71                return valueOf(Accessors.FuncCallArgsListNode(node).child(1));
    7272        }       
    7373       
     
    7777                }                       
    7878               
    79                 ASTNode argumentsList = Accessors.functionInvocationArgumentsList((FunctionInvocationNode) node);
     79                ASTNode ArgsList = Accessors.FuncCallArgsListNode((FuncCallNode) node);
    8080               
    81                 return BuiltinsUtil.isAdvance(argumentsList.child(0));
     81                return BuiltinsUtil.isAdvance(ArgsList.child(0));
    8282        }
    8383       
    8484        private void translateAdvanceNode(
    85                         FunctionInvocationNode node,
    86                         FunctionInvocationNode child,
     85                        FuncCallNode node,
     86                        FuncCallNode child,
    8787                        int amount1, int amount2) {
    8888               
    89                 node.replaceChild(      Accessors.functionInvocationArgumentsList(node),
    90                                                         Accessors.functionInvocationArgumentsList(child));
     89                node.replaceChild(      Accessors.FuncCallArgsListNode(node),
     90                                                        Accessors.FuncCallArgsListNode(child));
    9191               
    9292                IntegerConstantNode integerConstantNode = Generators.makeIntegerConstantNode(amount1+amount2, node.getToken());
    93                 if(Accessors.functionInvocationArgumentsList(node).nChildren()==1) {
    94                         Accessors.functionInvocationArgumentsList(child).appendChild(integerConstantNode);
     93                if(Accessors.FuncCallArgsListNode(node).nChildren()==1) {
     94                        Accessors.FuncCallArgsListNode(child).appendChild(integerConstantNode);
    9595                }
    96                 assert Accessors.functionInvocationArgumentsList(node).nChildren()==2;
    97                 Accessors.functionInvocationArgumentsList(node).replaceChild(
    98                                 Accessors.functionInvocationArgumentsList(node).child(1),
     96                assert Accessors.FuncCallArgsListNode(node).nChildren()==2;
     97                Accessors.FuncCallArgsListNode(node).replaceChild(
     98                                Accessors.FuncCallArgsListNode(node).child(1),
    9999                                integerConstantNode);
    100100        }
  • proto/pablo/src/compiler/visitors/AdvanceNCounterVisitor.java

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

    r2657 r2658  
    88import compiler.lang.carry.CarrySet2Lang;
    99
    10 public class AssertBitBlockAlignStatementsTransformer {
     10public class AssertBitBlockAlignStmtsXFormer {
    1111        private ASTNode ASTree;
    1212       
     
    1414        private CarrySet2Lang carrySet2Lang;
    1515       
    16         public AssertBitBlockAlignStatementsTransformer(ASTNode ASTree, Builtins2Lang builtins2Lang, CarrySet2Lang carrySet2Lang) {
     16        public AssertBitBlockAlignStmtsXFormer(ASTNode ASTree, Builtins2Lang builtins2Lang, CarrySet2Lang carrySet2Lang) {
    1717                this.ASTree = ASTree;
    1818                this.builtins2Lang = builtins2Lang;
     
    2020        }
    2121       
    22         public ASTNode transform() {
    23                 Transformer transformer = new Transformer();
    24                 ASTree.accept(transformer);
     22        public ASTNode XForm() {
     23                XFormer XFormer = new XFormer();
     24                ASTree.accept(XFormer);
    2525                return ASTree;
    2626        }
    2727
    28         private class Transformer extends VoidVisitor.Default {
     28        private class XFormer extends VoidVisitor.Default {
    2929                               
    30                 public Transformer () {}
     30                public XFormer () {}
    3131                               
    3232                public void visitEnter(LocalVarDeclNode node) {
    33                         addDumpStatement(node, Accessors.lhs(node));
     33                        addDumpStmt(node, Accessors.lhs(node));
    3434                }               
    3535               
    3636                public void visitEnter(AssignmentNode node) {
    37                         addDumpStatement(node, Accessors.lhs(node));
     37                        addDumpStmt(node, Accessors.lhs(node));
    3838                }
    3939
    40                 private void addDumpStatement(ASTNode node, ASTNode lhs) {
    41                         FunctionInvocationNode printRegisterStatement =
    42                                         Generators.makeFunctionInvocationNode(  builtins2Lang.getCode(Builtins.ASSERTBITBLOCKALIGN),
     40                private void addDumpStmt(ASTNode node, ASTNode lhs) {
     41                        FuncCallNode printRegisterStmt =
     42                                        Generators.makeFuncCallNode(  builtins2Lang.getCode(Builtins.ASSERTBITBLOCKALIGN),
    4343                                                                                                                        node.getToken(),
    4444                                                                                                                        new ASTNode [] {lhs});
    4545                       
    46                         (node.getParent()).insertAfterChild(node, printRegisterStatement);                             
     46                        (node.getParent()).insertAfterChild(node, printRegisterStmt);                           
    4747                }
    4848        }       
  • proto/pablo/src/compiler/visitors/AugAssignmentXFormer.java

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

    r2657 r2658  
    88import compiler.lang.idisa.*;
    99
    10 public class Bitwise2IDISATransformer {
     10public class Bitwise2IDISAXFormer {
    1111        private ASTNode ASTree;
    1212       
    13         public Bitwise2IDISATransformer(ASTNode ASTree) {
     13        public Bitwise2IDISAXFormer(ASTNode ASTree) {
    1414                this.ASTree = ASTree;
    1515        }
    1616       
    17         public ASTNode transform() {
     17        public ASTNode XForm() {
    1818                Bitwise2IDISAVisitor visitor = new Bitwise2IDISAVisitor();
    1919                ASTree.accept(visitor);
     
    2626                        if(op.isLextant(Lextant.NOT)) {
    2727
    28                                 FunctionInvocationNode functionInvocationNode =
    29                                                 Generators.makeFunctionInvocationNode(SIMD.NOT.idisaName(),
     28                                FuncCallNode FuncCallNode =
     29                                                Generators.makeFuncCallNode(SIMD.NOT.idisaName(),
    3030                                                                                                                                op,
    3131                                                                                                                                new ASTNode [] {Accessors.operand(node)});                     
    32                                 node.updateSelf(functionInvocationNode);
     32                                node.updateSelf(FuncCallNode);
    3333                        }
    3434                }               
     
    3737                        Token op = node.getToken();
    3838                        if(op.isLextant(Lextant.AND, Lextant.OR, Lextant.XOR)) {
    39                                 String functionName;
     39                                String FuncName;
    4040                                if(op.isLextant(Lextant.AND)) {
    41                                         functionName = SIMD.AND.idisaName();
     41                                        FuncName = SIMD.AND.idisaName();
    4242                                } else if(op.isLextant(Lextant.OR)) {
    43                                         functionName = SIMD.OR.idisaName();
     43                                        FuncName = SIMD.OR.idisaName();
    4444                                } else {
    45                                         functionName = SIMD.XOR.idisaName();
     45                                        FuncName = SIMD.XOR.idisaName();
    4646                                }
    4747                               
    48                                 FunctionInvocationNode functionInvocationNode =
    49                                                 Generators.makeFunctionInvocationNode(functionName,
     48                                FuncCallNode FuncCallNode =
     49                                                Generators.makeFuncCallNode(FuncName,
    5050                                                                                                                                op,
    5151                                                                                                                                new ASTNode [] {Accessors.leftOperand(node), Accessors.rightOperand(node)});
    52                                 node.updateSelf(functionInvocationNode);
     52                                node.updateSelf(FuncCallNode);
    5353                        }
    5454                }
     
    6767                               
    6868                                name = SIMD.CONSTANT.idisaConstantName(fieldWidth, constant);
    69                                 FunctionInvocationNode functionInvocationNode = Generators.makeFunctionInvocationNode(name, node.getToken());
    70                                 node.updateSelf(functionInvocationNode);
     69                                FuncCallNode FuncCallNode = Generators.makeFuncCallNode(name, node.getToken());
     70                                node.updateSelf(FuncCallNode);
    7171                        }
    7272                }
     
    9595                                       
    9696                                        String name = SIMD.CONSTANT.idisaConstantName(fieldWidth, constant);
    97                                         FunctionInvocationNode functionInvocationNode = Generators.makeFunctionInvocationNode(name, node.getToken());
    98                                         rhs.updateSelf(functionInvocationNode);
     97                                        FuncCallNode FuncCallNode = Generators.makeFuncCallNode(name, node.getToken());
     98                                        rhs.updateSelf(FuncCallNode);
    9999                                }
    100100                        }
     
    107107//        ifNode.test = makeCall('bitblock::any', [ifNode.test])
    108108//        return ifNode         
    109                 public void visitLeave(IfStatementNode node) {
     109                public void visitLeave(IfStmtNode node) {
    110110                        ASTNode ifTest = Accessors.ifTest(node);                       
    111                         String functionName = BITBLOCK.ANY.IDISAName();
    112                         FunctionInvocationNode functionInvocationNode = Generators.makeFunctionInvocationNode(functionName,
     111                        String FuncName = BITBLOCK.ANY.IDISAName();
     112                        FuncCallNode FuncCallNode = Generators.makeFuncCallNode(FuncName,
    113113                                                                                                                                                                                                node.getToken(),
    114114                                                                                                                                                                                                new ASTNode [] {ifTest});
    115                         node.replaceChild(ifTest, functionInvocationNode);
     115                        node.replaceChild(ifTest, FuncCallNode);
    116116                }
    117117               
     
    120120//              whileNode.test = makeCall('bitblock::any', [whileNode.test])
    121121//              return whileNode
    122                 public void visitLeave(WhileStatementNode node) {
    123                         ASTNode whileTest = Accessors.whileCondition(node);
    124                         String functionName = BITBLOCK.ANY.IDISAName();
    125                        
     122                public void visitLeave(WhileStmtNode node) {
     123                        ASTNode whileTest = Accessors.whileCondition(node);                     
    126124                                                                                                                               
    127                         FunctionInvocationNode functionInvocationNode = Generators.makeFunctionInvocationNode(functionName,
     125                        FuncCallNode FuncCallNode = Generators.makeFuncCallNode(
     126                                        BITBLOCK.ANY.IDISAName(),
    128127                                        node.getToken(),
    129128                                        new ASTNode [] {whileTest});                           
    130129                       
    131                         node.replaceChild(whileTest, functionInvocationNode);
     130                        node.replaceChild(whileTest, FuncCallNode);
    132131                }
    133132        }
  • proto/pablo/src/compiler/visitors/CPPUnparser.java

    r2657 r2658  
    7676       
    7777        ////////////////////////////////////////////////////////////////////////////
    78         // Stream Functions
    79         ////////////////////////////////////////////////////////////////////////////
    80         public CodeStore visitLeave(FunctionDefNode node, List<CodeStore> childResults) {
     78        // Stream Funcs
     79        ////////////////////////////////////////////////////////////////////////////
     80        public CodeStore visitLeave(FuncDefNode node, List<CodeStore> childResults) {
    8181                CodeStore code = new CodeStore();
    8282
    8383                CodeStore returnType = childResults.get(0);
    84                 CodeStore functionName = childResults.get(1);
    85                 CodeStore blockStatement; 
     84                CodeStore FuncName = childResults.get(1);
     85                CodeStore blockStmt; 
    8686               
    8787                String parameters = new String();
    8888                if(Accessors.hasParameters(node)) {
    8989                        parameters = childResults.get(2).getResultVariableName();
    90                         blockStatement = childResults.get(3);
     90                        blockStmt = childResults.get(3);
    9191                } else {
    92                         blockStatement = childResults.get(2);
     92                        blockStmt = childResults.get(2);
    9393                }
    9494                               
    9595                code.addFormattedLine("%s %s(%s)",
    9696                                returnType.getResultVariableName(),
    97                                 functionName.getResultVariableName(),
     97                                FuncName.getResultVariableName(),
    9898                                parameters);   
    9999               
    100100                code.addLine("{");
    101                 code.addAll(blockStatement, 1);
     101                code.addAll(blockStmt, 1);
    102102                code.dedentedLine("}");
    103103                return code;
     
    117117                String type = childResults.get(0).getResultVariableName();
    118118                String identifier = childResults.get(1).getResultVariableName();
    119                 code.setResultVariableName(type + " " + identifier);
    120                
    121                 return code;
    122         }
    123                
    124         ////////////////////////////////////////////////////////////////////////////
    125         // Statements
     119                code.setResultVariableName(type + " & " + identifier);
     120               
     121                return code;
     122        }
     123               
     124        ////////////////////////////////////////////////////////////////////////////
     125        // Stmts
    126126        ////////////////////////////////////////////////////////////////////////////   
    127127       
    128         // assignment statement
     128        // assignment Stmt
    129129        public CodeStore visitLeave(AssignmentNode node, List<CodeStore> childResults) {
    130130                CodeStore code = new CodeStore();
     
    138138        }
    139139
    140         // function invocation
     140        // Func invocation
    141141        //
    142142        // TODO - Verify correctness, both returns variable and code line.
    143143        //
    144         public CodeStore visitLeave(FunctionInvocationNode node, List<CodeStore> childResults) {
     144        public CodeStore visitLeave(FuncCallNode node, List<CodeStore> childResults) {
    145145                CodeStore code = new CodeStore();
    146146               
     
    152152                resultVariable.append(")");
    153153               
    154                 code.setResultVariableName(resultVariable.toString());   // function invocation as an expression       
    155                
    156                 code.addFormattedLine("%s;", resultVariable.toString()); // function invocation as a statement
    157                
    158                 return code;
    159         }       
    160        
    161         public CodeStore visitLeave(FunctionInvocationArgumentListNode node, List<CodeStore> childResults) {
     154                code.setResultVariableName(resultVariable.toString());   // Func invocation as an expression   
     155               
     156                code.addFormattedLine("%s;", resultVariable.toString()); // Func invocation as a Stmt
     157               
     158                return code;
     159        }       
     160       
     161        public CodeStore visitLeave(FuncCallArgListNode node, List<CodeStore> childResults) {
    162162                CodeStore code = new CodeStore();
    163163                Iterator<CodeStore> iter = childResults.iterator();
     
    166166        }
    167167               
    168         // if statement
    169         public CodeStore visitLeave(IfStatementNode node, List<CodeStore> childResults) {
     168        // if Stmt
     169        public CodeStore visitLeave(IfStmtNode node, List<CodeStore> childResults) {
    170170                CodeStore code = new CodeStore();
    171171                CodeStore ifTest                        = childResults.get(0);
    172                 CodeStore ifBlockStatement      = childResults.get(1);
     172                CodeStore ifBlockStmt   = childResults.get(1);
    173173                code.addFormattedLine("if (%s)", ifTest.getResultVariableName());
    174174                code.addLine("{");
    175                 code.addAll(ifBlockStatement, 1);
     175                code.addAll(ifBlockStmt, 1);
    176176                code.dedentedLine("}");
    177                 if(Accessors.hasElseBlockStatement(node)) {
    178                         CodeStore elseBlockStatement    = childResults.get(2);
     177                if(Accessors.hasElseBlockStmt(node)) {
     178                        CodeStore elseBlockStmt = childResults.get(2);
    179179                        code.addLine("else");
    180180                        code.addLine("{");
    181                         code.addAll(elseBlockStatement, 1);
     181                        code.addAll(elseBlockStmt, 1);
    182182                        code.dedentedLine("}");
    183183                }
     
    185185        }
    186186       
    187         // while statement
    188         public CodeStore visitLeave(WhileStatementNode node, List<CodeStore> childResults) {
     187        // while Stmt
     188        public CodeStore visitLeave(WhileStmtNode node, List<CodeStore> childResults) {
    189189                CodeStore code = new CodeStore();
    190190                CodeStore ifTest                        = childResults.get(0);
    191                 CodeStore blockStatement        = childResults.get(1);
     191                CodeStore blockStmt     = childResults.get(1);
    192192                code.addFormattedLine("while (%s)", ifTest.getResultVariableName());
    193193                code.addLine("{");
    194                 code.addAll(blockStatement, 1);
     194                code.addAll(blockStmt, 1);
    195195                code.dedentedLine("}");
    196196                return code;
    197197        }       
    198198       
    199         // return statement
    200         public CodeStore visitLeave(ReturnStatementNode node, List<CodeStore> childResults) {
     199        // return Stmt
     200        public CodeStore visitLeave(ReturnStmtNode node, List<CodeStore> childResults) {
    201201                CodeStore code = new CodeStore();
    202202                CodeStore child = childResults.get(0);
     
    232232        }       
    233233       
    234 //      public CodeStore visitLeave(AssignmentStatementNode node, List<CodeStore> childResults) {
     234//      public CodeStore visitLeave(AssignmentStmtNode node, List<CodeStore> childResults) {
    235235//              CodeStore code = new CodeStore();
    236236//              code.setResultVariableName(Accessors.assignmentOperator(node));
     
    238238//      }
    239239
    240         // block statements
    241         public CodeStore visitLeave(BlockStatementNode node, List<CodeStore> childResults) {
     240        // block Stmts
     241        public CodeStore visitLeave(BlockStmtNode node, List<CodeStore> childResults) {
    242242                CodeStore code = new CodeStore();
    243243               
  • proto/pablo/src/compiler/visitors/CarryCounterVisitor.java

    r2657 r2658  
    2525                }
    2626               
    27                 public void visitLeave(FunctionInvocationNode node) {
     27                public void visitLeave(FuncCallNode node) {
    2828                        if(BuiltinsUtil.isCarryOne(node)) {
    2929                            carryCount += 1;
  • proto/pablo/src/compiler/visitors/CarryIntroXFormer.java

    r2657 r2658  
    1111import ast.*;
    1212
    13 public class CarryIntroTransformer {
     13public class CarryIntroXFormer {
    1414               
    15         private ASTNode ASTTree; // FunctionDefNode     
     15        private ASTNode ASTTree; // FuncDefNode
    1616       
    1717        private CarrySet2Lang carrySet2Lang;
    1818               
    19     public CarryIntroTransformer(ASTNode node, CarrySet2Lang carrySet2Lang) {
    20         assert node instanceof FunctionDefNode;
     19    public CarryIntroXFormer(ASTNode node, CarrySet2Lang carrySet2Lang) {
     20        assert node instanceof FuncDefNode;
    2121        this.ASTTree = node;
    2222        this.carrySet2Lang = carrySet2Lang;
    2323    }
    2424
    25     /** Appends carry information to Pablo AST 'If' 'While' statement nodes.
     25    /** Appends carry information to Pablo AST 'If' 'While' Stmt nodes.
    2626     * 
    2727     * @param ci                        carry in mode
    2828     * @param co                        carry out mode
    2929     */ 
    30     public void transform(boolean ci, boolean co) {
     30    public void XForm(boolean ci, boolean co) {
    3131                CarryIntroVisitor visitor = new CarryIntroVisitor(ci, co);
    3232                ASTTree.accept(visitor);
     
    6464                //      #    fndef.body.insert(0, mkCallStmt('CarryDeclare', [self.carryvar, ast.Num(carry_count)]))
    6565                //          return fndef
    66                 public void visitEnter(FunctionDefNode node) {
     66                public void visitEnter(FuncDefNode node) {
    6767                        this.currentCarry = 0;
    6868                        //this.currentAdvN = 0;
     
    7474                                IntegerConstantNode carryCountNode =  Generators.makeIntegerConstantNode(carryCount, node.getToken());
    7575                               
    76                                 FunctionInvocationNode carryAdjustFunctionInvocation = (FunctionInvocationNode) Generators.makeFunctionInvocationNode(
     76                                FuncCallNode carryAdjustFuncCall = (FuncCallNode) Generators.makeFuncCallNode(
    7777                                                new String [] {CarrySet.CarryQ_IDENTIFIER, carrySet2Lang.getCode(CarrySet.CARRYQADJUST)},
    7878                                                node.getToken(),
    7979                                                new ASTNode [] {carryCountNode});
    8080                               
    81                                 BlockStatementNode blockStatementNode = Accessors.blockStatementNode(node);
    82                                 blockStatementNode.appendChild(carryAdjustFunctionInvocation);
     81                                BlockStmtNode blockStmtNode = Accessors.blockStmtNode(node);
     82                                blockStmtNode.appendChild(carryAdjustFuncCall);
    8383                        }
    8484                }               
    8585               
    86                 public void visitLeave(FunctionInvocationNode node) {
     86                public void visitLeave(FuncCallNode node) {
    8787                        if(BuiltinsUtil.isCarryOne(node)) {
    8888                                this.currentCarry += 1;
     
    102102                //return ast.If(new_test, ifNode.body, new_else_part)
    103103
    104                 public void visitEnter(IfStatementNode node) { // Current if strategy does not test any_carry() on n bits
     104                public void visitEnter(IfStmtNode node) { // Current if strategy does not test any_carry() on n bits
    105105                        assert (new AdvanceNCounterVisitor(node).count() == 0): "Advance(x,n) within if: illegal\n";
    106106                       
     
    121121                        IntegerConstantNode carryCountNode =  Generators.makeIntegerConstantNode(carryCount, node.getToken());
    122122               
    123                         FunctionInvocationNode rhs = (FunctionInvocationNode) Generators.makeFunctionInvocationNode(
     123                        FuncCallNode rhs = (FuncCallNode) Generators.makeFuncCallNode(
    124124                                        new String [] {CarrySet.CarryQ_IDENTIFIER, carrySet2Lang.getCode(CarrySet.CARRYTEST)},
    125125                                        node.getToken(),
     
    133133                       
    134134                        // else part, append CarryDequeueEnqueue call
    135                         FunctionInvocationNode carryDequeueEnqueue = (FunctionInvocationNode) Generators.makeFunctionInvocationNode(
     135                        FuncCallNode carryDequeueEnqueue = (FuncCallNode) Generators.makeFuncCallNode(
    136136                                        new String [] {CarrySet.CarryQ_IDENTIFIER, carrySet2Lang.getCode(CarrySet.CARRYDEQUEUEENQUEUE)},
    137137                                        node.getToken(),
     
    139139
    140140                       
    141                         if (Accessors.hasElseBlockStatement(node)) {   
    142                                 Accessors.elseBlockStatement(node).appendChild(carryDequeueEnqueue);
     141                        if (Accessors.hasElseBlockStmt(node)) {
     142                                Accessors.elseBlockStmt(node).appendChild(carryDequeueEnqueue);
    143143                        } else {
    144                                 BlockStatementNode blockStatementNode =
    145                                                 Generators.makeBlockStatementNode(LextantToken.make(node.getToken().getLocation(),
     144                                BlockStmtNode blockStmtNode =
     145                                                Generators.makeBlockStmtNode(LextantToken.make(node.getToken().getLocation(),
    146146                                                                                                                        Lextant.LCURLY.getPrimaryLexeme(),
    147147                                                                                                                        Lextant.LCURLY));
    148                                 blockStatementNode.appendChild(carryDequeueEnqueue);
    149                                 node.appendChild(blockStatementNode);
     148                                blockStmtNode.appendChild(carryDequeueEnqueue);
     149                                node.appendChild(blockStmtNode);
    150150                        }
    151151                                               
     
    154154}
    155155
    156 //class CarryIntro(ast.NodeTransformer):
     156//class CarryIntro(ast.NodeXFormer):
    157157
    158158//        def generic_xfrm(self, node):
  • proto/pablo/src/compiler/visitors/DumpAssignmentStmtsXFormer.java

    r2657 r2658  
    77import compiler.lang.pablo.Builtins2Lang;
    88
    9 public class DumpAssignmentStatementsTransformer {
     9public class DumpAssignmentStmtsXFormer {
    1010        private ASTNode ASTree;
    1111        private Builtins2Lang builtins2Lang;
    1212       
    13         public DumpAssignmentStatementsTransformer(ASTNode ASTree, Builtins2Lang builtins2Lang) {
     13        public DumpAssignmentStmtsXFormer(ASTNode ASTree, Builtins2Lang builtins2Lang) {
    1414                this.ASTree = ASTree;
    1515                this.builtins2Lang = builtins2Lang;
    1616        }
    1717       
    18         public ASTNode transform() {
    19                 Transformer transformer = new Transformer();
    20                 ASTree.accept(transformer);
     18        public ASTNode XForm() {
     19                XFormer XFormer = new XFormer();
     20                ASTree.accept(XFormer);
    2121                return ASTree;
    2222        }
    2323
    24         private class Transformer extends VoidVisitor.Default {
     24        private class XFormer extends VoidVisitor.Default {
    2525                               
    26                 public Transformer () {}
     26                public XFormer () {}
    2727                               
    2828                public void visitEnter(LocalVarDeclNode node) {
    29                         addDumpStatement(node, Accessors.lhs(node));
     29                        addDumpStmt(node, Accessors.lhs(node));
    3030                }               
    3131               
    3232                public void visitEnter(AssignmentNode node) {
    33                         addDumpStatement(node, Accessors.lhs(node));
     33                        addDumpStmt(node, Accessors.lhs(node));
    3434                }
    3535
    36                 private void addDumpStatement(ASTNode node, ASTNode lhs) {
    37                         FunctionInvocationNode printRegisterStatement =
    38                                         Generators.makeFunctionInvocationNode(  builtins2Lang.getCode(Builtins.PRINTBITBLOCK),
     36                private void addDumpStmt(ASTNode node, ASTNode lhs) {
     37                        FuncCallNode printRegisterStmt =
     38                                        Generators.makeFuncCallNode(  builtins2Lang.getCode(Builtins.PRINTBITBLOCK),
    3939                                                                                                                        node.getToken(),
    4040                                                                                                                        new ASTNode [] {lhs});
    4141                       
    42                         (node.getParent()).insertAfterChild(node, printRegisterStatement);                             
     42                        (node.getParent()).insertAfterChild(node, printRegisterStmt);                           
    4343                }
    4444        }       
  • proto/pablo/src/compiler/visitors/Pablo2CarryXFormer.java

    r2657 r2658  
    1414import ast.*;
    1515
    16 public class Pablo2CarryTransformer {
     16public class Pablo2CarryXFormer {
    1717               
    1818        private Builtins2Lang builtins2Lang;
    1919        private CarrySet2Lang carrySet2Lang;
    2020       
    21         private ASTNode ASTTree; // FunctionDefNode     
     21        private ASTNode ASTTree; // FuncDefNode
    2222       
    2323    //    def __init__(self, carryvar="carryQ", carryin = "_ci", carryout = "_co"):
     
    2626        //    self.carryout = carryout   
    2727       
    28     public Pablo2CarryTransformer(ASTNode node, Builtins2Lang builtins2Lang, CarrySet2Lang carrySet2Lang) {
    29         assert node instanceof FunctionDefNode;
     28    public Pablo2CarryXFormer(ASTNode node, Builtins2Lang builtins2Lang, CarrySet2Lang carrySet2Lang) {
     29        assert node instanceof FuncDefNode;
    3030        this.ASTTree = node;
    3131        this.builtins2Lang = builtins2Lang;
     
    3333    }
    3434
    35     /** Transforms FunctionDefNode AST sub-trees w.r.t. ci/co modes.
    36      * Augments AST with 'CarryQ' function calls.
     35    /** XForms FuncDefNode AST sub-trees w.r.t. ci/co modes.
     36     * Augments AST with 'CarryQ' Func calls.
    3737     * 
    3838     * @param ci                        carry in mode
    3939     * @param co                        carry out mode
    4040     */ 
    41     public void transform(boolean ci, boolean co) { // ci - carry in xformation mode, co - carry out mode xformation mode
     41    public void XForm(boolean ci, boolean co) { // ci - carry in xformation mode, co - carry out mode xformation mode
    4242                CarryIntroVisitor visitor = new CarryIntroVisitor(ci, co);
    4343                ASTTree.accept(visitor);
     
    7575                //      #    fndef.body.insert(0, mkCallStmt('CarryDeclare', [self.carryvar, ast.Num(carry_count)]))
    7676                //          return fndef
    77                 public void visitEnter(FunctionDefNode node) { // TODO - CarryIf duplicates
     77                public void visitEnter(FuncDefNode node) { // TODO - CarryIf duplicates
    7878                        this.currentCarry = 0;
    7979                        this.currentAdvN = 0;
     
    8181                }               
    8282               
    83                 public void visitLeave(FunctionInvocationNode node) {
     83                public void visitLeave(FuncCallNode node) {
    8484                       
    8585                        ASTNode replacementNode;
     
    9898//              adv_n_args = [mkCall('simd<1>::constant<0>', []), ast.Num(self.current_adv_n)]
    9999                        if(ciMode) {
    100                                 carryCall = Generators.makeFunctionInvocationNode(
     100                                carryCall = Generators.makeFuncCallNode(
    101101                                                new String [] {CarrySet.CarryQ_IDENTIFIER, carrySet2Lang.getCode(CarrySet.GETCARRYIN)},
    102102                                                node.getToken(),
    103103                                                new ASTNode [] {currentCarry});
    104104                               
    105                                 advNCall = Generators.makeFunctionInvocationNode(
     105                                advNCall = Generators.makeFuncCallNode(
    106106                                                new String [] {CarrySet.CarryQ_IDENTIFIER, carrySet2Lang.getCode(CarrySet.GETPENDING64)},
    107107                                                node.getToken(),
     
    120120        //                    return c                 
    121121                        if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.ADVANCE.pabloName(), Builtins.ADVANCE.argCount())) {         
    122                                 replaceFunctionInvocationNode(node,
     122                                replaceFuncCallNode(node,
    123123                                                CarrySet.CarryQ_IDENTIFIER,
    124124                                                builtins2Lang.getCode(Builtins.ADVANCE),
     
    135135        //            return c         
    136136                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.SCANTHRU.pabloName(), Builtins.SCANTHRU.argCount())) {                           
    137                                 replaceFunctionInvocationNode(node,
     137                                replaceFuncCallNode(node,
    138138                                                CarrySet.CarryQ_IDENTIFIER,
    139139                                                builtins2Lang.getCode(Builtins.SCANTHRU),
     
    150150        //            return c         
    151151                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.ADVANCETHENSCANTHRU.pabloName(), Builtins.ADVANCETHENSCANTHRU.argCount())) {
    152                                 replaceFunctionInvocationNode(node,
     152                                replaceFuncCallNode(node,
    153153                                                CarrySet.CarryQ_IDENTIFIER,
    154154                                                builtins2Lang.getCode(Builtins.ADVANCETHENSCANTHRU),
     
    165165        //            return c         
    166166                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.SPANUPTO.pabloName(), Builtins.SPANUPTO.argCount())) {
    167                                 replaceFunctionInvocationNode(node,
     167                                replaceFuncCallNode(node,
    168168                                                CarrySet.CarryQ_IDENTIFIER,
    169169                                                builtins2Lang.getCode(Builtins.SPANUPTO),
     
    182182        //            return c
    183183                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.ADVANCETHENSCANTO.pabloName(), Builtins.ADVANCETHENSCANTO.argCount())) {
    184                                 replaceFunctionInvocationNode(node,
     184                                replaceFuncCallNode(node,
    185185                                                CarrySet.CarryQ_IDENTIFIER,
    186186                                                builtins2Lang.getCode(Builtins.ADVANCETHENSCANTO),
     
    200200       
    201201                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.INCLUSIVESPAN.pabloName(), Builtins.INCLUSIVESPAN.argCount())) {
    202                                 replaceFunctionInvocationNode(node,
     202                                replaceFuncCallNode(node,
    203203                                                CarrySet.CarryQ_IDENTIFIER,
    204204                                                builtins2Lang.getCode(Builtins.INCLUSIVESPAN),
     
    218218       
    219219                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.EXCLUSIVESPAN.pabloName(), Builtins.EXCLUSIVESPAN.argCount())) {
    220                                 replaceFunctionInvocationNode(node,
     220                                replaceFuncCallNode(node,
    221221                                                CarrySet.CarryQ_IDENTIFIER,
    222222                                                builtins2Lang.getCode(Builtins.EXCLUSIVESPAN),
     
    238238       
    239239                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.SCANTO.pabloName(), Builtins.SCANTO.argCount())) {
    240                                 replaceFunctionInvocationNode(node,
     240                                replaceFuncCallNode(node,
    241241                                                CarrySet.CarryQ_IDENTIFIER,
    242242                                                builtins2Lang.getCode(Builtins.SCANTO),
     
    255255       
    256256                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.SCANTOFIRST.pabloName(), Builtins.SCANTOFIRST.argCount())) {
    257                                 replaceFunctionInvocationNode(node,
     257                                replaceFuncCallNode(node,
    258258                                                CarrySet.CarryQ_IDENTIFIER,
    259259                                                builtins2Lang.getCode(Builtins.SCANTOFIRST),
     
    270270        //            return c
    271271                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.ADVANCE32.pabloName(), Builtins.ADVANCE32.argCount())) {
    272                                 //replaceFunctionInvocationNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.ADVANCE32.cPPCode(), carryCall, currentAdvN);
     272                                //replaceFuncCallNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.ADVANCE32.cPPCode(), carryCall, currentAdvN);
    273273                                // TODO ==> verify advNCall
    274                                 replaceFunctionInvocationNode(node,
     274                                replaceFuncCallNode(node,
    275275                                                CarrySet.CarryQ_IDENTIFIER,
    276276                                                builtins2Lang.getCode(Builtins.ADVANCE32),
     
    287287        //            return c         
    288288                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.ADVANCEN.pabloName(), Builtins.ADVANCEN.argCount())) {
    289                                 //replaceFunctionInvocationNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.ADVANCEN.cPPCode(), carryCall, currentAdvN);                                       
     289                                //replaceFuncCallNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.ADVANCEN.cPPCode(), carryCall, currentAdvN);                                 
    290290                                // TODO ==> verify advNCall
    291                                 replaceFunctionInvocationNode(node,
     291                                replaceFuncCallNode(node,
    292292                                                CarrySet.CarryQ_IDENTIFIER,
    293293                                                builtins2Lang.getCode(Builtins.ADVANCE32),
     
    307307                                if(!this.coMode) { // if not final block
    308308                                        List<ASTNode> args = new ArrayList<ASTNode>();
    309                                         for(ASTNode arg : Accessors.functionInvocationArgumentsListNode(node).getChildren()) {
     309                                        for(ASTNode arg : Accessors.FuncCallArgsListNode(node).getChildren()) {
    310310                                                args.add(arg);
    311311                                        }       
    312312                                        args.add(Generators.makeIdentifierNode(builtins2Lang.getCode(Builtins.EOFMASK), node.getToken()));
    313                                         replacementNode = Generators.makeFunctionInvocationNode(SIMD.ANDC.idisaName(), node.getToken(), args);
     313                                        replacementNode = Generators.makeFuncCallNode(SIMD.ANDC.idisaName(), node.getToken(), args);
    314314                                       
    315315                                } else {
    316                                         replacementNode = Generators.makeFunctionInvocationNode(SIMD.CONSTANT.idisaConstantName(1, 0), node.getToken());                                       
     316                                        replacementNode = Generators.makeFuncCallNode(SIMD.CONSTANT.idisaConstantName(1, 0), node.getToken());                                 
    317317                                }
    318318                                node.updateSelf(replacementNode);
     
    330330                                        List<ASTNode> args = new ArrayList<ASTNode>();
    331331                                       
    332                                         for(ASTNode arg : Accessors.functionInvocationArgumentsListNode(node).getChildren()) {
     332                                        for(ASTNode arg : Accessors.FuncCallArgsListNode(node).getChildren()) {
    333333                                                args.add(arg);
    334334                                        }
    335335                                        args.add(Generators.makeIdentifierNode(builtins2Lang.getCode(Builtins.EOFMASK), node.getToken()));
    336                                         replacementNode = Generators.makeFunctionInvocationNode(SIMD.AND.idisaName(), node.getToken(), args);
     336                                        replacementNode = Generators.makeFuncCallNode(SIMD.AND.idisaName(), node.getToken(), args);
    337337                                       
    338338                                } else {
    339                                         replacementNode = Accessors.functionInvocationArgument(node,0);
     339                                        replacementNode = Accessors.FuncCallArg(node,0);
    340340                                }
    341341                                node.updateSelf(replacementNode);
     
    352352//
    353353//                      else if (Builtins.isCall(node, Builtins.BUILTIN_PACKAGE_NAME, NoCarry.STREAMSCAN.pabloName(), NoCarry.STREAMSCAN.argCount())) {
    354 //                              replacementNode = Generators.makeFunctionInvocationNode(NoCarry.STREAMSCAN.cPPCode(), node.getToken());
     354//                              replacementNode = Generators.makeFuncCallNode(NoCarry.STREAMSCAN.cPPCode(), node.getToken());
    355355//                             
    356 //                              ASTNode arg0 = Generators.makeIdentifierNode("(ScanBlock *) &" + Accessors.identifierLexeme(Accessors.functionInvocationArg(node, 0)), node.getToken());
     356//                              ASTNode arg0 = Generators.makeIdentifierNode("(ScanBlock *) &" + Accessors.identifierLexeme(Accessors.FuncCallArg(node, 0)), node.getToken());
    357357//                              ASTNode arg1 = Generators.makeIdentifierNode("sizeof(BitBlock)/sizeof(ScanBlock)", node.getToken());
    358 //                              ASTNode arg2 = Accessors.functionInvocationArg(node, 1);
     358//                              ASTNode arg2 = Accessors.FuncCallArg(node, 1);
    359359//                             
    360360//                              replacementNode.appendChild(arg0);
     
    367367//                    return callnode
    368368                        else {
    369                                 // do nothing // TODO - Dump: allow function calls to pass through the compiler.
     369                                // do nothing // TODO - Dump: allow Func calls to pass through the compiler.
    370370                        }
    371371                       
     
    373373                                       
    374374                // Helpers             
    375                 private void replaceFunctionInvocationNode(FunctionInvocationNode node, String targetPackage, String targetName,
     375                private void replaceFuncCallNode(FuncCallNode node, String targetPackage, String targetName,
    376376                                ASTNode call, IntegerConstantNode carry) {
    377                         FunctionInvocationNode replacementNode;
     377                        FuncCallNode replacementNode;
    378378
    379379                        List<ASTNode> args = new ArrayList<ASTNode>();
    380380                                               
    381                         for(ASTNode arg : Accessors.functionInvocationArgumentsListNode(node).getChildren()) {
     381                        for(ASTNode arg : Accessors.FuncCallArgsListNode(node).getChildren()) {
    382382                                args.add(arg);
    383383                        }       
     
    385385                        args.add(carry);
    386386                       
    387                         replacementNode = Generators.makeFunctionInvocationNode(
     387                        replacementNode = Generators.makeFuncCallNode(
    388388                                        new String [] {targetPackage, targetName},
    389389                                        node.getToken(),
     
    395395}
    396396
    397 //class CarryIntro(ast.NodeTransformer):
     397//class CarryIntro(ast.NodeXFormer):
    398398
    399399//        def generic_xfrm(self, node):
  • proto/pablo/src/compiler/visitors/StreamFuncVisitor.java

    r2651 r2658  
    99import compiler.ast.Accessors;
    1010
    11 //class StreamFunctionVisitor(ast.NodeVisitor):
     11//class StreamFuncVisitor(ast.NodeVisitor):
    1212//    def __init__(self,node):
    13 //        self.streamFunctionNode = {}
     13//        self.streamFuncNode = {}
    1414//        self.generic_visit(node)
    1515//
    16 //    def visit_FunctionDef(self, node):                       
     16//    def visit_FuncDef(self, node):                   
    1717//        key = node.name[0].upper() + node.name[1:]
    18 //        self.streamFunctionNode[key] = node
     18//        self.streamFuncNode[key] = node
    1919
    20 public class StreamFunctionVisitor {
     20public class StreamFuncVisitor {
    2121   
    2222    private ASTNode ASTree;
    2323   
    24     public StreamFunctionVisitor(ASTNode ASTree) {
     24    public StreamFuncVisitor(ASTNode ASTree) {
    2525        this.ASTree = ASTree;
    2626    }
    2727   
    2828    public void visit() {
    29         StreamFunctionVisitor1 visitor = new StreamFunctionVisitor1();
     29        StreamFuncVisitor1 visitor = new StreamFuncVisitor1();
    3030        ASTree.accept(visitor);
    3131    }   
    3232       
    33         public  Map<String, ASTNode> makeStreamFunctionMap() {
    34             StreamFunctionVisitor1 visitor = new StreamFunctionVisitor1();
     33        public  Map<String, ASTNode> makeStreamFuncMap() {
     34            StreamFuncVisitor1 visitor = new StreamFuncVisitor1();
    3535                ASTree.accept(visitor);
    36                 return ((StreamFunctionVisitor1)visitor).streamFunctionMap();
     36                return ((StreamFuncVisitor1)visitor).streamFuncMap();
    3737        }
    3838       
    39         private  class StreamFunctionVisitor1 extends VoidVisitor.Default {
     39        private  class StreamFuncVisitor1 extends VoidVisitor.Default {
    4040               
    41                 private LinkedHashMap<String, ASTNode> streamFunctionMap = new LinkedHashMap<String, ASTNode>();
     41                private LinkedHashMap<String, ASTNode> streamFuncMap = new LinkedHashMap<String, ASTNode>();
    4242               
    43                 public Map<String, ASTNode> streamFunctionMap() {
    44                         return streamFunctionMap;
     43                public Map<String, ASTNode> streamFuncMap() {
     44                        return streamFuncMap;
    4545                }
    4646                               
    47                 public void visitLeave(FunctionDefNode node) {
     47                public void visitLeave(FuncDefNode node) {
    4848                                               
    49                         ASTNode functionNameNode = Accessors.functionName(node);       
    50                         String functionName = functionNameNode.getToken().getLexeme();
    51                         functionName = capitalize(functionName);
    52                         IdentifierToken newNameToken = IdentifierToken.make(LexicalType.IDENTIFIER, functionNameNode.getToken().getLocation(), functionName);
     49                        ASTNode FuncNameNode = Accessors.FuncName(node);       
     50                        String FuncName = FuncNameNode.getToken().getLexeme();
     51                        FuncName = capitalize(FuncName);
     52                        IdentifierToken newNameToken = IdentifierToken.make(LexicalType.IDENTIFIER, FuncNameNode.getToken().getLocation(), FuncName);
    5353                       
    54                         functionNameNode.setToken(newNameToken);
    55                         streamFunctionMap.put(functionName, node);                                     
     54                        FuncNameNode.setToken(newNameToken);
     55                        streamFuncMap.put(FuncName, node);                                     
    5656                       
    5757                }
  • proto/pablo/src/grammar/PabloApplication.java

    r2410 r2658  
    1818       
    1919       
    20         protected static void checkArguments(String[] args, String applicationName) {
     20        protected static void checkArgs(String[] args, String applicationName) {
    2121                int length = args.length;
    2222                boolean inputDirFound = false;
  • proto/pablo/src/grammar/TestPabloAbstractSyntaxTree.java

    r2438 r2658  
    2727
    2828/**
    29  * Recursive function to descend into the directory tree and find all the files
     29 * Recursive Func to descend into the directory tree and find all the files
    3030 * that end with ".mp3"
    3131 * @param dir A file object defining the top directory
     
    3939         */
    4040        public static void main(String[] args) throws FileNotFoundException {
    41                 PabloApplication.checkArguments(args, "SampleAbstractSyntaxTree");
     41                PabloApplication.checkArgs(args, "SampleAbstractSyntaxTree");
    4242               
    4343                ASTPrinter.setPrintLevel(ASTPrinter.Level.FULL);
  • proto/pablo/src/parser/Parser.java

    r2625 r2658  
    5858                        else if( nowReading.isLextant(Lextant.FUNCTION) ) {
    5959                                {
    60                                         ASTNode child = parseFunctionDef();
     60                                        ASTNode child = parseFuncDef();
    6161                                        result.appendChild(child);
    6262                                        allChildren.add(child);
     
    181181        }
    182182         
    183         public ASTNode parseFunctionDef() {
     183        public ASTNode parseFuncDef() {
    184184                if( !(nowReading.isLextant(Lextant.FUNCTION)) ) {
    185                         return syntaxErrorNode("functionDef² [FUNCTION¹]");
    186                 }
    187        
    188                 boolean allowCompression = true;
    189                 ASTNode result = new FunctionDefNode(nowReading);
     185                        return syntaxErrorNode("FuncDef² [FUNCTION¹]");
     186                }
     187       
     188                boolean allowCompression = true;
     189                ASTNode result = new FuncDefNode(nowReading);
    190190                result.setProductionTag(6);
    191191                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     
    197197                }
    198198                {
    199                         ASTNode child = parseFunctionName();
     199                        ASTNode child = parseFuncName();
    200200                        result.appendChild(child);
    201201                        allChildren.add(child);
     
    211211                expect(Lextant.RROUND);
    212212                {
    213                         ASTNode child = parseBlockStatement();
     213                        ASTNode child = parseBlockStmt();
    214214                        result.appendChild(child);
    215215                        allChildren.add(child);
     
    272272        }
    273273         
    274         public ASTNode parseFunctionName() {
     274        public ASTNode parseFuncName() {
    275275                if( !((nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
    276                         return syntaxErrorNode("functionName² [IDENTIFIER¹]");
     276                        return syntaxErrorNode("FuncName² [IDENTIFIER¹]");
    277277                }
    278278       
     
    337337        }
    338338         
    339         public ASTNode parseStatement() {
     339        public ASTNode parseStmt() {
    340340                if( !(nowReading.isLextant(Lextant.IF, Lextant.RETURN, Lextant.VAR, Lextant.WHILE) || (nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
    341                         return syntaxErrorNode("statement² [IDENTIFIER¹, IF¹, RETURN¹, VAR¹, WHILE¹]");
     341                        return syntaxErrorNode("Stmt² [IDENTIFIER¹, IF¹, RETURN¹, VAR¹, WHILE¹]");
    342342                }
    343343       
     
    348348                if( (nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
    349349                        {
    350                                 ASTNode child = parseFunctionInvocationOrAssignmentStatement();
     350                                ASTNode child = parseFuncCallOrAssignmentStmt();
    351351                                result.appendChild(child);
    352352                                allChildren.add(child);
     
    355355                else if( nowReading.isLextant(Lextant.IF) ) {
    356356                        {
    357                                 ASTNode child = parseIfStatement();
     357                                ASTNode child = parseIfStmt();
    358358                                result.appendChild(child);
    359359                                allChildren.add(child);
     
    362362                else if( nowReading.isLextant(Lextant.WHILE) ) {
    363363                        {
    364                                 ASTNode child = parseWhileStatement();
     364                                ASTNode child = parseWhileStmt();
    365365                                result.appendChild(child);
    366366                                allChildren.add(child);
     
    369369                else if( nowReading.isLextant(Lextant.RETURN) ) {
    370370                        {
    371                                 ASTNode child = parseReturnStatement();
     371                                ASTNode child = parseReturnStmt();
    372372                                result.appendChild(child);
    373373                                allChildren.add(child);
     
    390390        }
    391391         
    392         public ASTNode parseFunctionInvocationOrAssignmentStatement() {
     392        public ASTNode parseFuncCallOrAssignmentStmt() {
    393393                if( !((nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
    394                         return syntaxErrorNode("functionInvocationOrAssignmentStatement² [IDENTIFIER¹]");
    395                 }
    396        
    397                 boolean allowCompression = true;
    398                 ASTNode result = new FunctionInvocationOrAssignmentStatementNode(nowReading);
     394                        return syntaxErrorNode("FuncCallOrAssignmentStmt² [IDENTIFIER¹]");
     395                }
     396       
     397                boolean allowCompression = true;
     398                ASTNode result = new FuncCallOrAssignmentStmtNode(nowReading);
    399399                result.setProductionTag(13);
    400400                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     
    406406                if( nowReading.isLextant(Lextant.LROUND) ) {
    407407                        {
    408                                 ASTNode child = parseFunctionInvocationRest();
     408                                ASTNode child = parseFuncCallRest();
    409409                                result.appendChild(child);
    410410                                allChildren.add(child);
     
    429429        }
    430430         
    431         public ASTNode parseFunctionInvocationRest() {
     431        public ASTNode parseFuncCallRest() {
    432432                if( !(nowReading.isLextant(Lextant.LROUND)) ) {
    433                         return syntaxErrorNode("functionInvocationRest² [LROUND¹]");
    434                 }
    435        
    436                 boolean allowCompression = true;
    437                 ASTNode result = new FunctionInvocationNode(nowReading);
     433                        return syntaxErrorNode("FuncCallRest² [LROUND¹]");
     434                }
     435       
     436                boolean allowCompression = true;
     437                ASTNode result = new FuncCallNode(nowReading);
    438438                result.setProductionTag(14);
    439439                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     
    441441                expect(Lextant.LROUND);
    442442                {
    443                         ASTNode child = parseFunctionInvocationArgumentList();
     443                        ASTNode child = parseFuncCallArgList();
    444444                        result.appendChild(child);
    445445                        allChildren.add(child);
     
    452452        }
    453453         
    454         public ASTNode parseFunctionInvocationArgumentList() {
    455                 boolean allowCompression = true;
    456                 ASTNode result = new FunctionInvocationArgumentListNode(nowReading);
     454        public ASTNode parseFuncCallArgList() {
     455                boolean allowCompression = true;
     456                ASTNode result = new FuncCallArgListNode(nowReading);
    457457                result.setProductionTag(15);
    458458                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     
    531531        }
    532532         
    533         public ASTNode parseIfStatement() {
     533        public ASTNode parseIfStmt() {
    534534                if( !(nowReading.isLextant(Lextant.IF)) ) {
    535                         return syntaxErrorNode("ifStatement² [IF¹]");
    536                 }
    537        
    538                 boolean allowCompression = true;
    539                 ASTNode result = new IfStatementNode(nowReading);
     535                        return syntaxErrorNode("ifStmt² [IF¹]");
     536                }
     537       
     538                boolean allowCompression = true;
     539                ASTNode result = new IfStmtNode(nowReading);
    540540                result.setProductionTag(18);
    541541                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     
    549549                expect(Lextant.RROUND);
    550550                {
    551                         ASTNode child = parseBlockStatement();
     551                        ASTNode child = parseBlockStmt();
    552552                        result.appendChild(child);
    553553                        allChildren.add(child);
     
    556556                        expect(Lextant.ELSE);
    557557                        {
    558                                 ASTNode child = parseBlockStatement();
    559                                 result.appendChild(child);
    560                                 allChildren.add(child);
    561                         }
    562                 }
    563                 if(allowCompression) {
    564                         return result;
    565                 }
    566                 return result;
    567         }
    568          
    569         public ASTNode parseWhileStatement() {
     558                                ASTNode child = parseBlockStmt();
     559                                result.appendChild(child);
     560                                allChildren.add(child);
     561                        }
     562                }
     563                if(allowCompression) {
     564                        return result;
     565                }
     566                return result;
     567        }
     568         
     569        public ASTNode parseWhileStmt() {
    570570                if( !(nowReading.isLextant(Lextant.WHILE)) ) {
    571                         return syntaxErrorNode("whileStatement² [WHILE¹]");
    572                 }
    573        
    574                 boolean allowCompression = true;
    575                 ASTNode result = new WhileStatementNode(nowReading);
     571                        return syntaxErrorNode("whileStmt² [WHILE¹]");
     572                }
     573       
     574                boolean allowCompression = true;
     575                ASTNode result = new WhileStmtNode(nowReading);
    576576                result.setProductionTag(19);
    577577                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     
    585585                expect(Lextant.RROUND);
    586586                {
    587                         ASTNode child = parseBlockStatement();
    588                         result.appendChild(child);
    589                         allChildren.add(child);
    590                 }
    591                 if(allowCompression) {
    592                         return result;
    593                 }
    594                 return result;
    595         }
    596          
    597         public ASTNode parseReturnStatement() {
     587                        ASTNode child = parseBlockStmt();
     588                        result.appendChild(child);
     589                        allChildren.add(child);
     590                }
     591                if(allowCompression) {
     592                        return result;
     593                }
     594                return result;
     595        }
     596         
     597        public ASTNode parseReturnStmt() {
    598598                if( !(nowReading.isLextant(Lextant.RETURN)) ) {
    599                         return syntaxErrorNode("returnStatement² [RETURN¹]");
    600                 }
    601        
    602                 boolean allowCompression = true;
    603                 ASTNode result = new ReturnStatementNode(nowReading);
     599                        return syntaxErrorNode("returnStmt² [RETURN¹]");
     600                }
     601       
     602                boolean allowCompression = true;
     603                ASTNode result = new ReturnStmtNode(nowReading);
    604604                result.setProductionTag(20);
    605605                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     
    678678        }
    679679         
    680         public ASTNode parseBlockStatement() {
     680        public ASTNode parseBlockStmt() {
    681681                if( !(nowReading.isLextant(Lextant.LCURLY)) ) {
    682                         return syntaxErrorNode("blockStatement² [LCURLY¹]");
    683                 }
    684        
    685                 boolean allowCompression = true;
    686                 ASTNode result = new BlockStatementNode(nowReading);
     682                        return syntaxErrorNode("blockStmt² [LCURLY¹]");
     683                }
     684       
     685                boolean allowCompression = true;
     686                ASTNode result = new BlockStmtNode(nowReading);
    687687                result.setProductionTag(23);
    688688                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     
    690690                while( nowReading.isLextant(Lextant.IF, Lextant.RETURN, Lextant.VAR, Lextant.WHILE) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
    691691                        {
    692                                 ASTNode child = parseStatement();
     692                                ASTNode child = parseStmt();
    693693                                result.appendChild(child);
    694694                                allChildren.add(child);
     
    825825                        if( nowReading.isLextant(Lextant.LROUND) ) {
    826826                                {
    827                                         ASTNode child = parseFunctionInvocationRest();
     827                                        ASTNode child = parseFuncCallRest();
    828828                                        result.appendChild(child);
    829829                                        allChildren.add(child);
Note: See TracChangeset for help on using the changeset viewer.