Changeset 2947


Ignore:
Timestamp:
Mar 19, 2013, 4:48:22 PM (5 years ago)
Author:
ksherdy
Message:

Code clean up and comments.

Location:
proto/pabloj/trunk/src
Files:
12 added
15 edited
1 moved

Legend:

Unmodified
Added
Removed
  • proto/pabloj/trunk/src/applicationGenerator/HeaderTemplateContentsGenerator.java

    r2935 r2947  
    1313import compiler.ast.pabloB.Accessors;
    1414import compiler.codeGenerator.visitors.Unparser;
    15 import compiler.template.FileTemplate;
    16 import compiler.template.Template;
     15import compiler.templating.FileTemplate;
     16import compiler.templating.Template;
     17
    1718import java.io.File;
    1819import java.io.IOException;
  • proto/pabloj/trunk/src/compiler/ast/pabloS/Generators.java

    r2936 r2947  
    241241                args.add(node);
    242242                args.add(Generators.makeIdentifierNode(builtins2Lang.getCode(Builtins.EOFMASK), node.getToken()));
    243                 return Generators.makeFuncCallNode(SIMD.AND.idisaLexeme(), node.getToken(), args);
     243                return Generators.makeFuncCallNode(SIMD.AND.IDISALexeme(), node.getToken(), args);
    244244        }
    245245
     
    248248                args.add(node);
    249249                args.add(Generators.makeIdentifierNode(builtins2Lang.getCode(Builtins.EOFMASK), node.getToken()));
    250                 return Generators.makeFuncCallNode(SIMD.ANDC.idisaLexeme(), node.getToken(), args);
     250                return Generators.makeFuncCallNode(SIMD.ANDC.IDISALexeme(), node.getToken(), args);
    251251        }       
    252252
     
    255255                args.add(Generators.makeIdentifierNode(builtins2Lang.getCode(Builtins.EOFMASK), node.getToken()));
    256256                args.add(node);
    257                 return Generators.makeFuncCallNode(SIMD.ANDC.idisaLexeme(), node.getToken(), args);
     257                return Generators.makeFuncCallNode(SIMD.ANDC.IDISALexeme(), node.getToken(), args);
    258258        }               
    259259       
     
    261261                List<ASTNode> args = new ArrayList<ASTNode>();
    262262                args.add(node);
    263                 return Generators.makeFuncCallNode(SIMD.NOT.idisaLexeme(), node.getToken(), args);
     263                return Generators.makeFuncCallNode(SIMD.NOT.IDISALexeme(), node.getToken(), args);
    264264        }               
    265265       
  • proto/pabloj/trunk/src/compiler/lang/idisa/SIMD.java

    r2939 r2947  
    5454        private static final String SIMD = "simd";
    5555       
    56         public String idisaLexeme() { return (SIMD + "_" + lexeme); }
    57         public String idisaLexeme(String fieldWidth) { return (SIMD + "<" + fieldWidth + ">::" + lexeme); }
    58         public String idisaConstantLexeme(String constant, String fieldWidth) {
     56        public String IDISALexeme() { return (SIMD + "_" + lexeme); }
     57        public String IDISALexeme(String fieldWidth) { return (SIMD + "<" + fieldWidth + ">::" + lexeme); }
     58        public String IDISAConstantLexeme(String constant, String fieldWidth) {
    5959                return (SIMD + "<" + fieldWidth + ">::" + CONSTANT.lexeme + "<" + constant +">");
    6060        }
  • proto/pabloj/trunk/src/compiler/lang/pabloB/Builtins.java

    r2939 r2947  
    1 package compiler.lang.PabloB;
     1package compiler.lang.pabloB;
    22
    33import java.util.ArrayList;
  • proto/pabloj/trunk/src/compiler/lang/pabloB/Builtins2Lang.java

    r2939 r2947  
    1 package compiler.lang.PabloB;
     1package compiler.lang.pabloB;
    22
    33public abstract class Builtins2Lang {
  • proto/pabloj/trunk/src/compiler/lang/pabloS/PabloSBuiltins2CPP.java

    r2939 r2947  
    3939        pabloS2CPPCode.put(Builtins.ADVANCEN, "BitBlock_advance_n_<%s>");
    4040
    41         pabloS2CPPCode.put(Builtins.MASK, SIMD.CONSTANT.idisaConstantLexeme("1", "%s"));
    42         pabloS2CPPCode.put(Builtins.MASKFW, SIMD.CONSTANT.idisaConstantLexeme("%s", "%s"));
     41        pabloS2CPPCode.put(Builtins.MASK, SIMD.CONSTANT.IDISAConstantLexeme("1", "%s"));
     42        pabloS2CPPCode.put(Builtins.MASKFW, SIMD.CONSTANT.IDISAConstantLexeme("%s", "%s"));
    4343       
    4444        pabloS2CPPCode.put(Builtins.ATEOF, "atEOF");
  • proto/pabloj/trunk/src/compiler/parser/Parser.java

    r2922 r2947  
    11/*
    22 * PabloS parser wrapper.
     3 *
    34 *
    45 * @author Ken Herdy <ksherdy at sfu dot ca>
  • proto/pabloj/trunk/src/pabloS/ast/ASTTransformer.java

    r2834 r2947  
    4242        public ASTNode visit(IntegerConstantNode node);
    4343
     44        public ASTNode visit(LocalVarAssignOperatorNode node);
     45
    4446        public ASTNode visit(LocalVarDeclNode node);
    4547
     
    5153
    5254        public ASTNode visit(ReturnStmtNode node);
    53 
    54         public ASTNode visit(StreamConstantNode node);
    5555
    5656        public ASTNode visit(StreamTypeNode node);
     
    145145                }
    146146
     147                public ASTNode visit(LocalVarAssignOperatorNode node) {
     148                        return defaultVisit(node);
     149                }
     150
    147151                public ASTNode visit(LocalVarDeclNode node) {
    148152                        return defaultVisit(node);
     
    162166
    163167                public ASTNode visit(ReturnStmtNode node) {
    164                         return defaultVisit(node);
    165                 }
    166 
    167                 public ASTNode visit(StreamConstantNode node) {
    168168                        return defaultVisit(node);
    169169                }
  • proto/pabloj/trunk/src/pabloS/ast/ASTVisitor.java

    r2834 r2947  
    5959        public T visitLeave(IntegerConstantNode node, List<T> childResults);
    6060
     61        public void visitEnter(LocalVarAssignOperatorNode node);
     62        public T visitLeave(LocalVarAssignOperatorNode node, List<T> childResults);
     63
    6164        public void visitEnter(LocalVarDeclNode node);
    6265        public T visitLeave(LocalVarDeclNode node, List<T> childResults);
     
    7376        public void visitEnter(ReturnStmtNode node);
    7477        public T visitLeave(ReturnStmtNode node, List<T> childResults);
    75 
    76         public void visitEnter(StreamConstantNode node);
    77         public T visitLeave(StreamConstantNode node, List<T> childResults);
    7878
    7979        public void visitEnter(StreamTypeNode node);
     
    236236                }
    237237
     238                public void visitEnter(LocalVarAssignOperatorNode node) {
     239                        defaultVisitEnter(node);
     240                }
     241                public T visitLeave(LocalVarAssignOperatorNode node, List<T> childResults) {
     242                        return defaultVisitLeave(node);
     243                }
     244
    238245                public void visitEnter(LocalVarDeclNode node) {
    239246                        defaultVisitEnter(node);
     
    268275                }
    269276                public T visitLeave(ReturnStmtNode node, List<T> childResults) {
    270                         return defaultVisitLeave(node);
    271                 }
    272 
    273                 public void visitEnter(StreamConstantNode node) {
    274                         defaultVisitEnter(node);
    275                 }
    276                 public T visitLeave(StreamConstantNode node, List<T> childResults) {
    277277                        return defaultVisitLeave(node);
    278278                }
  • proto/pabloj/trunk/src/pabloS/ast/SimpleVisitor.java

    r2834 r2947  
    4343        public void visit(IntegerConstantNode node);
    4444
     45        public void visit(LocalVarAssignOperatorNode node);
     46
    4547        public void visit(LocalVarDeclNode node);
    4648
     
    5254
    5355        public void visit(ReturnStmtNode node);
    54 
    55         public void visit(StreamConstantNode node);
    5656
    5757        public void visit(StreamTypeNode node);
     
    146146                }
    147147
     148                public void visit(LocalVarAssignOperatorNode node) {
     149                        defaultVisit(node);
     150                }
     151
    148152                public void visit(LocalVarDeclNode node) {
    149153                        defaultVisit(node);
     
    163167
    164168                public void visit(ReturnStmtNode node) {
    165                         defaultVisit(node);
    166                 }
    167 
    168                 public void visit(StreamConstantNode node) {
    169169                        defaultVisit(node);
    170170                }
  • proto/pabloj/trunk/src/pabloS/ast/VoidVisitor.java

    r2834 r2947  
    5757        public void visitLeave(IntegerConstantNode node);
    5858
     59        public void visitEnter(LocalVarAssignOperatorNode node);
     60        public void visitLeave(LocalVarAssignOperatorNode node);
     61
    5962        public void visitEnter(LocalVarDeclNode node);
    6063        public void visitLeave(LocalVarDeclNode node);
     
    7174        public void visitEnter(ReturnStmtNode node);
    7275        public void visitLeave(ReturnStmtNode node);
    73 
    74         public void visitEnter(StreamConstantNode node);
    75         public void visitLeave(StreamConstantNode node);
    7676
    7777        public void visitEnter(StreamTypeNode node);
     
    233233                }
    234234
     235                public void visitEnter(LocalVarAssignOperatorNode node) {
     236                        defaultVisitEnter(node);
     237                }
     238                public void visitLeave(LocalVarAssignOperatorNode node) {
     239                        defaultVisitLeave(node);
     240                }
     241
    235242                public void visitEnter(LocalVarDeclNode node) {
    236243                        defaultVisitEnter(node);
     
    265272                }
    266273                public void visitLeave(ReturnStmtNode node) {
    267                         defaultVisitLeave(node);
    268                 }
    269 
    270                 public void visitEnter(StreamConstantNode node) {
    271                         defaultVisitEnter(node);
    272                 }
    273                 public void visitLeave(StreamConstantNode node) {
    274274                        defaultVisitLeave(node);
    275275                }
  • proto/pabloj/trunk/src/pabloS/lexicalAnalyzer/Lextant.java

    r2834 r2947  
    4040        AND("&", "main"),
    4141        RROUND(")", "main"),
    42         MINUS("-", "main"),
    4342        RCURLY("}", "main"),
    4443        RANGLE(">", "main"),
  • proto/pabloj/trunk/src/pabloS/parser/Parser.java

    r2917 r2947  
    583583                        allChildren.add(child);
    584584                }
    585                 if( nowReading.isLextant(Lextant.AND_ASSIGN, Lextant.ASSIGN, Lextant.OR_ASSIGN, Lextant.XOR_ASSIGN) ) {
    586                         {
    587                                 ASTNode child = parseAssignOperator();
     585                if( nowReading.isLextant(Lextant.ASSIGN) ) {
     586                        {
     587                                ASTNode child = parseLocalVarAssignOperator();
    588588                                // node omitted - no result.appendChild(child);
    589589                                allChildren.add(child);
     
    596596                        }
    597597                }
     598                if(allowCompression) {
     599                        return result;
     600                }
     601                return result;
     602        }
     603         
     604        public ASTNode parseLocalVarAssignOperator() {
     605                if( !(nowReading.isLextant(Lextant.ASSIGN)) ) {
     606                        return syntaxErrorNode("localVarAssignOperator² [ASSIGN¹]");
     607                }
     608       
     609                boolean allowCompression = true;
     610                ASTNode result = new LocalVarAssignOperatorNode(nowReading);
     611                result.setProductionTag(20);
     612                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     613                expect(Lextant.ASSIGN);
    598614                if(allowCompression) {
    599615                        return result;
     
    609625                boolean allowCompression = true;
    610626                ASTNode result = new ASTNode(nowReading);
    611                 result.setProductionTag(20);
     627                result.setProductionTag(21);
    612628                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    613629                {
     
    629645                boolean allowCompression = true;
    630646                ASTNode result = new BlockStmtNode(nowReading);
    631                 result.setProductionTag(21);
     647                result.setProductionTag(22);
    632648                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    633649                expect(Lextant.LCURLY);
     
    653669                boolean allowCompression = true;
    654670                ASTNode result = new BinaryOperatorNode(nowReading);
    655                 result.setProductionTag(22);
     671                result.setProductionTag(23);
    656672                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    657673                {
     
    688704                boolean allowCompression = true;
    689705                ASTNode result = new BinaryOperatorNode(nowReading);
    690                 result.setProductionTag(23);
     706                result.setProductionTag(24);
    691707                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    692708                {
     
    717733                boolean allowCompression = true;
    718734                ASTNode result = new UnaryOperatorNode(nowReading);
    719                 result.setProductionTag(24);
     735                result.setProductionTag(25);
    720736                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    721737                if( nowReading.isLextant(Lextant.NOT) ) {
     
    743759                boolean allowCompression = true;
    744760                ASTNode result = new ASTNode(nowReading);
    745                 result.setProductionTag(25);
     761                result.setProductionTag(26);
    746762                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    747763                if( nowReading.isLextant(Lextant.LROUND) ) {
     
    791807         
    792808        public ASTNode parseConstant() {
    793                 if( !(nowReading.isLextant(Lextant.MINUS) || (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) || (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING))) ) {
    794                         return syntaxErrorNode("constant² [INTEGER_CONST¹, MINUS¹, SQ_STRING¹, STRING¹]");
    795                 }
    796        
    797                 boolean allowCompression = true;
    798                 ASTNode result = new ASTNode(nowReading);
    799                 result.setProductionTag(26);
    800                 RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    801                 if( (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING)) ) {
    802                         {
    803                                 ASTNode child = parseStringConstant();
    804                                 result.appendChild(child);
    805                                 allChildren.add(child);
    806                         }
    807                 }
    808                 else if( nowReading.isLextant(Lextant.MINUS) || (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) ) {
    809                         {
    810                                 ASTNode child = parseSignedIntegerConstant();
    811                                 result.appendChild(child);
    812                                 allChildren.add(child);
    813                         }
    814                 }
    815                 if(allowCompression) {
    816                         return compressIfPossible(result);
    817                 }
    818                 return result;
    819         }
    820          
    821         public ASTNode parseSignedIntegerConstant() {
    822                 if( !(nowReading.isLextant(Lextant.MINUS) || (nowReading.isLexicalType(LexicalType.INTEGER_CONST))) ) {
    823                         return syntaxErrorNode("signedIntegerConstant² [INTEGER_CONST¹, MINUS¹]");
     809                if( !((nowReading.isLexicalType(LexicalType.INTEGER_CONST)) || (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING))) ) {
     810                        return syntaxErrorNode("constant² [INTEGER_CONST¹, SQ_STRING¹, STRING¹]");
    824811                }
    825812       
     
    828815                result.setProductionTag(27);
    829816                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    830                 if( nowReading.isLextant(Lextant.MINUS) ) {
    831                         expect(Lextant.MINUS);
     817                if( (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING)) ) {
     818                        {
     819                                ASTNode child = parseStringConstant();
     820                                result.appendChild(child);
     821                                allChildren.add(child);
     822                        }
     823                }
     824                else if( (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) ) {
    832825                        {
    833826                                ASTNode child = parseIntegerConstant();
     
    835828                                allChildren.add(child);
    836829                        }
    837                         {
    838                                 ASTNode temp_1 = allChildren.revGet(0);
    839                                 IntValuedNodeType temp_3 = (IntValuedNodeType)temp_1;
    840                                 int temp_4 = 0;
    841                                 ASTNode temp_5 = allChildren.revGet(0);
    842                                 IntValuedNodeType temp_7 = (IntValuedNodeType)temp_5;
    843                                 int temp_6 = temp_7.getValue();
    844                                 int temp_8 = temp_4 - temp_6;
    845                                 temp_3.setValue( temp_8 );
    846                         }
    847                 }
    848                 else if( (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) ) {
    849                         {
    850                                 ASTNode child = parseIntegerConstant();
    851                                 result.appendChild(child);
    852                                 allChildren.add(child);
    853                         }
    854                 }
    855                 if(allowCompression) {
    856                         return compressIfPossible(result);
    857                 }
    858                 return result;
    859         }
    860          
    861         public ASTNode parseStreamConstant() {
    862                 if( !((nowReading.isLexicalType(LexicalType.INTEGER_CONST))) ) {
    863                         return syntaxErrorNode("streamConstant² [INTEGER_CONST¹]");
    864                 }
    865        
    866                 boolean allowCompression = true;
    867                 ASTNode result = new StreamConstantNode(nowReading);
    868                 result.setProductionTag(28);
    869                 RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    870                 if( !(nowReading.isLexicalType(LexicalType.INTEGER_CONST)) ) {
    871                         return syntaxErrorNode("INTEGER_CONST");
    872                 }
    873                 readToken();
    874                 {
    875                         ASTNode temp_9 = result;
    876                         IntValuedNodeType temp_11 = (IntValuedNodeType)temp_9;
    877                         IntConstantToken temp_14 = (IntConstantToken)previouslyRead;
    878                         int temp_13 = temp_14.getValue();
    879                         temp_11.setValue( temp_13 );
    880                 }
    881                 if(allowCompression) {
    882                         return result;
     830                }
     831                if(allowCompression) {
     832                        return compressIfPossible(result);
    883833                }
    884834                return result;
     
    892842                boolean allowCompression = true;
    893843                ASTNode result = new IntegerConstantNode(nowReading);
    894                 result.setProductionTag(29);
     844                result.setProductionTag(28);
    895845                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    896846                if( !(nowReading.isLexicalType(LexicalType.INTEGER_CONST)) ) {
     
    899849                readToken();
    900850                {
    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 );
     851                        ASTNode temp_1 = result;
     852                        IntValuedNodeType temp_3 = (IntValuedNodeType)temp_1;
     853                        IntConstantToken temp_6 = (IntConstantToken)previouslyRead;
     854                        int temp_5 = temp_6.getValue();
     855                        temp_3.setValue( temp_5 );
    906856                }
    907857                if(allowCompression) {
     
    918868                boolean allowCompression = true;
    919869                ASTNode result = new StringConstantNode(nowReading);
    920                 result.setProductionTag(30);
     870                result.setProductionTag(29);
    921871                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    922872                if( (nowReading.isLexicalType(LexicalType.STRING)) ) {
     
    945895                boolean allowCompression = true;
    946896                ASTNode result = new CompoundIdentifierNode(nowReading);
    947                 result.setProductionTag(31);
     897                result.setProductionTag(30);
    948898                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    949899                {
     
    974924                boolean allowCompression = true;
    975925                ASTNode result = new IdentifierNode(nowReading);
    976                 result.setProductionTag(32);
     926                result.setProductionTag(31);
    977927                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    978928                if( !(nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
     
    993943                boolean allowCompression = true;
    994944                ASTNode result = new ASTNode(nowReading);
    995                 result.setProductionTag(33);
     945                result.setProductionTag(32);
    996946                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    997947                if( nowReading.isLextant(Lextant.STREAM) ) {
     
    1036986                boolean allowCompression = true;
    1037987                ASTNode result = new StreamTypeNode(nowReading);
    1038                 result.setProductionTag(34);
     988                result.setProductionTag(33);
    1039989                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    1040990                expect(Lextant.STREAM);
     
    10611011                boolean allowCompression = true;
    10621012                ASTNode result = new FieldWidthNode(nowReading);
    1063                 result.setProductionTag(35);
    1064                 RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    1065                 {
    1066                         ASTNode child = parseStreamConstant();
     1013                result.setProductionTag(34);
     1014                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     1015                {
     1016                        ASTNode child = parseIntegerConstant();
    10671017                        result.appendChild(child);
    10681018                        allChildren.add(child);
     
    10811031                boolean allowCompression = true;
    10821032                ASTNode result = new ASTNode(nowReading);
    1083                 result.setProductionTag(36);
     1033                result.setProductionTag(35);
    10841034                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    10851035                {
     
    11011051                boolean allowCompression = true;
    11021052                ASTNode result = new StructTypeNode(nowReading);
    1103                 result.setProductionTag(37);
     1053                result.setProductionTag(36);
    11041054                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    11051055                expect(Lextant.STRUCT);
     
    11291079                boolean allowCompression = true;
    11301080                ASTNode result = new ASTNode(nowReading);
    1131                 result.setProductionTag(38);
     1081                result.setProductionTag(37);
    11321082                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    11331083                {
     
    11491099                boolean allowCompression = true;
    11501100                ASTNode result = new StructTypeBodyNode(nowReading);
    1151                 result.setProductionTag(39);
     1101                result.setProductionTag(38);
    11521102                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    11531103                expect(Lextant.LCURLY);
     
    11801130                boolean allowCompression = true;
    11811131                ASTNode result = new StructMemberNode(nowReading);
    1182                 result.setProductionTag(40);
     1132                result.setProductionTag(39);
    11831133                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    11841134                {
     
    12051155                boolean allowCompression = true;
    12061156                ASTNode result = new ASTNode(nowReading);
    1207                 result.setProductionTag(41);
     1157                result.setProductionTag(40);
    12081158                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    12091159                {
     
    12251175                boolean allowCompression = true;
    12261176                ASTNode result = new VoidNode(nowReading);
    1227                 result.setProductionTag(42);
     1177                result.setProductionTag(41);
    12281178                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    12291179                expect(Lextant.VOID);
  • proto/pabloj/trunk/src/test/PabloApplication.java

    r2834 r2947  
    1 //
    2 // This code is modified scatter parser-generator code.
    3 // See applications.SampleApplication.java.
    4 //
     1/*
     2 * Basic test harness.
     3 * This code is modified scatter parser-generator code.
     4 * See applications.SampleApplication.java.
     5 *
     6 * @author Ken Herdy <ksherdy at sfu dot ca>
     7 */
     8
    59package test;
    610
  • proto/pabloj/trunk/src/test/pabloS/PabloSTestHarness.java

    r2929 r2947  
    1313import  pabloS.logging.ScatterLogger;
    1414
    15 import compiler.lang.carry.CarrySetBuiltins2CPP;
    16 import compiler.lang.carry.CarrySetBuiltins2Lang;
    17 import compiler.lang.idisa.*;
    18 import compiler.lang.pabloS.Builtins2CPP;
     15import compiler.test.*;
     16import compiler.lang.carry.CarryBuiltins2CPP;
     17import compiler.lang.carry.CarryBuiltins2Lang;
     18import compiler.lang.pabloS.PabloSBuiltins2CPP;
    1919import compiler.lang.pabloS.Builtins2Lang;
    20 import compiler.test.*;
     20import compiler.lang.pabloS.Builtins;
     21
    2122import compiler.transformers.pabloS.AdvanceCombinerXFormer;
    2223import compiler.transformers.pabloS.AugAssignXFormer;
     
    207208                Map<String, ASTNode> streamFuncMap = streamFuncVisitor.makeStreamFuncMap();
    208209               
    209                 Builtins2Lang builtins2CPP = new Builtins2CPP();
     210                Builtins2Lang builtins2CPP = new PabloSBuiltins2CPP();
    210211               
    211212                for (Map.Entry<String, ASTNode> entry : streamFuncMap.entrySet()) {     
    212213                        ASTNode value = entry.getValue();                               
    213                         CarrySetBuiltins2Lang carrySet2CPP = new CarrySetBuiltins2CPP();
     214                        CarryBuiltins2Lang carrySet2CPP = new CarryBuiltins2CPP();
    214215                        CarryIntroXFormer pablo2CarryQ = new CarryIntroXFormer(value, builtins2CPP, carrySet2CPP);
    215216                        pablo2CarryQ.XForm(isFinalBlock);
Note: See TracChangeset for help on using the changeset viewer.