Ignore:
Timestamp:
Jun 4, 2013, 12:33:12 AM (6 years ago)
Author:
ksherdy
Message:

Added PabloB state node and state parameters to Kernels.

Location:
proto/pabloj/trunk/src
Files:
1 added
2 deleted
8 edited

Legend:

Unmodified
Added
Removed
  • proto/pabloj/trunk/src/application/generators/ApplicationGenerator.java

    r3249 r3260  
    5555               
    5656                // Transformation configurations to support multiple backends
    57                 toolchain.pabloS.lang.BuiltinEncoder pabloSbuiltins2Lang  = null;
    58                 toolchain.pabloB.lang.BuiltinEncoder pabloBBuiltins2Lang  = null;
    59                 AbstractUnparser unparser                       = null;
     57                toolchain.pabloS.lang.BuiltinEncoder pabloSbuiltinsEncoder  = null;
     58                toolchain.pabloB.lang.BuiltinEncoder pabloBBuiltinsEncoder  = null;
     59                AbstractUnparser unparser                                                                       = null;
    6060               
    61                 toolchain.pabloB.lang.carrySet.CarrySetEncoder carrySet2Lang = null;
     61                toolchain.pabloB.lang.carrySet.CarrySetEncoder carrySetEncoder = null;
    6262                               
    6363                if(applicationConfiguration.targetLang.contentEquals(Configuration.CLANG)) {
    64             pabloSbuiltins2Lang = new toolchain.pabloS.lang.PabloSBuiltins2C();
    65             pabloBBuiltins2Lang = new toolchain.pabloB.lang.PabloBBuiltins2C();
    66             carrySet2Lang = new toolchain.pabloB.lang.carrySet.CarrySetBuiltins2C();
    67                         unparser      = new Unparser(new IDISABuiltin2C());                     
     64            pabloSbuiltinsEncoder       = new toolchain.pabloS.lang.PabloSBuiltins2C();
     65            pabloBBuiltinsEncoder       = new toolchain.pabloB.lang.PabloBBuiltins2C();
     66            carrySetEncoder             = new toolchain.pabloB.lang.carrySet.CarrySetBuiltins2C();
     67                        unparser                        = new Unparser(new IDISABuiltin2C());                   
    6868                } else if(applicationConfiguration.targetLang.contentEquals(Configuration.CPPLANG)) {
    69                         pabloSbuiltins2Lang = new toolchain.pabloS.lang.PabloSBuiltins2CPP();
    70                         pabloBBuiltins2Lang = new toolchain.pabloB.lang.PabloBBuiltins2CPP();
    71                         carrySet2Lang = new toolchain.pabloB.lang.carrySet.CarrySetBuiltins2CPP();
    72                         unparser          = new Unparser(new IDISABuiltin2CPP());
     69                        pabloSbuiltinsEncoder   = new toolchain.pabloS.lang.PabloSBuiltins2CPP();
     70                        pabloBBuiltinsEncoder   = new toolchain.pabloB.lang.PabloBBuiltins2CPP();
     71                        carrySetEncoder                 = new toolchain.pabloB.lang.carrySet.CarrySetBuiltins2CPP();
     72                        unparser                                = new Unparser(new IDISABuiltin2CPP());
    7373                } /*else if(applicationConfiguration.targetLang.contentEquals(Configuration.LLVM)) {  // default C++
    7474                        builtins2Lang = new PabloSBuiltins2CPP();
     
    8585                        // transform PabloS builtins to Carry Set builtins
    8686                        toolchain.pabloS.transformer.Transformer pabloSXFormer = new toolchain.pabloS.transformer.Transformer(pabloSAST);
    87                         pabloSXFormer.setBuiltins2Lang(pabloSbuiltins2Lang);
    88                         pabloSXFormer.setCarrySet2Lang(carrySet2Lang);
     87                        pabloSXFormer.setBuiltins2Lang(pabloSbuiltinsEncoder);
     88                        pabloSXFormer.setCarrySet2Lang(carrySetEncoder);
    8989                       
    9090                        // Transform PabloS global functions in non-final block mode
     
    9696                        pabloS.ast.ProgramNode optDecoratedTree = (pabloS.ast.ProgramNode)pabloSXFormer.xForm();
    9797
    98                         // Transform PabloS to PabloB
    99                        
    100 
    101                         // 1. List stream functions
    102                         // 2. Map
    103                        
    10498                        ArrayList<pabloS.ast.FuncDefNode> funcDefNodes = StreamFunctions.makeList(pabloSAST);
    10599                        Map<String, CarryInfoSet> carryInfoSetMap = CarryInfoSetFactory.makeCarryInfoSetMap(funcDefNodes); 
    106100                       
    107                         PabloS2PabloBXFormer pabloS2PabloBXFormer = new PabloS2PabloBXFormer(carryInfoSetMap, carrySet2Lang);
     101                        PabloS2PabloBXFormer pabloS2PabloBXFormer = new PabloS2PabloBXFormer(carryInfoSetMap, carrySetEncoder);
    108102                        pabloBAST = pabloS2PabloBXFormer.XForm(decoratedTree, optDecoratedTree);
    109103                       
     
    117111        // PabloB AST Transforms
    118112        toolchain.pabloB.transformer.Transformer pabloBXFormer = new toolchain.pabloB.transformer.Transformer(pabloBAST);
    119         pabloBXFormer.setBuiltins2Lang(pabloBBuiltins2Lang);
     113        pabloBXFormer.setBuiltins2Lang(pabloBBuiltinsEncoder);
    120114       
    121115        if(applicationConfiguration.addAssertBitBlockAlignStmts) {
  • proto/pabloj/trunk/src/pabloS/ast/ASTNode.java

    r3259 r3260  
    2525       
    2626        Token token;
    27         int productionTag;
     27        int productionTag = NO_TAG;
    2828        boolean simplifiable;
     29        boolean compressed = false;
    2930       
    3031        private Type type = null;
     
    8283                return productionTag;
    8384        }
    84        
     85        public void setCompressed() {
     86                compressed = true;
     87        }
     88        public boolean isCompressed() {
     89                return compressed;
     90        }
    8591        public void setSimplifiable(boolean value) {
    8692                simplifiable = value;
  • proto/pabloj/trunk/src/pabloS/parser/Parser.java

    r3259 r3260  
    13461346        // return node or, if it has one child, its single child.       
    13471347        private ASTNode compressIfPossible(ASTNode node) {
    1348                 return node.nChildren() == 1 ? node.child(0) : node;
     1348                if(node.nChildren() != 1) {
     1349                        return node;
     1350                }
     1351                ASTNode result = node.child(0);
     1352                result.setCompressed();
     1353                return result;
    13491354        }
    13501355       
     
    13581363                ASTNode left   = top.child(0);
    13591364                ASTNode newTop = top.child(1);
    1360                 if((newTop.nChildren() != 2) || !fromSameProduction(top, newTop)) {
     1365               
     1366                if( (newTop.nChildren() == 2)  &&  fromSameProduction(top, newTop) ) {
     1367                        ASTNode middle = newTop.child(0);
     1368                        ASTNode right = newTop.child(1);
     1369
     1370                        top.initChildren();
     1371                        top.appendChild(left);
     1372                        top.appendChild(middle);
     1373                        top = rotateLeftIfPossible(top);
     1374
     1375                        newTop.initChildren();
     1376                        newTop.appendChild(top);
     1377                        newTop.appendChild(right);
     1378
     1379                        return newTop;
     1380                }
     1381                else  {
    13611382                        return top;
    13621383                }
    1363                 ASTNode middle = newTop.child(0);
    1364                 ASTNode right = newTop.child(1);
    1365                
    1366                 top.initChildren();
    1367                 top.appendChild(left);
    1368                 top.appendChild(middle);
    1369                 top = rotateLeftIfPossible(top);
    1370                
    1371                 newTop.initChildren();
    1372                 newTop.appendChild(top);
    1373                 newTop.appendChild(right);
    1374                
    1375                 return newTop;
    13761384        }
    13771385        private boolean fromSameProduction(ASTNode node1, ASTNode node2) {
    1378                 return node1.getProductionTag() == node2.getProductionTag();
     1386                return (node1.getProductionTag() == node2.getProductionTag()) &&
     1387                           !node1.isCompressed() &&
     1388                           !node2.isCompressed();
    13791389        }
    13801390        private ASTNode promoteLastChild(ASTNode tree) {
  • proto/pabloj/trunk/src/toolchain/pabloB/ast/Generators.java

    r3257 r3260  
    44
    55package toolchain.pabloB.ast;
     6import java.util.ArrayList;
    67import java.util.List;
    78
     
    138139       
    139140        // stateParameter      ->  stateName ASSIGN stateValue TERMINATOR ;
    140         public static StateParameterNode makeStateParameterNode (IdentifierNode identifier, StateValueNode stateValue) {
    141             StateParameterNode stateParameter = new StateParameterNode(identifier.getToken());
    142             stateParameter.appendChild(identifier);
     141        public static StateParameterNode makeStateParameterNode (IdentifierNode stateName, StateValueNode stateValue) {
     142            StateParameterNode stateParameter = new StateParameterNode(stateName.getToken());
     143            stateParameter.appendChild(stateName);
    143144            stateParameter.appendChild(stateValue);
    144145            return stateParameter;
     
    154155            return stateValue;
    155156        }
     157       
     158        // stateValue helper
     159        public static StateValueNode makeStateValueNode(Integer value, Locator locator) {
     160                List<Integer> values = new ArrayList<Integer>();
     161                values.add(value);
     162                return Generators.makeStateValueNode(values, locator);
     163        }       
    156164       
    157165        /* TODO Update init section and refactor
  • proto/pabloj/trunk/src/toolchain/pabloB/codeGenerator/visitors/Unparser.java

    r3258 r3260  
    4747
    4848public class Unparser extends AbstractUnparser {
    49 
    50         private String stateIdentifier = null;
    5149       
    5250        //////////////////////////////////////////////////////////////
     
    9290               
    9391
    94 //              CodeStore initDef = childResults.get(1); // KH: breakage
     92                CodeStore initDef = childResults.get(1); // KH: breakage
    9593               
    9694                CodeStore funcDefCodeStore = childResults.get(2);
     
    10098               
    10199                code.indentedFormattedLine("%s()", kernelName);
    102                
    103                 code.addLine("{}");
    104 //              code.addAll(initDef, 0); // KH: breakage
     100                code.addAll(initDef, 0);
    105101               
    106102                funcDefCodeStore.prependToFirst("IDISA_INLINE ");
    107                
    108103                code.addAll(funcDefCodeStore, 0);
    109104               
     
    132127        // Kernel Initialization
    133128        ////////////////////////////////////////////////////////////////////////////
    134 /*     
     129
    135130        public CodeStore visitLeave(StateDefNode node, List<CodeStore> childResults) {
    136131                CodeStore code = new CodeStore();
    137132               
    138                 // add strings // visit enter is needed here
    139                
    140                 CodeStore initBlockCodeStore = childResults.get(0);
    141                
    142133                code.addLine("{");
    143                 code.addAll(initBlockCodeStore, 1);
    144                 code.dedentedLine("}");         
     134                for (CodeStore child: childResults) {
     135                        code.addAll(child, 1);
     136                }       
     137                code.addLine("}");                             
    145138               
    146139                code.addLine(" "); // a blank line
     
    148141                return code;
    149142        }
    150                 */
    151 
     143
     144        public CodeStore visitLeave(StateParameterNode node, List<CodeStore> childResults) {
     145                CodeStore code = new CodeStore();               
     146                return code;
     147        }
     148
     149        public CodeStore visitLeave(StateValueNode node, List<CodeStore> childResults) {
     150                CodeStore code = new CodeStore();               
     151                return code;
     152        }
     153
     154       
    152155/*      public CodeStore visitLeave(InitBlockNode node, List<CodeStore> childResults) {
    153156                CodeStore code = new CodeStore();
     
    499502                return code;
    500503        }
     504
    501505}
  • proto/pabloj/trunk/src/toolchain/pabloB/lang/PabloBBuiltin.java

    r3208 r3260  
    88  public enum PabloBBuiltin {
    99
    10       PRINT_BITBLOCK("PrintBitBlock",CarryType.None, 1),
    11       ASSERT_BITBLOCK_ALIGN("AssertBitBlockAlign",CarryType.None, 1);
     10      PRINT_BITBLOCK("PrintBitBlock", CarryType.None, 1),
     11      ASSERT_BITBLOCK_ALIGN("AssertBitBlockAlign", CarryType.None, 1);
    1212     
    1313      public enum CarryType{One, N, None};   
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/PabloS2PabloBXFormer.java

    r3257 r3260  
    88
    99import java.lang.reflect.Constructor;
    10 import java.util.HashMap;
    11 import java.util.List;
    12 import java.util.Map;
    13 
    14 import pabloB.ast.FuncCallNode;
    15 import pabloB.ast.StateParameterNode;
     10import java.util.*;
     11
     12import pabloB.ast.*;
     13import pabloB.inputHandler.Locator;
     14import toolchain.pabloB.ast.Accessors;
     15import toolchain.pabloB.ast.Generators;
    1616import pabloS.ast.ASTVisitor.Default;
    1717import pabloS.lexicalAnalyzer.Lextant;
    18 import toolchain.pabloB.ast.Generators;
     18
     19import toolchain.pabloB.lang.KernelState;
     20import toolchain.pabloB.lang.carrySet.CarrySetBuiltins;
    1921import toolchain.pabloB.lang.carrySet.CarrySetEncoder;
    20 import toolchain.pabloB.lang.carrySet.CarrySetBuiltins;
    21 import toolchain.pabloS.ast.Accessors;
    2222import toolchain.pabloS.lang.BuiltinCallUtil;
    2323import toolchain.pabloS.transformer.visitors.carry.CarryInfoSet;
     
    2828        private static final String DO_OPT_BLOCK        = "do_final_block";
    2929       
    30         public static Boolean PABLO2PABLOB_XFORM_SUPPORT = false;
    31         public static String PABLO2PABLOB_XFORM_SUPPORT_MSG = "PabloS to PabloB node transformation not supported.";
     30        public static Boolean   PABLO2PABLOB_XFORM_SUPPORT = false;
     31        public static String    PABLO2PABLOB_XFORM_SUPPORT_MSG = "PabloS to PabloB node transformation not supported.";
    3232       
    3333        private pabloS.ast.ASTNode decoratedASTTree;   
     
    5151                pabloB.ast.ASTNode bASTTree     = this.decoratedASTTree.accept(new pabloBASTBuilder());
    5252                pabloB.ast.ASTNode bOptASTTree  = this.optDecoratedASTTree.accept(new pabloBASTBuilder());
    53                
    54                 // map function names to function definition nodes             
     53                               
    5554                Map<String, pabloB.ast.FuncDefNode> map         = makeFuncDefMap(bASTTree);
    5655                Map<String, pabloB.ast.FuncDefNode> optMap      = makeFuncDefMap(bOptASTTree);
     
    6160                        pabloB.ast.FuncDefNode optFuncDefNode           = optMap.get(entry.getKey());
    6261                       
    63                         pabloB.ast.IdentifierNode doBlockIdentifier = Generators.makeIdentifierNode(DO_BLOCK, funcDefNode);
    64                         funcDefNode.replaceChild(funcDefNode.child(1), doBlockIdentifier);
    65 
    66                         pabloB.ast.IdentifierNode doOptBlockIdentifier = Generators.makeIdentifierNode(DO_OPT_BLOCK, optFuncDefNode);
    67                         optFuncDefNode.replaceChild(optFuncDefNode.child(1), doOptBlockIdentifier);                     
     62                        Locator locator = funcDefNode.getToken();
     63                       
     64                        IdentifierNode doBlockIdentifier = Generators.makeIdentifierNode(DO_BLOCK, locator);
     65                        funcDefNode.replaceChild(Accessors.funcIdentifier(funcDefNode), doBlockIdentifier);
     66
     67                        IdentifierNode doOptBlockIdentifier = Generators.makeIdentifierNode(DO_OPT_BLOCK, locator);
     68                        optFuncDefNode.replaceChild(Accessors.funcIdentifier(optFuncDefNode), doOptBlockIdentifier);                   
    6869                       
    6970                        String kernelName = entry.getKey();                     
    70                         CarryInfoSet carryInfoSetSymbol = (CarryInfoSet) carryInfoSetMap.get(kernelName);
    71                        
    72                         pabloB.ast.StateDefNode stateDefNode = Generators.makeStateDefNode(funcDefNode);                       
    73                        
    74                         // Temporary fix
    75 /*                                             
    76             if(carryInfoSetSymbol.getCarry1Count() > 0) {
    77                                 StateInitStmtNode carry1StateNode = Generators.makeStateInitStmtNode(CarryInfoSet.CARRY1STATENAME,
    78                                                                                                                 carryInfoSetSymbol.getCarry1Array(),
    79                                                                                                                 locationToken);                 
    80                                
    81                                 IdentifierNode stateName    = makeIdentifierNode();
    82                                 StateValueNode stateValue   = makeStateValueNode();
    83                                
    84                                 // StateParameterNode stateParameter =
    85                         }
    86            
    87 */                     
    88                         /*
    89                         if(carryInfoSetSymbol.getCarryNCount() > 0) {
    90                                 StateInitStmtNode carryNStateNode = Generators.makeStateInitStmtNode(CarryInfoSet.CARRYNSTATENAME,
    91                                                                                                                 carryInfoSetSymbol.getCarryNArray(),
    92                                                                                                                 locationToken);
    93 
    94                         }
    95                         */
    96                        
    97                         if(carryInfoSetSymbol.getCarry1Count() > 0) { // KH: TODO Direct to StateDefNode.
    98                                                
    99                                 Integer [] carry1Array = carryInfoSetSymbol.getCarry1Array();   
     71                        CarryInfoSet carryInfoSetSymbol = carryInfoSetMap.get(kernelName);
     72                       
     73                        ////////////////////////////////////////////////////////////
     74                        // Kernel state parameters
     75                        ////////////////////////////////////////////////////////////
     76                        StateDefNode stateDefNode = Generators.makeStateDefNode(funcDefNode);                   
     77                       
     78                        ////////////////////////////////////////////////////////////
     79                        // Carry1
     80                IdentifierNode stateName                = Generators.makeIdentifierNode(KernelState.CARRY1_LIST.name(), locator);
     81                StateValueNode stateValue               = Generators.makeStateValueNode(carryInfoSetSymbol.Carry1List(), locator);
     82                        StateParameterNode stateParameter       = Generators.makeStateParameterNode(stateName, stateValue);
     83                        stateDefNode.appendChild(stateParameter);
     84                       
     85                        ////////////////////////////////////////////////////////////
     86                        // Carry1 Count
     87                stateName       = Generators.makeIdentifierNode(KernelState.CARRY1_COUNT.name(), locator);
     88                stateValue      = Generators.makeStateValueNode(carryInfoSetSymbol.Carry1Count(), locator);
     89                        stateParameter  = Generators.makeStateParameterNode(stateName, stateValue);
     90                        stateDefNode.appendChild(stateParameter);
     91
     92                        ////////////////////////////////////////////////////////////                   
     93                        // Add CarryFlip call for variable initialization                       
     94                       
     95                        for(Integer i : carryInfoSetSymbol.Carry1List()) {
     96
     97                                if(i > 0) {
    10098                                       
    101                                 for(int i=0; i < carry1Array.length; i++) {     
     99                                        pabloB.ast.IntegerConstantNode indexNode = Generators.makeIntegerConstantNode(i+1, locator);
    102100                                       
    103                                         if(carry1Array[i] > 0) {
    104                                                        
    105                                                         pabloB.ast.IntegerConstantNode indexNode = Generators.makeIntegerConstantNode(i, funcDefNode);
    106                                                        
    107                                                         FuncCallNode getCarryFuncCall = (FuncCallNode) Generators.makeFuncCallNode(
    108                                                                                                 CarrySetEncoder.CARRYSETBASENAME,
    109                                                                                                 carrySetEncoder.getCode(CarrySetBuiltins.GETCARRY),
    110                                                                                                 funcDefNode,
    111                                                                                                 indexNode);
    112                                                
    113                                                         FuncCallNode carryFlipFuncCall = (FuncCallNode) Generators.makeFuncCallNode(
    114                                                                                                 CarrySetEncoder.CARRYSETBASENAME,
    115                                                                                                 carrySetEncoder.getCode(CarrySetBuiltins.CARRYFLIP),
    116                                                                                                 funcDefNode,
    117                                                                                                 getCarryFuncCall);
    118                                                        
    119                                                         FuncCallNode setCarryFuncCall = (FuncCallNode) Generators.makeFuncCallNode(
    120                                                                                                 CarrySetEncoder.CARRYSETBASENAME,
    121                                                                                                 carrySetEncoder.getCode(CarrySetBuiltins.SETCARRY),
    122                                                                                                 funcDefNode,
    123                                                                                                 carryFlipFuncCall, indexNode);
    124                                                                                                        
    125                                                         // ? toolchain.pabloB.ast.Accessors.initBlockNode(initDefNode).appendChild(setCarryFuncCall);
    126                                         }
     101                                        FuncCallNode getCarryFuncCall = (FuncCallNode) Generators.makeFuncCallNode(
     102                                                                                CarrySetEncoder.CARRYSETBASENAME,
     103                                                                                carrySetEncoder.getCode(CarrySetBuiltins.GETCARRY),
     104                                                                                locator,
     105                                                                                indexNode);
     106                               
     107                                        FuncCallNode carryFlipFuncCall = (FuncCallNode) Generators.makeFuncCallNode(
     108                                                                                CarrySetEncoder.CARRYSETBASENAME,
     109                                                                                carrySetEncoder.getCode(CarrySetBuiltins.CARRYFLIP),
     110                                                                                locator,
     111                                                                                getCarryFuncCall);
     112                                       
     113                                        FuncCallNode setCarryFuncCall = (FuncCallNode) Generators.makeFuncCallNode(
     114                                                                                CarrySetEncoder.CARRYSETBASENAME,
     115                                                                                carrySetEncoder.getCode(CarrySetBuiltins.SETCARRY),
     116                                                                                locator,
     117                                                                                carryFlipFuncCall, indexNode);
     118                                                                                       
     119                                        stateDefNode.appendChild(setCarryFuncCall);
    127120                                }
    128121                        }
    129122                       
    130                         // make kernel node
     123                       
     124                        ////////////////////////////////////////////////////////////
     125                        // CarryN
     126                stateName       = Generators.makeIdentifierNode(KernelState.CARRYN_LIST.name(), locator);
     127                stateValue      = Generators.makeStateValueNode(carryInfoSetSymbol.CarryNList(), locator);
     128                        stateParameter  = Generators.makeStateParameterNode(stateName, stateValue);
     129                        stateDefNode.appendChild(stateParameter);
     130
     131                        ////////////////////////////////////////////////////////////
     132                        // CarryN Count                 
     133                stateName       = Generators.makeIdentifierNode(KernelState.CARRYN_COUNT.name(), locator);
     134                stateValue      = Generators.makeStateValueNode(carryInfoSetSymbol.CarryNCount(), locator);
     135                        stateParameter  = Generators.makeStateParameterNode(stateName, stateValue);
     136                        stateDefNode.appendChild(stateParameter);
     137                       
     138                        ////////////////////////////////////////////////////////////
     139                        // KH: TODO - LookAhead
     140                stateName       = Generators.makeIdentifierNode(KernelState.LOOK_AHEAD.name(), locator);
     141                stateValue      = Generators.makeStateValueNode(0, locator);
     142                        stateParameter  = Generators.makeStateParameterNode(stateName, stateValue);
     143                        stateDefNode.appendChild(stateParameter);
     144                       
     145                        ////////////////////////////////////////////////////////////
     146                        // KH: TODO - LookBehind
     147                stateName       = Generators.makeIdentifierNode(KernelState.LOOK_BEHIND.name(), locator);
     148                stateValue      = Generators.makeStateValueNode(0, locator);
     149                        stateParameter  = Generators.makeStateParameterNode(stateName, stateValue);
     150                        stateDefNode.appendChild(stateParameter);
     151                       
    131152                        pabloB.ast.KernelDefNode kernelDefNode =
    132153                                        Generators.makeKernelDef(kernelName,
     
    136157                                                        funcDefNode.getToken());
    137158                       
    138                         // add carry declare - hack
     159                        // add CarryDeclare(...) - hack
    139160                        Generators.addFuncCallNode(kernelDefNode, (pabloB.ast.FuncCallNode) funcDefNode.lastChild());
    140161                       
    141162                        // splice kernel node onto PabloB tree
    142163                        funcDefNode.updateSelf(kernelDefNode);
    143                 }
     164
     165                        }
    144166               
    145167                return bASTTree;
     
    200222                // Translates PabloS stream type to PabloB bitblock type 
    201223                //
    202                 // KH: TODO handle field width attributes on PabloS stream types
     224                // KH: TODO - Handle field width attributes on PabloS stream types
    203225                //
    204226                ////////////////////////////////////////////////////////////////////////////////////
     
    234256                                // field width integer constant
    235257                                int fieldWidthValue
    236                                         = Integer.valueOf(Accessors.argument(node, 0).getToken().getLexeme());
     258                                        = Integer.valueOf(toolchain.pabloS.ast.Accessors.argument(node, 0).getToken().getLexeme());
    237259                               
    238260                                pabloS.tokens.IntConstantToken fieldWidthConstantToken
     
    249271                                // mask integer constant
    250272                                int maskValue
    251                                         = Integer.valueOf(Accessors.argument(node, 1).getToken().getLexeme());
     273                                        = Integer.valueOf(toolchain.pabloS.ast.Accessors.argument(node, 1).getToken().getLexeme());
    252274                               
    253275                                pabloS.tokens.IntConstantToken maskToken
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/carry/CarryInfoSet.java

    r3249 r3260  
    1818        }
    1919       
    20         public int getCarry1Count() {
     20        public int Carry1Count() {
    2121                return carry1.size();
    2222        }
    2323
    24         public int getCarryNCount() {
     24        public int CarryNCount() {
    2525                return carryN.size();
    2626        }       
     
    3434        }       
    3535
    36         public Integer [] getCarry1Array() {
    37                 return (Integer [])carry1.toArray(new Integer [carry1.size()]);
     36        public ArrayList<Integer> Carry1List() {
     37                return carry1;
    3838        }
    3939
    40         public Integer [] getCarryNArray() {
    41                 return (Integer [])carryN.toArray(new Integer [carryN.size()]);
     40        public ArrayList<Integer> CarryNList() {
     41                return carryN;
    4242        }
    4343
Note: See TracChangeset for help on using the changeset viewer.