Changeset 2414


Ignore:
Timestamp:
Sep 28, 2012, 12:49:20 PM (6 years ago)
Author:
ksherdy
Message:

Refactored Pablo compiler. An effort to organise systematic code generation and eliminate 'small text strings' in Pablo compiler code.

Location:
proto/pablo/src/compiler
Files:
9 added
1 deleted
5 edited
1 moved

Legend:

Unmodified
Added
Removed
  • proto/pablo/src/compiler/PabloCompiler.java

    r2405 r2414  
    99import java.util.Map;
    1010
     11import compiler.lang.idisa.*;
    1112import compiler.visitors.AdvanceNCounter;
    1213import compiler.visitors.AdvanceCombiner;
     
    4142         */
    4243        public static void compile(String filename) throws FileNotFoundException {
     44                               
    4345                LexicalController lexController     = LexicalController.make(filename);
    4446                ASTNode syntaxTree    = Parser.parse(lexController);
     
    6062                        System.out.println("Adv n Count = " + advNCounter.count());
    6163                        System.out.println();
    62                
     64                       
    6365                }
    6466
  • proto/pablo/src/compiler/ast/Util.java

    r2410 r2414  
    44import java.util.Map.Entry;
    55
    6 
    7 import ast.*;
    8 import tokens.*;
    96import lexicalAnalyzer.LexicalType;
    107import lexicalAnalyzer.Lextant;
    11 import compiler.codeGeneration.*;
    12 import compiler.lang.Builtins;
    13 
    14 // The node helpers can be made public if useful in other classes.
    15 //
    16 public class ASTHelpers {
    17 
     8import tokens.IdentifierToken;
     9import tokens.IntConstantToken;
     10import tokens.LextantToken;
     11import tokens.StringConstantToken;
     12import tokens.Token;
     13import ast.ASTNode;
     14import ast.CompoundVariableNode;
     15import ast.FunctionDefNode;
     16import ast.FunctionInvocationNode;
     17import ast.IdentifierNode;
     18import ast.IntegerConstantNode;
     19import ast.StringConstantNode;
     20
     21public class Util {
    1822
    1923        ////////////////////////////////////////////////////////////////////////////
     
    2731        }
    2832
    29 
    3033        ////////////////////////////////////////////////////////////////////////////
    3134        // FunctionInvocationNode helpers
     
    4043                return node.getChildren().subList(1, node.nChildren());
    4144        }
    42 
    43 
    4445       
    4546        ////////////////////////////////////////////////////////////////////////////
     
    204205                return IdentifierToken.make(LexicalType.IDENTIFIER, locationToken.getLocation(), identifier);
    205206        }       
    206 
    207         ////////////////////////////////////////////////////////////////////////////
    208         // Builtin Methods
    209         //
    210         ////////////////////////////////////////////////////////////////////////////
    211                
    212     /** Returns true if the node represents a call to the
    213      *  given built-in 'Advance' function.
    214      * 
    215      * @param node                  node to be checked
    216      * @return                      whether the node is a call of the function
    217      */   
    218     public static boolean isAdvance(ASTNode node) {
    219         if(!(node instanceof FunctionInvocationNode)) {
    220             return false;
    221         }
    222        
    223         FunctionInvocationNode fNode = (FunctionInvocationNode)node;
    224         ASTNode nameNode = ASTHelpers.functionName(fNode);
    225        
    226         if (isQualifiedName(nameNode, Builtins.BUILTIN_PACKAGE_NAME, "Advance")) {
    227             return true;
    228         }
    229    
    230         return false;       
    231     }
    232    
    233     /** Returns true if the node represents a call to the
    234      *  given built-in 'Advance N' functions.
    235      * 
    236      * @param node                  node to be checked
    237      * @return                      whether the node is a call of the function
    238      */   
    239     public static boolean isAdvanceN(ASTNode node) {
    240        
    241         for (Entry<String, Integer> entry : Builtins.carryNBuiltins.entrySet()) {
    242             String functionName = entry.getKey();
    243             int numArgs = entry.getValue();
    244            
    245             if (isCall(node, Builtins.BUILTIN_PACKAGE_NAME, functionName, numArgs)) {
    246                 return true;
    247             }
    248         }       
    249    
    250         return false;       
    251     }
    252    
    253     /** Returns true if the node represents a call to the
    254      *  given built-in function.
    255      * 
    256      * @param node                  node to be checked
    257      * @return                      whether the node is a call of the function
    258      */
    259     public static boolean isBuiltInCallNoArgCount(ASTNode node) {
    260         if(!(node instanceof FunctionInvocationNode)) {
    261             return false;
    262         }
    263        
    264         FunctionInvocationNode fNode = (FunctionInvocationNode)node;
    265         ASTNode nameNode = ASTHelpers.functionName(fNode);
    266 
    267         for (Entry<String, Integer> entry : Builtins.carry1Builtins.entrySet()) {
    268             String functionName = entry.getKey();
    269            
    270             if (isQualifiedName(nameNode, Builtins.BUILTIN_PACKAGE_NAME, functionName)) {
    271                 return true;
    272             }
    273         }
    274        
    275         return false;
    276     }
    277    
    278     /** Returns true if the node represents a call to the
    279      *  given built-in function with the given number of arguments.
    280      * 
    281      * @param node                  node to be checked
    282      * @return                      whether the node is a call of the function with argNumToMatch arguments
    283      */
    284     public static boolean isBuiltInCall(ASTNode node) {
    285        
    286         for (Entry<String, Integer> entry : Builtins.carry1Builtins.entrySet()) {
    287             String functionName = entry.getKey();
    288             int numArgs = entry.getValue();
    289            
    290             if (isCall(node, Builtins.BUILTIN_PACKAGE_NAME, functionName, numArgs)) {
    291                 return true;
    292             }
    293         }       
    294        
    295         return false;
    296     }
    297    
    298     /** Returns true if the node represents a call to the
    299      *  given function with the given number of arguments.
    300      *  If node does not have a packageName attached, it is assumed to match the given packageName.
    301      * 
    302      * @param node                  node to be checked
    303      * @param packageName           package name that must be matched.
    304      * @param functionName          name of function to be matched
    305      * @param numArgs               number of arguments to be matched
    306      * @return                      whether the node is a call of the function with argNumToMatch arguments
    307      */
    308     public static boolean isCall(ASTNode node, String packageName, String functionName, int numArgs) {
    309         if(!(node instanceof FunctionInvocationNode)) {
    310             return false;
    311         }
    312        
    313         FunctionInvocationNode fNode = (FunctionInvocationNode)node;
    314         ASTNode nameNode = ASTHelpers.functionName(fNode);
    315 
    316         boolean nameMatches = isQualifiedName(nameNode, packageName, functionName);
    317         boolean numArgsMatches = ASTHelpers.functionArgs(fNode).size() == numArgs;
    318        
    319         return nameMatches && numArgsMatches;
    320     }
    321    
    322    
    323     /** Determines if node represents the name of the function described by packageName, functionName.
    324      *  In particular, if node represents a simple (non-qualified) name, then it is compared with functionName.
    325      *  (Essentially, this assumes that the packageName is correct.)
    326      *  If node represents a compound (qualified) name, then it is compared with 'packageName.functionName'.
    327      * 
    328      * @param node
    329      * @param packageName
    330      * @param functionName
    331      * @return True if the node matches packageName.functionName.
    332      */
    333     public static boolean isQualifiedName(ASTNode node, String packageName, String functionName) {
    334         if(node instanceof IdentifierNode) {
    335             return ASTHelpers.identifierLexeme(node) == functionName;
    336         }
    337         else if (node instanceof CompoundVariableNode) {
    338             ASTNode pckage = node.child(0);
    339             ASTNode member = node.child(1);
    340             return   (ASTHelpers.identifierLexeme(pckage) == packageName) &&
    341                      (ASTHelpers.identifierLexeme(member) == functionName);
    342         }
    343         return false;
    344     }
    345        
    346207       
    347208}
  • proto/pablo/src/compiler/visitors/AdvanceCombiner.java

    r2410 r2414  
    22
    33
    4 import compiler.ast.ASTHelpers;
     4import compiler.ast.Util;
     5import compiler.lang.pablo.builtins.Builtins;
    56
    67import tokens.*;
     
    99100        }
    100101        private boolean isAdvance(ASTNode node) {
    101                 return ASTHelpers.isAdvance(node);
     102                return Builtins.isAdvance(node);
    102103        }
    103104       
     
    106107                        int amount1, int amount2) {
    107108                node.replaceChild(child, streamBeingAdvanced);
    108                 IntegerConstantNode integerConstantNode = ASTHelpers.makeIntegerConstantNode(amount1+amount2, node.getToken());
     109                IntegerConstantNode integerConstantNode = Util.makeIntegerConstantNode(amount1+amount2, node.getToken());
    109110                if(node.nChildren()==2) {
    110111                        node.appendChild(integerConstantNode);
  • proto/pablo/src/compiler/visitors/AdvanceNCounter.java

    r2410 r2414  
    11package compiler.visitors;
    22
    3 import compiler.ast.ASTHelpers;
     3import compiler.ast.Util;
     4import compiler.lang.pablo.builtins.Builtins;
    45import ast.*;
    56
     
    2526
    2627                public void visitLeave(FunctionInvocationNode node) {
    27                         if(ASTHelpers.isAdvanceN(node)) {
     28                        if(Builtins.isAdvanceN(node)) {
    2829                            this.advNCount += 1;
    2930                        }
  • proto/pablo/src/compiler/visitors/CarryCounter.java

    r2410 r2414  
    33import ast.*;
    44import compiler.ast.*;
     5import compiler.lang.pablo.builtins.Builtins;
    56
    67public class CarryCounter {
     
    2728                public void visitLeave(FunctionInvocationNode node) {
    2829
    29                         if(ASTHelpers.isBuiltInCall(node)) {
     30                        if(Builtins.isBuiltInCall(node)) {
    3031                            carryCount += 1;
    3132                        }
  • proto/pablo/src/compiler/visitors/StreamFunctionVisitor.java

    r2410 r2414  
    77import java.util.*;
    88
    9 import compiler.ast.ASTHelpers;
     9import compiler.ast.Util;
    1010
    1111//class StreamFunctionVisitor(ast.NodeVisitor):
     
    4848                public void visitLeave(FunctionDefNode node) {
    4949                                               
    50                         ASTNode functionNameNode = ASTHelpers.functionName(node);       
     50                        ASTNode functionNameNode = Util.functionName(node);     
    5151                        String functionName = functionNameNode.getToken().getLexeme();
    5252                        functionName = capitalize(functionName);
Note: See TracChangeset for help on using the changeset viewer.