Changeset 2609


Ignore:
Timestamp:
Nov 5, 2012, 1:06:47 PM (6 years ago)
Author:
ksherdy
Message:

Check in all minor changes prior to grammar update.

Location:
proto/pablo
Files:
1 added
9 edited

Legend:

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

    r2608 r2609  
    115115        statement                                                       #-> (functionInvocationOrAssignmentStatement | ifStatement | whileStatement | returnStatement | localVarDecl) (TERMINATOR)? ;
    116116                       
    117         functionInvocationOrAssignmentStatement -> compoundVariable ((functionInvocation _promote_) | (assignmentStatementRest _promote_)) TERMINATOR ;
    118                
    119         functionInvocation                                              #-> functionInvocationRest;
     117        functionInvocationOrAssignmentStatement -> compoundVariable ((functionInvocationRest _promote_) | (assignmentStatementRest _promote_)) TERMINATOR ;
     118       
     119//      functionInvocationRest                          -> LROUND^ functionInvocationArgumentsList RROUND ;
     120       
     121        functionInvocationRest                          -> LROUND^ (expression (COMMA expression)*)? RROUND ;
     122
     123        functionInvocationArgumentsList         -> (expression (COMMA expression)*)? ; 
    120124               
    121125        assignmentOperator                                      -> ASSIGN | AND_ASSIGN | OR_ASSIGN | XOR_ASSIGN ;                               
     
    123127        assignmentStatementRest                         -> assignmentOperator^! expression ;                           
    124128                                       
    125         ifStatement                                                     -> IF LROUND expression RROUND blockStatement ; // (ELSE blockStatement)? ; // TODO - Support else?                     
     129        ifStatement                                                     -> IF LROUND expression RROUND blockStatement ; // (ELSE blockStatement)?                      
    126130                                                       
    127131        whileStatement                                          -> WHILE LROUND expression RROUND blockStatement ;
     
    157161                                                //)?
    158162                                                // ;
    159                                        
    160163                                                //expression4            -> DOT expression3 ;
    161164                                                //expression5    -> (LSQUARE INTEGER_CONST^ RSQUARE) (expression5Rest)?   ;     
    162165                                                //expression5Rest        -> DOT expression3 ;                                                                                           
    163                                                                                                                                                                                
    164         functionInvocationRest -> LROUND^ (expression (COMMA expression)*)? RROUND ; //(expression5Rest)?;                                             
    165                                                        
     166                                                                                                                                                                                                                                                                       
    166167        constant                                #-> stringConstant | signedIntegerConstant ;
    167168       
  • proto/pablo/input/test/pablo/funcDef/funcDef1.pablo

    r2608 r2609  
    1 struct Lex {
    2         stream b;
    3 };
    4 
    5 struct Lex {
    6         stream b;
    7         stream<1> d;
    8 };
    9 
    101function struct Lex ClassifyBytes(stream<1> a, stream b) {
    112
    12         i = 0;
    13         i &= 0;
    14         var stream j |= j;
    15 
    16         if(a) {
    17 
    18         }
    19        
     3        i = foo(a);     
    204};
  • proto/pablo/src/ast/ASTTransformer.java

    r2608 r2609  
    3434        public ASTNode visit(FunctionDefNode node);
    3535
     36        public ASTNode visit(FunctionInvocationArgumentsListNode node);
     37
    3638        public ASTNode visit(FunctionInvocationStatementNode node);
    3739
     
    127129                }
    128130
     131                public ASTNode visit(FunctionInvocationArgumentsListNode node) {
     132                        return defaultVisit(node);
     133                }
     134
    129135                public ASTNode visit(FunctionInvocationStatementNode node) {
    130136                        return defaultVisit(node);
  • proto/pablo/src/ast/ASTVisitor.java

    r2608 r2609  
    4747        public T visitLeave(FunctionDefNode node, List<T> childResults);
    4848
     49        public void visitEnter(FunctionInvocationArgumentsListNode node);
     50        public T visitLeave(FunctionInvocationArgumentsListNode node, List<T> childResults);
     51
    4952        public void visitEnter(FunctionInvocationStatementNode node);
    5053        public T visitLeave(FunctionInvocationStatementNode node, List<T> childResults);
     
    205208                }
    206209
     210                public void visitEnter(FunctionInvocationArgumentsListNode node) {
     211                        defaultVisitEnter(node);
     212                }
     213                public T visitLeave(FunctionInvocationArgumentsListNode node, List<T> childResults) {
     214                        return defaultVisitLeave(node);
     215                }
     216
    207217                public void visitEnter(FunctionInvocationStatementNode node) {
    208218                        defaultVisitEnter(node);
  • proto/pablo/src/ast/SimpleVisitor.java

    r2608 r2609  
    3535        public void visit(FunctionDefNode node);
    3636
     37        public void visit(FunctionInvocationArgumentsListNode node);
     38
    3739        public void visit(FunctionInvocationStatementNode node);
    3840
     
    128130                }
    129131
     132                public void visit(FunctionInvocationArgumentsListNode node) {
     133                        defaultVisit(node);
     134                }
     135
    130136                public void visit(FunctionInvocationStatementNode node) {
    131137                        defaultVisit(node);
  • proto/pablo/src/ast/VoidVisitor.java

    r2608 r2609  
    4545        public void visitLeave(FunctionDefNode node);
    4646
     47        public void visitEnter(FunctionInvocationArgumentsListNode node);
     48        public void visitLeave(FunctionInvocationArgumentsListNode node);
     49
    4750        public void visitEnter(FunctionInvocationStatementNode node);
    4851        public void visitLeave(FunctionInvocationStatementNode node);
     
    202205                }
    203206
     207                public void visitEnter(FunctionInvocationArgumentsListNode node) {
     208                        defaultVisitEnter(node);
     209                }
     210                public void visitLeave(FunctionInvocationArgumentsListNode node) {
     211                        defaultVisitLeave(node);
     212                }
     213
    204214                public void visitEnter(FunctionInvocationStatementNode node) {
    205215                        defaultVisitEnter(node);
  • proto/pablo/src/compiler/ast/Accessors.java

    r2608 r2609  
    3737       
    3838        ////////////////////////////////////////////////////////////////////////////
     39        // Function Invocation Statements
     40        ////////////////////////////////////////////////////////////////////////////                           
     41
     42        public static String assignmentOperator(FunctionInvocationStatementNode node) {
     43                return node.getToken().getLexeme();
     44        }       
     45       
     46        ////////////////////////////////////////////////////////////////////////////
    3947        // Local Variable Declaration Statements
    4048        ////////////////////////////////////////////////////////////////////////////                           
    41        
    4249        public static ASTNode lhs(LocalVarDeclNode node) {
    4350                return node.child(1);
     
    5360       
    5461        public static boolean hasInitializationAssignment(LocalVarDeclNode node) {
    55                 return (node.nChildren() > 2);
     62                return (node.nChildren() > 2); // TODO - improve test
    5663        }
    5764       
  • proto/pablo/src/compiler/visitors/CPPCodeGenerator.java

    r2608 r2609  
    102102        // Statements
    103103        ////////////////////////////////////////////////////////////////////////////   
     104       
     105        // assignment statement
    104106        public CodeStore visitLeave(AssignmentStatementNode node, List<CodeStore> childResults) {
    105107                CodeStore code = new CodeStore();
    106108                CodeStore lhs = childResults.get(0);
    107109                CodeStore rhs = childResults.get(1);
    108                 code.addFormattedLine("%s %s %s;",lhs.getResultVariableName()
    109                                                                                  ,node.getToken().getLexeme()
    110                                                                                  ,rhs.getResultVariableName());
    111                
    112                 return code;
    113         }
    114        
    115        
    116 
     110                code.addFormattedLine("%s %s %s;", lhs.getResultVariableName()
     111                                                                                 , Accessors.assignmentOperator(node)
     112                                                                                 , rhs.getResultVariableName());
     113               
     114                return code;
     115        }
     116
     117        // function invocation statement
     118        public CodeStore visitLeave(FunctionInvocationStatementNode node, List<CodeStore> childResults) {
     119                CodeStore code = new CodeStore();
     120                CodeStore lhs = childResults.get(0);
     121                CodeStore rhs = childResults.get(1);
     122                code.addFormattedLine("%s %s %s;", lhs.getResultVariableName()
     123                                                                                 , Accessors.assignmentOperator(node)
     124                                                                                 ,"rhs.getResultVariableName()");
     125               
     126                return code;
     127        }       
     128       
    117129        // if statement
    118130        public CodeStore visitLeave(IfStatementNode node, List<CodeStore> childResults) {
     
    139151        // variable declarations list
    140152        public CodeStore visitLeave(LocalVarDeclListNode node, List<CodeStore> childResults) {
    141                 // TODO
     153                // TODO - implement
    142154                return concatenatedChildrenCode(new CodeStore(), childResults, true);
    143155        }       
     
    150162                CodeStore type                                  = (CodeStore)childResults.get(0);
    151163                CodeStore identifier                    = (CodeStore)childResults.get(1);
    152                 //CodeStore assignmentOperator  = //(CodeStore)childResults.get(2);
    153164                CodeStore expression                    = (CodeStore)childResults.get(2);
    154165               
     
    159170                                                                expression.getResultVariableName());
    160171                return code;           
    161                
    162172        }       
    163173       
  • proto/pablo/src/parser/Parser.java

    r2608 r2609  
    397397                if( nowReading.isLextant(Lextant.LROUND) ) {
    398398                        {
    399                                 ASTNode child = parseFunctionInvocation();
     399                                ASTNode child = parseFunctionInvocationRest();
    400400                                result.appendChild(child);
    401401                                allChildren.add(child);
     
    420420        }
    421421         
    422         public ASTNode parseFunctionInvocation() {
     422        public ASTNode parseFunctionInvocationRest() {
    423423                if( !(nowReading.isLextant(Lextant.LROUND)) ) {
    424                         return syntaxErrorNode("functionInvocation² [LROUND¹]");
    425                 }
    426        
    427                 boolean allowCompression = true;
    428                 ASTNode result = new ASTNode(nowReading);
     424                        return syntaxErrorNode("functionInvocationRest² [LROUND¹]");
     425                }
     426       
     427                boolean allowCompression = true;
     428                ASTNode result = new FunctionInvocationStatementNode(nowReading);
    429429                result.setProductionTag(14);
    430430                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    431                 {
    432                         ASTNode child = parseFunctionInvocationRest();
    433                         result.appendChild(child);
    434                         allChildren.add(child);
    435                 }
    436                 if(allowCompression) {
    437                         return compressIfPossible(result);
     431                result.setToken(nowReading);
     432                expect(Lextant.LROUND);
     433                if( nowReading.isLextant(Lextant.LROUND, Lextant.MINUS, Lextant.NOT) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) || (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) || (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING)) ) {
     434                        {
     435                                ASTNode child = parseExpression();
     436                                result.appendChild(child);
     437                                allChildren.add(child);
     438                        }
     439                        while( nowReading.isLextant(Lextant.COMMA) ) {
     440                                expect(Lextant.COMMA);
     441                                {
     442                                        ASTNode child = parseExpression();
     443                                        result.appendChild(child);
     444                                        allChildren.add(child);
     445                                }
     446                        }
     447                }
     448                expect(Lextant.RROUND);
     449                if(allowCompression) {
     450                        return result;
     451                }
     452                return result;
     453        }
     454         
     455        public ASTNode parseFunctionInvocationArgumentsList() {
     456                boolean allowCompression = true;
     457                ASTNode result = new FunctionInvocationArgumentsListNode(nowReading);
     458                result.setProductionTag(15);
     459                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     460                if( nowReading.isLextant(Lextant.LROUND, Lextant.MINUS, Lextant.NOT) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) || (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) || (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING)) ) {
     461                        {
     462                                ASTNode child = parseExpression();
     463                                result.appendChild(child);
     464                                allChildren.add(child);
     465                        }
     466                        while( nowReading.isLextant(Lextant.COMMA) ) {
     467                                expect(Lextant.COMMA);
     468                                {
     469                                        ASTNode child = parseExpression();
     470                                        result.appendChild(child);
     471                                        allChildren.add(child);
     472                                }
     473                        }
     474                }
     475                if(allowCompression) {
     476                        return result;
    438477                }
    439478                return result;
     
    447486                boolean allowCompression = true;
    448487                ASTNode result = new AssignmentOperatorNode(nowReading);
    449                 result.setProductionTag(15);
     488                result.setProductionTag(16);
    450489                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    451490                if( nowReading.isLextant(Lextant.ASSIGN) ) {
     
    474513                boolean allowCompression = true;
    475514                ASTNode result = new AssignmentStatementNode(nowReading);
    476                 result.setProductionTag(16);
     515                result.setProductionTag(17);
    477516                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    478517                {
     
    500539                boolean allowCompression = true;
    501540                ASTNode result = new IfStatementNode(nowReading);
    502                 result.setProductionTag(17);
     541                result.setProductionTag(18);
    503542                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    504543                expect(Lextant.IF);
     
    528567                boolean allowCompression = true;
    529568                ASTNode result = new WhileStatementNode(nowReading);
    530                 result.setProductionTag(18);
     569                result.setProductionTag(19);
    531570                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    532571                expect(Lextant.WHILE);
     
    556595                boolean allowCompression = true;
    557596                ASTNode result = new ReturnStatementNode(nowReading);
    558                 result.setProductionTag(19);
     597                result.setProductionTag(20);
    559598                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    560599                expect(Lextant.RETURN);
     
    580619                boolean allowCompression = true;
    581620                ASTNode result = new LocalVarDeclNode(nowReading);
    582                 result.setProductionTag(20);
     621                result.setProductionTag(21);
    583622                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    584623                expect(Lextant.VAR);
     
    619658                boolean allowCompression = true;
    620659                ASTNode result = new ASTNode(nowReading);
    621                 result.setProductionTag(21);
     660                result.setProductionTag(22);
    622661                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    623662                {
     
    639678                boolean allowCompression = true;
    640679                ASTNode result = new BlockStatementNode(nowReading);
    641                 result.setProductionTag(22);
     680                result.setProductionTag(23);
    642681                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    643682                expect(Lextant.LCURLY);
     
    663702                boolean allowCompression = true;
    664703                ASTNode result = new BinaryOperatorNode(nowReading);
    665                 result.setProductionTag(23);
     704                result.setProductionTag(24);
    666705                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    667706                {
     
    698737                boolean allowCompression = true;
    699738                ASTNode result = new BinaryOperatorNode(nowReading);
    700                 result.setProductionTag(24);
     739                result.setProductionTag(25);
    701740                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    702741                {
     
    727766                boolean allowCompression = true;
    728767                ASTNode result = new UnaryOperatorNode(nowReading);
    729                 result.setProductionTag(25);
     768                result.setProductionTag(26);
    730769                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    731770                if( nowReading.isLextant(Lextant.NOT) ) {
     
    753792                boolean allowCompression = true;
    754793                ASTNode result = new ASTNode(nowReading);
    755                 result.setProductionTag(26);
     794                result.setProductionTag(27);
    756795                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    757796                if( nowReading.isLextant(Lextant.LROUND) ) {
     
    789828                if(allowCompression) {
    790829                        return compressIfPossible(result);
    791                 }
    792                 return result;
    793         }
    794          
    795         public ASTNode parseFunctionInvocationRest() {
    796                 if( !(nowReading.isLextant(Lextant.LROUND)) ) {
    797                         return syntaxErrorNode("functionInvocationRest² [LROUND¹]");
    798                 }
    799        
    800                 boolean allowCompression = true;
    801                 ASTNode result = new FunctionInvocationStatementNode(nowReading);
    802                 result.setProductionTag(27);
    803                 RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    804                 result.setToken(nowReading);
    805                 expect(Lextant.LROUND);
    806                 if( nowReading.isLextant(Lextant.LROUND, Lextant.MINUS, Lextant.NOT) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) || (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) || (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING)) ) {
    807                         {
    808                                 ASTNode child = parseExpression();
    809                                 result.appendChild(child);
    810                                 allChildren.add(child);
    811                         }
    812                         while( nowReading.isLextant(Lextant.COMMA) ) {
    813                                 expect(Lextant.COMMA);
    814                                 {
    815                                         ASTNode child = parseExpression();
    816                                         result.appendChild(child);
    817                                         allChildren.add(child);
    818                                 }
    819                         }
    820                 }
    821                 expect(Lextant.RROUND);
    822                 if(allowCompression) {
    823                         return result;
    824830                }
    825831                return result;
Note: See TracChangeset for help on using the changeset viewer.