Changeset 2943


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

Code clean up and comments.

Location:
proto/pabloj/trunk/src/compiler/transformers
Files:
15 edited

Legend:

Unmodified
Added
Removed
  • proto/pabloj/trunk/src/compiler/transformers/PabloS2PabloBXFormer.java

    r2924 r2943  
     1/*
     2 * Transform PabloS AST to PabloB AST.
     3 *
     4 * @author Ken Herdy <ksherdy at sfu dot ca>
     5 */
     6
    17package compiler.transformers;
    28
     
    612
    713import compiler.ast.pabloB.Generators;
    8 import compiler.lang.carry.CarrySetBuiltins;
    9 import compiler.lang.carry.CarrySetBuiltins2Lang;
    10 import compiler.symbols.CarryInfoSetSymbol;
    11 import compiler.symbols.SymbolTable;
     14import compiler.lang.carry.CarryBuiltins;
     15import compiler.lang.carry.CarryBuiltins2Lang;
     16import compiler.symbolTable.CarryInfoSetSymbol;
     17import compiler.symbolTable.SymbolTable;
    1218import pabloB.ast.AssignNode;
    1319import pabloB.ast.ASTNode;
     
    2632        private pabloS.ast.ASTNode optDecoratedASTTree;                 
    2733       
    28         private SymbolTable symbolTable;
    29 
    30        
    31         private CarrySetBuiltins2Lang carrySet2Lang;
     34        private SymbolTable pabloSSymbolTable;
     35
     36       
     37        private CarryBuiltins2Lang carrySet2Lang;
    3238       
    3339        /*
     
    3844         */
    3945 
    40     public PabloS2PabloBXFormer(compiler.symbols.SymbolTable symbolTable, CarrySetBuiltins2Lang carrySet2Lang) {
     46    public PabloS2PabloBXFormer(compiler.symbolTable.SymbolTable pabloSSymbolTable, CarryBuiltins2Lang carrySet2Lang) {
    4147        this.decoratedASTTree = null;
    4248        this.optDecoratedASTTree = null;
    43         this.symbolTable = symbolTable;
     49        this.pabloSSymbolTable = pabloSSymbolTable;
    4450       
    4551        this.carrySet2Lang = carrySet2Lang;
     
    4955                return XForm(decoratedASTTree, decoratedASTTree);
    5056    }
    51    
    52    
     57     
    5358    public pabloB.ast.ASTNode XForm(pabloS.ast.ASTNode decoratedASTTree, pabloS.ast.ASTNode optDecoratedASTTree) {
    5459               
     
    5661                this.optDecoratedASTTree = optDecoratedASTTree;
    5762       
     63                // pabloS to pabloB AST builders (all nodes)
    5864                pabloB.ast.ASTNode bASTTree = this.decoratedASTTree.accept(new pabloBASTBuilder());
    5965                pabloB.ast.ASTNode bOptASTTree = this.optDecoratedASTTree.accept(new pabloBASTBuilder());
    60                  
     66               
     67                // map function names to function definition nodes
    6168                Map<String, pabloB.ast.FuncDefNode> map = funcDefMapBuilder(bASTTree);
    6269                Map<String, pabloB.ast.FuncDefNode> optMap = funcDefMapBuilder(bOptASTTree);
    6370               
     71                // build kernels
    6472                for (Map.Entry<String, pabloB.ast.FuncDefNode> entry : map.entrySet())
    6573                {       
     
    7684                       
    7785                        String kernelName = entry.getKey();                     
    78                         CarryInfoSetSymbol carryInfoSetSymbol = (CarryInfoSetSymbol) symbolTable.get(kernelName);
    79                        
     86                        CarryInfoSetSymbol carryInfoSetSymbol = (CarryInfoSetSymbol) pabloSSymbolTable.get(kernelName);
    8087                       
    8188                        pabloB.ast.InitDefNode initDefNode = Generators.makeInitDefNode(locationToken);                 
     
    110117                                        if(carry1Array[i] > 0) {
    111118                                               
    112                                                         String carryFlipArrayExpr = String.format(CarrySetBuiltins2Lang.LOCALCARRYQARRAYNAME + "[%s]",
     119                                                        String carryFlipArrayExpr = String.format(CarryBuiltins2Lang.LOCALCARRYQARRAYNAME + "[%s]",
    113120                                                                                                                                                Integer.toString(i));   
    114121                                                       
    115                                                         String[] carryFlipIdentiferArray = new String [] {CarrySetBuiltins2Lang.CARRYQNAME, carryFlipArrayExpr};
     122                                                        String[] carryFlipIdentiferArray = new String [] {CarryBuiltins2Lang.CARRYQNAME, carryFlipArrayExpr};
    116123                                                       
    117124                                                        pabloB.ast.CompoundIdentifierNode carryFlipIdentifierNode
     
    120127                                                       
    121128                                                        FuncCallNode carryFlipFuncCall = (FuncCallNode) Generators.makeFuncCallNode(
    122                                                                         new String [] {CarrySetBuiltins2Lang.CARRYQNAME, carrySet2Lang.getCode(CarrySetBuiltins.CARRYFLIP)},
     129                                                                        new String [] {CarryBuiltins2Lang.CARRYQNAME, carrySet2Lang.getCode(CarryBuiltins.CARRYFLIP)},
    123130                                                                        locationToken,
    124131                                                                        new ASTNode [] {carryFlipIdentifierNode});
     
    147154                return bASTTree;
    148155    }
    149          
     156     
     157    /*
     158     * pabloS to pabloB node builder
     159     */
    150160        private class pabloBASTBuilder extends Default<pabloB.ast.ASTNode> {
    151161                       
  • proto/pabloj/trunk/src/compiler/transformers/pabloS/ASTAssertCompareVisitor.java

    r2924 r2943  
     1/*
     2 * Compares ASTs trees are equal.
     3 *
     4 * Useful to test generated ASTs against expected ASTs.
     5 *
     6 * @author Ken Herdy <ksherdy at sfu dot ca>
     7 */
    18
    29package compiler.transformers.pabloS;
     
    512import pabloS.ast.ASTNode;
    613
    7 /**
    8  * Through the static method <code>compare</code>,
    9  * this class asserts AST subtrees are equal.
    10  */
    1114public class ASTAssertCompareVisitor {
    1215
  • proto/pabloj/trunk/src/compiler/transformers/pabloS/AdvanceCombinerXFormer.java

    r2924 r2943  
     1/*
     2 * Optimize advance operations to advance(X,n).
     3 *     
     4 * Advance(Advance(X))          to      Advance(X, 2), and
     5 * Advance(Advance(X, n))       to  Advance(X, n+1) and
     6 * Advance(Advance(X, n2), n1).
     7 *
     8 * @author Ken Herdy <ksherdy at sfu dot ca>
     9 */
     10
    111package compiler.transformers.pabloS;
    212
     
    515import compiler.ast.pabloS.Generators;
    616import compiler.lang.pabloS.BuiltinsUtil;
    7 import compiler.symbols.SymbolTable;
    817
    918import pabloS.tokens.*;
     
    2231    }   
    2332   
    24         // Original python method optimized calls that look like:
    25         //              adv(adv(X))             to      adv(X, 2), and
    26         //              adv(adv(X, n))  to  adv(X, n+1)
    27         //
    28         // presumably adv(adv(X), n) were not optimized because this pattern
    29         // was not seen (often) in the input.  We instead choose to optimize
    30         // that pattern and also adv(adv(X, n2), n1).
    31 
    3233        private class AdvanceCombinerVisitor extends VoidVisitor.Default {
    3334
    3435                public void visitEnter(IfStmtNode node) {
    35                     // Additional carry logic req'd to support carry combine within If stmts
     36                    // Additional carry logic required to support carry combine within If stmts
    3637                        node.skipChildren();
    3738                }
    3839                public void visitEnter(WhileStmtNode node) {
    39                     // Additional carry logic req'd to support carry combine within While stmts
     40                    // Additional carry logic required to support carry combine within While stmts
    4041                        node.skipChildren();
    4142                }
  • proto/pabloj/trunk/src/compiler/transformers/pabloS/AdvanceNCounterVisitor.java

    r2924 r2943  
     1/*
     2 * Counts PabloS AdvanceN operations.
     3 *
     4 * @author Ken Herdy <ksherdy at sfu dot ca>
     5 */
     6
    17package compiler.transformers.pabloS;
    28
  • proto/pabloj/trunk/src/compiler/transformers/pabloS/AssertBitBlockAlignStmtsXFormer.java

    r2924 r2943  
     1/*
     2 * Adds BitBlock alignment assertion statements to the AST
     3 * after each assignment and variable declaration statement.
     4 *
     5 * TODO - Move to PabloB.
     6 *
     7 * @author Ken Herdy <ksherdy at sfu dot ca>
     8 */
     9
    110package compiler.transformers.pabloS;
    211
     
    2837                               
    2938                public void visitEnter(LocalVarDeclNode node) {
    30                         addDumpStmt(node, Accessors.lhs(node));
     39                        addAssertBitBlockAssignStmt(node, Accessors.lhs(node));
    3140                }               
    3241               
    3342                public void visitEnter(AssignNode node) {
    34                         addDumpStmt(node, Accessors.lhs(node));
     43                        addAssertBitBlockAssignStmt(node, Accessors.lhs(node));
    3544                }
    3645
    37                 private void addDumpStmt(ASTNode node, ASTNode lhs) {
     46                private void addAssertBitBlockAssignStmt(ASTNode node, ASTNode lhs) {
    3847                        FuncCallNode printRegisterStmt =
    3948                                        Generators.makeFuncCallNode(  builtins2Lang.getCode(Builtins.ASSERTBITBLOCKALIGN),
  • proto/pabloj/trunk/src/compiler/transformers/pabloS/AssertZeroXFormer.java

    r2924 r2943  
     1/*
     2 * Asserts BitBlock is all zero.
     3 *
     4 * TODO - Move to PabloB.
     5 *
     6 * @author Ken Herdy <ksherdy at sfu dot ca>
     7 */
     8
    19package compiler.transformers.pabloS;
    210
     
    4654                public void visitEnter(FuncCallNode node) {
    4755                       
    48                         if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.ASSERTZERO.pabloName(), Builtins.ASSERTZERO.argCount())) {
     56                        if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.ASSERTZERO.pabloSName(), Builtins.ASSERTZERO.argCount())) {
    4957                               
    5058                                assert (node.getParent() instanceof BlockStmtNode);
     
    5462                               
    5563                                assert errorCode instanceof StringConstantNode;
    56                                
    57                                 /*
    58                                 ASTNode anyFuncCallNode =
    59                                                 Generators.makeFuncCallNode(BitBlock.ANY.IDISAName(),
    60                                                                                                                                 node.getToken(),                               
    61                                                                                                                                 new ASTNode [] {errorStream});
    62                                 */     
    63                                 //ASTNode errorStream = Generators.makeIdentifierNode(errorStream, node.getToken());
    64                                
     64                                                               
    6565                                ASTNode assert0FuncCallNode
    6666                                                = Generators.makeFuncCallNode(builtins2Lang.getCode(Builtins.ASSERTZERO),
  • proto/pabloj/trunk/src/compiler/transformers/pabloS/AugAssignXFormer.java

    r2924 r2943  
     1/*
     2 * Transforms (expands) augmented (compound) assignment. 
     3 *
     4 * @author Ken Herdy <ksherdy at sfu dot ca>
     5 */
     6
    17package compiler.transformers.pabloS;
    28
     
    1016import pabloS.lexicalAnalyzer.Lextant;
    1117import pabloS.tokens.*;
    12 
    1318
    1419public class AugAssignXFormer {
  • proto/pabloj/trunk/src/compiler/transformers/pabloS/Bitwise2IDISAXFormer.java

    r2924 r2943  
     1/*
     2 * Transforms bitwise operations to IDISA operations.
     3 *
     4 * Transforms expressions to BitBlock::any(expr). BitBlock:any expects stream<1> type.
     5 *
     6 * TODO
     7 *
     8 * - Move to PabloB.
     9 * - Remove transformation of integer constants to simd::constant<1>(0)
     10 *
     11 * @author Ken Herdy <ksherdy at sfu dot ca>
     12 */
     13
    114package compiler.transformers.pabloS;
    215
     
    1629        }
    1730       
    18         public ASTNode XForm() { // Order AST traversal Binary <- Unary <- General
     31        public ASTNode XForm() {
    1932               
    2033                Bitwise2IDISABinaryOperatorXFormer binOpXformer = new Bitwise2IDISABinaryOperatorXFormer();
     
    3851                                FuncCallNode funcCallNode = null;
    3952                                if(token.isLextant(Lextant.OR)) {
    40                                         funcCallNode = Generators.makeFuncCallNode(SIMD.OR.idisaName(),
     53                                        funcCallNode = Generators.makeFuncCallNode(SIMD.OR.IDISALexeme(),
    4154                                                                                                                                token,
    4255                                                                                                                                new ASTNode [] {Accessors.lhs(node), Accessors.rhs(node)});
     
    4457                                       
    4558                                        if (Accessors.rhs(node).getToken().isLextant(Lextant.NOT)) {                                           
    46                                                 funcCallNode = Generators.makeFuncCallNode(SIMD.ANDC.idisaName(),
     59                                                funcCallNode = Generators.makeFuncCallNode(SIMD.ANDC.IDISALexeme(),
    4760                                                                                                                                        token,
    4861                                                                                                                                        new ASTNode [] {Accessors.lhs(node), Accessors.rhs(node).child(0)});
    4962                                        } else if(Accessors.lhs(node).getToken().isLextant(Lextant.NOT)) {
    50                                                 funcCallNode = Generators.makeFuncCallNode(SIMD.ANDC.idisaName(),
     63                                                funcCallNode = Generators.makeFuncCallNode(SIMD.ANDC.IDISALexeme(),
    5164                                                                                                                                        token,
    5265                                                                                                                                        new ASTNode [] {Accessors.rhs(node), Accessors.lhs(node).child(0)});
    5366                                        } else {
    54                                                 funcCallNode = Generators.makeFuncCallNode(SIMD.AND.idisaName(),
     67                                                funcCallNode = Generators.makeFuncCallNode(SIMD.AND.IDISALexeme(),
    5568                                                                                                                                        token,
    5669                                                                                                                                        new ASTNode [] {Accessors.lhs(node), Accessors.rhs(node)});                                             
     
    5871                                       
    5972                                } else if (token.isLextant(Lextant.XOR)){
    60                                         funcCallNode = Generators.makeFuncCallNode(SIMD.XOR.idisaName(),
     73                                        funcCallNode = Generators.makeFuncCallNode(SIMD.XOR.IDISALexeme(),
    6174                                                                                                                                token,
    6275                                                                                                                                new ASTNode [] {Accessors.lhs(node), Accessors.rhs(node)});
     
    8194
    8295                                FuncCallNode FuncCallNode =
    83                                                 Generators.makeFuncCallNode(SIMD.NOT.idisaName(),
     96                                                Generators.makeFuncCallNode(SIMD.NOT.IDISALexeme(),
    8497                                                                                                                                op,
    8598                                                                                                                                new ASTNode [] {Accessors.operand(node)});                     
     
    132145                                        int constant = -1 * value;
    133146                                       
    134                                         String name = SIMD.CONSTANT.idisaConstantName(fieldWidth, constant);
     147                                        String name = SIMD.CONSTANT.IDISAConstantLexeme(Integer.toString(fieldWidth), Integer.toString(constant));
    135148                                        FuncCallNode funcCallNode = Generators.makeFuncCallNode(name, node.getToken());
    136149                                        node.updateSelf(funcCallNode);
     
    145158                public void visitLeave(IfStmtNode node) {
    146159                        ASTNode ifTest = Accessors.ifTest(node);                       
    147                         String FuncName = BitBlock.ANY.IDISAName();
     160                        String FuncName = BitBlock.ANY.IDISALexeme();
    148161                        FuncCallNode FuncCallNode = Generators.makeFuncCallNode(FuncName, node.getToken(), new ASTNode [] {ifTest});
    149162                        node.replaceChild(ifTest, FuncCallNode);
     
    158171                                                                                                                               
    159172                        FuncCallNode FuncCallNode = Generators.makeFuncCallNode(
    160                                         BitBlock.ANY.IDISAName(),
     173                                        BitBlock.ANY.IDISALexeme(),
    161174                                        node.getToken(),
    162175                                        new ASTNode [] {whileTest});                           
  • proto/pabloj/trunk/src/compiler/transformers/pabloS/CarryCounterVisitor.java

    r2924 r2943  
     1/*
     2 * Counts carry generating operations.
     3 *
     4 * @author Ken Herdy <ksherdy at sfu dot ca>
     5 */
     6
    17package compiler.transformers.pabloS;
    28
  • proto/pabloj/trunk/src/compiler/transformers/pabloS/CarryInfoSetVisitor.java

    r2924 r2943  
    1010import compiler.lang.pabloS.Builtins;
    1111import compiler.lang.pabloS.BuiltinsUtil;
    12 import compiler.symbols.CarryInfoSetSymbol;
    13 import compiler.symbols.SymbolTable;
     12import compiler.symbolTable.CarryInfoSetSymbol;
     13import compiler.symbolTable.SymbolTable;
    1414import pabloS.ast.*;
    1515
     
    4242                       
    4343                        if(BuiltinsUtil.isCarryOne(node)) {
    44                                 if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.SCANTOFIRST.pabloName(), Builtins.SCANTOFIRST.argCount())) {
     44                                if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.SCANTOFIRST.pabloSName(), Builtins.SCANTOFIRST.argCount())) {
    4545                                        ((CarryInfoSetSymbol)symbolTable.get(key)).addCarry1(1);
    4646                                } else {
  • proto/pabloj/trunk/src/compiler/transformers/pabloS/CarryIntroXFormer.java

    r2924 r2943  
    1010import compiler.ast.pabloS.Accessors;
    1111import compiler.ast.pabloS.Generators;
    12 import compiler.lang.carry.CarrySetBuiltins;
    13 import compiler.lang.carry.CarrySetBuiltins2Lang;
     12
     13import compiler.lang.*;
     14import compiler.lang.carry.CarryBuiltins2Lang;
    1415import compiler.lang.idisa.SIMD;
    15 import compiler.lang.pabloS.Builtins;
    16 import compiler.lang.pabloS.Builtins2Lang;
    17 import compiler.lang.pabloS.BuiltinsUtil;
     16import compiler.lang.pabloS.*;
     17
    1818
    1919/*
     
    7474        private ASTNode ASTTree;       
    7575        private Builtins2Lang builtins2Lang;
    76         private CarrySetBuiltins2Lang carrySet2Lang;
    77        
    78     public CarryIntroXFormer(ASTNode node, Builtins2Lang builtins2Lang, CarrySetBuiltins2Lang carrySet2Lang) {
     76        private CarryBuiltins2Lang carrySet2Lang;
     77       
     78    public CarryIntroXFormer(ASTNode node, Builtins2Lang builtins2Lang, CarryBuiltins2Lang carrySet2Lang) {
    7979        this.ASTTree = node;
    8080        this.builtins2Lang = builtins2Lang;
     
    175175                                @SuppressWarnings("static-access")
    176176                                FuncCallNode carryAdjustFuncCall = (FuncCallNode) Generators.makeFuncCallNode(
    177                                                 new String [] {carrySet2Lang.CARRYQNAME, carrySet2Lang.getCode(CarrySetBuiltins.CARRYQADJUST)},
     177                                                new String [] {carrySet2Lang.CARRYQNAME, carrySet2Lang.getCode(compiler.lang.carry.CarryBuiltins.CARRYQADJUST)},
    178178                                                node.getToken(),
    179179                                                new ASTNode [] {carryCountNode});
     
    218218                        if(isCiMode()) {
    219219                                carryCall = Generators.makeFuncCallNode(
    220                                                 new String [] {getCarrySetIdentifier(), carrySet2Lang.getCode(CarrySetBuiltins.GETCARRYIN)},
     220                                                new String [] {getCarrySetIdentifier(), carrySet2Lang.getCode(compiler.lang.carry.CarryBuiltins.GETCARRYIN)},
    221221                                                node.getToken(),
    222222                                                new ASTNode [] {currentCarry});
    223223                               
    224224                                advNCall = Generators.makeFuncCallNode(
    225                                                 new String [] {getCarrySetIdentifier(), carrySet2Lang.getCode(CarrySetBuiltins.GETPENDING64)},
     225                                                new String [] {getCarrySetIdentifier(), carrySet2Lang.getCode(compiler.lang.carry.CarryBuiltins.GETPENDING64)},
    226226                                                node.getToken(),
    227227                                                new ASTNode [] {currentAdvN});
    228228                        } else {
    229                                 carryCall = Generators.makeFuncCallNode(SIMD.CONSTANT.idisaConstantName(1, 0), node.getToken());
    230                                 advNCall = Generators.makeFuncCallNode(SIMD.CONSTANT.idisaConstantName(1, 0), node.getToken());
     229                                carryCall = Generators.makeFuncCallNode(SIMD.CONSTANT.IDISAConstantLexeme("0", "1"), node.getToken());
     230                                advNCall = Generators.makeFuncCallNode(SIMD.CONSTANT.IDISAConstantLexeme("0", "1"), node.getToken());
    231231                        }
    232232                                               
     
    238238                        //                    return c
    239239                       
    240                         if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.ADVANCE.pabloName(), Builtins.ADVANCE.argCount())) {         
     240                        if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.ADVANCE.pabloSName(), Builtins.ADVANCE.argCount())) {         
    241241                               
    242242                                List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
     
    258258                        //      return c                                                       
    259259                       
    260                         else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.SCANTHRU.pabloName(), Builtins.SCANTHRU.argCount())) {                           
     260                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.SCANTHRU.pabloSName(), Builtins.SCANTHRU.argCount())) {                         
    261261                                List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
    262262                               
     
    277277                        //          return c                   
    278278                       
    279                         else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.ADVANCETHENSCANTHRU.pabloName(), Builtins.ADVANCETHENSCANTHRU.argCount())) {
     279                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.ADVANCETHENSCANTHRU.pabloSName(), Builtins.ADVANCETHENSCANTHRU.argCount())) {
    280280                                List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
    281281                               
     
    296296                        //      return c
    297297                       
    298                         else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.SPANUPTO.pabloName(), Builtins.SPANUPTO.argCount())) {
     298                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.SPANUPTO.pabloSName(), Builtins.SPANUPTO.argCount())) {
    299299                                List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
    300300                               
     
    317317                        //          return c                   
    318318                       
    319                         else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.ADVANCETHENSCANTO.pabloName(), Builtins.ADVANCETHENSCANTO.argCount())) {
     319                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.ADVANCETHENSCANTO.pabloSName(), Builtins.ADVANCETHENSCANTO.argCount())) {
    320320                                ASTNode argNode = Accessors.funcCallArg(node, 1);
    321321                                if(isFinalBlockMode()) {
     
    346346                        //            return c
    347347       
    348                         else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.INCLUSIVESPAN.pabloName(), Builtins.INCLUSIVESPAN.argCount())) {
     348                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.INCLUSIVESPAN.pabloSName(), Builtins.INCLUSIVESPAN.argCount())) {
    349349                                List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
    350350                               
     
    367367                        //            return c
    368368       
    369                         else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.EXCLUSIVESPAN.pabloName(), Builtins.EXCLUSIVESPAN.argCount())) {
     369                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.EXCLUSIVESPAN.pabloSName(), Builtins.EXCLUSIVESPAN.argCount())) {
    370370                                List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
    371371                               
     
    390390                        //            return c
    391391       
    392                         else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.SCANTO.pabloName(), Builtins.SCANTO.argCount())) {
     392                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.SCANTO.pabloSName(), Builtins.SCANTO.argCount())) {
    393393                               
    394394                                ASTNode argNode = Accessors.funcCallArg(node, 1);
     
    419419                        //            return c
    420420
    421                         else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.SCANTOFIRST.pabloName(), Builtins.SCANTOFIRST.argCount())) {
     421                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.SCANTOFIRST.pabloSName(), Builtins.SCANTOFIRST.argCount())) {
    422422                        //                      if(finalBlockMode) {
    423423                        //                              // TODO - Wrap within simd_andc(scan_class, EOF_mask)
     
    441441                        //            self.current_adv_n += 1
    442442                        //            return c
    443                         else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.ADVANCE32.pabloName(), Builtins.ADVANCE32.argCount())) {
     443                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.ADVANCE32.pabloSName(), Builtins.ADVANCE32.argCount())) {
    444444                                //replaceFuncCallNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.ADVANCE32.cPPCode(), carryCall, currentAdvN);
    445445                                // TODO ==> Verify implementation.
     
    462462                        //            self.current_adv_n += 1
    463463                        //            return c         
    464                         else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.ADVANCEN.pabloName(), Builtins.ADVANCEN.argCount())) {
     464                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.ADVANCEN.pabloSName(), Builtins.ADVANCEN.argCount())) {
    465465                                //replaceFuncCallNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.ADVANCEN.cPPCode(), carryCall, currentAdvN);                                 
    466466                               
     
    481481                        }                                       
    482482               
    483                         else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.ATEOF.pabloName(), Builtins.ATEOF.argCount())) {
     483                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.ATEOF.pabloSName(), Builtins.ATEOF.argCount())) {
    484484                                 
    485485                                if(isFinalBlockMode()) {
     
    487487                                        replacementNode = Generators.makeSIMDAndCEOFMaskFuncCall(argNode, builtins2Lang);
    488488                                } else {
    489                                         replacementNode = Generators.makeFuncCallNode(SIMD.CONSTANT.idisaConstantName(1, 0), node.getToken());                                 
     489                                        replacementNode = Generators.makeFuncCallNode(SIMD.CONSTANT.IDISAConstantLexeme("0", "1"), node.getToken());                                   
    490490                                }
    491491                                node.updateSelf(replacementNode);
     
    497497                        //              return callnode.args[0]
    498498                        //            else: return mkCall('simd_and', [callnode.args[0], ast.Name('EOF_mask', ast.Load())])
    499                         else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.INFILE.pabloName(), Builtins.INFILE.argCount())) {
     499                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.INFILE.pabloSName(), Builtins.INFILE.argCount())) {
    500500                               
    501501                                if(isFinalBlockMode()) {                                       
     
    573573                        // else part, append CarryDequeueEnqueue call
    574574                        FuncCallNode carryDequeueEnqueue = (FuncCallNode) Generators.makeFuncCallNode(
    575                                         new String [] {getCarrySetIdentifier(), carrySet2Lang.getCode(CarrySetBuiltins.CARRYDEQUEUEENQUEUE)},
     575                                        new String [] {getCarrySetIdentifier(), carrySet2Lang.getCode(compiler.lang.carry.CarryBuiltins.CARRYDEQUEUEENQUEUE)},
    576576                                        node.getToken(),
    577577                                        new ASTNode [] {carryBaseNode, carryCountNode});
     
    617617                       
    618618                        IdentifierNode localCarryId                     
    619                                                                 = Generators.makeIdentifierNode(CarrySetBuiltins2Lang.LOCALCARRYQNAME,
     619                                                                = Generators.makeIdentifierNode(compiler.lang.carry.CarryBuiltins2Lang.LOCALCARRYQNAME,
    620620                                                                                                                                node.getToken());
    621621                       
    622622                        CompoundIdentifierNode localCarryQArrayQName   
    623623                                                                = Generators.makeCompoundIdentifierNode(
    624                                                                                 new String [] {CarrySetBuiltins2Lang.LOCALCARRYQNAME,
    625                                                                                                 CarrySetBuiltins2Lang.LOCALCARRYQARRAYNAME},
     624                                                                                new String [] {compiler.lang.carry.CarryBuiltins2Lang.LOCALCARRYQNAME,
     625                                                                                                compiler.lang.carry.CarryBuiltins2Lang.LOCALCARRYQARRAYNAME},
    626626                                                                                node.getToken());
    627627                       
     
    653653                        WhileStmtNode innerWhile = node.deepCopy();
    654654                        CarryIntroXFormer xFormer = new CarryIntroXFormer(Accessors.whileBlockStmt(innerWhile), builtins2Lang, carrySet2Lang);
    655                         xFormer.XForm(finalBlockMode, false, CarrySetBuiltins2Lang.LOCALCARRYQNAME);
     655                        xFormer.XForm(finalBlockMode, false, compiler.lang.carry.CarryBuiltins2Lang.LOCALCARRYQNAME);
    656656                       
    657657                        FuncCallNode localCarryDeclare = (FuncCallNode) Generators.makeFuncCallNode(
    658                                         carrySet2Lang.getCode(CarrySetBuiltins.LOCALCARRYDECLARE),
     658                                        carrySet2Lang.getCode(compiler.lang.carry.CarryBuiltins.LOCALCARRYDECLARE),
    659659                                        node.getToken(),
    660660                                        new ASTNode [] {localCarryId, carryCountNode});
     
    663663
    664664                        FuncCallNode carryCombine = (FuncCallNode) Generators.makeFuncCallNode(
    665                                         new String [] {getCarrySetIdentifier(), carrySet2Lang.getCode(CarrySetBuiltins.CARRYCOMBINE)},
     665                                        new String [] {getCarrySetIdentifier(), carrySet2Lang.getCode(compiler.lang.carry.CarryBuiltins.CARRYCOMBINE)},
    666666                                        node.getToken(),
    667667                                        new ASTNode [] {localCarryQArrayQName, carryBaseNode, carryCountNode});
     
    692692                       
    693693                        FuncCallNode carryDequeueEnqueue = (FuncCallNode) Generators.makeFuncCallNode(
    694                                         new String [] {getCarrySetIdentifier(), carrySet2Lang.getCode(CarrySetBuiltins.CARRYDEQUEUEENQUEUE)},
     694                                        new String [] {getCarrySetIdentifier(), carrySet2Lang.getCode(compiler.lang.carry.CarryBuiltins.CARRYDEQUEUEENQUEUE)},
    695695                                        node.getToken(),
    696696                                        new ASTNode [] {carryBaseNode, carryCountNode});
     
    741741                       
    742742                        FuncCallNode rhs = (FuncCallNode) Generators.makeFuncCallNode(
    743                                         new String [] {getCarrySetIdentifier(), carrySet2Lang.getCode(CarrySetBuiltins.CARRYTEST)},
     743                                        new String [] {getCarrySetIdentifier(), carrySet2Lang.getCode(compiler.lang.carry.CarryBuiltins.CARRYTEST)},
    744744                                        lhs.getToken(),
    745745                                        new ASTNode [] {carryBaseNode, carryCountNode});
  • proto/pabloj/trunk/src/compiler/transformers/pabloS/DumpAssignStmtsXFormer.java

    r2924 r2943  
     1/*
     2 * Adds dumps statements to the AST
     3 * after each assignment and variable declaration statement.
     4 *
     5 * TODO - Move to PabloB.
     6 *
     7 * @author Ken Herdy <ksherdy at sfu dot ca>
     8 */
     9
    110package compiler.transformers.pabloS;
    211
  • proto/pabloj/trunk/src/compiler/transformers/pabloS/PabloSTransformer.java

    r2924 r2943  
    1010//
    1111
    12 
    13 import compiler.lang.carry.CarrySetBuiltins2CPP;
    14 import compiler.lang.carry.CarrySetBuiltins2Lang;
    15 import compiler.lang.pabloS.Builtins2CPP;
    16 import compiler.lang.pabloS.Builtins2Lang;
    17 //import compiler.symbols.SymbolTable;
    18 import compiler.transformer.visitors.*;
     12import compiler.lang.pabloS.*;
    1913
    2014public class PabloSTransformer {
     
    2418        //private SymbolTable symbolTable;
    2519       
    26         private Builtins2Lang builtins2Lang;
    27         private CarrySetBuiltins2Lang carrySet2Lang;
     20        private compiler.lang.pabloS.Builtins2Lang builtins2Lang;
     21        private compiler.lang.carry.CarryBuiltins2Lang carrySet2Lang;
    2822        private boolean finalBlockMode;
    2923       
     
    4943       
    5044        private void initDefaults() {
    51                 this.setBuiltins2Lang(new Builtins2CPP());
    52                 this.setCarrySet2Lang(new CarrySetBuiltins2CPP());
     45                this.setBuiltins2Lang(new PabloSBuiltins2CPP());
     46                this.setCarrySet2Lang(new compiler.lang.carry.CarryBuiltins2CPP());
    5347               
    5448                this.setAddDumpStmts(false);
     
    121115        }
    122116
    123         public CarrySetBuiltins2Lang getCarrySet2Lang() {
     117        public compiler.lang.carry.CarryBuiltins2Lang getCarrySet2Lang() {
    124118                return carrySet2Lang;
    125119        }
    126120
    127         public void setCarrySet2Lang(CarrySetBuiltins2Lang carrySet2Lang) {
     121        public void setCarrySet2Lang(compiler.lang.carry.CarryBuiltins2Lang carrySet2Lang) {
    128122                this.carrySet2Lang = carrySet2Lang;
    129123        }
  • proto/pabloj/trunk/src/compiler/transformers/pabloS/StreamFuncVisitor.java

    r2924 r2943  
     1/*
     2 * Constructs a map of stream function names to stream function nodes.
     3 *
     4 * @author Ken Herdy <ksherdy at sfu dot ca>
     5 */
     6
    17package compiler.transformers.pabloS;
    28
  • proto/pabloj/trunk/src/compiler/transformers/pabloS/helpers/AssertCompare.java

    r2924 r2943  
     1/*
     2 * Quick and Dirty visitor to compare nodes of various types.
     3 *
     4 * If inequality found Then System.exit(9).
     5 *
     6 * @author Ken Herdy <ksherdy at sfu dot ca>
     7 */
     8
    19package compiler.transformers.pabloS.helpers;
    210
Note: See TracChangeset for help on using the changeset viewer.