Changeset 3271


Ignore:
Timestamp:
Jun 5, 2013, 3:35:33 PM (6 years ago)
Author:
ksherdy
Message:

Created makeMasKFuncCall, harmonized 'Locator' position on PabloS/PabloB generators, simplified InitializeStreamDefaults?.

Location:
proto/pabloj/trunk/src/toolchain
Files:
1 added
12 edited

Legend:

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

    r3267 r3271  
    376376        }       
    377377       
    378         public static String fieldWidth(StreamTypeNode node) {
    379                 return Accessors.lexeme(node);
    380         }
    381 
     378        public static int fieldWidth(StreamTypeNode node) {
     379                return Integer.valueOf(Accessors.lexeme(node));
     380        }
     381       
    382382        ////////////////////////////////////////////////////////////////////////////
    383383        // CompoundIdentifierNode
  • proto/pabloj/trunk/src/toolchain/pabloS/ast/Generators.java

    r3264 r3271  
    1212import pabloS.ast.*;
    1313
    14 import java.util.ArrayList;
    15 import java.util.List;
    16 
    1714import pabloS.inputHandler.Locator;
    1815import pabloS.lexicalAnalyzer.*;
     
    4138        }
    4239       
    43         public static LocalVarDeclNode makeLocalVarDeclNode(ASTNode type, IdentifierNode identifier, ASTNode rhs, Locator locator) {
    44                
    45                 Token assignToken = Generators.makeLextantToken(Lextant.ASSIGN, locator);
     40        public static LocalVarDeclNode makeLocalVarDeclNode(Locator locator, ASTNode type, IdentifierNode identifier, ASTNode rhs) {
     41               
     42                Token assignToken = Generators.makeLextantToken(locator, Lextant.ASSIGN);
    4643                LocalVarDeclNode localVarDeclNode = new LocalVarDeclNode(assignToken);
    4744               
     
    5451       
    5552        // Make function Call variants 
    56         public static FuncCallNode makeFuncCallNode(String identifier, Locator locator) {
    57                 IdentifierNode identifierNode = Generators.makeIdentifierNode(identifier, locator);     
    58                 return Generators.makeFuncCallNode(identifierNode, locator);
    59         }
    60                
    61         public static FuncCallNode makeFuncCallNode(String identifier, Locator locator, ASTNode ...args) {
    62                 FuncCallNode node = Generators.makeFuncCallNode(identifier, locator);
     53        public static FuncCallNode makeFuncCallNode(Locator locator, String identifier) {
     54                IdentifierNode identifierNode = Generators.makeIdentifierNode(locator, identifier);     
     55                return Generators.makeFuncCallNode(locator, identifierNode);
     56        }
     57               
     58        public static FuncCallNode makeFuncCallNode(Locator locator, String identifier, ASTNode ...args) {
     59                FuncCallNode node = Generators.makeFuncCallNode(locator, identifier);
    6360                Generators.addFuncCallArgs(node, args);
    6461                return node;
    6562        }       
    6663       
    67         public static FuncCallNode makeFuncCallNode(String[] identifiers, Locator locator) {           
    68                 CompoundIdentifierNode identifierNode = Generators.makeCompoundIdentifierNode(locator, identifiers);
    69                 return Generators.makeFuncCallNode(identifierNode, locator);
    70         }
    71 
    72         public static FuncCallNode makeFuncCallNode(String pckage, String name, Locator locator) {
    73                 CompoundIdentifierNode compoundIdentifierNode = Generators.makeCompoundIdentifierNode(pckage, name, locator);   
    74                 return Generators.makeFuncCallNode(compoundIdentifierNode, locator);
    75         }
    76        
    77         public static FuncCallNode makeFuncCallNode(String pckage, String name, Locator locator, ASTNode ...args) {
    78                 CompoundIdentifierNode compoundIdentifierNode = Generators.makeCompoundIdentifierNode(pckage, name, locator);   
    79                 FuncCallNode node = Generators.makeFuncCallNode(compoundIdentifierNode, locator);
     64        public static FuncCallNode makeFuncCallNode(Locator locator, String pckage, String name) {
     65                CompoundIdentifierNode compoundIdentifierNode = Generators.makeCompoundIdentifierNode(locator, pckage, name);   
     66                return Generators.makeFuncCallNode(locator, compoundIdentifierNode);
     67        }
     68       
     69        public static FuncCallNode makeFuncCallNode(Locator locator, String pckage, String name, ASTNode ...args) {
     70                CompoundIdentifierNode compoundIdentifierNode = Generators.makeCompoundIdentifierNode(locator, pckage, name);   
     71                FuncCallNode node = Generators.makeFuncCallNode(locator, compoundIdentifierNode);
    8072                Generators.addFuncCallArgs(node, args);
    8173                return node;
    8274        }       
    8375       
    84         private static FuncCallNode makeFuncCallNode(ASTNode identifier, Locator locator) {
     76        private static FuncCallNode makeFuncCallNode(Locator locator, ASTNode identifier) {
    8577                assert ((identifier instanceof IdentifierNode) || (identifier instanceof CompoundIdentifierNode));
    8678
    87                 LextantToken token = Generators.makeLextantToken(Lextant.LROUND, locator);
     79                LextantToken token = Generators.makeLextantToken(locator, Lextant.LROUND);
    8880                FuncCallNode FuncCallNode = new FuncCallNode(token);
    8981                FuncCallNode.appendChild(identifier);
    90                 FuncCallNode.appendChild(new FuncCallArgListNode(token));               // TODO: verify the token is okay for the ArgListNode
     82                FuncCallNode.appendChild(new FuncCallArgListNode(token));               
    9183
    9284                return FuncCallNode;
     
    10193                }       
    10294        }               
    103         public static CompoundIdentifierNode makeCompoundIdentifierNode(String pckage, String name, Locator locator) {
     95        public static CompoundIdentifierNode makeCompoundIdentifierNode(Locator locator, String pckage, String name) {
    10496                return makeCompoundIdentifierNode(locator, new String [] {pckage, name});
    10597        }
     
    113105         */
    114106        public static CompoundIdentifierNode makeCompoundIdentifierNode(Locator locator, String ... identifiers) {
    115                 Token dotToken = Generators.makeLextantToken(Lextant.DOT, locator);
     107                Token dotToken = Generators.makeLextantToken(locator, Lextant.DOT);
    116108                CompoundIdentifierNode CompoundIdentifierNode = new CompoundIdentifierNode(dotToken);
    117109                for (String identifier : identifiers) {
    118                         IdentifierNode identifierNode = Generators.makeIdentifierNode(identifier, locator);
     110                        IdentifierNode identifierNode = Generators.makeIdentifierNode(locator, identifier);
    119111                        CompoundIdentifierNode.appendChild(identifierNode);
    120112                }
     
    123115
    124116        /** Makes a new IdentifierNode with a identifier string and the TextLocation taken from locator.
     117         * @param locator               a token containing the TextLocation for this new node.
    125118         * @param identifier
     119         * @return      the new IdentifierNode
     120         */
     121        public static IdentifierNode makeIdentifierNode(Locator locator, String identifier) {
     122                IdentifierToken newToken = Generators.makeIdentifierToken(locator, identifier);
     123                return new IdentifierNode(newToken);
     124        }
     125       
     126        /** Makes a new LextantToken with the given lextant and location taken from the given locator.
     127         * @param locator
     128         * @param lextant
     129         * @return the new LextantToken
     130         */
     131        public static LextantToken makeLextantToken(Locator locator, Lextant lextant) {
     132                return LextantToken.make(locator.getLocation(), lextant.getPrimaryLexeme(), lextant);
     133        }
     134
     135        /** Makes a new StringConstantToken with the given string and location taken from the given locator.
     136         * @param locator
     137         * @param string
     138         * @return the new StringConstantToken
     139         */
     140        public static StringConstantToken makeStringConstantToken(Locator locator, String string) {
     141                return StringConstantToken.make(LexicalType.STRING, locator.getLocation(), string);
     142        }
     143
     144        /** Makes a new IdentifierToken with the given identifier and location taken from the given locator.
     145         * @param locator
     146         * @param identifier
     147         * @return the new IdentifierToken
     148         */
     149        public static IdentifierToken makeIdentifierToken(Locator locator, String identifier) {
     150                return IdentifierToken.make(LexicalType.IDENTIFIER, locator.getLocation(), identifier);
     151        }
     152
     153        /** Makes a new StringConstantNode with the given string and the TextLocation taken from locator.
     154         * @param locator                       a locator containing the TextLocation for this new node.
     155         * @param string                        string value/lexeme of new node.
     156         * @return      the new StringConstantNode
     157         */
     158        public static StringConstantNode makeStringConstantNode(Locator locator, String string) {
     159                StringConstantToken newToken = makeStringConstantToken(locator, string);
     160                return new StringConstantNode(newToken);
     161        }
     162
     163        /** Makes a new IntegerConstantNode with a value of n and the TextLocation taken from locator.
    126164         * @param locator               a token containing the TextLocation for this new node.
    127          * @return      the new IdentifierNode
    128          */
    129         public static IdentifierNode makeIdentifierNode(String identifier, Locator locator) {
    130                 IdentifierToken newToken = Generators.makeIdentifierToken(identifier, locator);
    131                 return new IdentifierNode(newToken);
    132         }
    133        
    134         /** Makes a new LextantToken with the given lextant and location taken from the given locator.
    135          * @param lextant
    136          * @param locator
    137          * @return the new LextantToken
    138          */
    139         public static LextantToken makeLextantToken(Lextant lextant, Locator locator) {
    140                 return LextantToken.make(locator.getLocation(), lextant.getPrimaryLexeme(), lextant);
    141         }
    142 
    143         /** Makes a new StringConstantToken with the given string and location taken from the given locator.
    144          * @param string
    145          * @param locator
    146          * @return the new StringConstantToken
    147          */
    148         public static StringConstantToken makeStringConstantToken(String string, Locator locator) {
    149                 return StringConstantToken.make(LexicalType.STRING, locator.getLocation(), string);
    150         }
    151 
    152         /** Makes a new IdentifierToken with the given identifier and location taken from the given locator.
    153          * @param identifier
    154          * @param locator
    155          * @return the new IdentifierToken
    156          */
    157         public static IdentifierToken makeIdentifierToken(String identifier, Locator locator) {
    158                 return IdentifierToken.make(LexicalType.IDENTIFIER, locator.getLocation(), identifier);
    159         }
    160 
    161         /** Makes a new StringConstantNode with the given string and the TextLocation taken from locator.
    162          * @param string                        string value/lexeme of new node.
    163          * @param locator                       a locator containing the TextLocation for this new node.
    164          * @return      the new StringConstantNode
    165          */
    166         public static StringConstantNode makeStringConstantNode(String string, Locator locator) {
    167                 StringConstantToken newToken = makeStringConstantToken(string, locator);
    168                 return new StringConstantNode(newToken);
    169         }
    170 
    171         /** Makes a new IntegerConstantNode with a value of n and the TextLocation taken from locator.
    172165         * @param n                     integer value of new node.
    173          * @param locator               a token containing the TextLocation for this new node.
    174166         * @return      the new IntegerConstantNode
    175167         */
    176         public static IntegerConstantNode makeIntegerConstantNode(int n, Locator locator) {
     168        public static IntegerConstantNode makeIntegerConstantNode(Locator locator, int n) {
    177169                Token newToken = IntConstantToken.makeArtifical(LexicalType.INTEGER_CONST, locator.getLocation(), n);
    178170                IntegerConstantNode integerConstantNode = new IntegerConstantNode(newToken);
     
    181173        }
    182174       
    183         public static IntConstantToken makeIntegerConstantToken(int n,  Locator locator) {
     175        public static IntConstantToken makeIntegerConstantToken(Locator locator,  int n) {
    184176                return (IntConstantToken) IntConstantToken.makeArtifical(LexicalType.INTEGER_CONST, locator.getLocation(), n);
    185177        }       
     178       
     179        public static StreamTypeNode makeStreamType(Locator locator) {
     180                Token streamToken = Generators.makeLextantToken(locator, Lextant.STREAM);
     181                return new StreamTypeNode(streamToken);
     182        }
    186183       
    187184        public static BinaryOperatorNode makeBinaryOperatorNode(ASTNode lhs, ASTNode rhs, Token token) {
     
    193190       
    194191        public static BlockStmtNode makeBlockStmtNode(Locator locator, ASTNode ...children) {
    195                 LextantToken token = Generators.makeLextantToken(Lextant.LCURLY, locator);
     192                LextantToken token = Generators.makeLextantToken(locator, Lextant.LCURLY);
    196193               
    197194                BlockStmtNode result = new BlockStmtNode(token);
     
    209206       
    210207        public static IfStmtNode makeIfStmtNode(Locator locator, ASTNode expression, BlockStmtNode blockStmt) {
    211                 LextantToken token = Generators.makeLextantToken(Lextant.LCURLY, locator);
     208                LextantToken token = Generators.makeLextantToken(locator, Lextant.LCURLY);
    212209                IfStmtNode ifStmtNode = new IfStmtNode(token);
    213210                ifStmtNode.appendChild(expression);
     
    216213        }
    217214       
     215        public static FuncCallNode makeMaskFuncCall(Locator locator, int fieldWidth, int value) {
     216                IntegerConstantNode zeroConstantNode =  Generators.makeIntegerConstantNode(locator, value);
     217                IntegerConstantNode fieldWidthNode =    Generators.makeIntegerConstantNode(locator, fieldWidth);
     218
     219                FuncCallNode mask = Generators.makeFuncCallNode(locator, BuiltinCallUtil.BUILTIN_PACKAGE_NAME,
     220                                PabloSBuiltin.MASK.pabloSName(),
     221                                arguments(fieldWidthNode, zeroConstantNode));
     222                return mask;
     223        }
     224       
    218225        public static FuncCallNode makeSIMDAndEOFMaskFuncCall(ASTNode node, BuiltinEncoder encoder) {
    219226                Locator location = (Locator)node;
    220                 ASTNode eofMask = makeIdentifierNode(encoder.getCode(PabloSBuiltin.EOF_MASK), location);
    221                 return Generators.makeFuncCallNode(IDISASIMDBitwiseBuiltins.AND.Name(), location, arguments(node, eofMask));
     227                ASTNode eofMask = makeIdentifierNode(location, encoder.getCode(PabloSBuiltin.EOF_MASK));
     228                return Generators.makeFuncCallNode(location, IDISASIMDBitwiseBuiltins.AND.Name(), arguments(node, eofMask));
    222229        }               
    223230        private static ASTNode[] arguments(ASTNode...astNodes) {
     
    228235                ASTNode [] args = new ASTNode [2];
    229236                args[0] = node;
    230                 args[1] = Generators.makeIdentifierNode(builtins2Lang.getCode(PabloSBuiltin.EOF_MASK), node.getToken());
    231                 return Generators.makeFuncCallNode(IDISASIMDBitwiseBuiltins.ANDC.Name(), node.getToken(), args);
     237                args[1] = Generators.makeIdentifierNode(node.getToken(), builtins2Lang.getCode(PabloSBuiltin.EOF_MASK));
     238                return Generators.makeFuncCallNode(node.getToken(), IDISASIMDBitwiseBuiltins.ANDC.Name(), args);
    232239        }       
    233240
    234241        public static FuncCallNode makeSIMDEOFMaskAndCNodeFuncCall(ASTNode node, BuiltinEncoder builtins2Lang) {
    235242                ASTNode [] args = new ASTNode [2];
    236                 args[0] = Generators.makeIdentifierNode(builtins2Lang.getCode(PabloSBuiltin.EOF_MASK), node.getToken());
     243                args[0] = Generators.makeIdentifierNode(node.getToken(), builtins2Lang.getCode(PabloSBuiltin.EOF_MASK));
    237244                args[1] = node;
    238                 return Generators.makeFuncCallNode(IDISASIMDBitwiseBuiltins.ANDC.Name(), node.getToken(), args);
     245                return Generators.makeFuncCallNode(node.getToken(), IDISASIMDBitwiseBuiltins.ANDC.Name(), args);
    239246        }               
    240247       
     
    242249                ASTNode [] args = new ASTNode [1];
    243250                args[0] = node;
    244                 return Generators.makeFuncCallNode(IDISASIMDBitwiseBuiltins.NOT.Name(), node.getToken(), args);
    245         }               
    246        
    247         public static ParameterNode makeEOFMaskParameter(BuiltinEncoder builtins2Lang, Locator locator) {
    248                
    249                 Token parameterNodeToken = Generators.makeLextantToken(Lextant.STREAM, locator);
     251                return Generators.makeFuncCallNode(node.getToken(), IDISASIMDBitwiseBuiltins.NOT.Name(), args);
     252        }               
     253       
     254        public static ParameterNode makeEOFMaskParameter(Locator locator, BuiltinEncoder builtins2Lang) {
     255               
     256                Token parameterNodeToken = Generators.makeLextantToken(locator, Lextant.STREAM);
    250257                ParameterNode parameterNode = new ParameterNode(parameterNodeToken);
    251258               
    252                 Token streamTypeToken = Generators.makeLextantToken(Lextant.STREAM, locator);
     259                Token streamTypeToken = Generators.makeLextantToken(locator, Lextant.STREAM);
    253260                StreamTypeNode streamTypeNode = new StreamTypeNode(streamTypeToken);
    254                 IdentifierNode identifierNode = Generators.makeIdentifierNode(builtins2Lang.getCode(PabloSBuiltin.EOF_MASK), locator);
     261                IdentifierNode identifierNode = Generators.makeIdentifierNode(locator, builtins2Lang.getCode(PabloSBuiltin.EOF_MASK));
    255262               
    256263                parameterNode.appendChild(streamTypeNode);
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/CombineAdvances.java

    r3253 r3271  
    102102                }
    103103                private IntegerConstantNode integerConstant(int n, ASTNode locationReference) {
    104                         return Generators.makeIntegerConstantNode(n, locationReference.getToken());
     104                        return Generators.makeIntegerConstantNode(locationReference.getToken(), n);
    105105                }
    106106        }
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/ConvertBitwiseBooleanToIDISACalls.java

    r3213 r3271  
    127127                private void insertANYintoCondition(ASTNode node, ASTNode condition) {
    128128                        FuncCallNode FuncCallNode = Generators.makeFuncCallNode(
    129                                         IDISABitBlockBuiltins.ANY.IDISALexeme(), // TODO Update to IDISA syntax
    130                                         node,
     129                                        node, // TODO Update to IDISA syntax
     130                                        IDISABitBlockBuiltins.ANY.IDISALexeme(),
    131131                                        arguments(condition.deepCopy()));                               
    132132                       
     
    136136       
    137137        static private FuncCallNode makeIDISACall(IDISASIMDBitwiseBuiltins idisaName, ASTNode[] arguments, Locator locator) {
    138                 return Generators.makeFuncCallNode(idisaName.Name(), locator, arguments);
     138                return Generators.makeFuncCallNode(locator, idisaName.Name(), arguments);
    139139        }
    140140        static private ASTNode[] arguments(ASTNode...astNodes) {
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/InitializeStreamDefaults.java

    r3267 r3271  
    1616import toolchain.pabloS.ast.Accessors;
    1717import toolchain.pabloS.ast.Generators;
    18 import toolchain.pabloS.lang.BuiltinCallUtil;
    19 import toolchain.pabloS.lang.PabloSBuiltin;
    20 
    2118
    2219public class InitializeStreamDefaults {
     
    3936                        }
    4037
    41                         ASTNode type                            = Accessors.typeNode(node);
    42                         IdentifierNode identifier       = Accessors.identifier(node);
     38                        ASTNode type = Accessors.typeNode(node);
     39                       
     40                        if(type instanceof StreamTypeNode) {
     41                            StreamTypeNode streamType = (StreamTypeNode)type;
     42                                int fieldWidth = Accessors.fieldWidth(streamType);
    4343
    44                         if(type instanceof StreamTypeNode) {
    45                                 StreamTypeNode streamType = (StreamTypeNode)type;
    46 
    47                                 int fieldWidth = fieldWidth(streamType);
    48 
    49                                 IntegerConstantNode zeroConstantNode =  Generators.makeIntegerConstantNode(0, node);
    50                                 IntegerConstantNode fieldWidthNode =  Generators.makeIntegerConstantNode(fieldWidth, node);
    51 
    52                                 FuncCallNode mask = Generators.makeFuncCallNode(BuiltinCallUtil.BUILTIN_PACKAGE_NAME, PabloSBuiltin.MASK.pabloSName(),
    53                                                 node.getToken(),
    54                                                 arguments(fieldWidthNode, zeroConstantNode));
    55 
    56                                 // instead of the following, why not node.appendChild(mask)?
    57                                 LocalVarDeclNode localVarDeclNode = Generators.makeLocalVarDeclNode(type, identifier, mask, node);
    58                                 node.updateSelf(localVarDeclNode);
     44                                FuncCallNode maskCall = Generators.makeMaskFuncCall(type, fieldWidth, 0);
     45                                node.appendChild(maskCall);
    5946                        }
    6047                        else {
    6148                                // TS: leave unitialized?
    6249                        }
    63                 }
    64 
    65                 private int fieldWidth(StreamTypeNode streamType) {
    66                                 return streamType.getFieldWidth();
    6750                }
    6851               
     
    7154                }
    7255               
    73                 static private ASTNode[] arguments(ASTNode...astNodes) {
    74                         return astNodes;
    75                 }
    7656        }
    7757}
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/PabloS2PabloBXFormer.java

    r3264 r3271  
    170170    private FuncCallNode makeCarryDeclareCall(int carry1Count, int carryNCount, Locator locator) {
    171171       
    172         IdentifierNode carrySetBaseName         =   Generators.makeIdentifierNode(locator, CarrySetEncoder.CARRYSET_BASENAME_PREFIX + 0);
     172        IdentifierNode carrySetBaseName         =   Generators.makeIdentifierNode(locator, CarrySetEncoder.CARRYSET_NAME_PREFIX + 0);
    173173        IntegerConstantNode carry1CountNode     =   Generators.makeIntegerConstantNode(locator, carry1Count);
    174174        IntegerConstantNode carryNCountNode     =   Generators.makeIntegerConstantNode(locator, carryNCount);
     
    256256                        if(BuiltinCallUtil.isMask(node)) { // translates pablo.Mask(fw,constant) to an IDISA call
    257257                               
    258                                 pabloS.tokens.LextantToken lAngleToken = toolchain.pabloS.ast.Generators.makeLextantToken(Lextant.LANGLE, node.getToken());
     258                                pabloS.tokens.LextantToken lAngleToken = toolchain.pabloS.ast.Generators.makeLextantToken(node.getToken(), Lextant.LANGLE);
    259259               
    260260                                bNode = new pabloB.ast.IdisaFuncCallNode(Generators.makePabloBToken(lAngleToken)); //
     
    262262                                @SuppressWarnings("unused")
    263263                                pabloS.tokens.LextantToken dotToken
    264                                         = toolchain.pabloS.ast.Generators.makeLextantToken(Lextant.DOT, node.getToken());
     264                                        = toolchain.pabloS.ast.Generators.makeLextantToken(node.getToken(), Lextant.DOT);
    265265                                                       
    266266                                pabloB.ast.ASTNode compoundIdentifierNode = Generators.makeCompoundIdentifierNode(bNode, "simd", "constant");
     
    271271                               
    272272                                pabloS.tokens.IntConstantToken fieldWidthConstantToken
    273                                         = toolchain.pabloS.ast.Generators.makeIntegerConstantToken(fieldWidthValue, node.getToken());
     273                                        = toolchain.pabloS.ast.Generators.makeIntegerConstantToken(node.getToken(), fieldWidthValue);
    274274                               
    275275                                pabloB.ast.ASTNode fieldWidthConstantNode
     
    286286                               
    287287                                pabloS.tokens.IntConstantToken maskToken
    288                                         = toolchain.pabloS.ast.Generators.makeIntegerConstantToken(maskValue, node.getToken());
     288                                        = toolchain.pabloS.ast.Generators.makeIntegerConstantToken(node.getToken(), maskValue);
    289289
    290290                                pabloB.ast.ASTNode maskConstantNode
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/SurroundAssert0sWithIfs.java

    r3213 r3271  
    5959                                                               
    6060                                ASTNode assert0Call
    61                                                 = Generators.makeFuncCallNode(encoder.getCode(PabloSBuiltin.ASSERT_ZERO),
    62                                                                                                           locator,                             
     61                                                = Generators.makeFuncCallNode(locator,
     62                                                                                                          encoder.getCode(PabloSBuiltin.ASSERT_ZERO),                           
    6363                                                                                                          errorMsg,
    6464                                                                                                          errorStream);         // note switched arguments
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/carry/BuiltinTranslator.java

    r3264 r3271  
    103103                ASTNode argument = Accessors.argument(node, 1);
    104104                translateArgument(context, argument);
    105                 ASTNode replacement = Generators.makeCompoundIdentifierNode(BuiltinCallUtil.BUILTIN_PACKAGE_NAME,
    106                                 translatedBuiltin.pabloSName(), node);
     105                ASTNode replacement = Generators.makeCompoundIdentifierNode(node,
     106                                BuiltinCallUtil.BUILTIN_PACKAGE_NAME, translatedBuiltin.pabloSName());
    107107
    108108                node.replaceChild(Accessors.nameNode(node), replacement);
     
    132132
    133133                FuncCallNode replacementNode = Generators.makeFuncCallNode(
     134                                node,
    134135                                carryPackageName,
    135                                 carryBuiltin,
    136                                 node,
     136                                carryBuiltin,
    137137                                args);
    138138
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/carry/CarryIntroXFormer.java

    r3269 r3271  
    108108                public void visitLeave(FuncDefNode node) {
    109109                        if(context.isFinalBlockMode()) {
    110                                 ParameterNode EOFMaskParameter = Generators.makeEOFMaskParameter(context.getBuiltinEncoder(), node);
     110                                ParameterNode EOFMaskParameter = Generators.makeEOFMaskParameter(node, context.getBuiltinEncoder());
    111111                                Generators.appendParameter(node, EOFMaskParameter);
    112112                        }
     
    126126                       
    127127                        FuncCallNode carryAdjustment = Generators.makeFuncCallNode(
    128                                                                         context.getCarrySetIdentifier(),
    129                                                                         context.getCarrySetEncoder().getCode(CarrySetBuiltins.CARRYADJUST),                                                                     
    130                                                                         location,
     128                                                                        location,
     129                                                                        context.getCarrySetIdentifier(),                                                                       
     130                                                                        context.getCarrySetEncoder().getCode(CarrySetBuiltins.CARRYADJUST),
    131131                                                                        arguments(carry1CountNode));
    132132                        return carryAdjustment;
     
    189189                       
    190190                        FuncCallNode carryDequeueEnqueue = (FuncCallNode) Generators.makeFuncCallNode(
    191                                                                 context.getCarrySetIdentifier(),
     191                                                                location,
     192                                                                context.getCarrySetIdentifier(),
    192193                                                                context.getCarrySetEncoder().getCode(CarrySetBuiltins.CARRYDEQUEUEENQUEUE),
    193                                                                 location,
    194194                                                                arguments(carryBaseNode, carryCountNode));
    195195                        return carryDequeueEnqueue;
     
    289289                }
    290290                private BlockStmtNode outerIfElseClause(Locator locator, int carryBase, int carry1Count) {
    291                         IntegerConstantNode carryBaseNode       =       Generators.makeIntegerConstantNode(carryBase, locator);
    292                         IntegerConstantNode carry1CountNode =   Generators.makeIntegerConstantNode(carry1Count, locator);
     291                        IntegerConstantNode carryBaseNode       =       Generators.makeIntegerConstantNode(locator, carryBase);
     292                        IntegerConstantNode carry1CountNode =   Generators.makeIntegerConstantNode(locator, carry1Count);
    293293                       
    294294                        FuncCallNode carryDequeueEnqueue = (FuncCallNode) Generators.makeFuncCallNode(
    295                                                                         context.getCarrySetIdentifier(),
     295                                                                        locator,
     296                                                                        context.getCarrySetIdentifier(),
    296297                                                                        context.getCarrySetEncoder().getCode(CarrySetBuiltins.CARRYDEQUEUEENQUEUE),
    297                                                                         locator,
    298298                                                                        arguments(carryBaseNode, carry1CountNode));
    299299                       
     
    352352                       
    353353                        FuncCallNode carryDeclare = Generators.makeFuncCallNode(
     354                                                                location,
    354355                                                                context.getCode(CarrySetBuiltins.CARRYDECLARE),
    355                                                                 location,
    356356                                                                localCarrySetIdentifierNode, leaf(carry1Count, location), leaf(carryNCount, location));
    357357                        return carryDeclare;
     
    365365                       
    366366                        return Generators.makeFuncCallNode(
     367                                                locator,
    367368                                                context.getCode(CarrySetBuiltins.LOCALCARRYCOMBINE),
    368                                                 locator,
    369369                                                arguments(context.carrySetIdentifierNode(locator),
    370370                                                                  localCarrySetIdentifierNode,
     
    386386                        ASTNode carryCountNode = leaf(carryCount, location);
    387387                        ASTNode carryRange = Generators.makeFuncCallNode(
    388                                                                         context.getCarrySetIdentifier(),
     388                                                                        location,
     389                                                                        context.getCarrySetIdentifier(),
    389390                                                                        context.getCarrySetEncoder().getCode(CarrySetBuiltins.CARRYRANGE),
    390                                                                         location,
    391391                                                                        arguments(carryBaseNode, carryCountNode));
    392392
    393                         LextantToken or = Generators.makeLextantToken(Lextant.OR, condition);
     393                        LextantToken or = Generators.makeLextantToken(condition, Lextant.OR);
    394394                        return Generators.makeBinaryOperatorNode(condition, carryRange, or);
    395395                }
     
    404404                }
    405405                public IntegerConstantNode leaf(int n, Locator locator) {
    406                         return Generators.makeIntegerConstantNode(n, locator);
     406                        return Generators.makeIntegerConstantNode(locator, n);
    407407                }               
    408408        }
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/carry/Context.java

    r3269 r3271  
    5252        // compound operations
    5353        public final IdentifierNode carrySetIdentifierNode(Locator location) {
    54                 return Generators.makeIdentifierNode(getCarrySetIdentifier(), location);
     54                return Generators.makeIdentifierNode(location, getCarrySetIdentifier());
    5555        }
    5656        public final String getCode(CarrySetBuiltins carrySetBuiltin) {
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/carry/Counter.java

    r3262 r3271  
    2727        }
    2828        public IntegerConstantNode valueNode(Locator locator) {
    29                 return Generators.makeIntegerConstantNode(value(), locator);
     29                return Generators.makeIntegerConstantNode(locator, value());
    3030        }
    3131        public ASTNode callOrMask(Locator locator, Context context) {
    3232                if(context.isCarryInMode()) {
    3333                        return Generators.makeFuncCallNode(
     34                                        locator,
    3435                                        context.getCarrySetIdentifier(),
    35                                         context.getCarrySetEncoder().getCode(builtin),
    36                                         locator,
     36                                        context.getCarrySetEncoder().getCode(builtin),
    3737                                        valueNode(locator));
    3838                }
     
    4343        // the only reason this is here is because callOrMask calls it.
    4444        static public ASTNode mask(Locator locator) {
    45                 IntegerConstantNode zeroConstantNode =  Generators.makeIntegerConstantNode(0, locator);
    46                 IntegerConstantNode fieldWidthNode =  Generators.makeIntegerConstantNode(1, locator);
     45                IntegerConstantNode zeroConstantNode =  Generators.makeIntegerConstantNode(locator, 0);
     46                IntegerConstantNode fieldWidthNode =  Generators.makeIntegerConstantNode(locator, 1);
    4747               
    48                 return Generators.makeFuncCallNode(BuiltinCallUtil.BUILTIN_PACKAGE_NAME, PabloSBuiltin.MASK.pabloSName(),
    49                                 locator,
     48                return Generators.makeFuncCallNode(locator, BuiltinCallUtil.BUILTIN_PACKAGE_NAME,
     49                                PabloSBuiltin.MASK.pabloSName(),
    5050                                fieldWidthNode, zeroConstantNode);
    5151        }
  • proto/pabloj/trunk/src/toolchain/util/Labeller.java

    r3270 r3271  
    1010public class Labeller {
    1111        private long nextNumber = 0;
    12         String labelBase = "temp_";
     12        private String labelBase = "temp_";
    1313       
    1414        public String newLabel() {
     
    1818                labelBase = baseString;
    1919        }
     20        public void reset() {
     21                nextNumber = 0;
     22        }
    2023}
Note: See TracChangeset for help on using the changeset viewer.