Changeset 2710


Ignore:
Timestamp:
Dec 2, 2012, 12:50:44 AM (6 years ago)
Author:
ksherdy
Message:

General refactoring.

Location:
proto/pablo
Files:
9 added
4 deleted
42 edited
13 copied
15 moved

Legend:

Unmodified
Added
Removed
  • proto/pablo/ReadMe.txt

    r2702 r2710  
    165165
    166166Pablo language control structures.     
    167        
     167
     168Neither
     169
     170Ci (Carry In Only Mode)
     171
     172- While statements iteration i>1
     173
     174Co (Carry Out Only Mode)
     175
    168176Ci/Co (Carry In / Carry Out Mode)
    169177
     
    171179- If statements
    172180
    173 Ci (Carry In Only Mode)
    174 
    175 - While statements iteration i>1
    176 
    177 Co (Carry Out Only Mode)
    178 
    179 ...
    180 
    181 Pablo builtins
    182 
    183 ScanToFirst - Special consideration at initial block as well as atEOF, i.e. set carry bit at SOF, inFile(), atEOF()?
    184 SpanUpTo        - Special consideration atEOF, i.e. check to ensure scan terminates at a valid position
    185 Advance
    186 AdvanceN
    187 
    188 + Block Types
     181+ Potential Block Types
    189182
    190183Initial block(ScanToFirst)
     
    193186Initial/Final block
    194187
     18815. Apply &~ EOF_mask to all pablo builtin operations.
     189
     190+ Final Block EOF_mask
     191
     192Builtins
     193
     194AdvanceThenScanThru(M,S)        --> AdvanceThenScanThru(M, (S &~ EOF_mask))
     195AdvanceThenScanTo(M,S)          --> AdvanceThenScanThru(M,~(S &~ EOF_mask))
     196
     197
     198inFile(E) --> S & EOF_mask  --> assert_0(inFile(E))
     199i.e. tests only bits within the file the extent and then test none of this set of bits is marked
     200
     201atEOF(E)  --> S &~ EOF_mask --> assert_0(atEOF(E)) 
     202i.e. tests no bit beyond the file extents is marked
     203
     204Control Structures
     205
     206while (E) { S }
     207
     208-->
     209
     210if(bitblock::any( (E | carry_test(lower,count) &~ EOF_mask ) )
     211{
     212        S
     213       
     214        while (bitblock::any(simd_and(E, EOF_mask))
     215        {
     216                S
     217        }
     218}
     219
     220if (E) { S }
     221
     222-->
     223
     224if(bitblock::any( (E | carry_test(lower,count) &~ EOF_mask ) )
     225{
     226        S
     227}
  • proto/pablo/input/test/visitors/AdvanceCombinerXFormer/advance.pablo

    r2642 r2710  
    1414        temp = Advance(X,3);
    1515        temp = Advance(Advance(X,2));
    16        
    1716       
    1817        temp = Advance(X,3);
  • proto/pablo/input/test/visitors/Pablo2CarryQXFormer/NotFinalBlock/pablo2CarryQ.pablo

    r2684 r2710  
    55        var stream R;   // Result stream
    66       
     7        // TODO - UPDATE EXPECTED RESULTS
    78       
    89        R = carryQ.BitBlock_advance_ci_co(C,carryQ.get_carry_in(0),0);  // Expected
  • proto/pablo/src/application/ApplicationGenerator.java

    r2702 r2710  
    33//import ast.StartSymbolNode;
    44import ast.ASTNode;
    5 import ast.ProgramNode;
    6 import compiler.codeGenerator.CodeGenerator;
    7 import compiler.codeGenerator.visitors.CPPUnparser;
    8 import compiler.codeGenerator.visitors.Unparser;
     5import compiler.backend.CodeGenerator;
     6import compiler.backend.visitors.CPPUnparser;
     7import compiler.backend.visitors.Unparser;
     8import compiler.frontend.SyntacticAnalysisFailedException;
     9import compiler.frontend.SyntacticAnalyzer;
    910import compiler.lang.pablo.*;
    1011import compiler.lang.carryset.*;
    11 import compiler.semanticAnalyzer.SemanticAnalyzer;
    12 import compiler.syntacticAnalyzer.SyntacticAnalysisFailedException;
    13 import compiler.syntacticAnalyzer.SyntacticAnalyzer;
    1412
    1513import tokens.Tokens;
     
    6058                }
    6159               
    62                 // Transformation Mode ci/co, ci
    63                
     60                // Transformation
    6461                ASTNode syntaxTree = SyntacticAnalyzer.parse(applicationConfig.inputFile);
    6562               
    66                                                
    67                 /*
     63                // Generate Stream Type Decls   - Iterates over stream struct decl AST nodes
     64               
     65                // Generate Stream Functions    - Iterates over stream function decl ASTs nodes
     66               
     67               
     68                System.out.print(unparser.getCode(syntaxTree));
     69                               
    6870               
    6971                // Analyze and transform the AST
    70                 SemanticAnalyzer semanticAnalyzer = new SemanticAnalyzer(syntaxTree);
    71                 semanticAnalyzer.setTargetLang();
    72                 semanticAnalzyer.setMode();
    73                 ASTNode decorateCiCoTree = semanticAnalyzer.analyze();
     72                CodeGenerator semanticAnalyzer = new CodeGenerator(syntaxTree, builtins2Lang, carrySet2Lang);
     73                //ASTNode decorateTree = semanticAnalyzer.analyze();
    7474
    75                 //
    76                 ASTNode syntaxTree = SyntacticAnalyzer.parse(applicationConfig.inputFile);
    77                        
    78                 SemanticAnalyzer semanticAnalyzer = new SemanticAnalyzer(syntaxTree);
    79                 semanticAnalyzer.setTargetLang();
    80                 semanticAnalzyer.setMode();
    81                 ASTNode decorateCoTree = semanticAnalyzer.analyze();
     75                // Generate Template
     76                                       
     77                // Generate Code
    8278               
    83                 ASTNode syntaxTree = SyntacticAnalyzer.parse(applicationConfig.inputFile);
    84                
    85                 ASTNode SyntaxTree = SyntacticAnalyzer.parse(applicationConfig.inputFile);
    86                 semanticAnalyzer.setTargetLang();
    87                 semanticAnalzyer.setMode();
    88                 SemanticAnalyzer semanticAnalyzer = new SemanticAnalyzer(syntaxTree, builtins2Lang,     carrySet2Lang);
    89                 */
    90                 // Generate
    91                                        
    9279                /*
    9380                String global = CodeGenerator.makeStructDecls((ProgramNode)syntaxTree, unparser);
  • proto/pablo/src/application/TemplateContentsGenerator.java

    r2687 r2710  
    22
    33import ast.*;
    4 import compiler.codeGenerator.visitors.helpers.UnparserUtil;
     4import compiler.backend.visitors.helpers.UnparserUtil;
    55import compiler.template.Template;
    66import application.ApplicationGenerator;
  • proto/pablo/src/application/Test.java

    r2702 r2710  
    2525import compiler.lang.pablo.Builtins2Lang;
    2626import compiler.ast.visitors.*;
    27 import compiler.semanticAnalyzer.visitors.AdvanceCombinerXFormer;
    28 import compiler.semanticAnalyzer.visitors.AugAssignXFormer;
    29 import compiler.semanticAnalyzer.visitors.Bitwise2IDISAXFormer;
    30 import compiler.semanticAnalyzer.visitors.FinalBlockXFormer;
    31 import compiler.semanticAnalyzer.visitors.Pablo2CarryXFormer;
    32 import compiler.semanticAnalyzer.visitors.StreamFuncVisitor;
    33 import compiler.semanticAnalyzer.visitors.helpers.AssertCompare;
     27import compiler.backend.visitors.AdvanceCombinerXFormer;
     28import compiler.backend.visitors.AugAssignXFormer;
     29import compiler.backend.visitors.Bitwise2IDISAXFormer;
     30import compiler.backend.visitors.Pablo2CarryXFormer;
     31import compiler.backend.visitors.StreamFuncVisitor;
     32import compiler.backend.visitors.helpers.AssertCompare;
    3433import compiler.test.*;
    3534
     
    4847            BITWISE2IDISA("Bitwise2IDISAXFormer", true),
    4948            CARRYCOUNTER("CarryCounterVisitor", true),
    50             PABLO2CARRYQCI("Pablo2CarryQCiXFormer", true),
     49            PABLO2CARRYQNOTFINALBLOCK("Pablo2CarryQXFormer/NotFinalBlock", true),
     50            PABLO2CARRYQFINALBLOCK("Pablo2CarryQXFormer/FinalBlock", true),
    5151            CARRYINITTOONELIST("CarryInitToOneListVisitor", true),
    52             STREAMFUNCVISITOR("StreamFuncVisitor", true),
    53             FINALBLOCKXFORMERISFINAL("FinalBlockXFormer/FinalBlock",true),
    54             FINALBLOCKXFORMERISNOTFINAL("FinalBlockXFormer/NotFinalBlock",true);
     52            STREAMFUNCVISITOR("StreamFuncVisitor", true);
    5553            //CARRYQINTROXFORMER("",true); // TODO
    5654            //ASSERTZERO("",true);// TODO
     
    7876                Tokens.setPrintLevel(Tokens.Level.FULL);       
    7977                File testBase = new File(testDirectoryName);
    80 
     78                boolean isFinalBlock;
     79               
    8180                for(Visitor test: Visitor.values()) {
    82                        
    83                         System.out.println(test.name());
    8481                       
    8582                        if (test.addTest()) {
     
    9188                               
    9289                                for(File file: files) {
     90                                       
    9391                                        String fileAbsolutePath = file.getAbsolutePath();
    9492                                        System.out.println("Running: " + fileAbsolutePath);
     93                                       
    9594                                       
    9695                                        switch(test) {
     
    109108                                                case CARRYCOUNTER:
    110109                                                        // TODO
    111                                                         break;                                 
    112                                                 case PABLO2CARRYQCI:
    113                                                         pablo2CarryQTest(fileAbsolutePath, true);
     110                                                        break;
     111                                                case PABLO2CARRYQFINALBLOCK:
     112                                                        isFinalBlock = true;
     113                                                        pablo2CarryQTest(fileAbsolutePath, isFinalBlock);
    114114                                                        break; 
    115                                                 case FINALBLOCKXFORMERISFINAL:
    116                                                         finalBlockXFormerTest(fileAbsolutePath, true);
    117                                                         break;
    118                                                 case FINALBLOCKXFORMERISNOTFINAL:
    119                                                         finalBlockXFormerTest(fileAbsolutePath, false);
    120                                                         break;                                                 
     115                                                case PABLO2CARRYQNOTFINALBLOCK:
     116                                                        isFinalBlock = false;
     117                                                        pablo2CarryQTest(fileAbsolutePath, isFinalBlock);
     118                                                        break;                 
    121119                                                case CARRYINITTOONELIST:
    122120                                                        // TODO
     
    204202         * @throws FileNotFoundException - Final Block
    205203         */
    206         public static void pablo2CarryQTest(String fileAbsolutePath, boolean ciMode) throws FileNotFoundException {
     204        public static void pablo2CarryQTest(String fileAbsolutePath, boolean isFinalBlock) throws FileNotFoundException {
    207205                LexicalController lexController = LexicalController.make(fileAbsolutePath);
    208206                ASTNode syntaxTree = Parser.parse(lexController);
    209                
    210207               
    211208                StreamFuncVisitor streamFuncVisitor = new StreamFuncVisitor(syntaxTree);
     
    218215                        CarrySet2Lang carrySet2CPP = new CarrySet2CPP();
    219216                        Pablo2CarryXFormer pablo2CarryQ = new Pablo2CarryXFormer(value, builtins2CPP, carrySet2CPP);
    220                         pablo2CarryQ.XForm(ciMode);                     
    221                        
     217                        pablo2CarryQ.XForm(isFinalBlock);
    222218                }   
    223219               
     
    226222               
    227223        }       
    228 
    229         /**
    230          * @param fileAbsolutePath
    231          * @throws FileNotFoundException - Final Block
    232          */
    233         public static void finalBlockXFormerTest(String fileAbsolutePath, boolean isFinalBlock) throws FileNotFoundException {
    234                 LexicalController lexController = LexicalController.make(fileAbsolutePath);
    235                 ASTNode syntaxTree = Parser.parse(lexController);
    236                
    237                
    238                 StreamFuncVisitor streamFuncVisitor = new StreamFuncVisitor(syntaxTree);
    239                 Map<String, ASTNode> streamFuncMap = streamFuncVisitor.makeStreamFuncMap();
    240                
    241                 Builtins2Lang builtins2CPP = new Builtins2CPP();
    242                
    243                 for (Map.Entry<String, ASTNode> entry : streamFuncMap.entrySet()) {     
    244                         ASTNode value = entry.getValue();                               
    245                         CarrySet2Lang carrySet2CPP = new CarrySet2CPP();
    246                         FinalBlockXFormer finalBlockXFormer = new FinalBlockXFormer(value, builtins2CPP);
    247                         finalBlockXFormer.XForm(isFinalBlock);                 
    248                        
    249                 }   
    250                
    251                 AssertCompare astTest = new AssertCompare(syntaxTree);
    252                 astTest.compareAssignNodes();
    253                
    254         }               
    255224       
    256225//  CarryCounter carryCounter = new CarryCounter(node);
  • proto/pablo/src/ast/ASTNode.java

    r2686 r2710  
    3434                this.token = node.token;
    3535        }
     36       
     37        protected ASTNode deepCopy() {
     38                ASTNode parent = new ASTNode(this.getToken());
     39               
     40                for(ASTNode child: this.getChildren()) {
     41                        ASTNode copy = child.deepCopy();
     42                        parent.appendChild(copy);
     43                }
     44               
     45            return parent;             
     46        }
     47               
    3648        public Token getToken() {
    3749                return token;
  • proto/pablo/src/ast/AssignNode.java

    r2660 r2710  
    1818                super(node);
    1919        }
     20       
     21        public AssignNode deepCopy() {
     22                AssignNode parent = new AssignNode(this.getToken());
     23               
     24                for(ASTNode child: this.getChildren()) {
     25                        ASTNode copy = child.deepCopy();
     26                        parent.appendChild(copy);
     27                }
     28               
     29            return parent;             
     30        }
     31       
    2032       
    2133        ////////////////////////////////////////////////////////////
  • proto/pablo/src/ast/AssignOperatorNode.java

    r2660 r2710  
    1818                super(node);
    1919        }
     20       
     21        public AssignOperatorNode deepCopy() {
     22                AssignOperatorNode parent = new AssignOperatorNode(this.getToken());
     23               
     24                for(ASTNode child: this.getChildren()) {
     25                        ASTNode copy = child.deepCopy();
     26                        parent.appendChild(copy);
     27                }
     28               
     29            return parent;             
     30        }
     31       
    2032       
    2133        ////////////////////////////////////////////////////////////
  • proto/pablo/src/ast/BinaryOperatorNode.java

    r2415 r2710  
    1818                super(node);
    1919        }
     20       
     21        public BinaryOperatorNode deepCopy() {
     22                BinaryOperatorNode parent = new BinaryOperatorNode(this.getToken());
     23               
     24                for(ASTNode child: this.getChildren()) {
     25                        ASTNode copy = child.deepCopy();
     26                        parent.appendChild(copy);
     27                }
     28               
     29            return parent;             
     30        }
     31       
    2032       
    2133        ////////////////////////////////////////////////////////////
  • proto/pablo/src/ast/BlockStmtNode.java

    r2658 r2710  
    1818                super(node);
    1919        }
     20       
     21        public BlockStmtNode deepCopy() {
     22                BlockStmtNode parent = new BlockStmtNode(this.getToken());
     23               
     24                for(ASTNode child: this.getChildren()) {
     25                        ASTNode copy = child.deepCopy();
     26                        parent.appendChild(copy);
     27                }
     28               
     29            return parent;             
     30        }
     31       
    2032       
    2133        ////////////////////////////////////////////////////////////
  • proto/pablo/src/ast/CompoundIdentifierNode.java

    r2660 r2710  
    1818                super(node);
    1919        }
     20       
     21        public CompoundIdentifierNode deepCopy() {
     22                CompoundIdentifierNode parent = new CompoundIdentifierNode(this.getToken());
     23               
     24                for(ASTNode child: this.getChildren()) {
     25                        ASTNode copy = child.deepCopy();
     26                        parent.appendChild(copy);
     27                }
     28               
     29            return parent;             
     30        }
     31       
    2032       
    2133        ////////////////////////////////////////////////////////////
  • proto/pablo/src/ast/EpsilonNode.java

    r2415 r2710  
    1818                super(node);
    1919        }
     20       
     21        public EpsilonNode deepCopy() {
     22                EpsilonNode parent = new EpsilonNode(this.getToken());
     23               
     24                for(ASTNode child: this.getChildren()) {
     25                        ASTNode copy = child.deepCopy();
     26                        parent.appendChild(copy);
     27                }
     28               
     29            return parent;             
     30        }
     31       
    2032       
    2133        ////////////////////////////////////////////////////////////
  • proto/pablo/src/ast/ErrorNode.java

    r2415 r2710  
    1818                super(node);
    1919        }
     20       
     21        public ErrorNode deepCopy() {
     22                ErrorNode parent = new ErrorNode(this.getToken());
     23               
     24                for(ASTNode child: this.getChildren()) {
     25                        ASTNode copy = child.deepCopy();
     26                        parent.appendChild(copy);
     27                }
     28               
     29            return parent;             
     30        }
     31       
    2032       
    2133        ////////////////////////////////////////////////////////////
  • proto/pablo/src/ast/FieldWidthNode.java

    r2415 r2710  
    1818                super(node);
    1919        }
     20       
     21        public FieldWidthNode deepCopy() {
     22                FieldWidthNode parent = new FieldWidthNode(this.getToken());
     23               
     24                for(ASTNode child: this.getChildren()) {
     25                        ASTNode copy = child.deepCopy();
     26                        parent.appendChild(copy);
     27                }
     28               
     29            return parent;             
     30        }
     31       
    2032       
    2133        ////////////////////////////////////////////////////////////
  • proto/pablo/src/ast/FuncCallArgListNode.java

    r2658 r2710  
    1818                super(node);
    1919        }
     20       
     21        public FuncCallArgListNode deepCopy() {
     22                FuncCallArgListNode parent = new FuncCallArgListNode(this.getToken());
     23               
     24                for(ASTNode child: this.getChildren()) {
     25                        ASTNode copy = child.deepCopy();
     26                        parent.appendChild(copy);
     27                }
     28               
     29            return parent;             
     30        }
     31       
    2032       
    2133        ////////////////////////////////////////////////////////////
  • proto/pablo/src/ast/FuncCallNode.java

    r2658 r2710  
    1818                super(node);
    1919        }
     20       
     21        public FuncCallNode deepCopy() {
     22                FuncCallNode parent = new FuncCallNode(this.getToken());
     23               
     24                for(ASTNode child: this.getChildren()) {
     25                        ASTNode copy = child.deepCopy();
     26                        parent.appendChild(copy);
     27                }
     28               
     29            return parent;             
     30        }
     31       
    2032       
    2133        ////////////////////////////////////////////////////////////
  • proto/pablo/src/ast/FuncCallOrAssignStmtNode.java

    r2660 r2710  
    1818                super(node);
    1919        }
     20       
     21        public FuncCallOrAssignStmtNode deepCopy() {
     22                FuncCallOrAssignStmtNode parent = new FuncCallOrAssignStmtNode(this.getToken());
     23               
     24                for(ASTNode child: this.getChildren()) {
     25                        ASTNode copy = child.deepCopy();
     26                        parent.appendChild(copy);
     27                }
     28               
     29            return parent;             
     30        }
     31       
    2032       
    2133        ////////////////////////////////////////////////////////////
  • proto/pablo/src/ast/FuncDefNode.java

    r2658 r2710  
    1818                super(node);
    1919        }
     20       
     21        public FuncDefNode deepCopy() {
     22                FuncDefNode parent = new FuncDefNode(this.getToken());
     23               
     24                for(ASTNode child: this.getChildren()) {
     25                        ASTNode copy = child.deepCopy();
     26                        parent.appendChild(copy);
     27                }
     28               
     29            return parent;             
     30        }
     31       
    2032       
    2133        ////////////////////////////////////////////////////////////
  • proto/pablo/src/ast/IdentifierNode.java

    r2415 r2710  
    1818                super(node);
    1919        }
     20       
     21        public IdentifierNode deepCopy() {
     22                IdentifierNode parent = new IdentifierNode(this.getToken());
     23               
     24                for(ASTNode child: this.getChildren()) {
     25                        ASTNode copy = child.deepCopy();
     26                        parent.appendChild(copy);
     27                }
     28               
     29            return parent;             
     30        }
     31       
    2032       
    2133        ////////////////////////////////////////////////////////////
  • proto/pablo/src/ast/IfStmtNode.java

    r2658 r2710  
    1818                super(node);
    1919        }
     20       
     21        public IfStmtNode deepCopy() {
     22                IfStmtNode parent = new IfStmtNode(this.getToken());
     23               
     24                for(ASTNode child: this.getChildren()) {
     25                        ASTNode copy = child.deepCopy();
     26                        parent.appendChild(copy);
     27                }
     28               
     29            return parent;             
     30        }
     31       
    2032       
    2133        ////////////////////////////////////////////////////////////
  • proto/pablo/src/ast/IntegerConstantNode.java

    r2415 r2710  
    1818                super(node);
    1919        }
     20       
     21        public IntegerConstantNode deepCopy() {
     22                IntegerConstantNode parent = new IntegerConstantNode(this.getToken());
     23               
     24                for(ASTNode child: this.getChildren()) {
     25                        ASTNode copy = child.deepCopy();
     26                        parent.appendChild(copy);
     27                }
     28               
     29            return parent;             
     30        }
     31       
    2032       
    2133        ////////////////////////////////////////////////////////////
  • proto/pablo/src/ast/LocalVarDeclNode.java

    r2415 r2710  
    1818                super(node);
    1919        }
     20       
     21        public LocalVarDeclNode deepCopy() {
     22                LocalVarDeclNode parent = new LocalVarDeclNode(this.getToken());
     23               
     24                for(ASTNode child: this.getChildren()) {
     25                        ASTNode copy = child.deepCopy();
     26                        parent.appendChild(copy);
     27                }
     28               
     29            return parent;             
     30        }
     31       
    2032       
    2133        ////////////////////////////////////////////////////////////
  • proto/pablo/src/ast/ParameterListNode.java

    r2607 r2710  
    1818                super(node);
    1919        }
     20       
     21        public ParameterListNode deepCopy() {
     22                ParameterListNode parent = new ParameterListNode(this.getToken());
     23               
     24                for(ASTNode child: this.getChildren()) {
     25                        ASTNode copy = child.deepCopy();
     26                        parent.appendChild(copy);
     27                }
     28               
     29            return parent;             
     30        }
     31       
    2032       
    2133        ////////////////////////////////////////////////////////////
  • proto/pablo/src/ast/ParameterNode.java

    r2415 r2710  
    1818                super(node);
    1919        }
     20       
     21        public ParameterNode deepCopy() {
     22                ParameterNode parent = new ParameterNode(this.getToken());
     23               
     24                for(ASTNode child: this.getChildren()) {
     25                        ASTNode copy = child.deepCopy();
     26                        parent.appendChild(copy);
     27                }
     28               
     29            return parent;             
     30        }
     31       
    2032       
    2133        ////////////////////////////////////////////////////////////
  • proto/pablo/src/ast/ProgramNode.java

    r2415 r2710  
    1818                super(node);
    1919        }
     20       
     21        public ProgramNode deepCopy() {
     22                ProgramNode parent = new ProgramNode(this.getToken());
     23               
     24                for(ASTNode child: this.getChildren()) {
     25                        ASTNode copy = child.deepCopy();
     26                        parent.appendChild(copy);
     27                }
     28               
     29            return parent;             
     30        }
     31       
    2032       
    2133        ////////////////////////////////////////////////////////////
  • proto/pablo/src/ast/ReturnStmtNode.java

    r2658 r2710  
    1818                super(node);
    1919        }
     20       
     21        public ReturnStmtNode deepCopy() {
     22                ReturnStmtNode parent = new ReturnStmtNode(this.getToken());
     23               
     24                for(ASTNode child: this.getChildren()) {
     25                        ASTNode copy = child.deepCopy();
     26                        parent.appendChild(copy);
     27                }
     28               
     29            return parent;             
     30        }
     31       
    2032       
    2133        ////////////////////////////////////////////////////////////
  • proto/pablo/src/ast/StreamTypeNode.java

    r2415 r2710  
    1818                super(node);
    1919        }
     20       
     21        public StreamTypeNode deepCopy() {
     22                StreamTypeNode parent = new StreamTypeNode(this.getToken());
     23               
     24                for(ASTNode child: this.getChildren()) {
     25                        ASTNode copy = child.deepCopy();
     26                        parent.appendChild(copy);
     27                }
     28               
     29            return parent;             
     30        }
     31       
    2032       
    2133        ////////////////////////////////////////////////////////////
  • proto/pablo/src/ast/StringConstantNode.java

    r2415 r2710  
    1818                super(node);
    1919        }
     20       
     21        public StringConstantNode deepCopy() {
     22                StringConstantNode parent = new StringConstantNode(this.getToken());
     23               
     24                for(ASTNode child: this.getChildren()) {
     25                        ASTNode copy = child.deepCopy();
     26                        parent.appendChild(copy);
     27                }
     28               
     29            return parent;             
     30        }
     31       
    2032       
    2133        ////////////////////////////////////////////////////////////
  • proto/pablo/src/ast/StructMemberNode.java

    r2415 r2710  
    1818                super(node);
    1919        }
     20       
     21        public StructMemberNode deepCopy() {
     22                StructMemberNode parent = new StructMemberNode(this.getToken());
     23               
     24                for(ASTNode child: this.getChildren()) {
     25                        ASTNode copy = child.deepCopy();
     26                        parent.appendChild(copy);
     27                }
     28               
     29            return parent;             
     30        }
     31       
    2032       
    2133        ////////////////////////////////////////////////////////////
  • proto/pablo/src/ast/StructTypeBodyNode.java

    r2415 r2710  
    1818                super(node);
    1919        }
     20       
     21        public StructTypeBodyNode deepCopy() {
     22                StructTypeBodyNode parent = new StructTypeBodyNode(this.getToken());
     23               
     24                for(ASTNode child: this.getChildren()) {
     25                        ASTNode copy = child.deepCopy();
     26                        parent.appendChild(copy);
     27                }
     28               
     29            return parent;             
     30        }
     31       
    2032       
    2133        ////////////////////////////////////////////////////////////
  • proto/pablo/src/ast/StructTypeNode.java

    r2415 r2710  
    1818                super(node);
    1919        }
     20       
     21        public StructTypeNode deepCopy() {
     22                StructTypeNode parent = new StructTypeNode(this.getToken());
     23               
     24                for(ASTNode child: this.getChildren()) {
     25                        ASTNode copy = child.deepCopy();
     26                        parent.appendChild(copy);
     27                }
     28               
     29            return parent;             
     30        }
     31       
    2032       
    2133        ////////////////////////////////////////////////////////////
  • proto/pablo/src/ast/TypeDeclNode.java

    r2415 r2710  
    1818                super(node);
    1919        }
     20       
     21        public TypeDeclNode deepCopy() {
     22                TypeDeclNode parent = new TypeDeclNode(this.getToken());
     23               
     24                for(ASTNode child: this.getChildren()) {
     25                        ASTNode copy = child.deepCopy();
     26                        parent.appendChild(copy);
     27                }
     28               
     29            return parent;             
     30        }
     31       
    2032       
    2133        ////////////////////////////////////////////////////////////
  • proto/pablo/src/ast/TypeDefNode.java

    r2415 r2710  
    1818                super(node);
    1919        }
     20       
     21        public TypeDefNode deepCopy() {
     22                TypeDefNode parent = new TypeDefNode(this.getToken());
     23               
     24                for(ASTNode child: this.getChildren()) {
     25                        ASTNode copy = child.deepCopy();
     26                        parent.appendChild(copy);
     27                }
     28               
     29            return parent;             
     30        }
     31       
    2032       
    2133        ////////////////////////////////////////////////////////////
  • proto/pablo/src/ast/UnaryOperatorNode.java

    r2415 r2710  
    1818                super(node);
    1919        }
     20       
     21        public UnaryOperatorNode deepCopy() {
     22                UnaryOperatorNode parent = new UnaryOperatorNode(this.getToken());
     23               
     24                for(ASTNode child: this.getChildren()) {
     25                        ASTNode copy = child.deepCopy();
     26                        parent.appendChild(copy);
     27                }
     28               
     29            return parent;             
     30        }
     31       
    2032       
    2133        ////////////////////////////////////////////////////////////
  • proto/pablo/src/ast/VoidNode.java

    r2607 r2710  
    1818                super(node);
    1919        }
     20       
     21        public VoidNode deepCopy() {
     22                VoidNode parent = new VoidNode(this.getToken());
     23               
     24                for(ASTNode child: this.getChildren()) {
     25                        ASTNode copy = child.deepCopy();
     26                        parent.appendChild(copy);
     27                }
     28               
     29            return parent;             
     30        }
     31       
    2032       
    2133        ////////////////////////////////////////////////////////////
  • proto/pablo/src/ast/WhileStmtNode.java

    r2658 r2710  
    1818                super(node);
    1919        }
     20       
     21        public WhileStmtNode deepCopy() {
     22                WhileStmtNode parent = new WhileStmtNode(this.getToken());
     23               
     24                for(ASTNode child: this.getChildren()) {
     25                        ASTNode copy = child.deepCopy();
     26                        parent.appendChild(copy);
     27                }
     28               
     29            return parent;             
     30        }
     31       
    2032       
    2133        ////////////////////////////////////////////////////////////
  • proto/pablo/src/compiler/ast/Accessors.java

    r2702 r2710  
    246246               
    247247                if((index + 1) > Accessors.funcCallArgsListNode(node).getChildren().size()) {
    248                         throw new RuntimeException("Func invocation Arg out of range.");
     248                        throw new RuntimeException("Function invocation argument out of range.");
    249249                }
    250250                return Accessors.funcCallArgsListNode(node).child(index);
  • proto/pablo/src/compiler/ast/Generators.java

    r2702 r2710  
    22
    33import ast.*;
     4
    45import java.util.ArrayList;
    56import java.util.List;
     7
     8import compiler.lang.idisa.SIMD;
     9import compiler.lang.pablo.Builtins;
     10import compiler.lang.pablo.Builtins2Lang;
    611
    712import lexicalAnalyzer.LexicalType;
     
    211216        }
    212217       
     218        public static FuncCallNode makeSIMDAndEOFMaskFuncCall(ASTNode node, Builtins2Lang builtins2Lang) {
     219                List<ASTNode> args = new ArrayList<ASTNode>();
     220                args.add(node);
     221                args.add(Generators.makeIdentifierNode(builtins2Lang.getCode(Builtins.EOFMASK), node.getToken()));
     222                return Generators.makeFuncCallNode(SIMD.AND.idisaName(), node.getToken(), args);
     223        }
     224
     225        public static FuncCallNode makeSIMDAndCEOFMaskFuncCall(ASTNode node, Builtins2Lang builtins2Lang) {
     226                List<ASTNode> args = new ArrayList<ASTNode>();
     227                args.add(node);
     228                args.add(Generators.makeIdentifierNode(builtins2Lang.getCode(Builtins.EOFMASK), node.getToken()));
     229                return Generators.makeFuncCallNode(SIMD.ANDC.idisaName(), node.getToken(), args);
     230        }       
     231               
    213232        // Helper
    214233        public static String capitalize(String str) {
     
    219238                return str.substring(0, 1).toLowerCase() + str.substring(1);
    220239        }
     240       
     241       
    221242}
  • proto/pablo/src/compiler/backend/CodeGenerator.java

    r2702 r2710  
    1 package compiler.semanticAnalyzer;
     1package compiler.backend;
    22
    3 import compiler.ast.Accessors;
    4 import compiler.codeGenerator.visitors.CPPUnparser;
    5 import compiler.codeGenerator.visitors.helpers.UnparserUtil;
     3import compiler.backend.visitors.*;
    64import compiler.lang.carryset.CarrySet2Lang;
    75import compiler.lang.pablo.Builtins2Lang;
    8 import compiler.semanticAnalyzer.visitors.*;
    96
    107import ast.ASTNode;
    11 import ast.ProgramNode;
    128
    13 public class SemanticAnalyzer {
     9public class CodeGenerator {
    1410
    1511        private ASTNode root;
     
    2723        // static interface
    2824               
    29         public static ASTNode analyze(ASTNode root) {
    30                 SemanticAnalyzer analyzer = new SemanticAnalyzer(root);         
    31                 return analyzer.analyze();
     25        public static ASTNode analyze(ASTNode root, Builtins2Lang builtins2Lang, CarrySet2Lang carrySet2Lang) {
     26                CodeGenerator analyzer = new CodeGenerator(root, builtins2Lang, carrySet2Lang);         
     27                return analyzer.generate();
    3228        }       
    3329       
     
    3531        // constructor and helpers
    3632       
    37         public SemanticAnalyzer(ASTNode root) {         
     33        public CodeGenerator(ASTNode root, Builtins2Lang builtins2Lang, CarrySet2Lang carrySet2Lang) {         
    3834                this.root = root;               
    3935                this.setAddDumpStmts(false);
    4036                this.setAddAssertBitBlockAlignStmts(false);
    41                
    42                 //
    43                 // CPP builtins2Lang
    44                 // CPP carrySet2Lang
    45                 //
    46 
    47                 this.setCiMode(true);
    48                 this.setCoMode(false);
     37                this.setBuiltins2Lang(builtins2Lang);
     38                this.setCarrySet2Lang(carrySet2Lang);
    4939        }       
    50 
    51         //////////////////////////////////////////////////////////////
    52         // set defaults
    53         //
    54         //
    55         //
    56         //
    5740       
    5841        //////////////////////////////////////////////////////////////
    5942        // analysis
    60         public ASTNode analyze() {
     43        public ASTNode generate() {
    6144               
    6245            AdvanceCombinerXFormer advanceCombiner = new AdvanceCombinerXFormer(root);
     
    6649                AugAssign.XForm();
    6750               
    68                 CarryIntroXFormer carryQIntro = new CarryIntroXFormer(root, getCarrySet2Lang()); // TODO - go modeless
    69                 carryQIntro.XForm(ciMode /*, coMode */);
    70                
    71                 Pablo2CarryXFormer pablo2CarryQ = new Pablo2CarryXFormer(root, getBuiltins2Lang(), getCarrySet2Lang());
    72                 pablo2CarryQ.XForm(ciMode /*, coMode */);                   
     51                CarryIntroXFormer carryQIntro = new CarryIntroXFormer(root, getCarrySet2Lang());
     52                carryQIntro.XForm(/*ciMode , coMode */);
     53
     54                AssertZeroXFormer assertZeroXFormer = new AssertZeroXFormer(root, getBuiltins2Lang());
     55                assertZeroXFormer.XForm();             
    7356           
    74                 AssertZeroXFormer assertZeroXFormer = new AssertZeroXFormer(root, getBuiltins2Lang());
    75                 assertZeroXFormer.XForm();
    76                
    7757                Bitwise2IDISAXFormer bitwiseToIDISA = new Bitwise2IDISAXFormer(root);
    7858                bitwiseToIDISA.XForm();
    79        
    80                
     59
    8160                if(isAddDumpStmts()) {
    8261                        DumpAssignStmtsXFormer dumpAssignStmtsXFormer = new DumpAssignStmtsXFormer(root, getBuiltins2Lang()); 
     
    8766                        AssertBitBlockAlignStmtsXFormer assertBitBlockAlignStmtsXFormer = new AssertBitBlockAlignStmtsXFormer(root, getBuiltins2Lang(), getCarrySet2Lang()); 
    8867                        assertBitBlockAlignStmtsXFormer.XForm();
    89                 }                                       
     68                }                                                      
    9069               
    9170                return root;
  • proto/pablo/src/compiler/backend/visitors/ASTAssertCompareVisitor.java

    r2685 r2710  
    11
    2 package compiler.semanticAnalyzer.visitors;
     2package compiler.backend.visitors;
    33
    44import java.util.List;
  • proto/pablo/src/compiler/backend/visitors/AdvanceCombinerXFormer.java

    r2702 r2710  
    1 package compiler.semanticAnalyzer.visitors;
     1package compiler.backend.visitors;
    22
    33import ast.*;
  • proto/pablo/src/compiler/backend/visitors/AdvanceNCounterVisitor.java

    r2685 r2710  
    1 package compiler.semanticAnalyzer.visitors;
     1package compiler.backend.visitors;
    22
    33import ast.*;
  • proto/pablo/src/compiler/backend/visitors/AssertBitBlockAlignStmtsXFormer.java

    r2685 r2710  
    1 package compiler.semanticAnalyzer.visitors;
     1package compiler.backend.visitors;
    22
    33import ast.*;
  • proto/pablo/src/compiler/backend/visitors/AssertZeroXFormer.java

    r2702 r2710  
    1 package compiler.semanticAnalyzer.visitors;
     1package compiler.backend.visitors;
    22
    33import ast.*;
  • proto/pablo/src/compiler/backend/visitors/AugAssignXFormer.java

    r2685 r2710  
    1 package compiler.semanticAnalyzer.visitors;
     1package compiler.backend.visitors;
    22
    33import java.util.HashMap;
  • proto/pablo/src/compiler/backend/visitors/Bitwise2IDISAXFormer.java

    r2685 r2710  
    1 package compiler.semanticAnalyzer.visitors;
     1package compiler.backend.visitors;
    22
    33import ast.*;
  • proto/pablo/src/compiler/backend/visitors/CPPUnparser.java

    r2702 r2710  
    1 package compiler.codeGenerator.visitors;
     1package compiler.backend.visitors;
    22
    33import ast.*;
     
    77
    88import compiler.ast.Accessors;
    9 import compiler.ast.Generators;
     9import compiler.backend.visitors.helpers.CodeStore;
     10import compiler.backend.visitors.helpers.UnparserUtil;
    1011import compiler.codeGenerator.visitors.helpers.*;
     12import compiler.lang.carryset.CarrySet2CPP;
     13import compiler.lang.pablo.Builtins2CPP;
     14
     15//
     16// Design:      This class clones the AST function body in the visit(FuncDefNode) method and
     17//                      modifies the FuncDefNode body to handle atEOF, inFile and EOF_mask in block     
     18//                      final block processing.
     19//
     20
     21// Target
     22/*             
     23struct @name
     24{
     25  @name() {}
     26  IDISA_INLINE void do_block(@parameters)
     27  {
     28        @do_block                               
     29  }
     30  IDISA_INLINE void do_final_block(@parameters)
     31  {
     32    @do_final_block
     33  }                             
     34  CarryArray<@carry_count, @carry_n_count> carryQ;
     35};
     36*/
    1137
    1238public class CPPUnparser extends Unparser {
     
    2551                return codeStore.toStringIndented(indent);
    2652        }
    27 
     53       
    2854        //////////////////////////////////////////////////////////////
    2955        // visitors
     
    7399       
    74100        ////////////////////////////////////////////////////////////////////////////
    75         // Stream Funcs
     101        // Stream Funcs - User defined stream function (language extension point)
    76102        ////////////////////////////////////////////////////////////////////////////
    77103        public CodeStore visitLeave(FuncDefNode node, List<CodeStore> childResults) {
    78                 CodeStore code = new CodeStore();
    79 
    80                 CodeStore returnType = childResults.get(0);
    81                 CodeStore FuncName = childResults.get(1);
    82                 CodeStore blockStmt; 
    83                
     104               
     105               
     106               
     107                CodeStore code = new CodeStore();
     108                // CodeStore returnType = childResults.get(0);
     109                 
     110                String funcName = childResults.get(1).getResultVarName();
    84111                String parameters = new String();
     112                               
    85113                if(Accessors.hasParameters(node)) {
    86114                        parameters = childResults.get(2).getResultVarName();
    87                         blockStmt = childResults.get(3);
    88                 } else {
    89                         blockStmt = childResults.get(2);
    90                 }
     115                }
     116               
     117                // TODO - CarryArray carry_count ...
     118               
     119                boolean isFinalBlock = false;
     120                CodeStore nonFinalBlockCodeStore = XFormBlockStmt(Accessors.blockStmtNode(node), isFinalBlock);
     121                       
     122                isFinalBlock = true;
     123                CodeStore finalBlockCodeStore = XFormBlockStmt(Accessors.blockStmtNode(node), isFinalBlock);
     124               
     125                code.addFormattedLine("struct %s", funcName);
     126                code.addLine("{");
     127                code.indentedFormattedLine("%s () {}", funcName);
     128                code.addFormattedLine("IDISA_INLINE void do_block(%s)", parameters);
     129                code.addLine("{");
     130                code.addAll(nonFinalBlockCodeStore, 1);
     131                code.dedentedLine("}");
     132                code.addFormattedLine("IDISA_INLINE void do_final_block(%s)", parameters);
     133                code.addLine("{");
     134                code.addAll(finalBlockCodeStore, 1);
     135                code.dedentedLine("}");
     136                code.addFormattedLine("CarryArray<%s,%s> carryQ;", "99", "99"); // CGO
     137                code.dedentedLine("};");
    91138                               
    92                 code.addFormattedLine("%s %s(%s)",
    93                                 returnType.getResultVarName(),
    94                                 FuncName.getResultVarName(),
    95                                 parameters);   
    96                
    97                 code.addLine("{");
    98                 code.addAll(blockStmt, 1);
    99                 code.dedentedLine("}");
    100                 return code;
     139                return code;
     140        }
     141
     142        private CodeStore XFormBlockStmt(BlockStmtNode node, boolean isFinalBlock) {
     143                BlockStmtNode copy = node.deepCopy();
     144                Pablo2CarryXFormer pablo2CarryQ = new Pablo2CarryXFormer(copy, new Builtins2CPP(), new CarrySet2CPP());
     145                pablo2CarryQ.XForm(isFinalBlock);                   
     146                CodeStore codeStore = copy.accept(new CPPUnparser());
     147                return codeStore;
    101148        }
    102149
     
    135182        }
    136183
    137         // Func invocation
    138         //
    139         // TODO - Verify correctness, both returns Var and code line.
    140         //
     184        // FuncCall Stmt 
    141185        public CodeStore visitLeave(FuncCallNode node, List<CodeStore> childResults) {
    142186                CodeStore code = new CodeStore();
     
    149193                resultVar.append(")");
    150194               
    151                 code.setResultVarName(resultVar.toString());   // Func invocation as an expression     
    152                
    153                 code.addFormattedLine("%s;", resultVar.toString()); // Func invocation as a Stmt
     195                code.setResultVarName(resultVar.toString());            // Function invocation as an expression
     196               
     197                code.addFormattedLine("%s;", resultVar.toString()); // Function invocation as a statement
    154198               
    155199                return code;
     
    364408                code.addFormattedLine("struct %s", structName.getResultVarName());
    365409                code.addLine("{");
    366                 if(Accessors.hasStructBody(node)) {
     410                if(Accessors.hasStructBody(node)) {                             
    367411                        code.addAll(childResults.get(1),0);
    368412                }
     
    376420        public CodeStore visitLeave(StructTypeBodyNode node, List<CodeStore> childResults) {
    377421                CodeStore code = new CodeStore();
    378                 /*
     422               
    379423                for (CodeStore child: childResults.subList(0, 1)) {
    380                         code.addLine(child.toString(),1);
     424                        code.addAll(child,1);
    381425                }
    382426                for (CodeStore child: childResults.subList(1, childResults.size())) {
    383                         code.addLine(child.toString(),0);
     427                        code.addAll(child,0);
    384428                }       
    385                 */
    386                 code.addAll(childResults.get(0),1);
    387429               
    388430                return code;
  • proto/pablo/src/compiler/backend/visitors/CarryCounterVisitor.java

    r2685 r2710  
    1 package compiler.semanticAnalyzer.visitors;
     1package compiler.backend.visitors;
    22
    33import ast.*;
  • proto/pablo/src/compiler/backend/visitors/CarryIntroXFormer.java

    r2702 r2710  
    1 package compiler.semanticAnalyzer.visitors;
     1package compiler.backend.visitors;
    22
    33import ast.*;
     
    99import compiler.lang.carryset.CarrySet2Lang;
    1010import compiler.lang.pablo.BuiltinsUtil;
     11
     12// TODO - Add while type to switch on/off carry in mode. Carry in is an internal to this visitor.
    1113
    1214public class CarryIntroXFormer {
     
    2022    }
    2123
    22     public void XForm(boolean ci /*, boolean co*/) {
    23                 XFormer visitor = new XFormer(ci /*, co*/);
     24    public void XForm(/*boolean ci , boolean co*/) {
     25                XFormer visitor = new XFormer(/*ci , co*/);
    2426                ASTTree.accept(visitor);
    2527    }                   
     
    3234                //private String [] pending64QName = {CarryQ.CarryQ_PACKAGE_NAME, CarryQ.GETPENDING64.cPPCode()};
    3335               
     36                private boolean isFinalBlock;
     37               
    3438                private boolean ciMode;
    3539                //private boolean coMode;
     
    3943                //private int lastStmtCarries;
    4044               
    41                 XFormer(boolean ciMode /*, boolean coMode */) {
    42                         this.ciMode = ciMode;
     45                XFormer(/*boolean ciMode , boolean coMode */) {
     46                        this.ciMode = true;
    4347                        //this.coMode = coMode;
    4448                        this.currentCarry = 0;
  • proto/pablo/src/compiler/backend/visitors/DumpAssignStmtsXFormer.java

    r2685 r2710  
    1 package compiler.semanticAnalyzer.visitors;
     1package compiler.backend.visitors;
    22
    33import ast.*;
  • proto/pablo/src/compiler/backend/visitors/Pablo2CarryXFormer.java

    r2702 r2710  
    1 package compiler.semanticAnalyzer.visitors;
     1package compiler.backend.visitors;
    22
    33import java.util.ArrayList;
     
    1212import compiler.lang.pablo.*;
    1313
    14 
     14//TODO - Add while type to switch on/off carry in mode. Carry in is an internal to this visitor.
    1515
    1616public class Pablo2CarryXFormer {
     
    2020        private Builtins2Lang builtins2Lang;
    2121        private CarrySet2Lang carrySet2Lang;
    22        
    23     //    def __init__(self, carryvar="carryQ", carryin = "_ci", carryout = "_co"):
    24         //    self.carryvar = ast.Name(carryvar, ast.Load())
    25         //    self.carryin = carryin
    26         //    self.carryout = carryout   
    27        
     22               
    2823    public Pablo2CarryXFormer(ASTNode node, Builtins2Lang builtins2Lang, CarrySet2Lang carrySet2Lang) {
    2924        this.ASTTree = node;
     
    3227    }
    3328
    34     public void XForm(boolean ci /*, boolean co*/) {
    35                 XFormer visitor = new XFormer(ci /*, co*/);
     29    public void XForm(boolean isFinalBlock/* boolean ci, boolean co*/) {
     30                XFormer visitor = new XFormer(isFinalBlock/*ci , co*/);
    3631                ASTTree.accept(visitor);
    3732    }                   
     
    3934        private class XFormer extends VoidVisitor.Default {
    4035
    41                 //private final String ciSuffix = "_ci";
    42                 //private final String coSuffix = "_co";
    43                 //private String [] pendindCarryQName = {CarryQ.CarryQ_PACKAGE_NAME, CarryQ.GETCARRYIN.cPPCode()};
    44                 //private String [] pending64QName = {CarryQ.CarryQ_PACKAGE_NAME, CarryQ.GETPENDING64.cPPCode()};
    45                
     36                private boolean finalBlockMode;
    4637                private boolean ciMode;
    4738                //private boolean coMode;
     
    5142                //private int lastStmtCarries;
    5243               
    53                 XFormer(boolean ciMode /*, boolean coMode*/) {
    54                         this.ciMode = ciMode;
     44                XFormer(boolean isFinalBlock) { // TODO - ciMode parameter
     45                        this.finalBlockMode = isFinalBlock;
     46                        this.ciMode = true;
    5547                        //this.coMode = coMode;
    5648                        this.currentCarry = 0;
     
    9082//              carry_args = [mkCall('simd<1>::constant<0>', []), ast.Num(self.current_carry)]
    9183//              adv_n_args = [mkCall('simd<1>::constant<0>', []), ast.Num(self.current_adv_n)]
    92 
    93 //                      TODO - Deprecate ciMode - *likely* no longer required
    94 //
    95 //                     
     84                       
    9685                        if(ciMode) {
    9786                                carryCall = Generators.makeFuncCallNode(
     
    10493                                                node.getToken(),
    10594                                                new ASTNode [] {currentAdvN});
    106                                
    10795                        } else {
    10896                                carryCall = Generators.makeIntegerConstantNode(0, node.getToken());
     
    117105        //                    return c                 
    118106                        if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.ADVANCE.pabloName(), Builtins.ADVANCE.argCount())) {         
     107                                if(finalBlockMode) {
     108                                       
     109                                }
     110                               
    119111                                replaceFuncCallNode(node,
    120112                                                CarrySet.CarryQ_IDENTIFIER,
     
    122114                                                carryCall,
    123115                                                currentCarry);
     116                               
    124117                                this.currentCarry += 1;
    125118                        }
    126119       
    127         //          elif is_BuiltIn_Call(callnode, 'ScanThru', 2):
     120
    128121        //            #CARRYSET
    129122        //            rtn = self.carryvar.id + "." + "BitBlock_scanthru_ci_co"
     
    131124        //            self.current_carry += 1
    132125        //            return c         
     126                       
     127                                       
    133128                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.SCANTHRU.pabloName(), Builtins.SCANTHRU.argCount())) {                           
     129                                if(finalBlockMode) {
     130                                       
     131                                }
     132                               
    134133                                replaceFuncCallNode(node,
    135134                                                CarrySet.CarryQ_IDENTIFIER,
     
    139138                                this.currentCarry += 1;
    140139                        }
    141        
    142         //          elif is_BuiltIn_Call(callnode, 'AdvanceThenScanThru', 2):
    143         //            #CARRYSET
    144         //            rtn = self.carryvar.id + "." + "BitBlock_advance_then_scanthru"
    145         //            c = mkCall(rtn, callnode.args + carry_args)
    146         //            self.current_carry += 1
    147         //            return c         
     140                               
     141        //                  elif is_BuiltIn_Call(callnode, 'AdvanceThenScanThru', 2):
     142        //                  #CARRYSET
     143        //                  rtn = self.carryvar.id + "." + "BitBlock_advance_then_scanthru"
     144        //                  c = mkCall(rtn, callnode.args + carry_args)
     145        //                  self.current_carry += 1
     146        //                  return c                   
     147                       
    148148                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.ADVANCETHENSCANTHRU.pabloName(), Builtins.ADVANCETHENSCANTHRU.argCount())) {
     149                                if(finalBlockMode) {
     150                                                                       
     151                                }
     152                               
    149153                                replaceFuncCallNode(node,
    150154                                                CarrySet.CarryQ_IDENTIFIER,
     
    155159                        }               
    156160       
    157         //          elif is_BuiltIn_Call(callnode, 'SpanUpTo', 2):
     161        //            elif is_BuiltIn_Call(callnode, 'SpanUpTo', 2):
    158162        //            #CARRYSET
    159163        //            rtn = self.carryvar.id + "." + "BitBlock_span_upto"
     
    162166        //            return c         
    163167                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.SPANUPTO.pabloName(), Builtins.SPANUPTO.argCount())) {
     168                                if(finalBlockMode) {
     169                                               
     170                                }
     171       
    164172                                replaceFuncCallNode(node,
    165173                                                CarrySet.CarryQ_IDENTIFIER,
     
    169177                                this.currentCarry += 1;
    170178                        }               
    171        
    172         //          elif is_BuiltIn_Call(callnode, 'AdvanceThenScanTo', 2):
    173         //            #CARRYSET
    174         //            rtn = self.carryvar.id + "." + "BitBlock_advance_then_scanthru"
    175         //            if self.carryout == "":  scanclass = mkCall('simd_andc', [ast.Name('EOF_mask', ast.Load()), callnode.args[1]])
    176         //            else: scanclass = mkCall('simd_not', [callnode.args[1]])
    177         //            c = mkCall(rtn, [callnode.args[0], scanclass] + carry_args)
    178         //            self.current_carry += 1
    179         //            return c
     179                       
     180        //              elif is_BuiltIn_Call(callnode, 'AdvanceThenScanTo', 2):
     181        //      #CARRYSET
     182        //      rtn = self.carryvar.id + "." + "BitBlock_advance_then_scanthru"
     183        //      if self.carryout == "":  scanclass = mkCall('simd_andc', [ast.Name('EOF_mask', ast.Load()), callnode.args[1]])
     184        //      else: scanclass = mkCall('simd_not', [callnode.args[1]])
     185        //      c = mkCall(rtn, [callnode.args[0], scanclass] + carry_args)
     186        //      self.current_carry += 1
     187        //          return c                   
    180188                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.ADVANCETHENSCANTO.pabloName(), Builtins.ADVANCETHENSCANTO.argCount())) {
     189                                if(finalBlockMode) {
     190                                       
     191                                }
     192                               
    181193                                replaceFuncCallNode(node,
    182194                                                CarrySet.CarryQ_IDENTIFIER,
     
    197209       
    198210                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.INCLUSIVESPAN.pabloName(), Builtins.INCLUSIVESPAN.argCount())) {
     211                                if(finalBlockMode) {
     212                                       
     213                                }
     214
    199215                                replaceFuncCallNode(node,
    200216                                                CarrySet.CarryQ_IDENTIFIER,
     
    215231       
    216232                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.EXCLUSIVESPAN.pabloName(), Builtins.EXCLUSIVESPAN.argCount())) {
     233                                if(finalBlockMode) {
     234                                       
     235                                }
     236
    217237                                replaceFuncCallNode(node,
    218238                                                CarrySet.CarryQ_IDENTIFIER,
     
    235255       
    236256                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.SCANTO.pabloName(), Builtins.SCANTO.argCount())) {
     257                                if(finalBlockMode) {
     258                                       
     259                                }
     260
    237261                                replaceFuncCallNode(node,
    238262                                                CarrySet.CarryQ_IDENTIFIER,
     
    250274        //            self.current_carry += 1
    251275        //            return c
     276                       
     277
    252278       
    253279                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.SCANTOFIRST.pabloName(), Builtins.SCANTOFIRST.argCount())) {
     280                                if(finalBlockMode) {
     281                                       
     282                                }
     283
    254284                                replaceFuncCallNode(node,
    255285                                                CarrySet.CarryQ_IDENTIFIER,
     
    268298                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.ADVANCE32.pabloName(), Builtins.ADVANCE32.argCount())) {
    269299                                //replaceFuncCallNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.ADVANCE32.cPPCode(), carryCall, currentAdvN);
    270                                 // TODO ==> verify advNCall
     300                                // TODO ==> Verify implementation.
     301                                if(finalBlockMode) {
     302                                       
     303                                }
     304                               
    271305                                replaceFuncCallNode(node,
    272306                                                CarrySet.CarryQ_IDENTIFIER,
     
    285319                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.ADVANCEN.pabloName(), Builtins.ADVANCEN.argCount())) {
    286320                                //replaceFuncCallNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.ADVANCEN.cPPCode(), carryCall, currentAdvN);                                 
    287                                 // TODO - verify advNCall is correct
     321                                // TODO - Verify implementation.
     322                                if(finalBlockMode) {
     323                                       
     324                                }
     325                                                               
    288326                                replaceFuncCallNode(node,
    289327                                                CarrySet.CarryQ_IDENTIFIER,
     
    294332                        }                                       
    295333               
     334                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.ATEOF.pabloName(), Builtins.ATEOF.argCount())) {
     335                                 
     336                                if(finalBlockMode) {
     337                                        ASTNode arg0 = Accessors.funcCallArg(node, 0);
     338                                        replacementNode = Generators.makeSIMDAndCEOFMaskFuncCall(arg0, builtins2Lang);
     339                                } else {
     340                                        replacementNode = Generators.makeFuncCallNode(SIMD.CONSTANT.idisaConstantName(1, 0), node.getToken());                                 
     341                                }
     342                                node.updateSelf(replacementNode);
     343                        }                                       
     344       
     345        //          elif is_BuiltIn_Call(callnode, 'inFile', 1):
     346        //            if self.carryout != "": 
     347        //              # Non final block: inFile(x) = x.
     348        //              return callnode.args[0]
     349        //            else: return mkCall('simd_and', [callnode.args[0], ast.Name('EOF_mask', ast.Load())])
     350
     351                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.INFILE.pabloName(), Builtins.INFILE.argCount())) {
     352                               
     353                                if(finalBlockMode) {                                   
     354                                        ASTNode arg0 = Accessors.funcCallArg(node, 0);
     355                                        replacementNode = Generators.makeSIMDAndEOFMaskFuncCall(arg0, builtins2Lang);
     356                                } else {
     357                                        replacementNode = Accessors.funcCallArg(node,0);
     358                                }
     359                                node.updateSelf(replacementNode);
     360                        }                       
     361                       
    296362//                      Deprecated - New bitblock iterators replace StreamScan.
    297363//                     
  • proto/pablo/src/compiler/backend/visitors/StreamFuncVisitor.java

    r2702 r2710  
    1 package compiler.semanticAnalyzer.visitors;
     1package compiler.backend.visitors;
    22
    33import java.util.*;
  • proto/pablo/src/compiler/backend/visitors/Unparser.java

    r2702 r2710  
    1 package compiler.codeGenerator.visitors;
     1package compiler.backend.visitors;
    22
    33
    44import ast.ASTNode;
    55import ast.ASTVisitor.Default;
    6 import compiler.codeGenerator.visitors.helpers.CodeStore;
     6import compiler.backend.visitors.helpers.CodeStore;
    77
    88abstract public class Unparser extends Default<CodeStore> {
  • proto/pablo/src/compiler/backend/visitors/helpers/AssertCompare.java

    r2672 r2710  
    1 package compiler.semanticAnalyzer.visitors.helpers;
     1package compiler.backend.visitors.helpers;
    22
    3 import compiler.semanticAnalyzer.visitors.ASTAssertCompareVisitor;
     3import compiler.backend.visitors.ASTAssertCompareVisitor;
    44
    55import ast.*;
  • proto/pablo/src/compiler/backend/visitors/helpers/CodeStore.java

    r2702 r2710  
    1 package compiler.codeGenerator.visitors.helpers;
     1package compiler.backend.visitors.helpers;
    22
    33import java.util.ArrayList;
  • proto/pablo/src/compiler/backend/visitors/helpers/Labeller.java

    r2685 r2710  
    1 package compiler.codeGenerator.visitors.helpers;
     1package compiler.backend.visitors.helpers;
    22
    33public class Labeller {
  • proto/pablo/src/compiler/backend/visitors/helpers/UnparserUtil.java

    r2687 r2710  
    1 package compiler.codeGenerator.visitors.helpers;
     1package compiler.backend.visitors.helpers;
    22
    33import ast.*;
  • proto/pablo/src/compiler/codeGenerator/CodeGenerator.java

    r2702 r2710  
    55import compiler.ast.Accessors;
    66import compiler.ast.Generators;
    7 import compiler.codeGenerator.visitors.CPPUnparser;
    8 import compiler.codeGenerator.visitors.Unparser;
    9 import compiler.codeGenerator.visitors.helpers.CodeStore;
    10 import compiler.codeGenerator.visitors.helpers.UnparserUtil;
     7import compiler.backend.visitors.*;
     8import compiler.backend.visitors.helpers.CodeStore;
     9import compiler.backend.visitors.helpers.UnparserUtil;
    1110import compiler.lang.carryset.CarrySet2Lang;
    1211import compiler.lang.pablo.Builtins2Lang;
    13 import compiler.semanticAnalyzer.visitors.*;
    1412
    1513import ast.*;
    1614
    17 // Code Generator - Two Trees (i) do_block (ii) do_final_block
    18 
    19 // 1. do_block_code.
    20 // 2. do_final_block_code
    21 // 3.
    22 
    2315public class CodeGenerator {
    2416
    25         //private ASTNode cicoDecoratedASTTree;
    26         //private ASTNode coDecoratedASTTree;   
    27        
    2817        //////////////////////////////////////////////////////////////
    29         // static interface
    30        
    31         public static String makeStreamFuncDecls(ASTNode cicoASTTree, ASTNode coASTTree, Unparser unparser) {
     18        // static interface             
     19        /*
     20        public static String makeStreamFuncDecls(ProgramNode blockAST, ProgramNode finalBlockAST, Unparser unparser, int indent) {
     21                StringBuilder builder = new StringBuilder();
     22                List<FuncDefNode> funcDefs = Accessors.funcDefs((ProgramNode) node);
    3223               
    33                 StringBuilder builder = new StringBuilder();
    34                 List<FuncDefNode> cicoFuncDefs = Accessors.funcDefs((ProgramNode)cicoASTTree);
    35                
    36                 for(FuncDefNode funcDef: cicoFuncDefs) {
    37                         builder.append(unparser.getCode(funcDef));
     24                for(FuncDefNode funcDef: funcDefs) {
     25                        builder.append(makeStreamFuncDecl(funcDef, unparser, indent));
    3826                }       
    3927               
    4028                return builder.toString();
    4129        }       
     30        */
     31        /*
     32        struct @name {
     33               
     34                @name() {}
     35               
     36                IDISA_INLINE void do_block(@args) {
     37                        @do_block
     38                }
     39               
     40                IDISA_INLINE void do_final_block(@args) {
     41                        @do_final_block
     42                }
     43               
     44                IDISA_INLINE void do_segment(@args, int segment_blocks) {
     45                       
     46                }
     47               
     48                CarryArray<@carry_count, @carry_n_count> carryQ;
     49        };
     50        */
     51        /*
     52        public static String makeStreamFuncDecl(FuncDefNode node, Unparser unparser, int indent) {
     53               
     54                String funcName = Accessors.funcName(node);
     55               
    4256
    43         //////////////////////////////////////////////////////////////
    44         // constructor and helpers
     57               
     58                String parameters = Accessors.
     59
     60               
     61                return unparser.getCode(node, indent);
     62        }
     63        */
     64
     65        public static String makeStructDecls(ProgramNode node, Unparser unparser, int indent) {
     66                StringBuilder builder = new StringBuilder();
     67                List<StructTypeNode> structDecls = Accessors.structTypeDecls(node);
     68                for(StructTypeNode structDecl: structDecls) {
     69                        builder.append(makeStructDecl(structDecl, unparser, indent));
     70                }       
     71                return builder.toString();
     72        }       
     73       
     74        public static String makeStructDecl(StructTypeNode node, Unparser unparser, int indent) {
     75                return unparser.getCode(node, indent);
     76        }
    4577       
    4678        /*
    47         public static String makeStructDecls(ProgramNode node, Unparser unparser) {
    48                 String code = new String();
    49                 List<StructTypeNode> structDecls = Accessors.structTypeDecls(node);
    50                 for(StructTypeNode structDecl: structDecls) {
    51                         code += unparser.getCode(structDecl);
    52                 }       
    53                 return code;
    54         }       
    55                
    5679        public static String makeStructDefs(ProgramNode node, Unparser unparser) {
    5780                return unparser.getStructDefs(node, 0);
    5881        }
     82        */
    5983       
    6084        //////////////////////////////////////////////////////////////
    6185        //
    62         public String makeStructDefs(ProgramNode node, int indent) {
     86        /*
     87        public static String makeStructDefs(ProgramNode node, int indent) {
    6388                StringBuilder builder = new StringBuilder();
    6489                List<StructTypeNode> structDecls = Accessors.structTypeDecls(node);
    6590                for(StructTypeNode structDecl: structDecls) {
    66                         String name = Accessors.structName(structDecl);
    67                         CodeStore.addIndentation(builder, indent);
    68                         builder.append(Generators.capitalize(name));    // TODO - hack replace with 'real' stream kernels
    69                         builder.append(" ");
    70                         builder.append(Generators.unCapitalize(name));  // TODO - hack
    71                         builder.append(";");
    72                         builder.append(CodeStore.NEWLINE);
     91                        builder.append(makeStructDef(structDecl, indent));     
    7392                }
    7493                return builder.toString();
    7594        }
    7695       
    77         public String makeFuncDefs(ProgramNode node, int indent) {
     96        public static String makeStructDef(StructTypeNode node, int indent) {
     97                StringBuilder builder = new StringBuilder();
     98               
     99                String name = Accessors.structName(node);
     100                CodeStore.addIndentation(builder, indent);
     101                builder.append(Generators.capitalize(name));    // TODO -       hack
     102                builder.append(" ");                                                    //              replace capitalised struct type name and
     103                builder.append(Generators.unCapitalize(name));  //                      lower case instance name convention with a 'main' method         
     104                builder.append(";");
     105                builder.append(CodeStore.NEWLINE);
     106                               
     107                return builder.toString();
     108        }
     109       
     110        public static String makeFuncDefs(ProgramNode node, int indent) {
    78111                StringBuilder builder = new StringBuilder();
    79112                List<FuncDefNode> funcDefs = Accessors.funcDefs(node);
    80113                for(FuncDefNode funcDef: funcDefs) {
    81                         String name = Accessors.funcName(funcDef);
    82                         CodeStore.addIndentation(builder, indent);
    83                         builder.append(Generators.capitalize(name));    // TODO - hack replace with 'real' stream kernels
    84                         builder.append(" ");
    85                         builder.append(Generators.unCapitalize(name));  // TODO - hack
    86                         builder.append(";");
    87                         builder.append(CodeStore.NEWLINE);                     
     114                        builder.append(makeFuncDef(funcDef, indent));   
    88115                }       
    89116               
     
    91118        }
    92119       
    93         public String makeDoBlocks(ProgramNode node, int indent) {
     120        public static String makeFuncDef(FuncDefNode node, int indent) {
     121                StringBuilder builder = new StringBuilder();
     122               
     123                String name = Accessors.funcName(node);
     124                CodeStore.addIndentation(builder, indent);
     125                builder.append(Generators.capitalize(name));    // TODO - hack
     126                builder.append(" ");
     127                builder.append(Generators.unCapitalize(name)); 
     128                builder.append(";");
     129                builder.append(CodeStore.NEWLINE);
     130               
     131                return builder.toString();
     132        }
     133       
     134        /*
     135        public String makeFuncBodies(ProgramNode node, int indent) {
    94136                StringBuilder builder = new StringBuilder();
    95137                List<FuncDefNode> funcDefs = Accessors.funcDefs(node);
     
    102144                return null;
    103145        }
    104 
    105         public String makeDoFinalBlocks(ProgramNode node, int indent) {
    106                 StringBuilder builder = new StringBuilder();
    107                 List<FuncDefNode> funcDefs = Accessors.funcDefs(node);
    108                 for(FuncDefNode funcDef: funcDefs) {
    109                         String name = Accessors.funcName(funcDef);
    110                         CodeStore.addIndentation(builder, indent);
    111                         builder.append(Generators.unCapitalize(name));  // TODO - hack
    112                         builder.append(".doFinalBlock();");
    113                 }
    114                 return null;
     146       
     147        public String makeFuncBody(FuncDefNode node, indent) {
     148               
    115149        }
    116150        */
    117        
    118         /*
    119         public static String makeDoFinalBlockFinal(ASTNode root, Unparser unparser) {
    120                 CodeGenerator generator = new CodeGenerator(root, unparser);           
    121                 return generator.makeDoFinalBlock();
    122         }
    123         */             
    124151       
    125152        /*
  • proto/pablo/src/compiler/frontend/SyntacticAnalysisFailedException.java

    r2686 r2710  
    1 package compiler.syntacticAnalyzer;
     1package compiler.frontend;
    22
    33public class SyntacticAnalysisFailedException extends Exception {
  • proto/pablo/src/compiler/frontend/SyntacticAnalyzer.java

    r2686 r2710  
    44//
    55
    6 package  compiler.syntacticAnalyzer;
     6package  compiler.frontend;
    77
    88import parser.*;
     
    1111import lexicalAnalyzer.LexicalController;
    1212import logging.ScatterLogger;
    13 import compiler.syntacticAnalyzer.SyntacticAnalyzer;
     13import compiler.frontend.SyntacticAnalyzer;
    1414
    1515public class SyntacticAnalyzer {
Note: See TracChangeset for help on using the changeset viewer.