Changeset 2394

Timestamp:

Sep 25, 2012, 2:56:58 PM (7 years ago)

Author:

ksherdy

Message:

Refactored AdvanceCombiner?.

Location:

proto/pablo/src/compiler

Files:

• PabloCompiler.java (modified) (1 diff)
• visitors/AdvanceCombiner.java (modified) (4 diffs)

proto/pablo/src/compiler/PabloCompiler.java

@@ -56 +56 @@
                 
                 for (Map.Entry<String, ASTNode> entry : streamFunctionMap.entrySet()) {
-                        System.out.println("BEFORE");
-                        
-                        System.out.println(entry.getKey());
-                        System.out.println(entry.getValue());
                         
                         AdvanceCombiner.transform(entry.getValue());
                         
-                        
-                        System.out.println("AFTER");
-
-                        System.out.println(entry.getKey());
                         System.out.println(entry.getValue());
-
                 
                 }

proto/pablo/src/compiler/visitors/AdvanceCombiner.java

@@ -45 +45 @@
                         int amount2 = advanceAmount(child);
                         
-//                      System.out.println("amount1=" + amount1);
-//                      System.out.println("amount2=" + amount2);
-//                      System.out.println("sum=" + (amount1+amount2) );
-                        
-                        //ASTNode sum = astForSum(amount1, amount2);
 
-                        
-                        node.replaceChild(child, streamBeingAdvanced);
-                        IntegerConstantNode integerConstantNode = Helpers.makeIntegerConstantNode(amount1+amount2, node.getToken());
-                        if(node.nChildren()==2) {
-                                node.appendChild(integerConstantNode);
-                        }
-                        assert node.nChildren()==3;
-                        node.replaceChild(node.child(2), integerConstantNode);
+                        translateAdvanceNode(node, child, streamBeingAdvanced, amount1,
+                                        amount2);
                         
                 }
                 
-                
-//              private ASTNode astForSum(ASTNode amount1, ASTNode amount2) {
-//                      Token token = amount1.getToken();       // used for its location only.
-//                      
-//                      // optimize when both amounts are constant.
-//                      // this if can be removed if tree is later subject to an
-//                      // optimizer that does this anyway.
-//                      if(isIntConstant(amount1) && isIntConstant(amount2)) {
-//                              int sum = valueOf(amount1) + valueOf(amount2);
-//                              return makeIntegerConstantNode(sum, token);
-//                      }
-//                      
-//                      BinaryOperatorNode sumNode = new BinaryOperatorNode(newPlusToken(token));
-//                      sumNode.appendChild(amount1);
-//                      sumNode.appendChild(amount2);
-//                      return sumNode;
-//              }
-//              private LextantToken newPlusToken(Token token) {
-//                      return makeLextantToken(Lextant.PLUS, token);
-//              }
         }
         
@@ -97 +66 @@
                 return node instanceof IntegerConstantNode;
         }
-        
-        
+                
         ///////////////////////////////////////////////////////////////////
         // intelligence about calls to advance()
@@ -107 +75 @@
                 assert isAdvance(node);
                 return node.child(1);
-        }
-        // given that node is an advance, advance by how much?  (expressed as an AST node)
-//      private static ASTNode advanceAmount(FunctionInvocationNode node) {
-//              assert isAdvance(node);
-//              if(node.nChildren()==2) {
-//                      return Helpers.makeIntegerConstantNode(1, node.getToken());
-//              }
-//              assert node.nChildren()==3;
-//              return node.child(2);
-//      }
-        private static void updateAdvanceNode(FunctionInvocationNode node, ASTNode streamBeingAdvanced, int amount1, int amount2) {
-                assert isAdvance(node);
-                node.replaceChild(node.child(1), streamBeingAdvanced);
-                IntegerConstantNode integerConstantNode = Helpers.makeIntegerConstantNode(amount1 + amount2, node.getToken());
-                node.appendChild(integerConstantNode);
-
         }
 
@@ -144 +96 @@
                 return Helpers.isBuiltInCall(node, "Advance");
         }
+        
+        private static void translateAdvanceNode(FunctionInvocationNode node,
+                        FunctionInvocationNode child, ASTNode streamBeingAdvanced,
+                        int amount1, int amount2) {
+                node.replaceChild(child, streamBeingAdvanced);
+                IntegerConstantNode integerConstantNode = Helpers.makeIntegerConstantNode(amount1+amount2, node.getToken());
+                if(node.nChildren()==2) {
+                        node.appendChild(integerConstantNode);
+                }
+                assert node.nChildren()==3;
+                node.replaceChild(node.child(2), integerConstantNode);
+        }
+        
 }