Changeset 2969


Ignore:
Timestamp:
Mar 24, 2013, 1:37:28 AM (5 years ago)
Author:
ksherdy
Message:

Minor updates. Partial default stream initializer impl.

Location:
proto/pabloj/trunk/src/pabloS
Files:
1 added
1 deleted
5 edited

Legend:

Unmodified
Added
Removed
  • proto/pabloj/trunk/src/pabloS/ast/ASTTransformer.java

    r2947 r2969  
    5454        public ASTNode visit(ReturnStmtNode node);
    5555
     56        public ASTNode visit(RoundNode node);
     57
    5658        public ASTNode visit(StreamTypeNode node);
    5759
     
    169171                }
    170172
     173                public ASTNode visit(RoundNode node) {
     174                        return defaultVisit(node);
     175                }
     176
    171177                public ASTNode visit(StreamTypeNode node) {
    172178                        return defaultVisit(node);
  • proto/pabloj/trunk/src/pabloS/ast/ASTVisitor.java

    r2947 r2969  
    7777        public T visitLeave(ReturnStmtNode node, List<T> childResults);
    7878
     79        public void visitEnter(RoundNode node);
     80        public T visitLeave(RoundNode node, List<T> childResults);
     81
    7982        public void visitEnter(StreamTypeNode node);
    8083        public T visitLeave(StreamTypeNode node, List<T> childResults);
     
    278281                }
    279282
     283                public void visitEnter(RoundNode node) {
     284                        defaultVisitEnter(node);
     285                }
     286                public T visitLeave(RoundNode node, List<T> childResults) {
     287                        return defaultVisitLeave(node);
     288                }
     289
    280290                public void visitEnter(StreamTypeNode node) {
    281291                        defaultVisitEnter(node);
  • proto/pabloj/trunk/src/pabloS/ast/SimpleVisitor.java

    r2947 r2969  
    5555        public void visit(ReturnStmtNode node);
    5656
     57        public void visit(RoundNode node);
     58
    5759        public void visit(StreamTypeNode node);
    5860
     
    170172                }
    171173
     174                public void visit(RoundNode node) {
     175                        defaultVisit(node);
     176                }
     177
    172178                public void visit(StreamTypeNode node) {
    173179                        defaultVisit(node);
  • proto/pabloj/trunk/src/pabloS/ast/VoidVisitor.java

    r2947 r2969  
    7575        public void visitLeave(ReturnStmtNode node);
    7676
     77        public void visitEnter(RoundNode node);
     78        public void visitLeave(RoundNode node);
     79
    7780        public void visitEnter(StreamTypeNode node);
    7881        public void visitLeave(StreamTypeNode node);
     
    275278                }
    276279
     280                public void visitEnter(RoundNode node) {
     281                        defaultVisitEnter(node);
     282                }
     283                public void visitLeave(RoundNode node) {
     284                        defaultVisitLeave(node);
     285                }
     286
    277287                public void visitEnter(StreamTypeNode node) {
    278288                        defaultVisitEnter(node);
  • proto/pabloj/trunk/src/pabloS/parser/Parser.java

    r2947 r2969  
    368368                expect(Lextant.TERMINATOR);
    369369                if(allowCompression) {
    370                         return result;
     370                        return compressIfPossible(result);
    371371                }
    372372                return result;
     
    382382                result.setProductionTag(12);
    383383                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    384                 result.setToken(nowReading);
    385                 expect(Lextant.LROUND);
    386384                {
    387385                        ASTNode child = parseFuncCallArgList();
     
    397395         
    398396        public ASTNode parseFuncCallArgList() {
     397                if( !(nowReading.isLextant(Lextant.LROUND)) ) {
     398                        return syntaxErrorNode("funcCallArgList² [LROUND¹]");
     399                }
     400       
    399401                boolean allowCompression = true;
    400402                ASTNode result = new FuncCallArgListNode(nowReading);
    401403                result.setProductionTag(13);
    402404                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     405                {
     406                        ASTNode child = parseRound();
     407                        result.appendChild(child);
     408                        allChildren.add(child);
     409                }
    403410                if( nowReading.isLextant(Lextant.LROUND, Lextant.NOT) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) || (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) || (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING)) ) {
    404411                        {
     
    422429        }
    423430         
     431        public ASTNode parseRound() {
     432                if( !(nowReading.isLextant(Lextant.LROUND)) ) {
     433                        return syntaxErrorNode("round² [LROUND¹]");
     434                }
     435       
     436                boolean allowCompression = true;
     437                ASTNode result = new RoundNode(nowReading);
     438                result.setProductionTag(14);
     439                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     440                result.setToken(nowReading);
     441                expect(Lextant.LROUND);
     442                if(allowCompression) {
     443                        return result;
     444                }
     445                return result;
     446        }
     447         
    424448        public ASTNode parseAssignOperator() {
    425449                if( !(nowReading.isLextant(Lextant.AND_ASSIGN, Lextant.ASSIGN, Lextant.OR_ASSIGN, Lextant.XOR_ASSIGN)) ) {
     
    429453                boolean allowCompression = true;
    430454                ASTNode result = new AssignOperatorNode(nowReading);
    431                 result.setProductionTag(14);
     455                result.setProductionTag(15);
    432456                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    433457                if( nowReading.isLextant(Lextant.ASSIGN) ) {
     
    456480                boolean allowCompression = true;
    457481                ASTNode result = new AssignNode(nowReading);
    458                 result.setProductionTag(15);
     482                result.setProductionTag(16);
    459483                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    460484                {
     
    482506                boolean allowCompression = true;
    483507                ASTNode result = new IfStmtNode(nowReading);
    484                 result.setProductionTag(16);
     508                result.setProductionTag(17);
    485509                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    486510                expect(Lextant.IF);
     
    518542                boolean allowCompression = true;
    519543                ASTNode result = new WhileStmtNode(nowReading);
    520                 result.setProductionTag(17);
     544                result.setProductionTag(18);
    521545                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    522546                expect(Lextant.WHILE);
     
    546570                boolean allowCompression = true;
    547571                ASTNode result = new ReturnStmtNode(nowReading);
    548                 result.setProductionTag(18);
     572                result.setProductionTag(19);
    549573                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    550574                expect(Lextant.RETURN);
     
    570594                boolean allowCompression = true;
    571595                ASTNode result = new LocalVarDeclNode(nowReading);
    572                 result.setProductionTag(19);
     596                result.setProductionTag(20);
    573597                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    574598                expect(Lextant.VAR);
     
    609633                boolean allowCompression = true;
    610634                ASTNode result = new LocalVarAssignOperatorNode(nowReading);
    611                 result.setProductionTag(20);
     635                result.setProductionTag(21);
    612636                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    613637                expect(Lextant.ASSIGN);
     
    625649                boolean allowCompression = true;
    626650                ASTNode result = new ASTNode(nowReading);
    627                 result.setProductionTag(21);
     651                result.setProductionTag(22);
    628652                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    629653                {
     
    645669                boolean allowCompression = true;
    646670                ASTNode result = new BlockStmtNode(nowReading);
    647                 result.setProductionTag(22);
     671                result.setProductionTag(23);
    648672                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    649673                expect(Lextant.LCURLY);
     
    669693                boolean allowCompression = true;
    670694                ASTNode result = new BinaryOperatorNode(nowReading);
    671                 result.setProductionTag(23);
     695                result.setProductionTag(24);
    672696                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    673697                {
     
    704728                boolean allowCompression = true;
    705729                ASTNode result = new BinaryOperatorNode(nowReading);
    706                 result.setProductionTag(24);
     730                result.setProductionTag(25);
    707731                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    708732                {
     
    733757                boolean allowCompression = true;
    734758                ASTNode result = new UnaryOperatorNode(nowReading);
    735                 result.setProductionTag(25);
     759                result.setProductionTag(26);
    736760                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    737761                if( nowReading.isLextant(Lextant.NOT) ) {
     
    759783                boolean allowCompression = true;
    760784                ASTNode result = new ASTNode(nowReading);
    761                 result.setProductionTag(26);
     785                result.setProductionTag(27);
    762786                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    763787                if( nowReading.isLextant(Lextant.LROUND) ) {
     
    813837                boolean allowCompression = true;
    814838                ASTNode result = new ASTNode(nowReading);
    815                 result.setProductionTag(27);
     839                result.setProductionTag(28);
    816840                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    817841                if( (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING)) ) {
     
    842866                boolean allowCompression = true;
    843867                ASTNode result = new IntegerConstantNode(nowReading);
    844                 result.setProductionTag(28);
     868                result.setProductionTag(29);
    845869                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    846870                if( !(nowReading.isLexicalType(LexicalType.INTEGER_CONST)) ) {
     
    868892                boolean allowCompression = true;
    869893                ASTNode result = new StringConstantNode(nowReading);
    870                 result.setProductionTag(29);
     894                result.setProductionTag(30);
    871895                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    872896                if( (nowReading.isLexicalType(LexicalType.STRING)) ) {
     
    895919                boolean allowCompression = true;
    896920                ASTNode result = new CompoundIdentifierNode(nowReading);
    897                 result.setProductionTag(30);
     921                result.setProductionTag(31);
    898922                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    899923                {
     
    924948                boolean allowCompression = true;
    925949                ASTNode result = new IdentifierNode(nowReading);
    926                 result.setProductionTag(31);
     950                result.setProductionTag(32);
    927951                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    928952                if( !(nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
     
    943967                boolean allowCompression = true;
    944968                ASTNode result = new ASTNode(nowReading);
    945                 result.setProductionTag(32);
     969                result.setProductionTag(33);
    946970                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    947971                if( nowReading.isLextant(Lextant.STREAM) ) {
     
    9861010                boolean allowCompression = true;
    9871011                ASTNode result = new StreamTypeNode(nowReading);
    988                 result.setProductionTag(33);
     1012                result.setProductionTag(34);
    9891013                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    9901014                expect(Lextant.STREAM);
     
    10111035                boolean allowCompression = true;
    10121036                ASTNode result = new FieldWidthNode(nowReading);
    1013                 result.setProductionTag(34);
     1037                result.setProductionTag(35);
    10141038                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    10151039                {
     
    10311055                boolean allowCompression = true;
    10321056                ASTNode result = new ASTNode(nowReading);
    1033                 result.setProductionTag(35);
     1057                result.setProductionTag(36);
    10341058                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    10351059                {
     
    10511075                boolean allowCompression = true;
    10521076                ASTNode result = new StructTypeNode(nowReading);
    1053                 result.setProductionTag(36);
     1077                result.setProductionTag(37);
    10541078                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    10551079                expect(Lextant.STRUCT);
     
    10791103                boolean allowCompression = true;
    10801104                ASTNode result = new ASTNode(nowReading);
    1081                 result.setProductionTag(37);
     1105                result.setProductionTag(38);
    10821106                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    10831107                {
     
    10991123                boolean allowCompression = true;
    11001124                ASTNode result = new StructTypeBodyNode(nowReading);
    1101                 result.setProductionTag(38);
     1125                result.setProductionTag(39);
    11021126                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    11031127                expect(Lextant.LCURLY);
     
    11301154                boolean allowCompression = true;
    11311155                ASTNode result = new StructMemberNode(nowReading);
    1132                 result.setProductionTag(39);
     1156                result.setProductionTag(40);
    11331157                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    11341158                {
     
    11551179                boolean allowCompression = true;
    11561180                ASTNode result = new ASTNode(nowReading);
    1157                 result.setProductionTag(40);
     1181                result.setProductionTag(41);
    11581182                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    11591183                {
     
    11751199                boolean allowCompression = true;
    11761200                ASTNode result = new VoidNode(nowReading);
    1177                 result.setProductionTag(41);
     1201                result.setProductionTag(42);
    11781202                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    11791203                expect(Lextant.VOID);
Note: See TracChangeset for help on using the changeset viewer.