Changeset 2399


Ignore:
Timestamp:
Sep 26, 2012, 5:48:16 PM (7 years ago)
Author:
ksherdy
Message:

Refactored visitors and helpers. Seperated Pablo AST accessors from built in function definitions and methods.

Location:
proto/pablo/src/compiler/visitors
Files:
2 added
3 edited
1 moved

Legend:

Unmodified
Added
Removed
  • proto/pablo/src/compiler/visitors/ASTHelpers.java

    r2394 r2399  
    99import lexicalAnalyzer.Lextant;
    1010
     11
    1112// The node helpers can be made public if useful in other classes.
    1213//
    13 public class Helpers {
    14         public static String BUILTIN_PACKAGE_NAME = "pablo";
     14public class ASTHelpers {
     15
    1516
    1617        ////////////////////////////////////////////////////////////////////////////
     
    3132        // what the children of a FunctionInvocationNode are.
    3233        ////////////////////////////////////////////////////////////////////////////
    33         private static ASTNode functionName(FunctionInvocationNode node) {
     34        public static ASTNode functionName(FunctionInvocationNode node) {
    3435                return node.child(0);
    3536        }
    36         private static List<ASTNode> functionArgs(FunctionInvocationNode node) {
     37        public static List<ASTNode> functionArgs(FunctionInvocationNode node) {
    3738                return node.getChildren().subList(1, node.nChildren());
    3839        }
     
    4647        // this returns that IdentifierNode's lexeme.
    4748        ////////////////////////////////////////////////////////////////////////////
    48         private static String identifierLexeme(ASTNode functionName) {
     49        public static String identifierLexeme(ASTNode functionName) {
    4950                IdentifierNode identifier = (IdentifierNode)functionName;
    5051                return identifier.getToken().getLexeme();
    5152        }
    52 
    53        
    54 
    55         ////////////////////////////////////////////////////////////////////////////   
    56         // Python -> Java translation note:
    57         //              3-arg  is_BuiltIn_Call   is translated as isBuiltInCall()
    58         //              4-arg  is_BuiltIn_Call   is translated as isCall() where argument 4 of python is moved to arg 2 of java.
    59         //
    60         //
    61         //   def is_BuiltIn_Call(fncall, builtin_fnname, builtin_arg_cnt, builtin_fnmod_noprefix='pablo'):
    62         //         if isinstance(fncall.func, ast.Name):
    63         //                      iscall = fncall.func.id == builtin_fnname
    64         //         elif isinstance(fncall.func, ast.Attribute) and isinstance(fncall.func.value, ast.Name):
    65         //               iscall = fncall.func.value.id == builtin_fnmod_noprefix and fncall.func.attr == builtin_fnname
    66         //         return iscall and len(fncall.args) == builtin_arg_cnt
    67         ////////////////////////////////////////////////////////////////////////////
    68 
    69         /** Returns true if the node represents a call to the
    70          *  given built-in function.
    71          * 
    72          * @param node                                  node to be checked
    73          * @param functionName                  name of function to be matched
    74          * @return                                              whether the node is a call of the function
    75          */
    76         public static boolean isBuiltInCall(ASTNode node, String functionName) {
    77                 if(!(node instanceof FunctionInvocationNode)) {
    78                         return false;
    79                 }
    80                
    81                 FunctionInvocationNode fNode = (FunctionInvocationNode)node;
    82                 ASTNode nameNode = functionName(fNode);
    83 
    84                 return isQualifiedName(nameNode, BUILTIN_PACKAGE_NAME, functionName);
    85         }
    86        
    87         /** Returns true if the node represents a call to the
    88          *  given built-in function with the given number of arguments.
    89          * 
    90          * @param node                                  node to be checked
    91          * @param functionName                  name of function to be matched
    92          * @param numArgs                           number of arguments to be matched
    93          * @return                                              whether the node is a call of the function with argNumToMatch arguments
    94          */
    95         public static boolean isBuiltInCall(ASTNode node, String functionName, int numArgs) {
    96                 return isCall(node, BUILTIN_PACKAGE_NAME, functionName, numArgs);
    97         }
    98        
    99         /** Returns true if the node represents a call to the
    100          *  given function with the given number of arguments.
    101          *  If node does not have a packageName attached, it is assumed to match the given packageName.
    102          * 
    103          * @param node                                  node to be checked
    104          * @param packageName                   package name that must be matched.
    105          * @param functionName                  name of function to be matched
    106          * @param numArgs                           number of arguments to be matched
    107          * @return                                              whether the node is a call of the function with argNumToMatch arguments
    108          */
    109         public static boolean isCall(ASTNode node, String packageName, String functionName, int numArgs) {
    110                 if(!(node instanceof FunctionInvocationNode)) {
    111                         return false;
    112                 }
    113                
    114                 FunctionInvocationNode fNode = (FunctionInvocationNode)node;
    115                 ASTNode nameNode = functionName(fNode);
    116 
    117                 boolean nameMatches = isQualifiedName(nameNode, packageName, functionName);
    118                 boolean numArgsMatches = functionArgs(fNode).size() == numArgs;
    119                
    120                 return nameMatches && numArgsMatches;
    121         }
    122        
    123        
    124         /** Determines if node represents the name of the function described by packageName, functionName.
    125          *  In particular, if node represents a simple (non-qualified) name, then it is compared with functionName.
    126          *  (Essentially, this assumes that the packageName is correct.)
    127          *  If node represents a compound (qualified) name, then it is compared with 'packageName.functionName'.
    128          * 
    129          * @param node
    130          * @param packageName
    131          * @param functionName
    132          * @return True if the node matches packageName.functionName.
    133          */
    134         public static boolean isQualifiedName(ASTNode node, String packageName, String functionName) {
    135                 if(node instanceof IdentifierNode) {
    136                         return identifierLexeme(node) == functionName;
    137                 }
    138                 else if (node instanceof CompoundVariableNode) {
    139                         ASTNode pckage = node.child(0);
    140                         ASTNode member = node.child(1);
    141                         return   (identifierLexeme(pckage) == packageName) &&
    142                                          (identifierLexeme(member) == functionName);
    143                 }
    144                 return false;
    145         }
    146 
    14753       
    14854        public static String functionIdentifier(FunctionInvocationNode node) {
     
    18389         * @return      the new FunctionInvocationNode
    18490         */
    185         private static ASTNode makeFunctionInvocationNode(ASTNode identifier, Token locationToken) {
     91        public static ASTNode makeFunctionInvocationNode(ASTNode identifier, Token locationToken) {
    18692                assert identifier instanceof IdentifierNode || identifier instanceof CompoundVariableNode;
    18793               
  • proto/pablo/src/compiler/visitors/AdvanceCombiner.java

    r2397 r2399  
    9696        }
    9797        private boolean isAdvance(ASTNode node) {
    98                 return Helpers.isBuiltInCall(node, "Advance");
     98                return Builtins.isAdvance(node);
    9999        }
    100100       
     
    103103                        int amount1, int amount2) {
    104104                node.replaceChild(child, streamBeingAdvanced);
    105                 IntegerConstantNode integerConstantNode = Helpers.makeIntegerConstantNode(amount1+amount2, node.getToken());
     105                IntegerConstantNode integerConstantNode = ASTHelpers.makeIntegerConstantNode(amount1+amount2, node.getToken());
    106106                if(node.nChildren()==2) {
    107107                        node.appendChild(integerConstantNode);
  • proto/pablo/src/compiler/visitors/CarryCounter.java

    r2397 r2399  
    2222        private class CarryCounterVisitor extends VoidVisitor.Default {
    2323                private int carryCount = 0;
    24                
    25                 private final Map<String, Integer> funAndArgNum = new LinkedHashMap<String, Integer>();
    26                 public CarryCounterVisitor() {
    27                         funAndArgNum.put("Advance", 1);
    28                         funAndArgNum.put("ScanToFirst", 1);
    29                         funAndArgNum.put("ScanThru", 2);
    30                         funAndArgNum.put("ScanTo", 2);
    31                         funAndArgNum.put("AdvanceThenScanThru", 2);
    32                         funAndArgNum.put("AdvanceThenScanTo", 2);
    33                         funAndArgNum.put("SpanUpTo", 2);
    34                         funAndArgNum.put("InclusiveSpan", 2);
    35                         funAndArgNum.put("ExclusiveSpan", 2);
    36                 }
    37                
     24
    3825                public int carryCount() {
    3926                        return carryCount;
     
    4128               
    4229                public void visitLeave(FunctionInvocationNode node) {
    43                         for (Entry<String, Integer> entry : funAndArgNum.entrySet()) {
    44                                 String funName = entry.getKey();
    45                                 int funArgNum = entry.getValue();
    46                                 if(Helpers.isBuiltInCall(node, funName, funArgNum)) {
    47                             carryCount += 1;
    48                                     break;
    49                                 }
     30
     31                        if(Builtins.isBuiltInCall(node)) {
     32                            carryCount += 1;
    5033                        }
     34                   
    5135                }
    5236               
  • proto/pablo/src/compiler/visitors/StreamFunctionVisitor.java

    r2397 r2399  
    4646                public void visitLeave(FunctionDefNode node) {
    4747                                               
    48                         ASTNode functionNameNode = Helpers.functionName(node); 
     48                        ASTNode functionNameNode = ASTHelpers.functionName(node);       
    4949                        String functionName = functionNameNode.getToken().getLexeme();
    5050                        functionName = capitalize(functionName);
Note: See TracChangeset for help on using the changeset viewer.