Changeset 2397


Ignore:
Timestamp:
Sep 26, 2012, 3:44:38 PM (6 years ago)
Author:
ksherdy
Message:

Refactored 'static' visitors in favour of visitor instances.

Location:
proto/pablo/src/compiler
Files:
4 edited

Legend:

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

    r2395 r2397  
    5454//              System.out.print(syntaxTree);
    5555               
    56                 Map<String, ASTNode> streamFunctionMap = StreamFunctionVisitor.makeStreamFunctionMap(syntaxTree);
     56               
     57                StreamFunctionVisitor streamFunctionVisitor = new StreamFunctionVisitor(syntaxTree);
     58                Map<String, ASTNode> streamFunctionMap = streamFunctionVisitor.makeStreamFunctionMap();
    5759               
    5860                for (Map.Entry<String, ASTNode> entry : streamFunctionMap.entrySet()) {
    5961                       
    60                         //AdvanceCombiner.transform(entry.getValue());
     62                    AdvanceCombiner advanceCombiner = new AdvanceCombiner(entry.getValue());
    6163                        //System.out.println(entry.getValue());
    6264                       
    63                         int carryCount = CarryCounter.count(entry.getValue());
     65                    CarryCounter carryCounter = new CarryCounter(entry.getValue());
    6466                       
    6567                        System.out.println(entry.getKey());
    66                         System.out.println("Carry Count = " + carryCount);
     68                        System.out.println("Carry Count = " + carryCounter.count());
    6769                        System.out.println();
    6870               
  • proto/pablo/src/compiler/visitors/AdvanceCombiner.java

    r2396 r2397  
    66public class AdvanceCombiner {
    77       
    8         public static void transform(ASTNode node) {
    9             AdvanceCombinerVisitor visitor = new AdvanceCombinerVisitor();
    10                 node.accept(visitor);
    11         }
    12        
     8    private ASTNode ASTree;
     9   
     10    public AdvanceCombiner(ASTNode ASTree) {
     11        this.ASTree = ASTree;
     12    }
     13   
     14    public void transform() {
     15        AdvanceCombinerVisitor visitor = new AdvanceCombinerVisitor();
     16        ASTree.accept(visitor);
     17    }   
     18   
    1319        // Original python method optimized calls that look like:
    1420        //              adv(adv(X))             to      adv(X, 2), and
     
    1925        // that pattern and also adv(adv(X, n2), n1).
    2026
    21         private static class AdvanceCombinerVisitor extends VoidVisitor.Default {
     27        private class AdvanceCombinerVisitor extends VoidVisitor.Default {
    2228
    2329                public void visitEnter(IfStatementNode node) {
     30                    // Additional carry logic req'd to support carry combine within If statements
    2431                        node.skipChildren();
    2532                }
    26                 public void visitEnter(WhileStatementNode node) {
     33                public void visitEnter(WhileStatementNode node) {
     34                    // Additional carry logic req'd to support carry combine within While statements
    2735                        node.skipChildren();
    2836                }
     
    5462       
    5563        // given that node is an IntegerConstantNode, what is its value?
    56         private static int valueOf(ASTNode node) {
     64        private int valueOf(ASTNode node) {
    5765                assert node instanceof IntegerConstantNode;
    5866                IntConstantToken token = (IntConstantToken) node.getToken();
     
    6674
    6775        // given that node is an advance, what is the stream being advanced?
    68         private static ASTNode streamBeingAdvanced(FunctionInvocationNode node) {
     76        private ASTNode streamBeingAdvanced(FunctionInvocationNode node) {
    6977                assert isAdvance(node);
    7078                return node.child(1);
    7179        }
    7280
    73         private static int advanceAmount(FunctionInvocationNode node) {
     81        private int advanceAmount(FunctionInvocationNode node) {
    7482                assert isAdvance(node);
    7583                if(node.nChildren()==2) {
     
    8088        }       
    8189       
    82         private static boolean isAdvanceOfAdvance(ASTNode node) {
     90        private boolean isAdvanceOfAdvance(ASTNode node) {
    8391                if(!isAdvance(node))
    8492                        return false;
     
    8795                return isAdvance(child);
    8896        }
    89         private static boolean isAdvance(ASTNode node) {
     97        private boolean isAdvance(ASTNode node) {
    9098                return Helpers.isBuiltInCall(node, "Advance");
    9199        }
    92100       
    93         private static void translateAdvanceNode(FunctionInvocationNode node,
     101        private void translateAdvanceNode(FunctionInvocationNode node,
    94102                        FunctionInvocationNode child, ASTNode streamBeingAdvanced,
    95103                        int amount1, int amount2) {
  • proto/pablo/src/compiler/visitors/CarryCounter.java

    r2396 r2397  
    88public class CarryCounter {
    99       
    10         public static int count(ASTNode node) {
    11             CarryCounterVisitor visitor = new CarryCounterVisitor();
    12                 node.accept(visitor);
    13                 return visitor.carryCount();
    14         }
    15        
    16         private static class CarryCounterVisitor extends VoidVisitor.Default {
     10    private ASTNode ASTree;
     11   
     12    public CarryCounter(ASTNode ASTree) {
     13        this.ASTree = ASTree;
     14    }
     15   
     16    public int count() {
     17        CarryCounterVisitor visitor = new CarryCounterVisitor();
     18        this.ASTree.accept(visitor);
     19        return ((CarryCounterVisitor)visitor).carryCount();
     20    }   
     21       
     22        private class CarryCounterVisitor extends VoidVisitor.Default {
    1723                private int carryCount = 0;
    1824               
    19                 private static Map<String, Integer> funAndArgNum = new LinkedHashMap<String, Integer>();
     25                private final Map<String, Integer> funAndArgNum = new LinkedHashMap<String, Integer>();
    2026                public CarryCounterVisitor() {
    2127                        funAndArgNum.put("Advance", 1);
  • proto/pablo/src/compiler/visitors/StreamFunctionVisitor.java

    r2396 r2397  
    44import tokens.StringConstantToken;
    55import ast.*;
     6
    67import java.util.*;
    78
     
    1718
    1819public class StreamFunctionVisitor {
     20   
     21    private ASTNode ASTree;
     22   
     23    public StreamFunctionVisitor(ASTNode ASTree) {
     24        this.ASTree = ASTree;
     25    }
     26   
     27    public void visit() {
     28        StreamFunctionVisitor1 visitor = new StreamFunctionVisitor1();
     29        ASTree.accept(visitor);
     30    }   
    1931       
    20         public static Map<String, ASTNode> makeStreamFunctionMap(ASTNode node) {
     32        public  Map<String, ASTNode> makeStreamFunctionMap() {
    2133            StreamFunctionVisitor1 visitor = new StreamFunctionVisitor1();
    22                 node.accept(visitor);
     34                ASTree.accept(visitor);
    2335                return ((StreamFunctionVisitor1)visitor).streamFunctionMap();
    2436        }
    2537       
    26         private static class StreamFunctionVisitor1 extends VoidVisitor.Default {
     38        private class StreamFunctionVisitor1 extends VoidVisitor.Default {
    2739               
    2840                private LinkedHashMap<String, ASTNode> streamFunctionMap = new LinkedHashMap<String, ASTNode>();
Note: See TracChangeset for help on using the changeset viewer.