Changeset 2815


Ignore:
Timestamp:
Jan 18, 2013, 4:45:35 PM (6 years ago)
Author:
ksherdy
Message:

Added distinct stream constant type vs. integer constant type. Additional type system design required.

Location:
proto/pablo
Files:
2 added
22 edited

Legend:

Unmodified
Added
Removed
  • proto/pablo/.classpath

    r2654 r2815  
    33        <classpathentry kind="src" path="src"/>
    44        <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6"/>
    5         <classpathentry kind="lib" path="/home/ken/workspace/pablo/ext/lib/commons-cli-1.2.jar"/>
     5        <classpathentry kind="lib" path="ext/lib/commons-cli-1.2.jar"/>
    66        <classpathentry kind="output" path="bin"/>
    77</classpath>
  • proto/pablo/input/grammar/scatter/pabloB.scatter

    r2809 r2815  
    55// PabloBlock (block-at-a-time language)
    66//
    7 // TODO - Support '+','-'
    8 //
    9 //
     7// COMMENTS -   
     8//
     9//                      PabloB expression evaluate to types ? -> Add type checking support.
     10//                      Add support for a boolean type.
     11//
     12//
     13// TODO -       
     14//                      Add support for IDISA operations.
     15//                      Add support for '+', '-'.
     16//                      Extend integer type system to include int8, int16, int32, int64, int128, int256 types.
     17//                      Stream constant type.
     18//                      Map PabloS builtins to PabloB equivalents. Effectively expand PabloS macros to support an optimization pass the
     19//                      PabloB intermediate language level.
     20//             
    1021//
    1122context main {
     
    7586  funcCall {} [funcCallRest],
    7687  integerConstant{intValued;} [],
     88  streamConstant{intValued;} [],
    7789}
    7890
     
    115127        stateSize                       ->  integerConstant ;
    116128       
    117         //stateInitList         ->      integerConstant (COMMA integerConstant)* ;
    118        
    119         stateInitList           ->      streamType (COMMA streamType)* ;
     129        stateInitList           ->      integerConstant (COMMA integerConstant)* ; // a carry constant of intX type
     130       
     131        //stateInitList         ->      streamType (COMMA streamType)* ;
    120132       
    121133        // k e r n e l   f u n c t i o n s
     
    175187       
    176188        expr3           #-> LROUND expr RROUND
    177                                         | constant
     189                                        | streamConstant
     190                                        | stringConstant
    178191                                        | compoundIdentifier (funcCallRest _promote_)?
    179192                                        ;
    180193                                                                                                                                                                                       
    181         constant                                #-> stringConstant | signedIntegerConstant ;
     194        constant                                #->  stringConstant | signedIntegerConstant | streamConstant ; 
     195       
     196        streamConstant                  -> INTEGER_CONST {@value = @@value;} ;
    182197       
    183198        signedIntegerConstant   #-> MINUS integerConstant {@:value = 0 - @:value;}
  • proto/pablo/input/grammar/scatter/pabloS.scatter

    r2809 r2815  
    6969  funcCall {} [funcCallRest],
    7070  integerConstant{intValued;} [],
     71  streamConstant{intValued;} [],
    7172}
    7273
     
    148149       
    149150        expr3           #-> LROUND expr RROUND
    150                                         | constant
     151                                        | streamConstant
     152                                        | stringConstant
    151153                                        | compoundIdentifier (funcCallRest _promote_)?
    152154                                        ;
     
    164166        constant                                #-> stringConstant | signedIntegerConstant ;
    165167       
     168        streamConstant                  -> INTEGER_CONST {@value = @@value;} ;
     169       
    166170        signedIntegerConstant   #-> MINUS integerConstant {@:value = 0 - @:value;}
    167171                                            | integerConstant ;
    168172                                           
    169         integerConstant                 -> INTEGER_CONST {@value = @@value;} ;
     173        integerConstant                 -> INTEGER_CONST {@value = @@value;} ; 
    170174       
    171175        stringConstant                  -> STRING | SQ_STRING ;
  • proto/pablo/input/test/pabloB/kernelDef/kernelDel1.pablob

    r2809 r2815  
    1111        function void do_block ()
    1212        {
    13                 a.a = call();
     13                var stream s = 0;
    1414        }
    1515
  • proto/pablo/output/cpplang/pablo_definitions.hpp

    r2809 r2815  
    650650                        while (bitblock::any(CtCDPI_Cursor))
    651651                        {
    652                                 LocalCarryDeclare("cq", 13);
     652                                LocalCarryDeclare(subcarryQ, 13);
    653653                                CtCDPI_starts = simd_or(CtCDPI_starts, CtCDPI_Cursor);
    654654                                BitBlock PI_Cursor = simd_and(CtCDPI_Cursor, PI_opener);
     
    702702                                }
    703703                                CtCDPI_Cursor = subcarryQ.BitBlock_scanthru_ci_co(CtCDPI_Cursor, CtCDPI_opener, 0, 12);
    704                                 CarryCombine("subcarryQ", 3, 13);
     704                                carryQ.CarryCombine(subcarryQ.cq, 3, 13);
    705705                        }
    706706                }
     
    817817                        while (bitblock::any(simd_and(CtCDPI_Cursor, EOF_mask)))
    818818                        {
    819                                 LocalCarryDeclare("cq", 13);
     819                                LocalCarryDeclare(subcarryQ, 13);
    820820                                CtCDPI_starts = simd_or(CtCDPI_starts, CtCDPI_Cursor);
    821821                                BitBlock PI_Cursor = simd_and(CtCDPI_Cursor, PI_opener);
     
    869869                                }
    870870                                CtCDPI_Cursor = subcarryQ.BitBlock_scanthru_ci_co(CtCDPI_Cursor, simd_andc(CtCDPI_opener, EOF_mask), 0, 12);
    871                                 CarryCombine("subcarryQ", 3, 13);
     871                                carryQ.CarryCombine(subcarryQ.cq, 3, 13);
    872872                        }
    873873                }
     
    954954                                while (bitblock::any(AttNameStart))
    955955                                {
    956                                         LocalCarryDeclare("cq", 7);
     956                                        LocalCarryDeclare(subcarryQ, 7);
    957957                                        ParseError = simd_or(ParseError, simd_andc(AttNameStart, lex.NameScan));
    958958                                        tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts, AttNameStart);
     
    990990                                        }
    991991                                        ParseError = simd_or(ParseError, simd_and(AttValFollow, AttNameStart));
    992                                         CarryCombine("subcarryQ", 2, 7);
     992                                        carryQ.CarryCombine(subcarryQ.cq, 2, 7);
    993993                                }
    994994                        }
     
    10861086                                while (bitblock::any(simd_and(AttNameStart, EOF_mask)))
    10871087                                {
    1088                                         LocalCarryDeclare("cq", 7);
     1088                                        LocalCarryDeclare(subcarryQ, 7);
    10891089                                        ParseError = simd_or(ParseError, simd_andc(AttNameStart, lex.NameScan));
    10901090                                        tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts, AttNameStart);
     
    11221122                                        }
    11231123                                        ParseError = simd_or(ParseError, simd_and(AttValFollow, AttNameStart));
    1124                                         CarryCombine("subcarryQ", 2, 7);
     1124                                        carryQ.CarryCombine(subcarryQ.cq, 2, 7);
    11251125                                }
    11261126                        }
  • proto/pablo/src/compiler/ast/pabloB/Accessors.java

    r2809 r2815  
    169169
    170170        ////////////////////////////////////////////////////////////////////////////
     171        // Integer Constant
     172        ////////////////////////////////////////////////////////////////////////////           
     173        public static String streamConstantLexeme(StreamConstantNode node) {
     174                return node.getToken().getLexeme();
     175        }               
     176       
     177        ////////////////////////////////////////////////////////////////////////////
    171178        // String Constant
    172179        ////////////////////////////////////////////////////////////////////////////           
  • proto/pablo/src/compiler/ast/pabloS/Accessors.java

    r2809 r2815  
    153153        }                       
    154154
     155        ////////////////////////////////////////////////////////////////////////////
     156        // Integer Constant
     157        ////////////////////////////////////////////////////////////////////////////           
     158        public static String streamConstantLexeme(StreamConstantNode node) {
     159                return node.getToken().getLexeme();
     160        }                       
     161               
    155162        ////////////////////////////////////////////////////////////////////////////
    156163        // String Constant
  • proto/pablo/src/compiler/codeGenerator/visitors/CPPUnparser.java

    r2809 r2815  
    465465        }
    466466       
     467        ////////////////////////////////////////////////////////////////////////////
     468        // StreamConstant
     469        ////////////////////////////////////////////////////////////////////////////
     470        public CodeStore visitLeave(StreamConstantNode node, List<CodeStore> childResults) {
     471        CodeStore code = new CodeStore();
     472        code.setResultVarName(Accessors.streamConstantLexeme(node));
     473        return code;
     474        }
     475       
    467476       
    468477        ////////////////////////////////////////////////////////////////////////////
  • proto/pablo/src/compiler/transformer/visitors/Bitwise2IDISAXFormer.java

    r2804 r2815  
    106106                }
    107107                */
     108               
     109                /*
    108110                public void visitLeave(LocalVarDeclNode node) {
    109111                        if(Accessors.hasInitializationAssign(node)) {
     
    112114                        }
    113115                }
    114 
    115                 public void visitLeave(AssignNode node) {
    116                         ASTNode rhs = Accessors.rhs(node);
    117                         integerConstant2IDISA(node, rhs);
     116                */
     117               
     118                public void visitLeave(StreamConstantNode node) {
     119                        streamConstant2IDISA(node);
    118120                }
    119121               
    120                 private void integerConstant2IDISA(ASTNode node, ASTNode rhs) {
    121                         if(rhs instanceof IntegerConstantNode) {
     122                // public void visitLeave()
     123               
     124                private void streamConstant2IDISA(ASTNode node) {
     125                        if(node instanceof StreamConstantNode) {
    122126                       
    123                                 int constantValue = ((IntegerConstantNode) rhs).getValue();
     127                                int value = ((StreamConstantNode) node).getValue();
    124128                               
    125                                 if(constantValue == 0 || constantValue == -1) {
     129                                if(value == 0 || value == -1) {
    126130                                       
    127131                                        int fieldWidth = 1;
    128                                         int constant = -1 * constantValue;
     132                                        int constant = -1 * value;
    129133                                       
    130134                                        String name = SIMD.CONSTANT.idisaConstantName(fieldWidth, constant);
    131                                         FuncCallNode FuncCallNode = Generators.makeFuncCallNode(name, node.getToken());
    132                                         rhs.updateSelf(FuncCallNode);
     135                                        FuncCallNode funcCallNode = Generators.makeFuncCallNode(name, node.getToken());
     136                                        node.updateSelf(funcCallNode);
    133137                                }
    134138                        }
  • proto/pablo/src/compiler/transformer/visitors/CarryInfoSetVisitor.java

    r2809 r2815  
    5151                        if(BuiltinsUtil.isCarryN(node)) {
    5252                                List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
    53                                 String value = Accessors.integerConstantLexeme((IntegerConstantNode)arguments.get(1));
     53                                String value = Accessors.streamConstantLexeme((StreamConstantNode)arguments.get(1));
    5454                                ((CarryInfoSetSymbol)symbolTable.get(key)).addCarryN(Integer.parseInt(value));
    5555                        }
  • proto/pablo/src/compiler/transformer/visitors/CarryIntroXFormer.java

    r2809 r2815  
    228228                        } else {
    229229                                carryCall = Generators.makeIntegerConstantNode(0, node.getToken());
     230                               
    230231                                advNCall = Generators.makeIntegerConstantNode(0, node.getToken());
    231232                        }
     
    461462                               
    462463                                ASTNode formatValue = Accessors.funcCallArg(node, 1);
    463                                 String value = Accessors.integerConstantLexeme((IntegerConstantNode)formatValue);
     464                                String value = Accessors.streamConstantLexeme((StreamConstantNode)formatValue);
    464465                               
    465466                                List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
     
    611612                        IntegerConstantNode carryCountNode      =  Generators.makeIntegerConstantNode(carryCount, node.getToken());
    612613                       
    613                         StringConstantNode localCarryId                         
    614                                         = Generators.makeStringConstantNode(CarrySetBuiltins2Lang.LOCALCARRYQARRAYNAME, node.getToken());
    615                        
     614                        // TODO - Update to Compound Variable
     615                       
     616                        IdentifierNode localCarryId                     
     617                                        = Generators.makeIdentifierNode(CarrySetBuiltins2Lang.LOCALCARRYQNAME, node.getToken());
     618                       
     619                        CompoundIdentifierNode localCarryQArrayQName =
     620                                        Generators.makeCompoundIdentifierNode(new String [] {CarrySetBuiltins2Lang.LOCALCARRYQNAME,
     621                                                                                                                                                        CarrySetBuiltins2Lang.LOCALCARRYQARRAYNAME},
     622                                                                                                                                                        node.getToken());
     623                       
     624                        /*
     625
    616626                        StringConstantNode localCarryQArrayQName       
    617                                         = Generators.makeStringConstantNode(CarrySetBuiltins2Lang.LOCALCARRYQNAME, node.getToken());
    618                        
     627                                        = Generators.makeStringConstantNode(
     628                                                        CarrySetBuiltins2Lang.LOCALCARRYQNAME
     629                                                        + "."
     630                                                        + CarrySetBuiltins2Lang.LOCALCARRYQARRAYNAME,
     631                                                        node.getToken());
     632                        */
    619633
    620634                        //          inner_while = CarryIntro(local_carryvar, '', self.carryout).generic_xfrm(copy.deepcopy(whileNode))
     
    645659
    646660                        FuncCallNode carryCombine = (FuncCallNode) Generators.makeFuncCallNode(
    647                                         carrySet2Lang.getCode(CarrySetBuiltins.CARRYCOMBINE),
     661                                        new String [] { CarrySetBuiltins2Lang.CARRYQNAME,
     662                                        carrySet2Lang.getCode(CarrySetBuiltins.CARRYCOMBINE)},
    648663                                        node.getToken(),
    649664                                        new ASTNode [] {localCarryQArrayQName, carryBaseNode, carryCountNode});
  • proto/pablo/src/compiler/transformer/visitors/PabloS2PabloBXFormer.java

    r2809 r2815  
    66
    77import compiler.ast.pabloB.Generators;
    8 import compiler.lang.carry.CarryInfoSet;
    98import compiler.lang.carry.CarrySetBuiltins;
    109import compiler.lang.carry.CarrySetBuiltins2Lang;
    11 import compiler.lang.pabloS.Builtins2Lang;
    1210import compiler.symbols.CarryInfoSetSymbol;
    1311import compiler.symbols.SymbolTable;
    1412import pabloB.ast.AssignNode;
    15 import pabloB.ast.StateInitStmtNode;
    1613import pabloB.ast.ASTNode;
    1714import pabloB.ast.FuncCallNode;
     
    113110                                if(carry1Array[i] > 0) {
    114111                                       
    115                                                 String carryFlipArrayExpr = String.format(carrySet2Lang.LOCALCARRYQARRAYNAME + "[%s]", Integer.toString(i));   
    116                                                
    117                                                 String[] carryFlipIdentiferArray = new String [] {carrySet2Lang.CARRYQNAME, carryFlipArrayExpr};
     112                                                String carryFlipArrayExpr = String.format(CarrySetBuiltins2Lang.LOCALCARRYQARRAYNAME + "[%s]", Integer.toString(i));   
     113                                               
     114                                                String[] carryFlipIdentiferArray = new String [] {CarrySetBuiltins2Lang.CARRYQNAME, carryFlipArrayExpr};
    118115                                               
    119116                                                pabloB.ast.CompoundIdentifierNode carryFlipIdentifierNode
     
    122119                                               
    123120                                                FuncCallNode carryFlipFuncCall = (FuncCallNode) Generators.makeFuncCallNode(
    124                                                                 new String [] {carrySet2Lang.CARRYQNAME, carrySet2Lang.getCode(CarrySetBuiltins.CARRYFLIP)},
     121                                                                new String [] {CarrySetBuiltins2Lang.CARRYQNAME, carrySet2Lang.getCode(CarrySetBuiltins.CARRYFLIP)},
    125122                                                                locationToken,
    126123                                                                new ASTNode [] {carryFlipIdentifierNode});
     
    329326                }
    330327
     328                /*
     329                public void visitEnter(StreamConstantNode node) {
     330                        defaultVisitEnter(node);
     331                }
     332                */
     333               
     334                public pabloB.ast.ASTNode visitLeave(pabloS.ast.StreamConstantNode node, List<pabloB.ast.ASTNode> childResults) {
     335                        pabloB.ast.ASTNode bNode = new pabloB.ast.StreamConstantNode(Generators.makePabloBToken(node.getToken()));
     336                        int value = new Integer(bNode.getToken().getLexeme());
     337                        ((pabloB.ast.StreamConstantNode)bNode).setValue(value); // set integer constant value
     338                        appendChildResults(bNode, childResults);
     339                        return bNode;
     340                }               
     341               
    331342                /*
    332343                public void visitEnter(LocalVarDeclNode node) {
  • proto/pablo/src/pabloB/ast/ASTTransformer.java

    r2809 r2815  
    6666        public ASTNode visit(StateSizeNode node);
    6767
     68        public ASTNode visit(StreamConstantNode node);
     69
    6870        public ASTNode visit(StreamTypeNode node);
    6971
     
    203205                }
    204206
     207                public ASTNode visit(StreamConstantNode node) {
     208                        return defaultVisit(node);
     209                }
     210
    205211                public ASTNode visit(StreamTypeNode node) {
    206212                        return defaultVisit(node);
  • proto/pablo/src/pabloB/ast/ASTVisitor.java

    r2809 r2815  
    9595        public T visitLeave(StateSizeNode node, List<T> childResults);
    9696
     97        public void visitEnter(StreamConstantNode node);
     98        public T visitLeave(StreamConstantNode node, List<T> childResults);
     99
    97100        public void visitEnter(StreamTypeNode node);
    98101        public T visitLeave(StreamTypeNode node, List<T> childResults);
     
    335338                }
    336339
     340                public void visitEnter(StreamConstantNode node) {
     341                        defaultVisitEnter(node);
     342                }
     343                public T visitLeave(StreamConstantNode node, List<T> childResults) {
     344                        return defaultVisitLeave(node);
     345                }
     346
    337347                public void visitEnter(StreamTypeNode node) {
    338348                        defaultVisitEnter(node);
  • proto/pablo/src/pabloB/ast/SimpleVisitor.java

    r2809 r2815  
    6767        public void visit(StateSizeNode node);
    6868
     69        public void visit(StreamConstantNode node);
     70
    6971        public void visit(StreamTypeNode node);
    7072
     
    204206                }
    205207
     208                public void visit(StreamConstantNode node) {
     209                        defaultVisit(node);
     210                }
     211
    206212                public void visit(StreamTypeNode node) {
    207213                        defaultVisit(node);
  • proto/pablo/src/pabloB/ast/VoidVisitor.java

    r2809 r2815  
    9393        public void visitLeave(StateSizeNode node);
    9494
     95        public void visitEnter(StreamConstantNode node);
     96        public void visitLeave(StreamConstantNode node);
     97
    9598        public void visitEnter(StreamTypeNode node);
    9699        public void visitLeave(StreamTypeNode node);
     
    332335                }
    333336
     337                public void visitEnter(StreamConstantNode node) {
     338                        defaultVisitEnter(node);
     339                }
     340                public void visitLeave(StreamConstantNode node) {
     341                        defaultVisitLeave(node);
     342                }
     343
    334344                public void visitEnter(StreamTypeNode node) {
    335345                        defaultVisitEnter(node);
  • proto/pablo/src/pabloB/parser/Parser.java

    r2809 r2815  
    623623                result.setProductionTag(22);
    624624                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    625                 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)) ) {
     625                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)) ) {
    626626                        {
    627627                                ASTNode child = parseExpr();
     
    771771                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    772772                expect(Lextant.RETURN);
    773                 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)) ) {
     773                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)) ) {
    774774                        {
    775775                                ASTNode child = parseExpr();
     
    869869         
    870870        public ASTNode parseExpr() {
    871                 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))) ) {
    872                         return syntaxErrorNode("expr² [IDENTIFIER¹, INTEGER_CONST¹, LROUND¹, MINUS¹, NOT¹, SQ_STRING¹, STRING¹]");
     871                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))) ) {
     872                        return syntaxErrorNode("expr² [IDENTIFIER¹, INTEGER_CONST¹, LROUND¹, NOT¹, SQ_STRING¹, STRING¹]");
    873873                }
    874874       
     
    904904         
    905905        public ASTNode parseExpr1() {
    906                 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))) ) {
    907                         return syntaxErrorNode("expr1² [IDENTIFIER¹, INTEGER_CONST¹, LROUND¹, MINUS¹, NOT¹, SQ_STRING¹, STRING¹]");
     906                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))) ) {
     907                        return syntaxErrorNode("expr1² [IDENTIFIER¹, INTEGER_CONST¹, LROUND¹, NOT¹, SQ_STRING¹, STRING¹]");
    908908                }
    909909       
     
    933933         
    934934        public ASTNode parseExpr2() {
    935                 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))) ) {
    936                         return syntaxErrorNode("expr2² [IDENTIFIER¹, INTEGER_CONST¹, LROUND¹, MINUS¹, NOT¹, SQ_STRING¹, STRING¹]");
     935                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))) ) {
     936                        return syntaxErrorNode("expr2² [IDENTIFIER¹, INTEGER_CONST¹, LROUND¹, NOT¹, SQ_STRING¹, STRING¹]");
    937937                }
    938938       
     
    959959         
    960960        public ASTNode parseExpr3() {
    961                 if( !(nowReading.isLextant(Lextant.LROUND, Lextant.MINUS) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) || (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) || (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING))) ) {
    962                         return syntaxErrorNode("expr3² [IDENTIFIER¹, INTEGER_CONST¹, LROUND¹, MINUS¹, SQ_STRING¹, STRING¹]");
     961                if( !(nowReading.isLextant(Lextant.LROUND) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) || (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) || (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING))) ) {
     962                        return syntaxErrorNode("expr3² [IDENTIFIER¹, INTEGER_CONST¹, LROUND¹, SQ_STRING¹, STRING¹]");
    963963                }
    964964       
     
    976976                        expect(Lextant.RROUND);
    977977                }
    978                 else if( nowReading.isLextant(Lextant.MINUS) || (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) || (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING)) ) {
    979                         {
    980                                 ASTNode child = parseConstant();
     978                else if( (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) ) {
     979                        {
     980                                ASTNode child = parseStreamConstant();
     981                                result.appendChild(child);
     982                                allChildren.add(child);
     983                        }
     984                }
     985                else if( (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING)) ) {
     986                        {
     987                                ASTNode child = parseStringConstant();
    981988                                result.appendChild(child);
    982989                                allChildren.add(child);
     
    10281035                        }
    10291036                }
    1030                 if(allowCompression) {
    1031                         return compressIfPossible(result);
     1037                else if( (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) ) {
     1038                        {
     1039                                ASTNode child = parseStreamConstant();
     1040                                result.appendChild(child);
     1041                                allChildren.add(child);
     1042                        }
     1043                }
     1044                if(allowCompression) {
     1045                        return compressIfPossible(result);
     1046                }
     1047                return result;
     1048        }
     1049         
     1050        public ASTNode parseStreamConstant() {
     1051                if( !((nowReading.isLexicalType(LexicalType.INTEGER_CONST))) ) {
     1052                        return syntaxErrorNode("streamConstant² [INTEGER_CONST¹]");
     1053                }
     1054       
     1055                boolean allowCompression = true;
     1056                ASTNode result = new StreamConstantNode(nowReading);
     1057                result.setProductionTag(36);
     1058                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     1059                if( !(nowReading.isLexicalType(LexicalType.INTEGER_CONST)) ) {
     1060                        return syntaxErrorNode("INTEGER_CONST");
     1061                }
     1062                readToken();
     1063                {
     1064                        ASTNode temp_1 = result;
     1065                        IntValuedNodeType temp_3 = (IntValuedNodeType)temp_1;
     1066                        IntConstantToken temp_6 = (IntConstantToken)previouslyRead;
     1067                        int temp_5 = temp_6.getValue();
     1068                        temp_3.setValue( temp_5 );
     1069                }
     1070                if(allowCompression) {
     1071                        return result;
    10321072                }
    10331073                return result;
     
    10411081                boolean allowCompression = true;
    10421082                ASTNode result = new ASTNode(nowReading);
    1043                 result.setProductionTag(36);
     1083                result.setProductionTag(37);
    10441084                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    10451085                if( nowReading.isLextant(Lextant.MINUS) ) {
     
    10511091                        }
    10521092                        {
    1053                                 ASTNode temp_1 = allChildren.revGet(0);
    1054                                 IntValuedNodeType temp_3 = (IntValuedNodeType)temp_1;
    1055                                 int temp_4 = 0;
    1056                                 ASTNode temp_5 = allChildren.revGet(0);
    1057                                 IntValuedNodeType temp_7 = (IntValuedNodeType)temp_5;
    1058                                 int temp_6 = temp_7.getValue();
    1059                                 int temp_8 = temp_4 - temp_6;
    1060                                 temp_3.setValue( temp_8 );
     1093                                ASTNode temp_7 = allChildren.revGet(0);
     1094                                IntValuedNodeType temp_9 = (IntValuedNodeType)temp_7;
     1095                                int temp_10 = 0;
     1096                                ASTNode temp_11 = allChildren.revGet(0);
     1097                                IntValuedNodeType temp_13 = (IntValuedNodeType)temp_11;
     1098                                int temp_12 = temp_13.getValue();
     1099                                int temp_14 = temp_10 - temp_12;
     1100                                temp_9.setValue( temp_14 );
    10611101                        }
    10621102                }
     
    10811121                boolean allowCompression = true;
    10821122                ASTNode result = new IntegerConstantNode(nowReading);
    1083                 result.setProductionTag(37);
     1123                result.setProductionTag(38);
    10841124                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    10851125                if( !(nowReading.isLexicalType(LexicalType.INTEGER_CONST)) ) {
     
    10881128                readToken();
    10891129                {
    1090                         ASTNode temp_9 = result;
    1091                         IntValuedNodeType temp_11 = (IntValuedNodeType)temp_9;
    1092                         IntConstantToken temp_14 = (IntConstantToken)previouslyRead;
    1093                         int temp_13 = temp_14.getValue();
    1094                         temp_11.setValue( temp_13 );
     1130                        ASTNode temp_15 = result;
     1131                        IntValuedNodeType temp_17 = (IntValuedNodeType)temp_15;
     1132                        IntConstantToken temp_20 = (IntConstantToken)previouslyRead;
     1133                        int temp_19 = temp_20.getValue();
     1134                        temp_17.setValue( temp_19 );
    10951135                }
    10961136                if(allowCompression) {
     
    11071147                boolean allowCompression = true;
    11081148                ASTNode result = new StringConstantNode(nowReading);
    1109                 result.setProductionTag(38);
     1149                result.setProductionTag(39);
    11101150                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    11111151                if( (nowReading.isLexicalType(LexicalType.STRING)) ) {
     
    11341174                boolean allowCompression = true;
    11351175                ASTNode result = new CompoundIdentifierNode(nowReading);
    1136                 result.setProductionTag(39);
     1176                result.setProductionTag(40);
    11371177                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    11381178                {
     
    11631203                boolean allowCompression = true;
    11641204                ASTNode result = new IdentifierNode(nowReading);
    1165                 result.setProductionTag(40);
     1205                result.setProductionTag(41);
    11661206                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    11671207                if( !(nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
     
    11821222                boolean allowCompression = true;
    11831223                ASTNode result = new ASTNode(nowReading);
    1184                 result.setProductionTag(41);
     1224                result.setProductionTag(42);
    11851225                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    11861226                if( nowReading.isLextant(Lextant.STREAM) ) {
     
    12251265                boolean allowCompression = true;
    12261266                ASTNode result = new StreamTypeNode(nowReading);
    1227                 result.setProductionTag(42);
     1267                result.setProductionTag(43);
    12281268                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    12291269                expect(Lextant.STREAM);
     
    12501290                boolean allowCompression = true;
    12511291                ASTNode result = new FieldWidthNode(nowReading);
    1252                 result.setProductionTag(43);
     1292                result.setProductionTag(44);
    12531293                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    12541294                {
     
    12701310                boolean allowCompression = true;
    12711311                ASTNode result = new ASTNode(nowReading);
    1272                 result.setProductionTag(44);
     1312                result.setProductionTag(45);
    12731313                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    12741314                {
     
    12901330                boolean allowCompression = true;
    12911331                ASTNode result = new StructTypeNode(nowReading);
    1292                 result.setProductionTag(45);
     1332                result.setProductionTag(46);
    12931333                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    12941334                expect(Lextant.STRUCT);
     
    13181358                boolean allowCompression = true;
    13191359                ASTNode result = new ASTNode(nowReading);
    1320                 result.setProductionTag(46);
     1360                result.setProductionTag(47);
    13211361                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    13221362                {
     
    13381378                boolean allowCompression = true;
    13391379                ASTNode result = new StructTypeBodyNode(nowReading);
    1340                 result.setProductionTag(47);
     1380                result.setProductionTag(48);
    13411381                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    13421382                expect(Lextant.LCURLY);
     
    13691409                boolean allowCompression = true;
    13701410                ASTNode result = new StructMemberNode(nowReading);
    1371                 result.setProductionTag(48);
     1411                result.setProductionTag(49);
    13721412                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    13731413                {
     
    13941434                boolean allowCompression = true;
    13951435                ASTNode result = new ASTNode(nowReading);
    1396                 result.setProductionTag(49);
     1436                result.setProductionTag(50);
    13971437                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    13981438                {
     
    14141454                boolean allowCompression = true;
    14151455                ASTNode result = new VoidNode(nowReading);
    1416                 result.setProductionTag(50);
     1456                result.setProductionTag(51);
    14171457                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    14181458                expect(Lextant.VOID);
  • proto/pablo/src/pabloS/ast/ASTTransformer.java

    r2749 r2815  
    5252        public ASTNode visit(ReturnStmtNode node);
    5353
     54        public ASTNode visit(StreamConstantNode node);
     55
    5456        public ASTNode visit(StreamTypeNode node);
    5557
     
    163165                }
    164166
     167                public ASTNode visit(StreamConstantNode node) {
     168                        return defaultVisit(node);
     169                }
     170
    165171                public ASTNode visit(StreamTypeNode node) {
    166172                        return defaultVisit(node);
  • proto/pablo/src/pabloS/ast/ASTVisitor.java

    r2749 r2815  
    7474        public T visitLeave(ReturnStmtNode node, List<T> childResults);
    7575
     76        public void visitEnter(StreamConstantNode node);
     77        public T visitLeave(StreamConstantNode node, List<T> childResults);
     78
    7679        public void visitEnter(StreamTypeNode node);
    7780        public T visitLeave(StreamTypeNode node, List<T> childResults);
     
    268271                }
    269272
     273                public void visitEnter(StreamConstantNode node) {
     274                        defaultVisitEnter(node);
     275                }
     276                public T visitLeave(StreamConstantNode node, List<T> childResults) {
     277                        return defaultVisitLeave(node);
     278                }
     279
    270280                public void visitEnter(StreamTypeNode node) {
    271281                        defaultVisitEnter(node);
  • proto/pablo/src/pabloS/ast/SimpleVisitor.java

    r2749 r2815  
    5353        public void visit(ReturnStmtNode node);
    5454
     55        public void visit(StreamConstantNode node);
     56
    5557        public void visit(StreamTypeNode node);
    5658
     
    164166                }
    165167
     168                public void visit(StreamConstantNode node) {
     169                        defaultVisit(node);
     170                }
     171
    166172                public void visit(StreamTypeNode node) {
    167173                        defaultVisit(node);
  • proto/pablo/src/pabloS/ast/VoidVisitor.java

    r2749 r2815  
    7272        public void visitLeave(ReturnStmtNode node);
    7373
     74        public void visitEnter(StreamConstantNode node);
     75        public void visitLeave(StreamConstantNode node);
     76
    7477        public void visitEnter(StreamTypeNode node);
    7578        public void visitLeave(StreamTypeNode node);
     
    265268                }
    266269
     270                public void visitEnter(StreamConstantNode node) {
     271                        defaultVisitEnter(node);
     272                }
     273                public void visitLeave(StreamConstantNode node) {
     274                        defaultVisitLeave(node);
     275                }
     276
    267277                public void visitEnter(StreamTypeNode node) {
    268278                        defaultVisitEnter(node);
  • proto/pablo/src/pabloS/parser/Parser.java

    r2809 r2815  
    401401                result.setProductionTag(13);
    402402                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    403                 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)) ) {
     403                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)) ) {
    404404                        {
    405405                                ASTNode child = parseExpr();
     
    549549                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    550550                expect(Lextant.RETURN);
    551                 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)) ) {
     551                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)) ) {
    552552                        {
    553553                                ASTNode child = parseExpr();
     
    647647         
    648648        public ASTNode parseExpr() {
    649                 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))) ) {
    650                         return syntaxErrorNode("expr² [IDENTIFIER¹, INTEGER_CONST¹, LROUND¹, MINUS¹, NOT¹, SQ_STRING¹, STRING¹]");
     649                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))) ) {
     650                        return syntaxErrorNode("expr² [IDENTIFIER¹, INTEGER_CONST¹, LROUND¹, NOT¹, SQ_STRING¹, STRING¹]");
    651651                }
    652652       
     
    682682         
    683683        public ASTNode parseExpr1() {
    684                 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))) ) {
    685                         return syntaxErrorNode("expr1² [IDENTIFIER¹, INTEGER_CONST¹, LROUND¹, MINUS¹, NOT¹, SQ_STRING¹, STRING¹]");
     684                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))) ) {
     685                        return syntaxErrorNode("expr1² [IDENTIFIER¹, INTEGER_CONST¹, LROUND¹, NOT¹, SQ_STRING¹, STRING¹]");
    686686                }
    687687       
     
    711711         
    712712        public ASTNode parseExpr2() {
    713                 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))) ) {
    714                         return syntaxErrorNode("expr2² [IDENTIFIER¹, INTEGER_CONST¹, LROUND¹, MINUS¹, NOT¹, SQ_STRING¹, STRING¹]");
     713                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))) ) {
     714                        return syntaxErrorNode("expr2² [IDENTIFIER¹, INTEGER_CONST¹, LROUND¹, NOT¹, SQ_STRING¹, STRING¹]");
    715715                }
    716716       
     
    737737         
    738738        public ASTNode parseExpr3() {
    739                 if( !(nowReading.isLextant(Lextant.LROUND, Lextant.MINUS) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) || (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) || (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING))) ) {
    740                         return syntaxErrorNode("expr3² [IDENTIFIER¹, INTEGER_CONST¹, LROUND¹, MINUS¹, SQ_STRING¹, STRING¹]");
     739                if( !(nowReading.isLextant(Lextant.LROUND) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) || (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) || (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING))) ) {
     740                        return syntaxErrorNode("expr3² [IDENTIFIER¹, INTEGER_CONST¹, LROUND¹, SQ_STRING¹, STRING¹]");
    741741                }
    742742       
     
    754754                        expect(Lextant.RROUND);
    755755                }
    756                 else if( nowReading.isLextant(Lextant.MINUS) || (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) || (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING)) ) {
    757                         {
    758                                 ASTNode child = parseConstant();
     756                else if( (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) ) {
     757                        {
     758                                ASTNode child = parseStreamConstant();
     759                                result.appendChild(child);
     760                                allChildren.add(child);
     761                        }
     762                }
     763                else if( (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING)) ) {
     764                        {
     765                                ASTNode child = parseStringConstant();
    759766                                result.appendChild(child);
    760767                                allChildren.add(child);
     
    812819        }
    813820         
     821        public ASTNode parseStreamConstant() {
     822                if( !((nowReading.isLexicalType(LexicalType.INTEGER_CONST))) ) {
     823                        return syntaxErrorNode("streamConstant² [INTEGER_CONST¹]");
     824                }
     825       
     826                boolean allowCompression = true;
     827                ASTNode result = new StreamConstantNode(nowReading);
     828                result.setProductionTag(27);
     829                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     830                if( !(nowReading.isLexicalType(LexicalType.INTEGER_CONST)) ) {
     831                        return syntaxErrorNode("INTEGER_CONST");
     832                }
     833                readToken();
     834                {
     835                        ASTNode temp_1 = result;
     836                        IntValuedNodeType temp_3 = (IntValuedNodeType)temp_1;
     837                        IntConstantToken temp_6 = (IntConstantToken)previouslyRead;
     838                        int temp_5 = temp_6.getValue();
     839                        temp_3.setValue( temp_5 );
     840                }
     841                if(allowCompression) {
     842                        return result;
     843                }
     844                return result;
     845        }
     846         
    814847        public ASTNode parseSignedIntegerConstant() {
    815848                if( !(nowReading.isLextant(Lextant.MINUS) || (nowReading.isLexicalType(LexicalType.INTEGER_CONST))) ) {
     
    819852                boolean allowCompression = true;
    820853                ASTNode result = new ASTNode(nowReading);
    821                 result.setProductionTag(27);
     854                result.setProductionTag(28);
    822855                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    823856                if( nowReading.isLextant(Lextant.MINUS) ) {
     
    829862                        }
    830863                        {
    831                                 ASTNode temp_1 = allChildren.revGet(0);
    832                                 IntValuedNodeType temp_3 = (IntValuedNodeType)temp_1;
    833                                 int temp_4 = 0;
    834                                 ASTNode temp_5 = allChildren.revGet(0);
    835                                 IntValuedNodeType temp_7 = (IntValuedNodeType)temp_5;
    836                                 int temp_6 = temp_7.getValue();
    837                                 int temp_8 = temp_4 - temp_6;
    838                                 temp_3.setValue( temp_8 );
     864                                ASTNode temp_7 = allChildren.revGet(0);
     865                                IntValuedNodeType temp_9 = (IntValuedNodeType)temp_7;
     866                                int temp_10 = 0;
     867                                ASTNode temp_11 = allChildren.revGet(0);
     868                                IntValuedNodeType temp_13 = (IntValuedNodeType)temp_11;
     869                                int temp_12 = temp_13.getValue();
     870                                int temp_14 = temp_10 - temp_12;
     871                                temp_9.setValue( temp_14 );
    839872                        }
    840873                }
     
    859892                boolean allowCompression = true;
    860893                ASTNode result = new IntegerConstantNode(nowReading);
    861                 result.setProductionTag(28);
     894                result.setProductionTag(29);
    862895                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    863896                if( !(nowReading.isLexicalType(LexicalType.INTEGER_CONST)) ) {
     
    866899                readToken();
    867900                {
    868                         ASTNode temp_9 = result;
    869                         IntValuedNodeType temp_11 = (IntValuedNodeType)temp_9;
    870                         IntConstantToken temp_14 = (IntConstantToken)previouslyRead;
    871                         int temp_13 = temp_14.getValue();
    872                         temp_11.setValue( temp_13 );
     901                        ASTNode temp_15 = result;
     902                        IntValuedNodeType temp_17 = (IntValuedNodeType)temp_15;
     903                        IntConstantToken temp_20 = (IntConstantToken)previouslyRead;
     904                        int temp_19 = temp_20.getValue();
     905                        temp_17.setValue( temp_19 );
    873906                }
    874907                if(allowCompression) {
     
    885918                boolean allowCompression = true;
    886919                ASTNode result = new StringConstantNode(nowReading);
    887                 result.setProductionTag(29);
     920                result.setProductionTag(30);
    888921                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    889922                if( (nowReading.isLexicalType(LexicalType.STRING)) ) {
     
    912945                boolean allowCompression = true;
    913946                ASTNode result = new CompoundIdentifierNode(nowReading);
    914                 result.setProductionTag(30);
     947                result.setProductionTag(31);
    915948                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    916949                {
     
    941974                boolean allowCompression = true;
    942975                ASTNode result = new IdentifierNode(nowReading);
    943                 result.setProductionTag(31);
     976                result.setProductionTag(32);
    944977                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    945978                if( !(nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
     
    960993                boolean allowCompression = true;
    961994                ASTNode result = new ASTNode(nowReading);
    962                 result.setProductionTag(32);
     995                result.setProductionTag(33);
    963996                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    964997                if( nowReading.isLextant(Lextant.STREAM) ) {
     
    10031036                boolean allowCompression = true;
    10041037                ASTNode result = new StreamTypeNode(nowReading);
    1005                 result.setProductionTag(33);
     1038                result.setProductionTag(34);
    10061039                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    10071040                expect(Lextant.STREAM);
     
    10281061                boolean allowCompression = true;
    10291062                ASTNode result = new FieldWidthNode(nowReading);
    1030                 result.setProductionTag(34);
     1063                result.setProductionTag(35);
    10311064                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    10321065                {
     
    10481081                boolean allowCompression = true;
    10491082                ASTNode result = new ASTNode(nowReading);
    1050                 result.setProductionTag(35);
     1083                result.setProductionTag(36);
    10511084                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    10521085                {
     
    10681101                boolean allowCompression = true;
    10691102                ASTNode result = new StructTypeNode(nowReading);
    1070                 result.setProductionTag(36);
     1103                result.setProductionTag(37);
    10711104                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    10721105                expect(Lextant.STRUCT);
     
    10961129                boolean allowCompression = true;
    10971130                ASTNode result = new ASTNode(nowReading);
    1098                 result.setProductionTag(37);
     1131                result.setProductionTag(38);
    10991132                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    11001133                {
     
    11161149                boolean allowCompression = true;
    11171150                ASTNode result = new StructTypeBodyNode(nowReading);
    1118                 result.setProductionTag(38);
     1151                result.setProductionTag(39);
    11191152                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    11201153                expect(Lextant.LCURLY);
     
    11471180                boolean allowCompression = true;
    11481181                ASTNode result = new StructMemberNode(nowReading);
    1149                 result.setProductionTag(39);
     1182                result.setProductionTag(40);
    11501183                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    11511184                {
     
    11721205                boolean allowCompression = true;
    11731206                ASTNode result = new ASTNode(nowReading);
    1174                 result.setProductionTag(40);
     1207                result.setProductionTag(41);
    11751208                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    11761209                {
     
    11921225                boolean allowCompression = true;
    11931226                ASTNode result = new VoidNode(nowReading);
    1194                 result.setProductionTag(41);
     1227                result.setProductionTag(42);
    11951228                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    11961229                expect(Lextant.VOID);
Note: See TracChangeset for help on using the changeset viewer.