Changeset 2972


Ignore:
Timestamp:
Mar 24, 2013, 10:32:31 PM (4 years ago)
Author:
ksherdy
Message:

Added pablo.Mask(fw,value) builtin.

Location:
proto/pabloj/trunk
Files:
1 deleted
18 edited

Legend:

Unmodified
Added
Removed
  • proto/pabloj/trunk/docs/notes

    r2967 r2972  
    1212
    1313================================================================================
     14PabloS Types
     15================================================================================
     16
     171. Strings and integers are constants that must be initialized on declaration.
     18
     192. 2^k stream types are initialized to simd<k>::constant(0).
     20
     213. Mask?
     22
     23================================================================================
    1424PabloS Visitors
    1525================================================================================
    1626
    17 1. Wrap all PabloS conditional in BitBlock::any() calls.
     271. All PabloS conditional expression E are wrapped in BitBlock::any(E) calls.
    1828
    1929================================================================================
  • proto/pabloj/trunk/input/test/pabloS/py2pablo/parabix2_pablo.pablos

    r2834 r2972  
    217217    pablo.assert_0(pablo.inFile(lex_error), "Error: illegal character");
    218218    u8.unibyte = (~ basis_bits.bit_0);
    219     u8.suffix = 0;
    220     var stream<1> u8_error = 0;
    221     var stream<1> u8_FFFE_FFFF = 0;
    222     var stream<1> u8anyscope = 0;
     219    u8.suffix = pablo.Mask(1,0);
     220    var stream<1> u8_error;
     221    var stream<1> u8_FFFE_FFFF;
     222    var stream<1> u8anyscope;
    223223    if (basis_bits.bit_0) {
    224224        u8.prefix = (basis_bits.bit_0 & basis_bits.bit_1);
     
    279279
    280280function void Parse_CtCDPI(struct Lex lex, struct Marker marker, struct CtCDPI_Callouts ctCDPI_Callouts, struct Check_streams check_streams) {
    281     ctCDPI_Callouts.Ct_starts = 0;
    282     ctCDPI_Callouts.Ct_ends = 0;
    283     ctCDPI_Callouts.CD_starts = 0;
    284     ctCDPI_Callouts.CD_ends = 0;
    285     ctCDPI_Callouts.PI_starts = 0;
    286     ctCDPI_Callouts.PI_name_starts = 0;
    287     ctCDPI_Callouts.PI_name_ends = 0;
    288     ctCDPI_Callouts.PI_ends = 0;
    289     var stream<1> CtCDPI_starts = 0;
    290     var stream<1> CtCDPI_ends = 0;
    291     var stream<1> ctCDPI_mask = 0;
     281    ctCDPI_Callouts.Ct_starts = pablo.Mask(1,0);
     282    ctCDPI_Callouts.Ct_ends = pablo.Mask(1,0);
     283    ctCDPI_Callouts.CD_starts = pablo.Mask(1,0);
     284    ctCDPI_Callouts.CD_ends = pablo.Mask(1,0);
     285    ctCDPI_Callouts.PI_starts = pablo.Mask(1,0);
     286    ctCDPI_Callouts.PI_name_starts = pablo.Mask(1,0);
     287    ctCDPI_Callouts.PI_name_ends = pablo.Mask(1,0);
     288    ctCDPI_Callouts.PI_ends = pablo.Mask(1,0);
     289    var stream<1> CtCDPI_starts;
     290    var stream<1> CtCDPI_ends;
     291    var stream<1> ctCDPI_mask;
    292292    var stream<1> v = (lex.LAngle | lex.Hyphen);
    293293    var stream<1> w = (lex.Hyphen | lex.QMark);
     
    298298    var stream<1> CtCD_opener = (LAngle_scope & lex.Exclam);
    299299    var stream<1> CtCDPI_opener = (PI_opener | CtCD_opener);
    300     var stream<1> CD_closer = 0;
     300    var stream<1> CD_closer;
    301301    var stream<1> DoubleHyphen = ((v1 & w1) & lex.Hyphen);
    302302    if (lex.RBracket) {
     
    354354
    355355function void Parse_tags(struct Lex lex, struct Marker marker, struct Tag_Callouts tag_Callouts) {
    356     var stream<1> EqExpected = 0;
    357     var stream<1> AttListEnd = 0;
     356    var stream<1> EqExpected;
     357    var stream<1> AttListEnd;
    358358    var stream<1> DQuoteDelim = (lex.DQuote | lex.LAngle);
    359359    var stream<1> SQuoteDelim = (lex.SQuote | lex.LAngle);
     
    363363    tag_Callouts.ElemName_ends = pablo.ScanThru(tag_Callouts.ElemName_starts, lex.NameScan);
    364364    var stream<1> ParseError = (tag_Callouts.ElemName_starts & tag_Callouts.ElemName_ends);
    365     tag_Callouts.AttName_starts = 0;
    366     tag_Callouts.AttName_ends = 0;
    367     tag_Callouts.AttVal_starts = 0;
    368     tag_Callouts.AttVal_ends = 0;
     365    tag_Callouts.AttName_starts = pablo.Mask(1,0);
     366    tag_Callouts.AttName_ends = pablo.Mask(1,0);
     367    tag_Callouts.AttVal_starts = pablo.Mask(1,0);
     368    tag_Callouts.AttVal_ends = pablo.Mask(1,0);
    369369    if ((tag_Callouts.ElemName_ends & lex.WS)) {
    370370        var stream<1> AfterWS = pablo.ScanThru(tag_Callouts.ElemName_ends, lex.WS);
     
    422422
    423423function void Parse_refs(struct Lex lex, struct Marker marker, struct Ref_Callouts ref_Callouts) {
    424     ref_Callouts.GenRef_starts = 0;
    425     ref_Callouts.GenRef_ends = 0;
    426     ref_Callouts.DecRef_starts = 0;
    427     ref_Callouts.DecRef_ends = 0;
    428     ref_Callouts.HexRef_starts = 0;
    429     ref_Callouts.HexRef_ends = 0;
    430     var stream<1> ref_error = 0;
     424    ref_Callouts.GenRef_starts = pablo.Mask(1,0);
     425    ref_Callouts.GenRef_ends = pablo.Mask(1,0);
     426    ref_Callouts.DecRef_starts = pablo.Mask(1,0);
     427    ref_Callouts.DecRef_ends = pablo.Mask(1,0);
     428    ref_Callouts.HexRef_starts = pablo.Mask(1,0);
     429    ref_Callouts.HexRef_ends = pablo.Mask(1,0);
     430    var stream<1> ref_error;
    431431    if (marker.Ref_opener) {
    432432        var stream<1> Ref_scope = pablo.Advance(marker.Ref_opener);
  • proto/pabloj/trunk/input/test/pabloS/statements/while/while1.pablos

    r2834 r2972  
    11function void While() {
    2        
     2               
    33        var stream cursor = 1;
    44       
  • proto/pabloj/trunk/src/applicationGenerator/ApplicationGenerator.java

    r2967 r2972  
    5454               
    5555                // Transformation configurations to support multiple backends
    56                 Builtins2Lang builtins2Lang             = null;
     56                PabloSBuiltins2Lang builtins2Lang               = null;
    5757                CarrySetBuiltins2Lang carrySet2Lang     = null;
    5858                Unparser unparser                                       = null;
  • proto/pabloj/trunk/src/compilers/pabloB/lang/idisa/IDISABitBlockBuiltins.java

    r2971 r2972  
    1515        POPCOUNT("popcount", 1);
    1616               
    17         private String lexeme;
     17        private String name;
    1818        private int argCount;
    1919       
    20         private IDISABitBlockBuiltins(String lexeme, int argCount) {
    21                 this.lexeme = lexeme;
     20        private IDISABitBlockBuiltins(String name, int argCount) {
     21                this.name = name;
    2222                this.argCount = argCount;
    2323        }
     
    2525        private static final String BITBLOCK = "bitblock";
    2626       
    27         public String IDISALexeme() { return BITBLOCK + "::" + lexeme; }
     27        public String IDISALexeme() { return BITBLOCK + "::" + name; }
    2828        public int argCount() { return argCount; }
    2929}
  • proto/pabloj/trunk/src/compilers/pabloB/lang/idisa/IDISASIMDBuiltins.java

    r2971 r2972  
    2929        SRA("sra",1,2),
    3030       
    31         CONSTANT("constant",1,1);
     31        CONSTANT("constant",1,0);
    3232       
    3333        private String name;
     
    4343        private static final String SIMD = "simd";
    4444       
    45         public String Name(String fieldWidth) { return (SIMD + "<" + fieldWidth + ">::" + name); }
     45        public String Name(String fieldWidth) {
     46                return (SIMD + "<" + fieldWidth + ">::" + name);
     47        }
     48       
     49        public String ConstantName(String fieldWidth, String constantValue) {
     50                return Name(fieldWidth) + "<" + constantValue + ">"; 
     51        }
     52       
    4653        public int getFieldWidth() { return fieldWidth; }
    4754        public int argCount() { return argCount; }
  • proto/pabloj/trunk/src/compilers/pabloS/ast/Generators.java

    r2971 r2972  
    1515import java.util.List;
    1616
    17 import compilers.pabloB.lang.idisa.IDISASIMDBitwiseBuiltins;
    18 import compilers.pabloS.lang.PabloSBuiltins;
    19 import compilers.pabloS.lang.PabloSBuiltins2Lang;
    20 
    21 import pabloS.lexicalAnalyzer.LexicalType;
    22 import pabloS.lexicalAnalyzer.Lextant;
    23 import pabloS.tokens.IdentifierToken;
    24 import pabloS.tokens.IntConstantToken;
    25 import pabloS.tokens.LextantToken;
    26 import pabloS.tokens.StringConstantToken;
    27 import pabloS.tokens.Token;
     17import compilers.pabloB.lang.idisa.*;
     18import compilers.pabloS.lang.*;
     19import pabloS.lexicalAnalyzer.*;
     20import pabloS.tokens.*;
    2821
    2922public class Generators {
  • proto/pabloj/trunk/src/compilers/pabloS/lang/PabloSBuiltins.java

    r2971 r2972  
    1919    ADVANCEN(Type.N, "Advance", 2),
    2020
    21     MASK(Type.None, "Mask", 1),
    22     MASKFW(Type.None, "MaskFW", 2),
    23    
     21    MASK(Type.None, "Mask", 2),   
    2422    ATEOF(Type.None, "atEOF", 1),
    2523    INFILE(Type.None, "inFile", 1),
  • proto/pabloj/trunk/src/compilers/pabloS/lang/PabloSBuiltins2CPP.java

    r2971 r2972  
    3939
    4040        pabloS2CPPCode.put(PabloSBuiltins.MASK, "Mask");
    41         pabloS2CPPCode.put(PabloSBuiltins.MASKFW, "Mask");
    42        
    4341        pabloS2CPPCode.put(PabloSBuiltins.ATEOF, "atEOF");
    4442        pabloS2CPPCode.put(PabloSBuiltins.INFILE, "inFile");
  • proto/pabloj/trunk/src/compilers/pabloS/semanticAnalyzer/visitors/Bitwise2IDISAXFormer.java

    r2971 r2972  
    3939
    4040        /*
    41          * PabloS binary bitwise ops to IDISA calls
     41         * PabloS binary bitwise operations to IDISA calls.
     42         *
     43         * Transforms A AND NOT B --> A ANDC B.
     44         * Transforms NOT A AND B --> B ANDC A.
     45         *
    4246         */
    4347        private class Bitwise2IDISABinaryOperatorXFormer extends VoidVisitor.Default {
  • proto/pabloj/trunk/src/compilers/pabloS/semanticAnalyzer/visitors/CarryIntroXFormer.java

    r2971 r2972  
    258258                                                new ASTNode [] {currentAdvN});
    259259                        } else {
    260                                 IntegerConstantNode zero = Generators.makeIntegerConstantNode(0, node.getToken());
    261                                 carryAtCallOrConstant = Generators.makeFuncCallNode(IDISASIMDBuiltins.CONSTANT.Name("1"), node.getToken(), new ASTNode [] {zero});
    262                                 pending64CallOrConstant = Generators.makeFuncCallNode(IDISASIMDBuiltins.CONSTANT.Name("1"), node.getToken(), new ASTNode [] {zero});
     260                                carryAtCallOrConstant = Generators.makeFuncCallNode(IDISASIMDBuiltins.CONSTANT.ConstantName("1", "0"), node.getToken());
     261                                pending64CallOrConstant = Generators.makeFuncCallNode(IDISASIMDBuiltins.CONSTANT.ConstantName("1", "0"), node.getToken());
    263262                        }
    264263                                               
     
    566565                                        replacementNode = Generators.makeSIMDAndCEOFMaskFuncCall(argNode, builtins2Lang);
    567566                                } else {                                       
    568                                         IntegerConstantNode zero = Generators.makeIntegerConstantNode(0, node.getToken());
    569                                         replacementNode = Generators.makeFuncCallNode(IDISASIMDBuiltins.CONSTANT.Name("1"), node.getToken(), new ASTNode [] {zero});                                   
     567                                        replacementNode = Generators.makeFuncCallNode(IDISASIMDBuiltins.CONSTANT.ConstantName("1", "0"), node.getToken());                                     
    570568                                }
    571569                                node.updateSelf(replacementNode);
     
    620618                                        PabloSBuiltins.MASK.argCount())) {
    621619                               
    622                                         ASTNode fieldWidth = Accessors.funcCallArg(node, 0);
    623                                         ASTNode value = Accessors.funcCallArg(node, 1);
    624                                
    625                                         IntegerConstantNode zero = Generators.makeIntegerConstantNode(0, node.getToken());
    626                                         replacementNode = Generators.makeFuncCallNode(IDISASIMDBuiltins.CONSTANT.Name("1"), node.getToken(), new ASTNode [] {zero});                           
     620                                        replacementNode = Generators.makeFuncCallNode(IDISASIMDBuiltins.CONSTANT.ConstantName("1","0"), node.getToken());                               
    627621                                       
    628622                                        node.updateSelf(replacementNode);
  • proto/pabloj/trunk/src/compilers/pabloS/semanticAnalyzer/visitors/InitStreamDefaultsXFormer.java

    r2971 r2972  
    5252                                        }
    5353                                       
    54                                         IntegerConstantNode zero = Generators.makeIntegerConstantNode(0, node.getToken());
    55                                         FuncCallNode funcCallNode = Generators.makeFuncCallNode(IDISASIMDBuiltins.CONSTANT.Name(fieldWidth), node.getToken(), new ASTNode [] {zero});
     54                                        FuncCallNode funcCallNode = Generators.makeFuncCallNode(IDISASIMDBuiltins.CONSTANT.ConstantName(fieldWidth,"0"), node.getToken());
    5655                                       
    5756                                        LocalVarDeclNode localVarDeclNode = Generators.makeLocalVarDeclNode(type, identifier, funcCallNode, node.getToken());
  • proto/pabloj/trunk/src/pabloS/ast/ASTTransformer.java

    r2969 r2972  
    5454        public ASTNode visit(ReturnStmtNode node);
    5555
    56         public ASTNode visit(RoundNode node);
    57 
    5856        public ASTNode visit(StreamTypeNode node);
    5957
     
    171169                }
    172170
    173                 public ASTNode visit(RoundNode node) {
    174                         return defaultVisit(node);
    175                 }
    176 
    177171                public ASTNode visit(StreamTypeNode node) {
    178172                        return defaultVisit(node);
  • proto/pabloj/trunk/src/pabloS/ast/ASTVisitor.java

    r2969 r2972  
    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 
    8279        public void visitEnter(StreamTypeNode node);
    8380        public T visitLeave(StreamTypeNode node, List<T> childResults);
     
    281278                }
    282279
    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 
    290280                public void visitEnter(StreamTypeNode node) {
    291281                        defaultVisitEnter(node);
  • proto/pabloj/trunk/src/pabloS/ast/SimpleVisitor.java

    r2969 r2972  
    5555        public void visit(ReturnStmtNode node);
    5656
    57         public void visit(RoundNode node);
    58 
    5957        public void visit(StreamTypeNode node);
    6058
     
    172170                }
    173171
    174                 public void visit(RoundNode node) {
    175                         defaultVisit(node);
    176                 }
    177 
    178172                public void visit(StreamTypeNode node) {
    179173                        defaultVisit(node);
  • proto/pabloj/trunk/src/pabloS/ast/VoidVisitor.java

    r2969 r2972  
    7575        public void visitLeave(ReturnStmtNode node);
    7676
    77         public void visitEnter(RoundNode node);
    78         public void visitLeave(RoundNode node);
    79 
    8077        public void visitEnter(StreamTypeNode node);
    8178        public void visitLeave(StreamTypeNode node);
     
    278275                }
    279276
    280                 public void visitEnter(RoundNode node) {
    281                         defaultVisitEnter(node);
    282                 }
    283                 public void visitLeave(RoundNode node) {
    284                         defaultVisitLeave(node);
    285                 }
    286 
    287277                public void visitEnter(StreamTypeNode node) {
    288278                        defaultVisitEnter(node);
  • proto/pabloj/trunk/src/pabloS/parser/Parser.java

    r2969 r2972  
    382382                result.setProductionTag(12);
    383383                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     384                result.setToken(nowReading);
     385                expect(Lextant.LROUND);
    384386                {
    385387                        ASTNode child = parseFuncCallArgList();
     
    395397         
    396398        public ASTNode parseFuncCallArgList() {
    397                 if( !(nowReading.isLextant(Lextant.LROUND)) ) {
    398                         return syntaxErrorNode("funcCallArgList² [LROUND¹]");
    399                 }
    400        
    401399                boolean allowCompression = true;
    402400                ASTNode result = new FuncCallArgListNode(nowReading);
    403401                result.setProductionTag(13);
    404402                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    405                 {
    406                         ASTNode child = parseRound();
    407                         result.appendChild(child);
    408                         allChildren.add(child);
    409                 }
    410403                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)) ) {
    411404                        {
     
    429422        }
    430423         
    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          
    448424        public ASTNode parseAssignOperator() {
    449425                if( !(nowReading.isLextant(Lextant.AND_ASSIGN, Lextant.ASSIGN, Lextant.OR_ASSIGN, Lextant.XOR_ASSIGN)) ) {
     
    453429                boolean allowCompression = true;
    454430                ASTNode result = new AssignOperatorNode(nowReading);
    455                 result.setProductionTag(15);
     431                result.setProductionTag(14);
    456432                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    457433                if( nowReading.isLextant(Lextant.ASSIGN) ) {
     
    480456                boolean allowCompression = true;
    481457                ASTNode result = new AssignNode(nowReading);
    482                 result.setProductionTag(16);
     458                result.setProductionTag(15);
    483459                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    484460                {
     
    506482                boolean allowCompression = true;
    507483                ASTNode result = new IfStmtNode(nowReading);
    508                 result.setProductionTag(17);
     484                result.setProductionTag(16);
    509485                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    510486                expect(Lextant.IF);
     
    542518                boolean allowCompression = true;
    543519                ASTNode result = new WhileStmtNode(nowReading);
    544                 result.setProductionTag(18);
     520                result.setProductionTag(17);
    545521                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    546522                expect(Lextant.WHILE);
     
    570546                boolean allowCompression = true;
    571547                ASTNode result = new ReturnStmtNode(nowReading);
    572                 result.setProductionTag(19);
     548                result.setProductionTag(18);
    573549                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    574550                expect(Lextant.RETURN);
     
    594570                boolean allowCompression = true;
    595571                ASTNode result = new LocalVarDeclNode(nowReading);
    596                 result.setProductionTag(20);
     572                result.setProductionTag(19);
    597573                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    598574                expect(Lextant.VAR);
     
    633609                boolean allowCompression = true;
    634610                ASTNode result = new LocalVarAssignOperatorNode(nowReading);
    635                 result.setProductionTag(21);
     611                result.setProductionTag(20);
    636612                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    637613                expect(Lextant.ASSIGN);
     
    649625                boolean allowCompression = true;
    650626                ASTNode result = new ASTNode(nowReading);
    651                 result.setProductionTag(22);
     627                result.setProductionTag(21);
    652628                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    653629                {
     
    669645                boolean allowCompression = true;
    670646                ASTNode result = new BlockStmtNode(nowReading);
    671                 result.setProductionTag(23);
     647                result.setProductionTag(22);
    672648                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    673649                expect(Lextant.LCURLY);
     
    693669                boolean allowCompression = true;
    694670                ASTNode result = new BinaryOperatorNode(nowReading);
    695                 result.setProductionTag(24);
     671                result.setProductionTag(23);
    696672                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    697673                {
     
    728704                boolean allowCompression = true;
    729705                ASTNode result = new BinaryOperatorNode(nowReading);
    730                 result.setProductionTag(25);
     706                result.setProductionTag(24);
    731707                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    732708                {
     
    757733                boolean allowCompression = true;
    758734                ASTNode result = new UnaryOperatorNode(nowReading);
    759                 result.setProductionTag(26);
     735                result.setProductionTag(25);
    760736                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    761737                if( nowReading.isLextant(Lextant.NOT) ) {
     
    783759                boolean allowCompression = true;
    784760                ASTNode result = new ASTNode(nowReading);
    785                 result.setProductionTag(27);
     761                result.setProductionTag(26);
    786762                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    787763                if( nowReading.isLextant(Lextant.LROUND) ) {
     
    837813                boolean allowCompression = true;
    838814                ASTNode result = new ASTNode(nowReading);
    839                 result.setProductionTag(28);
     815                result.setProductionTag(27);
    840816                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    841817                if( (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING)) ) {
     
    866842                boolean allowCompression = true;
    867843                ASTNode result = new IntegerConstantNode(nowReading);
    868                 result.setProductionTag(29);
     844                result.setProductionTag(28);
    869845                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    870846                if( !(nowReading.isLexicalType(LexicalType.INTEGER_CONST)) ) {
     
    892868                boolean allowCompression = true;
    893869                ASTNode result = new StringConstantNode(nowReading);
    894                 result.setProductionTag(30);
     870                result.setProductionTag(29);
    895871                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    896872                if( (nowReading.isLexicalType(LexicalType.STRING)) ) {
     
    919895                boolean allowCompression = true;
    920896                ASTNode result = new CompoundIdentifierNode(nowReading);
    921                 result.setProductionTag(31);
     897                result.setProductionTag(30);
    922898                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    923899                {
     
    948924                boolean allowCompression = true;
    949925                ASTNode result = new IdentifierNode(nowReading);
    950                 result.setProductionTag(32);
     926                result.setProductionTag(31);
    951927                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    952928                if( !(nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
     
    967943                boolean allowCompression = true;
    968944                ASTNode result = new ASTNode(nowReading);
    969                 result.setProductionTag(33);
     945                result.setProductionTag(32);
    970946                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    971947                if( nowReading.isLextant(Lextant.STREAM) ) {
     
    1010986                boolean allowCompression = true;
    1011987                ASTNode result = new StreamTypeNode(nowReading);
    1012                 result.setProductionTag(34);
     988                result.setProductionTag(33);
    1013989                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    1014990                expect(Lextant.STREAM);
     
    10351011                boolean allowCompression = true;
    10361012                ASTNode result = new FieldWidthNode(nowReading);
    1037                 result.setProductionTag(35);
     1013                result.setProductionTag(34);
    10381014                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    10391015                {
     
    10551031                boolean allowCompression = true;
    10561032                ASTNode result = new ASTNode(nowReading);
    1057                 result.setProductionTag(36);
     1033                result.setProductionTag(35);
    10581034                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    10591035                {
     
    10751051                boolean allowCompression = true;
    10761052                ASTNode result = new StructTypeNode(nowReading);
    1077                 result.setProductionTag(37);
     1053                result.setProductionTag(36);
    10781054                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    10791055                expect(Lextant.STRUCT);
     
    11031079                boolean allowCompression = true;
    11041080                ASTNode result = new ASTNode(nowReading);
    1105                 result.setProductionTag(38);
     1081                result.setProductionTag(37);
    11061082                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    11071083                {
     
    11231099                boolean allowCompression = true;
    11241100                ASTNode result = new StructTypeBodyNode(nowReading);
    1125                 result.setProductionTag(39);
     1101                result.setProductionTag(38);
    11261102                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    11271103                expect(Lextant.LCURLY);
     
    11541130                boolean allowCompression = true;
    11551131                ASTNode result = new StructMemberNode(nowReading);
    1156                 result.setProductionTag(40);
     1132                result.setProductionTag(39);
    11571133                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    11581134                {
     
    11791155                boolean allowCompression = true;
    11801156                ASTNode result = new ASTNode(nowReading);
    1181                 result.setProductionTag(41);
     1157                result.setProductionTag(40);
    11821158                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    11831159                {
     
    11991175                boolean allowCompression = true;
    12001176                ASTNode result = new VoidNode(nowReading);
    1201                 result.setProductionTag(42);
     1177                result.setProductionTag(41);
    12021178                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    12031179                expect(Lextant.VOID);
  • proto/pabloj/trunk/src/test/pabloS/PabloSTestHarness.java

    r2967 r2972  
    1515import compilers.pabloB.lang.carrySet.CarrySetBuiltins2CPP;
    1616import compilers.pabloB.lang.carrySet.CarrySetBuiltins2Lang;
    17 import compilers.pabloS.lang.Builtins;
    18 import compilers.pabloS.lang.Builtins2Lang;
     17import compilers.pabloS.lang.PabloSBuiltins;
     18import compilers.pabloS.lang.PabloSBuiltins2Lang;
    1919import compilers.pabloS.lang.PabloSBuiltins2CPP;
    2020import compilers.pabloS.semanticAnalyzer.helpers.AssertCompare;
    2121import compilers.pabloS.semanticAnalyzer.visitors.AdvanceCombinerXFormer;
    2222import compilers.pabloS.semanticAnalyzer.visitors.AugAssignXFormer;
    23 import compilers.pabloS.semanticAnalyzer.visitors.Bitwise2IDISAXFormer;
     23import compilers.pabloS.semanticAnalyzer.visitors.InitStreamDefaultsXFormer;
    2424import compilers.pabloS.semanticAnalyzer.visitors.CarryIntroXFormer;
    2525import compilers.pabloS.semanticAnalyzer.visitors.StreamFuncVisitor;
     
    163163               
    164164                for (Map.Entry<String, ASTNode> entry : streamFuncMap.entrySet()) {                                             
    165                         Bitwise2IDISAXFormer bitwiseToIDISA = new Bitwise2IDISAXFormer(entry.getValue());
     165                        InitStreamDefaultsXFormer bitwiseToIDISA = new InitStreamDefaultsXFormer(entry.getValue());
    166166                        bitwiseToIDISA.XForm();                     
    167167                }
     
    208208                Map<String, ASTNode> streamFuncMap = streamFuncVisitor.makeStreamFuncMap();
    209209               
    210                 Builtins2Lang builtins2CPP = new PabloSBuiltins2CPP();
     210                PabloSBuiltins2Lang builtins2CPP = new PabloSBuiltins2CPP();
    211211               
    212212                for (Map.Entry<String, ASTNode> entry : streamFuncMap.entrySet()) {     
Note: See TracChangeset for help on using the changeset viewer.