Ignore:
Timestamp:
May 28, 2013, 8:05:01 PM (6 years ago)
Author:
shermer
Message:

Renamed PabloSBuiltinsUtil -> BuiltinCallUtil?
reorganized code therein.
Removed argument count checking from this class, because signatures will soon be verified in a typechecker.

Location:
proto/pabloj/trunk/src/toolchain/pabloS
Files:
11 edited
1 moved

Legend:

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

    r3209 r3210  
    1111
    1212import pabloS.ast.*;
     13
    1314import java.util.ArrayList;
    1415import java.util.List;
     
    238239                return node.getToken().getLexeme();
    239240        }
    240         public static ASTNode funcCallIdentifier(FuncCallNode node) {
    241                 return node.child(0);
    242         }
    243         public static ASTNode funcCallArgsListNode(FuncCallNode node) {
     241        public static ASTNode nameNode(FuncCallNode node) {
     242                return node.child(0);
     243        }
     244        public static ASTNode argsListNode(FuncCallNode node) {
    244245                return node.child(1);
    245246        }
    246         public static int funcCallArgCount(FuncCallNode node) {
    247                 ASTNode argList = Accessors.funcCallArgsListNode(node);
     247        public static int argCount(FuncCallNode node) {
     248                ASTNode argList = Accessors.argsListNode(node);
    248249                if (argList == null) {
    249250                        return 0;
     
    252253        }
    253254       
    254         public static ASTNode funcCallArg(FuncCallNode node, int index) {
    255                
    256                 if((index + 1) > Accessors.funcCallArgsListNode(node).getChildren().size()) {
     255        public static ASTNode argument(FuncCallNode node, int index) {
     256                if((index + 1) > Accessors.argsListNode(node).getChildren().size()) {
    257257                        throw new RuntimeException("Function invocation argument out of range.");
    258258                }
    259                 return Accessors.funcCallArgsListNode(node).child(index);
    260         }
    261        
    262         public static List<ASTNode> funcCallArgsList(FuncCallNode node) {
    263                 return Accessors.funcCallArgsListNode(node).getChildren();
     259                return Accessors.argsListNode(node).child(index);
     260        }
     261       
     262        public static List<ASTNode> argsList(FuncCallNode node) {
     263                return Accessors.argsListNode(node).getChildren();
    264264        }
    265265    public static String funcCallName(ASTNode node) {
     
    337337
    338338        ////////////////////////////////////////////////////////////////////////////
     339        // CompoundIdentifierNode
     340        ////////////////////////////////////////////////////////////////////////////
     341        public static String pckageName(CompoundIdentifierNode compound) {
     342                ASTNode pckageNode = pckageNode(compound);
     343                return name(pckageNode);
     344        }
     345        public static ASTNode pckageNode(CompoundIdentifierNode compound) {
     346                return compound.child(0);
     347        }
     348        public static String funcName(CompoundIdentifierNode compound) {
     349                ASTNode funcNameNode = funcNameNode(compound);
     350                return name(funcNameNode);
     351        }
     352        public static ASTNode funcNameNode(CompoundIdentifierNode compound) {
     353                return compound.child(1);
     354        }
     355       
     356        ////////////////////////////////////////////////////////////////////////////
    339357        // IdentifierNode
    340358        ////////////////////////////////////////////////////////////////////////////
     
    350368                return node.getToken().getLexeme();
    351369        }                       
    352        
     370
    353371}
  • proto/pabloj/trunk/src/toolchain/pabloS/ast/Generators.java

    r3206 r3210  
    109109                if(args.length > 0) {
    110110                        for(ASTNode child: args) {
    111                                 Accessors.funcCallArgsListNode(node).appendChild(child);
     111                                Accessors.argsListNode(node).appendChild(child);
    112112                        }
    113                         Accessors.funcCallArgsListNode(node).setToken(args[0].getToken());
     113                        Accessors.argsListNode(node).setToken(args[0].getToken());
    114114                }       
    115115        }       
     
    119119                if(args.size() > 0) {
    120120                        for(ASTNode child: args) {
    121                                 Accessors.funcCallArgsListNode(node).appendChild(child);
     121                                Accessors.argsListNode(node).appendChild(child);
    122122                        }
    123                         Accessors.funcCallArgsListNode(node).setToken(args.get(0).getToken());
     123                        Accessors.argsListNode(node).setToken(args.get(0).getToken());
    124124                }               
    125125        }       
  • proto/pabloj/trunk/src/toolchain/pabloS/lang/BuiltinCallUtil.java

    r3209 r3210  
    77import toolchain.pabloS.ast.Accessors;
    88
    9 public class PabloSBuiltinsUtil {
    10    
     9public class BuiltinCallUtil {
    1110    public static final String BUILTIN_PACKAGE_NAME = "pablo";
    1211       
    13    
    14     public static boolean isMask(FuncCallNode node) { // Advance(X) || Advance(X,n)
    15                
    16                 if (isCall(node, PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME, PabloSBuiltin.MASK.pabloSName(), PabloSBuiltin.MASK.argCount())) {
    17                     return true;
    18                 }       
    19         return false;       
    20     }   
    21    
    22     public static boolean isAdvance(FuncCallNode node) { // Advance(X) || Advance(X,n)
    23        
    24         if (isCall(node, PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME, PabloSBuiltin.ADVANCE.pabloSName(), PabloSBuiltin.ADVANCE.argCount()) ||
    25                         isCall(node, PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME, PabloSBuiltin.ADVANCE.pabloSName(), PabloSBuiltin.ADVANCE_N.argCount())) {
    26             return true;
    27         }
    28         return false;       
    29     }
    30 
    31     public static boolean isAdvanceN(FuncCallNode node) { // Advance(X) || Advance(X,n)
    32        
    33         if (isCall(node, PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME, PabloSBuiltin.ADVANCE.pabloSName(), PabloSBuiltin.ADVANCE_N.argCount())) {
    34             return true;
    35         }
    36         return false;       
    37     }   
    38    
    39     public static boolean isBuiltinOperations(ASTNode node) {
    40        
    41                 for (PabloSBuiltin builtin : PabloSBuiltin.values()) {   
    42                 if (isQualifiedName(node, PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME, builtin.pabloSName())) {
    43                     return true;
    44                 }               
    45                 }
    46                 return false;
     12    public static boolean isMask(FuncCallNode node) {
     13        return isBuiltInCall(node, PabloSBuiltin.MASK);
     14    } 
     15    public static boolean isAdvance1(FuncCallNode node) {
     16        return isBuiltInCall(node, PabloSBuiltin.ADVANCE);   
     17    }   
     18    public static boolean isAdvanceN(FuncCallNode node) {
     19        return isBuiltInCall(node, PabloSBuiltin.ADVANCE_N);   
     20    }
     21    public static boolean isAdvance(FuncCallNode node) {                // Advance(X) || Advance(X,n)
     22        return isAdvance1(node) || isAdvanceN(node);   
    4723    }
    4824     
    49     public static boolean isCarryOne(FuncCallNode node) {
    50        
    51                 for (PabloSBuiltin carryOneOperation : PabloSBuiltin.carryOneOperations()) {                           
    52                         @SuppressWarnings("unused")
    53                         int argCount = Accessors.funcCallArgCount((FuncCallNode)node);
    54                 if (isCall(node, PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME, carryOneOperation.pabloSName(), carryOneOperation.argCount())){
    55                                 return true;
    56                 }               
    57                 }
    58                 return false;
     25    public static boolean isCarry1(FuncCallNode node) {
     26        if(isBuiltInCall(node)) {
     27                PabloSBuiltin builtin = builtin(node);
     28                return builtin.isCarry1();
     29        }
     30        return false;
     31    }
     32    public static boolean isCarryN(FuncCallNode node) {
     33        if(isBuiltInCall(node)) {
     34                PabloSBuiltin builtin = builtin(node);
     35                return builtin.isCarryN();
     36        }
     37        return false;
    5938    }
    6039   
    61     public static boolean isCarryN(FuncCallNode node) {
    62 
    63         for (PabloSBuiltin carryNOperation : PabloSBuiltin.carryNOperations()) {
    64                     if (isCall(node, PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME, carryNOperation.pabloSName(), carryNOperation.argCount())){
    65                         return true;
    66                 }               
    67                 }
    68                 return false;
    69     }
    70    
     40    // guard invocation with isCarryN
    7141        public static String carryNValue(FuncCallNode node) {
    72                 List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
     42                assert isCarryN(node);
     43                List<ASTNode> arguments = Accessors.argsListNode(node).getChildren();
    7344                String value = Accessors.lexeme(arguments.get(1));
    7445                return value;
    7546        }
    76        
    77     public static boolean isBuiltInCall(FuncCallNode node) {
    78         for (PabloSBuiltin builtin : PabloSBuiltin.values()) {   
    79             if (isCall(node, PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME, builtin.pabloSName(), builtin.argCount())) {
    80                 return true;
    81             }
    82         }       
    83         return false;
    84     }
    8547   
    86     /** Returns true if the node represents a call to the given function with the given number of args.
    87      *  If node does not have a packageName attached, it is assumed to match the given packageName.
    88      * 
    89      * @param node                  node to be checked
    90      * @param packageName           package name that must be matched.
    91      * @param FuncName                   name of Func to be matched
    92      * @param numArgs               number of Args to be matched
    93      * @return                      whether the node is a call of the Func with argNumToMatch Args
    94      */
    95     public static boolean isCall(FuncCallNode node, String packageName, String FuncName, int numArgs) {
    96         if(!(node instanceof FuncCallNode)) {
    97             return false;
    98         }
    99        
    100         FuncCallNode funcNode = (FuncCallNode)node;
    101         ASTNode nameNode = Accessors.funcCallIdentifier(funcNode);
    10248
    103         boolean nameMatches = isQualifiedName(nameNode, packageName, FuncName);
    104         boolean numArgsMatches = Accessors.funcCallArgsListNode(funcNode).nChildren() == numArgs;
    105        
    106         return nameMatches && numArgsMatches;
    107     }
    108    
    109     /** Returns true if node represents the name of the function described by packageName, FuncName.
    110      *  In particular, if node represents a simple (non-qualified) name, then it is compared with FuncName.
    111      *  (Essentially, this assumes that the packageName is correct.)
    112      *  If node represents a compound (qualified) name, then it is compared with 'packageName.FuncName'.
    113      * 
    114      * @param node
    115      * @param packageName
    116      * @param funcName
    117      * @return True if the node matches packageName.FuncName.
    118      */
    119     public static boolean isQualifiedName(ASTNode node, String packageName, String funcName) {
    120         if(node instanceof IdentifierNode) {           
    121             return Accessors.name(node) == funcName;
    122         }
    123         else if (node instanceof CompoundIdentifierNode) {
    124             ASTNode pckage = node.child(0);
    125             ASTNode member = node.child(1);
    126            
    127             return   (Accessors.name(pckage) == packageName) &&
    128                      (Accessors.name(member) == funcName);
    129         }
    130         return false;
    131     }
    132        
     49        ///////////////////////////////////////////////////////////////////////////////////
     50        // builtin(node) - what builtin does this node invoke?
     51        // guard invocations with isBuiltInCall
     52        ///////////////////////////////////////////////////////////////////////////////////
     53        public static PabloSBuiltin builtin(FuncCallNode node) {
     54                assert isBuiltInCall(node);
     55                CompoundIdentifierNode compound = (CompoundIdentifierNode)Accessors.nameNode(node);
     56                String builtinName = Accessors.funcName(compound);
     57                return PabloSBuiltin.forName(builtinName);
     58        }
     59       
     60        ///////////////////////////////////////////////////////////////////////////////////
     61        // isBuiltinCall(node, builtin) - is this node an invocation of the given builtin?
     62        ///////////////////////////////////////////////////////////////////////////////////
     63        public static boolean isBuiltInCall(FuncCallNode node, PabloSBuiltin builtin) {
     64                if(isBuiltInCall(node)) {
     65                        return builtin(node) == builtin;
     66                }
     67                return false;
     68        }
     69
     70        ///////////////////////////////////////////////////////////////////////////////////
     71        // isBuiltinCall(node) - is this node an invocation of a builtin?
     72        ///////////////////////////////////////////////////////////////////////////////////
     73        public static boolean isBuiltInCall(FuncCallNode node) {
     74                ASTNode nameNode = Accessors.nameNode(node);
     75                return hasPackage(nameNode, BUILTIN_PACKAGE_NAME);
     76        }
     77        private static boolean hasPackage(ASTNode nameNode, String pckage) {
     78                if(nameNode instanceof IdentifierNode) {
     79                        return false;
     80                }
     81                else if (nameNode instanceof CompoundIdentifierNode) {
     82                        CompoundIdentifierNode compound = (CompoundIdentifierNode)nameNode;
     83                        String invokedPackage = Accessors.pckageName(compound);
     84                        return invokedPackage.equals(pckage);
     85                }
     86                assert false;
     87                return false;
     88        }
    13389}
  • proto/pabloj/trunk/src/toolchain/pabloS/lang/PabloSBuiltin.java

    r3208 r3210  
    22
    33import java.util.ArrayList;
     4import java.util.HashMap;
    45import java.util.List;
     6import java.util.Map;
    57
    68public enum PabloSBuiltin {
     
    2426    IN_FILE("inFile", CarryType.None, 1),
    2527    ASSERT_ZERO("assert_0", CarryType.None, 2),
    26     EOF_MASK("EOF_mask", CarryType.None, 0); // deprecated
     28    EOF_MASK("EOF_mask", CarryType.None, 0), // deprecated
     29    NULL_BUILTIN("NULL", CarryType.None, 0);
    2730
    2831    public enum CarryType{One, N, None};   
     
    3740                this.argCount = argCount;
    3841        }
    39        
     42
     43        static private Map<String, PabloSBuiltin> builtinForName = new HashMap<String, PabloSBuiltin>();
     44        static {
     45                for(PabloSBuiltin builtin: values()) {
     46                        builtinForName.put(builtin.pabloSName(), builtin);
     47                }
     48        }
    4049        public String pabloSName() { return this.name; }
    4150        public int argCount() { return this.argCount; }
    4251        public final CarryType getCarryType() { return type; }
    43         public final boolean isCarryOne() { return type == CarryType.One; }
     52        public final boolean isCarry1() { return type == CarryType.One; }
    4453        public final boolean isCarryN() { return type == CarryType.N; }
    4554       
     
    6877                return carryN;
    6978        }
     79
     80        public static PabloSBuiltin forName(String builtinName) {
     81                if(builtinForName.containsKey(builtinName)) {
     82                        return builtinForName.get(builtinName);
     83                }
     84                return NULL_BUILTIN;
     85        }
    7086}
  • proto/pabloj/trunk/src/toolchain/pabloS/semanticAnalyzer/visitors/CombineAdvances.java

    r3115 r3210  
    1616import toolchain.pabloS.ast.Accessors;
    1717import toolchain.pabloS.ast.Generators;
    18 import static toolchain.pabloS.lang.PabloSBuiltinsUtil.isAdvance;
     18import toolchain.pabloS.lang.BuiltinCallUtil;
    1919
    2020public class CombineAdvances {
     
    4646                       
    4747                        if(isAdvanceOfAdvance(node)) { 
    48                                 FuncCallNode child = (FuncCallNode) Accessors.funcCallArg(node,0);
     48                                FuncCallNode child = (FuncCallNode) Accessors.argument(node,0);
    4949                                combineAdvanceNodes(node, child);
    5050                        }                       
     
    5252
    5353                private int advanceAmount(FuncCallNode node) {
    54                         assert isAdvance(node);
    55                         switch(Accessors.funcCallArgCount(node)) {
     54                        assert BuiltinCallUtil.isAdvance(node);
     55                        switch(Accessors.argCount(node)) {
    5656                        case 1:         return 1;
    57                         case 2:         return valueOf(Accessors.funcCallArg(node,  1));
     57                        case 2:         return valueOf(Accessors.argument(node,  1));
    5858                        default:        assert false;                   // programmer or compiler error? assert or exception?
    5959                                                return 0;
     
    6868               
    6969                private boolean isAdvanceOfAdvance(FuncCallNode node) {
    70                         if(!isAdvance(node)) {
     70                        if(!BuiltinCallUtil.isAdvance(node)) {
    7171                                return false;
    7272                        }                       
    7373                       
    74                         ASTNode child = Accessors.funcCallArg(node, 0);         // again, if #args==0 this will throw.  Programmer or compiler?
     74                        ASTNode child = Accessors.argument(node, 0);            // again, if #args==0 this will throw.  Programmer or compiler?
    7575                        if(!(child instanceof FuncCallNode)) {
    7676                                return false;
    7777                        }
    78                         return isAdvance((FuncCallNode)child);
     78                        return BuiltinCallUtil.isAdvance((FuncCallNode)child);
    7979                }       
    8080
     
    8282                        int combinedAmount = advanceAmount(node) + advanceAmount(child);
    8383                       
    84                         ASTNode newArgumentList = Accessors.funcCallArgsListNode(child);
    85                         ASTNode oldArgumentList = Accessors.funcCallArgsListNode(node);
     84                        ASTNode newArgumentList = Accessors.argsListNode(child);
     85                        ASTNode oldArgumentList = Accessors.argsListNode(node);
    8686                        node.replaceChild(oldArgumentList, newArgumentList);
    8787                       
  • proto/pabloj/trunk/src/toolchain/pabloS/semanticAnalyzer/visitors/PabloS2PabloBXFormer.java

    r3192 r3210  
    99import java.lang.reflect.Constructor;
    1010import java.util.HashMap;
    11 import java.util.LinkedHashMap;
    1211import java.util.List;
    1312import java.util.Map;
     
    2322import toolchain.pabloB.symbols.SymbolTable;
    2423import toolchain.pabloS.ast.Accessors;
    25 import toolchain.pabloS.lang.PabloSBuiltinsUtil;
     24import toolchain.pabloS.lang.BuiltinCallUtil;
    2625
    2726public class PabloS2PabloBXFormer {
     
    269268                        pabloB.ast.ASTNode bNode = null;
    270269                       
    271                         if(PabloSBuiltinsUtil.isMask(node)) { // translate Mask(fw,constant) tp IDISA call
     270                        if(BuiltinCallUtil.isMask(node)) { // translate Mask(fw,constant) tp IDISA call
    272271                               
    273272                                pabloS.tokens.LextantToken lAngleToken
     
    285284                                // field width integer constant
    286285                                int fieldWidthValue
    287                                         = Integer.valueOf(Accessors.funcCallArg(node, 0).getToken().getLexeme());
     286                                        = Integer.valueOf(Accessors.argument(node, 0).getToken().getLexeme());
    288287                               
    289288                                pabloS.tokens.IntConstantToken fieldWidthConstantToken
     
    300299                                // mask integer constant
    301300                                int maskValue
    302                                         = Integer.valueOf(Accessors.funcCallArg(node, 1).getToken().getLexeme());
     301                                        = Integer.valueOf(Accessors.argument(node, 1).getToken().getLexeme());
    303302                               
    304303                                pabloS.tokens.IntConstantToken maskToken
  • proto/pabloj/trunk/src/toolchain/pabloS/semanticAnalyzer/visitors/SurroundAssert0sWithIfs.java

    r3206 r3210  
    1515import toolchain.pabloS.lang.BuiltinEncoder;
    1616import toolchain.pabloS.lang.PabloSBuiltin;
    17 import toolchain.pabloS.lang.PabloSBuiltinsUtil;
     17import toolchain.pabloS.lang.BuiltinCallUtil;
    1818
    1919// ugh!  do pabloB programmers have to use a different arg order than pabloS??
     
    5252                                Locator locator = (Locator)node;
    5353
    54                                 ASTNode errorStream = Accessors.funcCallArg(node, 0);
    55                                 ASTNode errorMsg    = Accessors.funcCallArg(node, 1);
     54                                ASTNode errorStream = Accessors.argument(node, 0);
     55                                ASTNode errorMsg    = Accessors.argument(node, 1);
    5656                               
    5757                                // should this be exception?  Does grammar or typechecking prevent programmer from doing this?
     
    7474
    7575                private boolean isAssertZeroCall(FuncCallNode node) {
    76                         return PabloSBuiltinsUtil.isCall(node,
    77                                         PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME,
    78                                         PabloSBuiltin.ASSERT_ZERO.pabloSName(),
    79                                         PabloSBuiltin.ASSERT_ZERO.argCount());
     76                        return BuiltinCallUtil.isBuiltInCall(node, PabloSBuiltin.ASSERT_ZERO);
    8077                }               
    8178        }       
  • proto/pabloj/trunk/src/toolchain/pabloS/semanticAnalyzer/visitors/carry/AdvanceNCount.java

    r3133 r3210  
    88
    99import pabloS.ast.*;
    10 import toolchain.pabloS.lang.PabloSBuiltinsUtil;
     10import toolchain.pabloS.lang.BuiltinCallUtil;
    1111
    1212public class AdvanceNCount {
     
    2525
    2626                public void visitLeave(FuncCallNode node) {
    27                         if(PabloSBuiltinsUtil.isAdvanceN(node)) {
     27                        if(BuiltinCallUtil.isAdvanceN(node)) {
    2828                            this.advNCount += 1;
    2929                        }
  • proto/pabloj/trunk/src/toolchain/pabloS/semanticAnalyzer/visitors/carry/BuiltinTranslator.java

    r3206 r3210  
    1212import toolchain.pabloS.lang.PabloSBuiltin;
    1313import toolchain.pabloS.lang.PabloSBuiltin.CarryType;
    14 import toolchain.pabloS.lang.PabloSBuiltinsUtil;
     14import toolchain.pabloS.lang.BuiltinCallUtil;
    1515
    1616public enum BuiltinTranslator {
     
    6060       
    6161        public boolean isCall(FuncCallNode node) {
    62                 return PabloSBuiltinsUtil.isCall(node,
    63                                         PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME,
    64                                         builtin.pabloSName(),
    65                                         builtin.argCount());
     62                return BuiltinCallUtil.isBuiltInCall(node, builtin);
    6663        }
    6764
     
    9289       
    9390        public void carryAction(FuncCallNode node, Counter counter, Context context, PabloSBuiltin translation) {
    94                 List<ASTNode> arguments = Accessors.funcCallArgsList(node);
     91                List<ASTNode> arguments = Accessors.argsList(node);
    9592               
    9693                replaceCallWithCarryCall(node,
     
    104101        }               
    105102        public void scanToAction(FuncCallNode node, PabloSBuiltin translation, Counter counter, Context context) {
    106                 ASTNode argument = Accessors.funcCallArg(node, 1);
     103                ASTNode argument = Accessors.argument(node, 1);
    107104                translateArgument(context, argument);
    108                 ASTNode replacement = Generators.makeCompoundIdentifierNode(PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME,
     105                ASTNode replacement = Generators.makeCompoundIdentifierNode(BuiltinCallUtil.BUILTIN_PACKAGE_NAME,
    109106                                                                                                                                                                        translation.pabloSName(), node);
    110107               
    111                 node.replaceChild(Accessors.funcCallIdentifier(node), replacement);
     108                node.replaceChild(Accessors.nameNode(node), replacement);
    112109                carryAction(node, counter, context, translation);
    113110        }
     
    123120        }               
    124121        public void advanceNAction(FuncCallNode node, Counter counter, Context context) {
    125                 ASTNode formatValue = Accessors.funcCallArg(node, 1);
     122                ASTNode formatValue = Accessors.argument(node, 1);
    126123                String value = Accessors.lexeme(formatValue);
    127124
    128                 List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
     125                List<ASTNode> arguments = Accessors.argsListNode(node).getChildren();
    129126
    130127                // TS: TODO: gnarly
     
    141138        public void atEOFAction(FuncCallNode node, Counter counter, Context context) {
    142139                if(context.isFinalBlockMode()) {
    143                         ASTNode argNode = Accessors.funcCallArg(node, 0);
     140                        ASTNode argNode = Accessors.argument(node, 0);
    144141                        ASTNode replacementNode = Generators.makeSIMDAndCEOFMaskFuncCall(argNode, context.getBuiltinEncoder());
    145142                        node.updateSelf(replacementNode);
     
    151148        public void infileAction(FuncCallNode node, Counter counter, Context context) {
    152149                if(context.isFinalBlockMode()) {                                       
    153                         ASTNode argNode = Accessors.funcCallArg(node, 0);
     150                        ASTNode argNode = Accessors.argument(node, 0);
    154151                        ASTNode replacementNode = Generators.makeSIMDAndEOFMaskFuncCall(argNode, context.getBuiltinEncoder());
    155152                        node.updateSelf(replacementNode);
    156153                } else {
    157                         node.updateSelf(Accessors.funcCallArg(node,0));
     154                        node.updateSelf(Accessors.argument(node,0));
    158155                }
    159156        }                       
  • proto/pabloj/trunk/src/toolchain/pabloS/semanticAnalyzer/visitors/carry/Carry1Count.java

    r3133 r3210  
    88
    99import pabloS.ast.*;
    10 import toolchain.pabloS.lang.PabloSBuiltinsUtil;
     10import toolchain.pabloS.lang.BuiltinCallUtil;
    1111
    1212public class Carry1Count {
     
    2727                               
    2828                public void visitLeave(FuncCallNode node) {
    29                         if(PabloSBuiltinsUtil.isCarryOne(node)) {
     29                        if(BuiltinCallUtil.isCarry1(node)) {
    3030                            carry1Count += 1;
    3131                        }                       
  • proto/pabloj/trunk/src/toolchain/pabloS/semanticAnalyzer/visitors/carry/CarryInfoSetVisitor.java

    r3206 r3210  
    1111import toolchain.pabloS.ast.Accessors;
    1212import toolchain.pabloS.lang.PabloSBuiltin;
    13 import toolchain.pabloS.lang.PabloSBuiltinsUtil;
     13import toolchain.pabloS.lang.BuiltinCallUtil;
    1414
    1515public class CarryInfoSetVisitor {
     
    4040                public void visitLeave(FuncCallNode node) {
    4141                       
    42                         if(PabloSBuiltinsUtil.isCarryOne(node)) {
    43                                 if (PabloSBuiltinsUtil.isCall(node, PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME, PabloSBuiltin.SCANTO_FIRST.pabloSName(), PabloSBuiltin.SCANTO_FIRST.argCount())) {
     42                        if(BuiltinCallUtil.isCarry1(node)) {
     43                                if (BuiltinCallUtil.isBuiltInCall(node, PabloSBuiltin.SCANTO_FIRST)) {
    4444                                        ((CarryInfoSetSymbol)symbolTable.get(key)).addCarry1(1);
    4545                                } else {
  • proto/pabloj/trunk/src/toolchain/pabloS/semanticAnalyzer/visitors/carry/CarryNCount.java

    r3133 r3210  
    22
    33import pabloS.ast.*;
    4 import toolchain.pabloS.lang.PabloSBuiltinsUtil;
     4import toolchain.pabloS.lang.BuiltinCallUtil;
    55
    66public class CarryNCount {
     
    2020                               
    2121                public void visitLeave(FuncCallNode node) {
    22                         if(PabloSBuiltinsUtil.isCarryN(node)) {
     22                        if(BuiltinCallUtil.isCarryN(node)) {
    2323                            carryNCount += 1;
    2424                        }                       
Note: See TracChangeset for help on using the changeset viewer.