Ignore:
Timestamp:
May 30, 2013, 12:18:28 PM (6 years ago)
Author:
ksherdy
Message:

Refactored to use packageName, functionName for the creation of builtin calls.

Location:
proto/pabloj/trunk/src/toolchain/pabloS
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • proto/pabloj/trunk/src/toolchain/pabloS/ast/Generators.java

    r3237 r3240  
    101101               
    102102        // deprecate
    103         public static FuncCallNode makeFuncCallNode(String[] identifiers, Locator locator, ASTNode ...args) {
    104                 FuncCallNode node = Generators.makeFuncCallNode(identifiers, locator);
    105                 Generators.addFuncCallArgs(node, args);
    106                 return node;
    107         }
     103//      public static FuncCallNode makeFuncCallNode(String[] identifiers, Locator locator, ASTNode ...args) {
     104//              FuncCallNode node = Generators.makeFuncCallNode(identifiers, locator);
     105//              Generators.addFuncCallArgs(node, args);
     106//              return node;
     107//      }
    108108
    109109        // deprecate
    110         public static FuncCallNode makeFuncCallNode(String[] identifiers, Locator locator, List<ASTNode> args) {
    111                
    112                 FuncCallNode node = Generators.makeFuncCallNode(identifiers, locator);
    113                 Generators.addFuncCallArgs(node, args);
    114                 return node;
    115         }               
    116                
     110//      public static FuncCallNode makeFuncCallNode(String[] identifiers, Locator locator, List<ASTNode> args) {
     111//             
     112//              FuncCallNode node = Generators.makeFuncCallNode(identifiers, locator);
     113//              Generators.addFuncCallArgs(node, args);
     114//              return node;
     115//      }               
    117116       
    118117       
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/InitializeStreamDefaults.java

    r3213 r3240  
    1616import toolchain.pabloS.ast.Accessors;
    1717import toolchain.pabloS.ast.Generators;
     18import toolchain.pabloS.lang.BuiltinCallUtil;
    1819import toolchain.pabloS.lang.PabloSBuiltin;
    1920
     
    4950                                IntegerConstantNode fieldWidthNode =  Generators.makeIntegerConstantNode(fieldWidth, node);
    5051
    51                                 FuncCallNode mask = Generators.makeFuncCallNode(PabloSBuiltin.MASK.pabloSName(),
     52                                FuncCallNode mask = Generators.makeFuncCallNode(BuiltinCallUtil.BUILTIN_PACKAGE_NAME, PabloSBuiltin.MASK.pabloSName(),
    5253                                                node.getToken(),
    5354                                                arguments(fieldWidthNode, zeroConstantNode));
     
    6768               
    6869                public void visitLeave(StructMemberNode node) {
    69                         // TODO - implement
     70                        // TODO - Add logic for filed initialization.
    7071                }
    7172               
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/PabloS2PabloBXFormer.java

    r3233 r3240  
    7575                        pabloB.ast.FuncDefNode funcDefNode                      = entry.getValue();
    7676                        pabloB.ast.FuncDefNode optFuncDefNode           = optMap.get(entry.getKey());
    77                
    78                         pabloB.tokens.Token locationToken                       = funcDefNode.getToken();
    79                        
    80                         pabloB.ast.IdentifierNode doBlockIdentifier = Generators.makeIdentifierNode(DO_BLOCK, locationToken);
     77                       
     78                        pabloB.ast.IdentifierNode doBlockIdentifier = Generators.makeIdentifierNode(DO_BLOCK, funcDefNode);
    8179                        funcDefNode.replaceChild(funcDefNode.child(1), doBlockIdentifier);
    8280
    83                         pabloB.ast.IdentifierNode doOptBlockIdentifier = Generators.makeIdentifierNode(DO_OPT_BLOCK, locationToken);
     81                        pabloB.ast.IdentifierNode doOptBlockIdentifier = Generators.makeIdentifierNode(DO_OPT_BLOCK, optFuncDefNode);
    8482                        optFuncDefNode.replaceChild(optFuncDefNode.child(1), doOptBlockIdentifier);                     
    8583                       
     
    8785                        CarryInfoSetSymbol carryInfoSetSymbol = (CarryInfoSetSymbol) pabloSSymbolTable.get(kernelName);
    8886                       
    89                         pabloB.ast.InitDefNode initDefNode = Generators.makeInitDefNode(locationToken);                 
     87                        pabloB.ast.InitDefNode initDefNode = Generators.makeInitDefNode(funcDefNode);                   
    9088                       
    9189                        // Temporary fix
     
    118116                                        if(carry1Array[i] > 0) {
    119117                                                       
    120                                                         pabloB.ast.IntegerConstantNode indexNode = Generators.makeIntegerConstantNode(i, locationToken);
    121                                                
     118                                                        pabloB.ast.IntegerConstantNode indexNode = Generators.makeIntegerConstantNode(i, funcDefNode);
     119                                                       
    122120                                                        FuncCallNode getCarryFuncCall = (FuncCallNode) Generators.makeFuncCallNode(
    123                                                                 new String [] {CarrySetEncoder.CARRYSETBASENAME,
    124                                                                                                 carrySetEncoder.getCode(CarrySetBuiltins.GETCARRY)},
    125                                                                                                 locationToken,
    126                                                                                                 new ASTNode [] {indexNode});
     121                                                                                                CarrySetEncoder.CARRYSETBASENAME,
     122                                                                                                carrySetEncoder.getCode(CarrySetBuiltins.GETCARRY),
     123                                                                                                funcDefNode,
     124                                                                                                indexNode);
    127125                                               
    128126                                                        FuncCallNode carryFlipFuncCall = (FuncCallNode) Generators.makeFuncCallNode(
    129                                                                         new String [] {CarrySetEncoder.CARRYSETBASENAME,
    130                                                                                                         carrySetEncoder.getCode(CarrySetBuiltins.CARRYFLIP)},
    131                                                                                                         locationToken,
    132                                                                                                         new ASTNode [] {getCarryFuncCall});
     127                                                                                                CarrySetEncoder.CARRYSETBASENAME,
     128                                                                                                carrySetEncoder.getCode(CarrySetBuiltins.CARRYFLIP),
     129                                                                                                funcDefNode,
     130                                                                                                getCarryFuncCall);
    133131                                                       
    134132                                                        FuncCallNode setCarryFuncCall = (FuncCallNode) Generators.makeFuncCallNode(
    135                                                                         new String [] {CarrySetEncoder.CARRYSETBASENAME,
    136                                                                                                         carrySetEncoder.getCode(CarrySetBuiltins.SETCARRY)},
    137                                                                                                         locationToken,
    138                                                                                                         new ASTNode [] {carryFlipFuncCall, indexNode});
     133                                                                                                CarrySetEncoder.CARRYSETBASENAME,
     134                                                                                                carrySetEncoder.getCode(CarrySetBuiltins.SETCARRY),
     135                                                                                                funcDefNode,
     136                                                                                                carryFlipFuncCall, indexNode);
    139137                                                                                                       
    140138                                                        toolchain.pabloB.ast.Accessors.initBlockNode(initDefNode).appendChild(setCarryFuncCall);
     
    149147                                                        funcDefNode,
    150148                                                        optFuncDefNode,
    151                                                         locationToken);
     149                                                        funcDefNode);
    152150                       
    153151                        // add carry declare
     
    210208                // Special cases.
    211209               
    212                 // pabloS stream type to pabloB bitblock type 
     210               
     211                ////////////////////////////////////////////////////////////////////////////////////
     212                // Translates PabloS stream type to PabloB bitblock type 
    213213                //
    214                 // TODO consider field width attributes
     214                // TODO handle field width attributes on PabloS stream types
     215                //
     216                ////////////////////////////////////////////////////////////////////////////////////
    215217                public pabloB.ast.ASTNode visitLeave(pabloS.ast.StreamTypeNode node, List<pabloB.ast.ASTNode> childResults) {
    216218                       
     
    226228                }
    227229               
    228                 /*
    229                 public pabloB.ast.ASTNode visitLeave(pabloS.ast.AssignNode node, List<pabloB.ast.ASTNode> childResults) {
    230                         pabloB.ast.ASTNode bNode = new pabloB.ast.AssignNode(Generators.makePabloBToken(node.getToken()));
    231                         appendChildResults(bNode, childResults);
    232                         return bNode;
    233                 }
    234                                
    235                 public pabloB.ast.ASTNode visitLeave(pabloS.ast.BlockStmtNode node, List<pabloB.ast.ASTNode> childResults) {
    236                         pabloB.ast.ASTNode bNode = new pabloB.ast.BlockStmtNode(Generators.makePabloBToken(node.getToken()));
    237                         appendChildResults(bNode, childResults);
    238                         return bNode;
    239                 }
    240 
    241                 public pabloB.ast.ASTNode visitLeave(pabloS.ast.CompoundIdentifierNode node, List<pabloB.ast.ASTNode> childResults) {
    242                         pabloB.ast.ASTNode bNode = new pabloB.ast.CompoundIdentifierNode(Generators.makePabloBToken(node.getToken()));
    243                         appendChildResults(bNode, childResults);
    244                         return bNode;
    245                 }
    246                
    247                 public pabloB.ast.ASTNode visitLeave(pabloS.ast.EpsilonNode node, List<pabloB.ast.ASTNode> childResults) {
    248                         pabloB.ast.ASTNode bNode = new pabloB.ast.EpsilonNode(Generators.makePabloBToken(node.getToken()));
    249                         appendChildResults(bNode, childResults);
    250                         return bNode;
    251                 }
    252                
    253                 public pabloB.ast.ASTNode visitLeave(pabloS.ast.ErrorNode node, List<pabloB.ast.ASTNode> childResults) {
    254                         pabloB.ast.ASTNode bNode = new pabloB.ast.ErrorNode(Generators.makePabloBToken(node.getToken()));
    255                         appendChildResults(bNode, childResults);
    256                         return bNode;
    257                 }
    258                
    259                 public pabloB.ast.ASTNode visitLeave(pabloS.ast.FuncCallArgListNode node, List<pabloB.ast.ASTNode> childResults) {
    260                         pabloB.ast.ASTNode bNode = new pabloB.ast.FuncCallArgListNode(Generators.makePabloBToken(node.getToken()));
    261                         appendChildResults(bNode, childResults);
    262                         return bNode;
    263                 }
    264                 */
    265                
    266230                public pabloB.ast.ASTNode visitLeave(pabloS.ast.FuncCallNode node, List<pabloB.ast.ASTNode> childResults) {
    267231                       
    268232                        pabloB.ast.ASTNode bNode = null;
    269233                       
    270                         if(BuiltinCallUtil.isMask(node)) { // translate Mask(fw,constant) tp IDISA call
    271                                
    272                                 pabloS.tokens.LextantToken lAngleToken
    273                                 = toolchain.pabloS.ast.Generators.makeLextantToken(Lextant.LANGLE, node.getToken());
     234                        if(BuiltinCallUtil.isMask(node)) { // translates pablo.Mask(fw,constant) to an IDISA call
     235                               
     236                                pabloS.tokens.LextantToken lAngleToken = toolchain.pabloS.ast.Generators.makeLextantToken(Lextant.LANGLE, node.getToken());
    274237               
    275238                                bNode = new pabloB.ast.IdisaFuncCallNode(Generators.makePabloBToken(lAngleToken)); //
     
    278241                                        = toolchain.pabloS.ast.Generators.makeLextantToken(Lextant.DOT, node.getToken());
    279242                                                       
    280                                 pabloB.ast.ASTNode compoundIdentifierNode
    281                                         = Generators.makeCompoundIdentifierNode(new String [] {"simd","constant"},
    282                                                                                                                                 Generators.makePabloBToken(dotToken));
     243                                pabloB.ast.ASTNode compoundIdentifierNode = Generators.makeCompoundIdentifierNode("simd", "constant", bNode);
    283244                               
    284245                                // field width integer constant
     
    326287                        return bNode;
    327288                }
    328                
    329                 /*
    330                 public pabloB.ast.ASTNode visitLeave(pabloS.ast.FuncCallOrAssignStmtNode node, List<pabloB.ast.ASTNode> childResults) {
    331                         pabloB.ast.ASTNode bNode = new pabloB.ast.FuncCallOrAssignStmtNode(Generators.makePabloBToken(node.getToken()));
    332                         appendChildResults(bNode, childResults);
    333                         return bNode;
    334                 }
    335                        
    336                 public pabloB.ast.ASTNode visitLeave(pabloS.ast.FuncDefNode node, List<pabloB.ast.ASTNode> childResults) {
    337                         pabloB.ast.ASTNode bNode = new pabloB.ast.FuncDefNode(Generators.makePabloBToken(node.getToken()));
    338                         appendChildResults(bNode, childResults);
    339                         return bNode;
    340                 }
    341 
    342                 public pabloB.ast.ASTNode visitLeave(pabloS.ast.IdentifierNode node, List<pabloB.ast.ASTNode> childResults) {
    343                         pabloB.ast.ASTNode bNode = new pabloB.ast.IdentifierNode(Generators.makePabloBToken(node.getToken()));
    344                         appendChildResults(bNode, childResults);
    345                         return bNode;
    346                 }
    347 
    348                 public pabloB.ast.ASTNode visitLeave(pabloS.ast.IfStmtNode node, List<pabloB.ast.ASTNode> childResults) {
    349                         pabloB.ast.ASTNode bNode = new pabloB.ast.IfStmtNode(Generators.makePabloBToken(node.getToken()));
    350                         appendChildResults(bNode, childResults);
    351                         return bNode;
    352                 }
    353                 */
    354                
     289                               
    355290                public pabloB.ast.ASTNode visitLeave(pabloS.ast.IntegerConstantNode node, List<pabloB.ast.ASTNode> childResults) {
    356291                        pabloB.ast.ASTNode bNode = new pabloB.ast.IntegerConstantNode(Generators.makePabloBToken(node.getToken()));
     
    360295                        return bNode;
    361296                }
    362                
    363                 /*
    364                 public pabloB.ast.ASTNode visitLeave(pabloS.ast.LocalVarDeclNode node, List<pabloB.ast.ASTNode> childResults) {
    365                         pabloB.ast.ASTNode bNode = new pabloB.ast.LocalVarDeclNode(Generators.makePabloBToken(node.getToken()));
    366                         appendChildResults(bNode, childResults);
    367                         return bNode;
    368                 }
    369                                
    370                 public pabloB.ast.ASTNode visitLeave(pabloS.ast.ParameterListNode node, List<pabloB.ast.ASTNode> childResults) {
    371                         pabloB.ast.ASTNode bNode = new pabloB.ast.ParameterListNode(Generators.makePabloBToken(node.getToken()));                       
    372                         appendChildResults(bNode, childResults);
    373                         return bNode;
    374                 }
    375                
    376                 public pabloB.ast.ASTNode visitLeave(pabloS.ast.ParameterNode node, List<pabloB.ast.ASTNode> childResults) {
    377                         pabloB.ast.ASTNode bNode = new pabloB.ast.ParameterNode(Generators.makePabloBToken(node.getToken()));
    378                         appendChildResults(bNode, childResults);
    379                         return bNode;
    380                 }
    381                
    382                 public pabloB.ast.ASTNode visitLeave(pabloS.ast.ProgramNode node, List<pabloB.ast.ASTNode> childResults) {
    383                         pabloB.ast.ProgramNode bNode = new pabloB.ast.ProgramNode(Generators.makePabloBToken(node.getToken()));
    384                         appendChildResults(bNode, childResults);
    385                         return bNode;
    386                 }
    387 
    388                 public pabloB.ast.ASTNode visitLeave(pabloS.ast.ReturnStmtNode node, List<pabloB.ast.ASTNode> childResults) {
    389                         pabloB.ast.ASTNode bNode = new pabloB.ast.ReturnStmtNode(Generators.makePabloBToken(node.getToken()));
    390                         appendChildResults(bNode, childResults);
    391                         return bNode;
    392                 }
    393                
    394                 public pabloB.ast.ASTNode visitLeave(pabloS.ast.StringConstantNode node, List<pabloB.ast.ASTNode> childResults) {
    395                         pabloB.ast.ASTNode bNode = new pabloB.ast.StringConstantNode(Generators.makePabloBToken(node.getToken()));
    396                         appendChildResults(bNode, childResults);
    397                         return bNode;
    398                 }
    399                
    400                 public pabloB.ast.ASTNode visitLeave(pabloS.ast.PrimitiveTypeNode node, List<pabloB.ast.ASTNode> childResults) {
    401                         pabloB.ast.ASTNode bNode = new pabloB.ast.VoidTypeNode(Generators.makePabloBToken(node.getToken()));
    402                         appendChildResults(bNode, childResults);
    403                         return bNode;
    404                 }
    405                
    406                 public pabloB.ast.ASTNode visitLeave(pabloS.ast.StructMemberNode node, List<pabloB.ast.ASTNode> childResults) {
    407                         pabloB.ast.ASTNode bNode = new pabloB.ast.StructMemberNode(Generators.makePabloBToken(node.getToken()));
    408                         appendChildResults(bNode, childResults);
    409                         return bNode;
    410                 }
    411 
    412                 public pabloB.ast.ASTNode visitLeave(pabloS.ast.StructTypeBodyNode node, List<pabloB.ast.ASTNode> childResults) {
    413                         pabloB.ast.ASTNode bNode = new pabloB.ast.StructTypeBodyNode(Generators.makePabloBToken(node.getToken()));
    414                         appendChildResults(bNode, childResults);
    415                         return bNode;
    416                 }
    417                
    418                 public pabloB.ast.ASTNode visitLeave(pabloS.ast.StructTypeNode node, List<pabloB.ast.ASTNode> childResults) {
    419                         pabloB.ast.ASTNode bNode = new pabloB.ast.StructTypeNode(Generators.makePabloBToken(node.getToken()));
    420                         appendChildResults(bNode, childResults);
    421                         return bNode;
    422                 }
    423                                
    424                 public pabloB.ast.ASTNode visitLeave(pabloS.ast.WhileStmtNode node, List<pabloB.ast.ASTNode> childResults) {
    425                         pabloB.ast.ASTNode bNode = new pabloB.ast.WhileStmtNode(Generators.makePabloBToken(node.getToken()));
    426                         appendChildResults(bNode, childResults);
    427                         return bNode;
    428                 }
    429                 */
    430297        }       
    431298       
     
    436303        }
    437304       
    438        
    439         /*
    440          @SuppressWarnings("unused")
    441          private static pabloS.ast.FuncDefNode searchForFuncDefByName(pabloS.ast.ASTNode node, String name) {
     305        @SuppressWarnings("unused")
     306        private static pabloS.ast.FuncDefNode searchForFuncDefByName(pabloS.ast.ASTNode node, String name) {
    442307       
    443308                if(node instanceof pabloS.ast.FuncDefNode) {
     
    457322               
    458323                return result; 
    459         }*/
     324        }
    460325       
    461326}
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/carry/BuiltinTranslator.java

    r3213 r3240  
    171171               
    172172                FuncCallNode replacementNode = Generators.makeFuncCallNode(
    173                                 new String [] {carryIdentifier, carryBuiltin},
     173                                carryIdentifier,
     174                                carryBuiltin,
    174175                                node,
    175176                                args);
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/carry/CarryIntroXFormer.java

    r3213 r3240  
    130130                       
    131131                        FuncCallNode carryAdjustment = Generators.makeFuncCallNode(
    132                                                                         carrySetFunction(CarrySetBuiltins.CARRYADJUST),
     132                                                                        context.getCarrySetIdentifier(),
     133                                                                        context.getCarrySetEncoder().getCode(CarrySetBuiltins.CARRYADJUST),                                                                     
    133134                                                                        location,
    134135                                                                        arguments(carry1CountNode));
     
    205206                       
    206207                        FuncCallNode carryDequeueEnqueue = (FuncCallNode) Generators.makeFuncCallNode(
    207                                                                 carrySetFunction(CarrySetBuiltins.CARRYDEQUEUEENQUEUE),
     208                                                                context.getCarrySetIdentifier(),
     209                                                                context.getCarrySetEncoder().getCode(CarrySetBuiltins.CARRYDEQUEUEENQUEUE),
    208210                                                                location,
    209211                                                                arguments(carryBaseNode, carryCountNode));
     
    308310                       
    309311                        FuncCallNode carryDequeueEnqueue = (FuncCallNode) Generators.makeFuncCallNode(
    310                                                                         carrySetFunction(CarrySetBuiltins.CARRYDEQUEUEENQUEUE),
     312                                                                        context.getCarrySetIdentifier(),
     313                                                                        context.getCarrySetEncoder().getCode(CarrySetBuiltins.CARRYDEQUEUEENQUEUE),
    311314                                                                        locator,
    312315                                                                        arguments(carryBaseNode, carry1CountNode));
     
    400403                        ASTNode carryCountNode = leaf(carryCount, location);
    401404                        ASTNode carryRange = Generators.makeFuncCallNode(
    402                                                                         carrySetFunction(CarrySetBuiltins.CARRYRANGE),
     405                                                                        context.getCarrySetIdentifier(),
     406                                                                        context.getCarrySetEncoder().getCode(CarrySetBuiltins.CARRYRANGE),
    403407                                                                        location,
    404408                                                                        arguments(carryBaseNode, carryCountNode));
     
    412416                ///////////////////////////////////////////////////////////////////
    413417                // Utilities
    414 
    415                 // gives the proper array of strings for a carrySetBuiltin call.
    416                 private String[] carrySetFunction(CarrySetBuiltins carrySetBuiltin) {
    417                         return new String [] { 
    418                                         context.getCarrySetIdentifier(),
    419                                         context.getCarrySetEncoder().getCode(carrySetBuiltin)
    420                         };
    421                 }               
     418               
    422419                private ASTNode[] arguments(ASTNode...astNodes) {
    423420                        return astNodes;
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/carry/Counter.java

    r3213 r3240  
    66import toolchain.pabloB.lang.carrySet.CarrySetBuiltins;
    77import toolchain.pabloS.ast.Generators;
     8import toolchain.pabloS.lang.BuiltinCallUtil;
    89import toolchain.pabloS.lang.PabloSBuiltin;
    910
     
    3132                if(context.isCarryInMode()) {
    3233                        return Generators.makeFuncCallNode(
    33                                         new String [] {context.getCarrySetIdentifier(), context.getCarrySetEncoder().getCode(builtin)},
     34                                        context.getCarrySetIdentifier(),
     35                                        context.getCarrySetEncoder().getCode(builtin),
    3436                                        locator,
    3537                                        valueNode(locator));
     
    4446                IntegerConstantNode fieldWidthNode =  Generators.makeIntegerConstantNode(1, locator);
    4547               
    46                 return Generators.makeFuncCallNode(PabloSBuiltin.MASK.pabloSName(),
     48                return Generators.makeFuncCallNode(BuiltinCallUtil.BUILTIN_PACKAGE_NAME, PabloSBuiltin.MASK.pabloSName(),
    4749                                locator,
    4850                                fieldWidthNode, zeroConstantNode);
Note: See TracChangeset for help on using the changeset viewer.