Changeset 3264 for proto/pabloj/trunk


Ignore:
Timestamp:
Jun 4, 2013, 5:07:43 PM (6 years ago)
Author:
ksherdy
Message:

Removed List types from Generators to reduce redundancy. Moved Locator parameter to 0th position to support variable length array args in PabloB generators. Need to do the same for PabloS.

Location:
proto/pabloj/trunk/src/toolchain
Files:
7 edited

Legend:

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

    r3263 r3264  
    44
    55package toolchain.pabloB.ast;
    6 import java.util.ArrayList;
    7 import java.util.List;
    86
    97import pabloB.ast.*;
     
    106104                        Locator locator) {
    107105               
    108                         LextantToken token = Generators.makeLextantToken(Lextant.KERNEL, locator);
     106                        LextantToken token = Generators.makeLextantToken(locator, Lextant.KERNEL);
    109107                        KernelDefNode kernelDefNode = new KernelDefNode(token);
    110                         pabloB.ast.IdentifierNode identifierNode = Generators.makeIdentifierNode(identifier, locator);         
     108                        pabloB.ast.IdentifierNode identifierNode = Generators.makeIdentifierNode(locator, identifier);         
    111109                       
    112110                        kernelDefNode.appendChild(identifierNode);
     
    123121
    124122    public static InitDefNode makeInitDefNode (Locator locator) {
    125         InitDefNode stateDef = new InitDefNode(Generators.makeLextantToken(Lextant.LCURLY, locator));
     123        InitDefNode stateDef = new InitDefNode(Generators.makeLextantToken(locator, Lextant.LCURLY));
    126124        return stateDef;
    127125    }
    128126       
    129127        public static InitDefNode makeInitDefNode (Locator locator, KernelPropertyNode ...stateParameters) {
    130                 InitDefNode stateDef = new InitDefNode(Generators.makeLextantToken(Lextant.LCURLY, locator));
     128                InitDefNode stateDef = new InitDefNode(Generators.makeLextantToken(locator, Lextant.LCURLY));
    131129                for(KernelPropertyNode stateParameter : stateParameters) {
    132130                    stateDef.appendChild(stateParameter);
     
    143141   
    144142        public static PropertyValueNode makePropertyValueNode(Locator locator, Integer... values) {
    145             PropertyValueNode stateValue = new PropertyValueNode(Generators.makeLextantToken(Lextant.LSQUARE, locator));
     143            PropertyValueNode stateValue = new PropertyValueNode(Generators.makeLextantToken(locator, Lextant.LSQUARE));
    146144        for(Integer i : values) {
    147             IntegerConstantNode n = Generators.makeIntegerConstantNode(i, locator);
     145            IntegerConstantNode n = Generators.makeIntegerConstantNode(locator, i);
    148146            stateValue.appendChild(n);
    149147        }           
     
    151149        }
    152150       
    153         public static PropertyValueNode makePropertyValueNode(Integer value, Locator locator) {
     151        public static PropertyValueNode makePropertyValueNode(Locator locator, Integer value) {
    154152                Integer [] values = new Integer[1];
    155153                values[0] = value;
     
    157155        }       
    158156
    159         public static FuncCallNode makeFuncCallNode(String identifier, Locator locator, ASTNode ...args) {
    160                 FuncCallNode node = Generators.makeFuncCallNode(identifier, locator);
     157        public static FuncCallNode makeFuncCallNode(Locator locator, String identifier, ASTNode ...args) {
     158                FuncCallNode node = Generators.makeFuncCallNode(locator, identifier);
    161159                Generators.addFuncCallArgs(node, args);
    162160                return node;
    163161        }       
    164162
    165     public static FuncCallNode makeFuncCallNode(String identifier, Locator locator) {
    166         IdentifierNode identifierNode = Generators.makeIdentifierNode(identifier, locator);
    167         return Generators.makeFuncCallNode(identifierNode, locator);
    168     }
    169        
    170         public static FuncCallNode makeFuncCallNode(String pckage, String name, Locator locator) {
    171                 CompoundIdentifierNode compoundIdentifierNode = Generators.makeCompoundIdentifierNode(pckage, name, locator);   
    172                 return Generators.makeFuncCallNode(compoundIdentifierNode, locator);
    173         }
    174        
    175         public static FuncCallNode makeFuncCallNode(String pckage, String name, Locator locator, ASTNode ...args ) {
    176                 CompoundIdentifierNode compoundIdentifierNode = Generators.makeCompoundIdentifierNode(pckage, name, locator);   
    177                 FuncCallNode node = Generators.makeFuncCallNode(compoundIdentifierNode, locator);
     163    public static FuncCallNode makeFuncCallNode(Locator locator, String identifier) {
     164        IdentifierNode identifierNode = Generators.makeIdentifierNode(locator, identifier);
     165        return Generators.makeFuncCallNode(locator, identifierNode);
     166    }
     167       
     168        public static FuncCallNode makeFuncCallNode(Locator locator, String pckage, String name) {
     169                CompoundIdentifierNode compoundIdentifierNode = Generators.makeCompoundIdentifierNode(locator, pckage, name);   
     170                return Generators.makeFuncCallNode(locator, compoundIdentifierNode);
     171        }
     172       
     173        public static FuncCallNode makeFuncCallNode(Locator locator, String pckage, String name, ASTNode ...args ) {
     174                CompoundIdentifierNode compoundIdentifierNode = Generators.makeCompoundIdentifierNode(locator, pckage, name);   
     175                FuncCallNode node = Generators.makeFuncCallNode(locator, compoundIdentifierNode);
    178176                Generators.addFuncCallArgs(node, args);
    179177                return node;
    180178        }       
    181179
    182         private static FuncCallNode makeFuncCallNode(ASTNode identifier, Locator locator) {
     180        private static FuncCallNode makeFuncCallNode(Locator locator, ASTNode identifier) {
    183181                assert ((identifier instanceof IdentifierNode) || (identifier instanceof CompoundIdentifierNode));
    184 
    185                 LextantToken token = Generators.makeLextantToken(Lextant.LROUND, locator);
     182                LextantToken token = Generators.makeLextantToken(locator, Lextant.LROUND);
    186183                FuncCallNode FuncCallNode = new FuncCallNode(token);
    187184                FuncCallNode.appendChild(identifier);
    188                 FuncCallNode.appendChild(new FuncCallArgListNode(token));               // TODO: verify the token is okay for the ArgListNode
    189 
     185                FuncCallNode.appendChild(new FuncCallArgListNode(token));               
    190186                return FuncCallNode;
    191187        }       
     
    200196        }       
    201197       
    202 /* WARNING - IdisaFuncCallNode must be fixed.
    203  *
    204  * public static IdisaFuncCallNode makeIdisaFuncCallNode(CompoundIdentifierNode compoundIdentifierNode, Token locationToken, ASTNode ...args) {
    205 
    206                 IdisaFuncCallNode node = Generators.makeIdisaFuncCallNode(compoundIdentifierNode, locationToken);
    207                 List<ASTNode> list = new ArrayList<ASTNode>();
    208                 for(ASTNode arg: args) {
    209                         list.add(arg);
    210                 }
    211                 Generators.addIdisaFuncCallsArgs(node, list);           
    212                 return node;
    213         }*/
    214        
    215 /* WARNING - IdisaFuncCallNode must be fixed.   
    216  *
    217  * private static IdisaFuncCallNode makeIdisaFuncCallNode(ASTNode identifier, Token locationToken) {
    218                 assert ((identifier instanceof IdentifierNode) || (identifier instanceof CompoundIdentifierNode));
    219 
    220                 LextantToken token = Generators.makeLextantToken(Lextant.LANGLE, locationToken);
    221                 IdisaFuncCallNode idisaFuncCallNode = new IdisaFuncCallNode(token);
    222                 idisaFuncCallNode.appendChild(identifier);
    223                 idisaFuncCallNode.appendChild(new FuncCallArgListNode(locationToken));
    224 
    225                 return idisaFuncCallNode;
    226         }               
    227 */
    228 /* WARNING - IdisaFuncCallNode must be fixed.   
    229  *
    230  * private static void addIdisaFuncCallsArgs(IdisaFuncCallNode node, List<ASTNode> args) {
    231                
    232                 if(args.size() > 0) {
    233                         for(ASTNode child: args) {
    234                                 Accessors.idisaFuncCallArgListNode(node).appendChild(child);
    235                         }
    236                         Accessors.idisaFuncCallArgListNode(node).setToken(args.get(0).getToken());
    237                 }               
    238         }*/     
    239        
    240         public static AssignNode makeAssignEqualNode(String [] identifiers, ASTNode rhs, Token locationToken) {
    241                
    242                 Token assignEqualToken = Generators.makeLextantToken(Lextant.ASSIGN, locationToken);
     198        public static AssignNode makeAssignEqualNode(Locator locator, String [] identifiers, ASTNode rhs) {
     199               
     200                Token assignEqualToken = Generators.makeLextantToken(locator, Lextant.ASSIGN);
    243201                AssignNode assignEqualNode = new AssignNode(assignEqualToken);
    244202               
    245                 CompoundIdentifierNode lhs = Generators.makeCompoundIdentifierNode(identifiers, locationToken);
     203                CompoundIdentifierNode lhs = Generators.makeCompoundIdentifierNode(locator, identifiers);
    246204               
    247205                assignEqualNode.appendChild(lhs);
     
    251209        }
    252210       
    253         public static CompoundIdentifierNode makeCompoundIdentifierNode(String pckage, String name, Locator locator) {
    254                 return makeCompoundIdentifierNode(new String [] {pckage, name}, locator);
     211        public static CompoundIdentifierNode makeCompoundIdentifierNode(Locator locator, String pckage, String name) {
     212                return makeCompoundIdentifierNode(locator, pckage, name);
    255213        }
    256214       
     
    258216         * Currently, no special consideration with only one identifier in the array.
    259217         * (Maybe we can return a IdentifierNode directly in later versions.)
     218         * @param locator               a token containing the TextLocation for this new node.
    260219         * @param identifiers           all identifiers
    261          * @param locator               a token containing the TextLocation for this new node.
    262220         * @return      the new CompoundIdentifierNode
    263221         */
    264         public static CompoundIdentifierNode makeCompoundIdentifierNode(String[] identifiers, Locator locator) {
    265                 Token dotToken = Generators.makeLextantToken(Lextant.DOT, locator);
     222        public static CompoundIdentifierNode makeCompoundIdentifierNode(Locator locator, String... identifiers) {
     223                Token dotToken = Generators.makeLextantToken(locator, Lextant.DOT);
    266224                CompoundIdentifierNode CompoundIdentifierNode = new CompoundIdentifierNode(dotToken);
    267225                for (String identifier : identifiers) {
    268                         IdentifierNode identifierNode = Generators.makeIdentifierNode(identifier, locator);
     226                        IdentifierNode identifierNode = Generators.makeIdentifierNode(locator, identifier);
    269227                        CompoundIdentifierNode.appendChild(identifierNode);
    270228                }
     
    273231
    274232        /** Makes a new LextantToken with the given lextant and location taken from the given locator.
     233         * @param locator
    275234         * @param lextant
     235         * @return the new LextantToken
     236         */
     237        public static LextantToken makeLextantToken(Locator locator, Lextant lextant) {
     238                return LextantToken.make(locator.getLocation(), lextant.getPrimaryLexeme(), lextant);
     239        }       
     240       
     241        /** Makes a new IdentifierNode with a identifier string and the TextLocation taken from locator.
     242         * @param locator               a token containing the TextLocation for this new node.
     243         * @param identifier
     244         * @return      the new IdentifierNode
     245         */
     246        public static IdentifierNode makeIdentifierNode(Locator locator, String identifier) {
     247                IdentifierToken newToken = makeIdentifierToken(locator, identifier);
     248                return new IdentifierNode(newToken);
     249        }       
     250               
     251        /** Makes a new IdentifierToken with the given identifier and location taken from the given locator.
    276252         * @param locator
    277          * @return the new LextantToken
    278          */
    279         public static LextantToken makeLextantToken(Lextant lextant, Locator locator) {
    280                 return LextantToken.make(locator.getLocation(), lextant.getPrimaryLexeme(), lextant);
    281         }       
    282        
    283         /** Makes a new IdentifierNode with a identifier string and the TextLocation taken from locator.
    284253         * @param identifier
    285          * @param locator               a token containing the TextLocation for this new node.
    286          * @return      the new IdentifierNode
    287          */
    288         public static IdentifierNode makeIdentifierNode(String identifier, Locator locator) {
    289                 IdentifierToken newToken = makeIdentifierToken(identifier, locator);
    290                 return new IdentifierNode(newToken);
    291         }       
    292                
    293         /** Makes a new IdentifierToken with the given identifier and location taken from the given locator.
    294          * @param identifier
    295          * @param locator
    296254         * @return the new IdentifierToken
    297255         */
    298         public static IdentifierToken makeIdentifierToken(String identifier, Locator locator) {
     256        public static IdentifierToken makeIdentifierToken(Locator locator, String identifier) {
    299257                return IdentifierToken.make(LexicalType.IDENTIFIER, locator.getLocation(), identifier);
    300258        }
    301         public static IntegerConstantNode makeIntegerConstantNode(int n, Locator locator) {
    302                 IntegerConstantNode integerConstantNode = new IntegerConstantNode(makeIntegerConstantToken(n, locator));
     259        public static IntegerConstantNode makeIntegerConstantNode(Locator locator, int n) {
     260                IntegerConstantNode integerConstantNode = new IntegerConstantNode(makeIntegerConstantToken(locator, n));
    303261                integerConstantNode.setValue(n);
    304262            return integerConstantNode;
    305263        }       
    306264       
    307         public static IntConstantToken makeIntegerConstantToken(int n,  Locator locator) {
     265        public static IntConstantToken makeIntegerConstantToken(Locator locator,  int n) {
    308266                return (IntConstantToken) IntConstantToken.makeArtifical(LexicalType.INTEGER_CONST, locator.getLocation(), n);
    309267        }                       
    310268
    311         private static LextantToken makeLextantToken(Lextant lextant, Token locationToken) {
    312                 return LextantToken.make(locationToken.getLocation(), lextant.getPrimaryLexeme(), lextant);
    313         }       
    314 
    315     public static StringConstantNode makeStringConstantNode(String string, Locator locator) {
    316         StringConstantToken newToken = makeStringConstantToken(string, locator);
     269    public static StringConstantNode makeStringConstantNode(Locator locator, String string) {
     270        StringConstantToken newToken = makeStringConstantToken(locator, string);
    317271        return new StringConstantNode(newToken);
    318272    }
    319273       
    320     public static StringConstantToken makeStringConstantToken(String string, Locator locator) {
    321         return StringConstantToken.make(LexicalType.STRING, locator.getLocation(), string);
     274    public static StringConstantToken makeStringConstantToken(Locator locator, String string) {
     275        return StringConstantToken.make(LexicalType.STRING, locator, string);
    322276    }
    323277}
  • proto/pabloj/trunk/src/toolchain/pabloB/transformer/visitors/AddAlignmentAssertions.java

    r3248 r3264  
    4949                private FuncCallNode makeAssertAlignCall(ASTNode node, ASTNode lhs) {
    5050                        String assertAlign = encoder.getCode(PabloBBuiltin.ASSERT_BITBLOCK_ALIGN);
    51                         return Generators.makeFuncCallNode(assertAlign, node.getToken(), lhs);
     51                        return Generators.makeFuncCallNode(node.getToken(), assertAlign, lhs);
    5252                }
    5353        }       
  • proto/pabloj/trunk/src/toolchain/pabloB/transformer/visitors/AddAssignmentPrints.java

    r3248 r3264  
    5151                private FuncCallNode makePrintCall(ASTNode node, ASTNode argument) {
    5252                        String printBitblockCode = encoder.getCode(PabloBBuiltin.PRINT_BITBLOCK);
    53                         ASTNode label = Generators.makeStringConstantNode(Accessors.name(argument), node);
    54                         return Generators.makeFuncCallNode(printBitblockCode, node.getToken(), label, argument);
     53                        ASTNode label = Generators.makeStringConstantNode(node, Accessors.name(argument));
     54                        return Generators.makeFuncCallNode(node.getToken(), printBitblockCode, label, argument);
    5555                }
    5656        }       
  • proto/pabloj/trunk/src/toolchain/pabloS/ast/Generators.java

    r3257 r3264  
    6464                return node;
    6565        }       
    66 
    67         public static FuncCallNode makeFuncCallNode(String identifier, Locator locator, List<ASTNode> args) {
    68                 FuncCallNode node = Generators.makeFuncCallNode(identifier, locator);
    69                 Generators.addFuncCallArgs(node, args);
    70                 return node;
    71         }       
    7266       
    7367        public static FuncCallNode makeFuncCallNode(String[] identifiers, Locator locator) {           
    74                 CompoundIdentifierNode identifierNode = Generators.makeCompoundIdentifierNode(identifiers, locator);
     68                CompoundIdentifierNode identifierNode = Generators.makeCompoundIdentifierNode(locator, identifiers);
    7569                return Generators.makeFuncCallNode(identifierNode, locator);
    7670        }
     
    8781                return node;
    8882        }       
    89 
    90         public static FuncCallNode makeFuncCallNode(String pckage, String name, Locator locator, List<ASTNode> args) {
    91                 CompoundIdentifierNode compoundIdentifierNode = Generators.makeCompoundIdentifierNode(pckage, name, locator);   
    92                 FuncCallNode node = Generators.makeFuncCallNode(compoundIdentifierNode, locator);
    93                 Generators.addFuncCallArgs(node, args);
    94                 return node;
    95         }
    96                
    97         // deprecate
    98 //      public static FuncCallNode makeFuncCallNode(String[] identifiers, Locator locator, ASTNode ...args) {
    99 //              FuncCallNode node = Generators.makeFuncCallNode(identifiers, locator);
    100 //              Generators.addFuncCallArgs(node, args);
    101 //              return node;
    102 //      }
    103 
    104         // deprecate
    105 //      public static FuncCallNode makeFuncCallNode(String[] identifiers, Locator locator, List<ASTNode> args) {
    106 //             
    107 //              FuncCallNode node = Generators.makeFuncCallNode(identifiers, locator);
    108 //              Generators.addFuncCallArgs(node, args);
    109 //              return node;
    110 //      }               
    111        
    11283       
    11384        private static FuncCallNode makeFuncCallNode(ASTNode identifier, Locator locator) {
     
    12293        }       
    12394               
    124         private static void addFuncCallArgs(FuncCallNode node, ASTNode[] args) {
     95        private static void addFuncCallArgs(FuncCallNode node, ASTNode ... args) {
    12596                if(args.length > 0) {
    12697                        for(ASTNode child: args) {
     
    129100                        Accessors.argsListNode(node).setToken(args[0].getToken());
    130101                }       
    131         }       
    132 
    133         private static void addFuncCallArgs(FuncCallNode node, List<ASTNode> args) {
    134                
    135                 if(args.size() > 0) {
    136                         for(ASTNode child: args) {
    137                                 Accessors.argsListNode(node).appendChild(child);
    138                         }
    139                         Accessors.argsListNode(node).setToken(args.get(0).getToken());
    140                 }               
    141         }       
    142                        
    143        
    144        
     102        }               
    145103        public static CompoundIdentifierNode makeCompoundIdentifierNode(String pckage, String name, Locator locator) {
    146                 return makeCompoundIdentifierNode(new String [] {pckage, name}, locator);
     104                return makeCompoundIdentifierNode(locator, new String [] {pckage, name});
    147105        }
    148106       
     
    150108         * Currently, no special consideration with only one identifier in the array.
    151109         * (Maybe we can return a IdentifierNode directly in later versions.)
     110         * @param locator               a token containing the TextLocation for this new node.
    152111         * @param identifiers           all identifiers
    153          * @param locator               a token containing the TextLocation for this new node.
    154112         * @return      the new CompoundIdentifierNode
    155113         */
    156         public static CompoundIdentifierNode makeCompoundIdentifierNode(String[] identifiers, Locator locator) {
     114        public static CompoundIdentifierNode makeCompoundIdentifierNode(Locator locator, String ... identifiers) {
    157115                Token dotToken = Generators.makeLextantToken(Lextant.DOT, locator);
    158116                CompoundIdentifierNode CompoundIdentifierNode = new CompoundIdentifierNode(dotToken);
     
    268226
    269227        public static FuncCallNode makeSIMDAndCEOFMaskFuncCall(ASTNode node, BuiltinEncoder builtins2Lang) {
    270                 List<ASTNode> args = new ArrayList<ASTNode>();
    271                 args.add(node);
    272                 args.add(Generators.makeIdentifierNode(builtins2Lang.getCode(PabloSBuiltin.EOF_MASK), node.getToken()));
     228                ASTNode [] args = new ASTNode [2];
     229                args[0] = node;
     230                args[1] = Generators.makeIdentifierNode(builtins2Lang.getCode(PabloSBuiltin.EOF_MASK), node.getToken());
    273231                return Generators.makeFuncCallNode(IDISASIMDBitwiseBuiltins.ANDC.Name(), node.getToken(), args);
    274232        }       
    275233
    276234        public static FuncCallNode makeSIMDEOFMaskAndCNodeFuncCall(ASTNode node, BuiltinEncoder builtins2Lang) {
    277                 List<ASTNode> args = new ArrayList<ASTNode>();
    278                 args.add(Generators.makeIdentifierNode(builtins2Lang.getCode(PabloSBuiltin.EOF_MASK), node.getToken()));
    279                 args.add(node);
     235                ASTNode [] args = new ASTNode [2];
     236                args[0] = Generators.makeIdentifierNode(builtins2Lang.getCode(PabloSBuiltin.EOF_MASK), node.getToken());
     237                args[1] = node;
    280238                return Generators.makeFuncCallNode(IDISASIMDBitwiseBuiltins.ANDC.Name(), node.getToken(), args);
    281239        }               
    282240       
    283241        public static FuncCallNode makeSIMDNotFuncCall(ASTNode node, BuiltinEncoder builtins2Lang) {
    284                 List<ASTNode> args = new ArrayList<ASTNode>();
    285                 args.add(node);
     242                ASTNode [] args = new ASTNode [1];
     243                args[0] = node;
    286244                return Generators.makeFuncCallNode(IDISASIMDBitwiseBuiltins.NOT.Name(), node.getToken(), args);
    287245        }               
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/ExpandAugmentedAssignments.java

    r3213 r3264  
    4545                        Token token = node.getToken();
    4646                        if(isAugmentedAssignment(token)) {
    47                                 LextantToken binaryOperatorToken = includedOperatorToken(token);
    48                                
    49                                 // TODO: fix, changes associativity from left associativity to right associativity on x |= y | z
    50                                
     47                                LextantToken binaryOperatorToken = includedOperatorToken(token);                               
    5148                                BinaryOperatorNode binaryOperatorNode = Generators.makeBinaryOperatorNode(lhs.deepCopy(), rhs.deepCopy(), binaryOperatorToken);
    5249                                changeTokenToAssign(node);                                     
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/PabloS2PabloBXFormer.java

    r3263 r3264  
    6161                        Locator locator = funcDefNode.getToken();
    6262                       
    63                         IdentifierNode doBlockIdentifier = Generators.makeIdentifierNode(DO_BLOCK, locator);
     63                        IdentifierNode doBlockIdentifier = Generators.makeIdentifierNode(locator, DO_BLOCK);
    6464                        funcDefNode.replaceChild(Accessors.funcIdentifier(funcDefNode), doBlockIdentifier);
    6565
    66                         IdentifierNode doOptBlockIdentifier = Generators.makeIdentifierNode(DO_OPT_BLOCK, locator);
     66                        IdentifierNode doOptBlockIdentifier = Generators.makeIdentifierNode(locator, DO_OPT_BLOCK);
    6767                        optFuncDefNode.replaceChild(Accessors.funcIdentifier(optFuncDefNode), doOptBlockIdentifier);                   
    6868                       
     
    7777                        ////////////////////////////////////////////////////////////
    7878                        // Carry1
    79                 IdentifierNode propertyName             = Generators.makeIdentifierNode(KernelState.CARRY1_LIST.name(), locator);
     79                IdentifierNode propertyName             = Generators.makeIdentifierNode(locator, KernelState.CARRY1_LIST.name());
    8080                PropertyValueNode propertyValue         = Generators.makePropertyValueNode(locator, streamFunctionPropertySet.getCarry1InitValues());
    8181                        KernelPropertyNode property         = Generators.makeKernelPropertyNode(propertyName, propertyValue);
     
    8484                        ////////////////////////////////////////////////////////////
    8585                        // Carry1 Count
    86                 propertyName            = Generators.makeIdentifierNode(KernelState.CARRY1_COUNT.name(), locator);
    87                 propertyValue           = Generators.makePropertyValueNode(streamFunctionPropertySet.carry1Count(), locator);
     86                propertyName            = Generators.makeIdentifierNode(locator, KernelState.CARRY1_COUNT.name());
     87                propertyValue           = Generators.makePropertyValueNode(locator, streamFunctionPropertySet.carry1Count());
    8888                        property                = Generators.makeKernelPropertyNode(propertyName, propertyValue);
    8989                        stateDefNode.appendChild(property);
     
    9191                        ////////////////////////////////////////////////////////////
    9292                        // CarryN
    93                 propertyName       = Generators.makeIdentifierNode(KernelState.CARRYN_LIST.name(), locator);
     93                propertyName       = Generators.makeIdentifierNode(locator, KernelState.CARRYN_LIST.name());
    9494                propertyValue      = Generators.makePropertyValueNode(locator, streamFunctionPropertySet.getCarryNInitValues());
    9595                        property           = Generators.makeKernelPropertyNode(propertyName, propertyValue);
     
    9898                        ////////////////////////////////////////////////////////////
    9999                        // CarryN count                         
    100                 propertyName       = Generators.makeIdentifierNode(KernelState.CARRYN_COUNT.name(), locator);
    101                 propertyValue      = Generators.makePropertyValueNode(streamFunctionPropertySet.carryNCount(), locator);
     100                propertyName       = Generators.makeIdentifierNode(locator, KernelState.CARRYN_COUNT.name());
     101                propertyValue      = Generators.makePropertyValueNode(locator, streamFunctionPropertySet.carryNCount());
    102102                        property           = Generators.makeKernelPropertyNode(propertyName, propertyValue);
    103103                        stateDefNode.appendChild(property);
     
    105105                        ////////////////////////////////////////////////////////////
    106106                        // KH: TODO - LookAhead
    107                 propertyName       = Generators.makeIdentifierNode(KernelState.LOOK_AHEAD.name(), locator);
    108                 propertyValue      = Generators.makePropertyValueNode(0, locator);
     107                propertyName       = Generators.makeIdentifierNode(locator, KernelState.LOOK_AHEAD.name());
     108                propertyValue      = Generators.makePropertyValueNode(locator, 0);
    109109                        property           = Generators.makeKernelPropertyNode(propertyName, propertyValue);
    110110                        stateDefNode.appendChild(property);
     
    112112                        ////////////////////////////////////////////////////////////
    113113                        // KH: TODO - LookBehind
    114                 propertyName            = Generators.makeIdentifierNode(KernelState.LOOK_BEHIND.name(), locator);
    115                 propertyValue           = Generators.makePropertyValueNode(0, locator);
     114                propertyName            = Generators.makeIdentifierNode(locator, KernelState.LOOK_BEHIND.name());
     115                propertyValue           = Generators.makePropertyValueNode(locator, 0);
    116116                        property        = Generators.makeKernelPropertyNode(propertyName, propertyValue);
    117117                        stateDefNode.appendChild(property);
     
    152152        int pos = (index+1);
    153153       
    154         pabloB.ast.IntegerConstantNode indexNode = Generators.makeIntegerConstantNode(pos, locator);
    155        
    156         FuncCallNode getCarryFuncCall   = Generators.makeFuncCallNode(CarrySetEncoder.CARRYSETBASENAME,
    157                                                                     carrySetEncoder.getCode(CarrySetBuiltins.GETCARRY),
    158                                                                     locator, indexNode);
     154        pabloB.ast.IntegerConstantNode indexNode = Generators.makeIntegerConstantNode(locator, pos);
     155       
     156        FuncCallNode getCarryFuncCall   = Generators.makeFuncCallNode(locator,
     157                                                                    CarrySetEncoder.CARRYSETBASENAME,
     158                                                                    carrySetEncoder.getCode(CarrySetBuiltins.GETCARRY), indexNode);
    159159           
    160         FuncCallNode carryFlipFuncCall  = Generators.makeFuncCallNode(CarrySetEncoder.CARRYSETBASENAME,
    161                                                                     carrySetEncoder.getCode(CarrySetBuiltins.CARRYFLIP),
    162                                                                     locator, getCarryFuncCall);
    163        
    164         FuncCallNode setCarryFuncCall   = Generators.makeFuncCallNode(CarrySetEncoder.CARRYSETBASENAME,
    165                                                                     carrySetEncoder.getCode(CarrySetBuiltins.SETCARRY),
    166                                                                     locator, carryFlipFuncCall, indexNode);
     160        FuncCallNode carryFlipFuncCall  = Generators.makeFuncCallNode(locator,
     161                                                                    CarrySetEncoder.CARRYSETBASENAME,
     162                                                                    carrySetEncoder.getCode(CarrySetBuiltins.CARRYFLIP), getCarryFuncCall);
     163       
     164        FuncCallNode setCarryFuncCall   = Generators.makeFuncCallNode(locator,
     165                                                                    CarrySetEncoder.CARRYSETBASENAME,
     166                                                                    carrySetEncoder.getCode(CarrySetBuiltins.SETCARRY), carryFlipFuncCall, indexNode);
    167167        return setCarryFuncCall;
    168168    }
     
    170170    private FuncCallNode makeCarryDeclareCall(int carry1Count, int carryNCount, Locator locator) {
    171171       
    172         IdentifierNode carrySetBaseName         =   Generators.makeIdentifierNode(CarrySetEncoder.CARRYSET_BASENAME_PREFIX + 0, locator);
    173         IntegerConstantNode carry1CountNode     =   Generators.makeIntegerConstantNode(carry1Count, locator);
    174         IntegerConstantNode carryNCountNode     =   Generators.makeIntegerConstantNode(carryNCount, locator);
     172        IdentifierNode carrySetBaseName         =   Generators.makeIdentifierNode(locator, CarrySetEncoder.CARRYSET_BASENAME_PREFIX + 0);
     173        IntegerConstantNode carry1CountNode     =   Generators.makeIntegerConstantNode(locator, carry1Count);
     174        IntegerConstantNode carryNCountNode     =   Generators.makeIntegerConstantNode(locator, carryNCount);
    175175     
    176         FuncCallNode carryDeclareFuncCall       =   Generators.makeFuncCallNode(carrySetEncoder.getCode(CarrySetBuiltins.CARRYDECLARE),
    177                                                                                    locator, carrySetBaseName, carry1CountNode, carryNCountNode);
     176        FuncCallNode carryDeclareFuncCall       =   Generators.makeFuncCallNode(locator,
     177                                                                                   carrySetEncoder.getCode(CarrySetBuiltins.CARRYDECLARE), carrySetBaseName, carry1CountNode, carryNCountNode);
    178178        return carryDeclareFuncCall;
    179179    }
     
    264264                                        = toolchain.pabloS.ast.Generators.makeLextantToken(Lextant.DOT, node.getToken());
    265265                                                       
    266                                 pabloB.ast.ASTNode compoundIdentifierNode = Generators.makeCompoundIdentifierNode("simd", "constant", bNode);
     266                                pabloB.ast.ASTNode compoundIdentifierNode = Generators.makeCompoundIdentifierNode(bNode, "simd", "constant");
    267267                               
    268268                                // field width integer constant
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/carry/BuiltinTranslator.java

    r3244 r3264  
    129129                        ASTNode call, IntegerConstantNode carry) {
    130130
    131                 List<ASTNode> args = makeCarryCallArgs(arguments, call, carry);
     131                ASTNode [] args = makeCarryCallArgs(arguments, call, carry);
    132132
    133133                FuncCallNode replacementNode = Generators.makeFuncCallNode(
     
    140140        }
    141141
    142         private static List<ASTNode> makeCarryCallArgs(List<ASTNode> arguments,
     142        private static ASTNode [] makeCarryCallArgs(List<ASTNode> arguments,
    143143                        ASTNode call, IntegerConstantNode carry) {
    144144                List<ASTNode> args = new ArrayList<ASTNode>(arguments);
    145145                args.add(call);
    146146                args.add(carry);
    147                 return args;
     147                return args.toArray(new ASTNode [args.size()]);
    148148        }               
    149149}
Note: See TracChangeset for help on using the changeset viewer.