Changeset 2394


Ignore:
Timestamp:
Sep 25, 2012, 2:56:58 PM (7 years ago)
Author:
ksherdy
Message:

Refactored AdvanceCombiner?.

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

Legend:

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

    r2392 r2394  
    5656               
    5757                for (Map.Entry<String, ASTNode> entry : streamFunctionMap.entrySet()) {
    58                         System.out.println("BEFORE");
    59                        
    60                         System.out.println(entry.getKey());
    61                         System.out.println(entry.getValue());
    6258                       
    6359                        AdvanceCombiner.transform(entry.getValue());
    6460                       
    65                        
    66                         System.out.println("AFTER");
    67 
    68                         System.out.println(entry.getKey());
    6961                        System.out.println(entry.getValue());
    70 
    7162               
    7263                }
  • proto/pablo/src/compiler/visitors/AdvanceCombiner.java

    r2392 r2394  
    4545                        int amount2 = advanceAmount(child);
    4646                       
    47 //                      System.out.println("amount1=" + amount1);
    48 //                      System.out.println("amount2=" + amount2);
    49 //                      System.out.println("sum=" + (amount1+amount2) );
    50                        
    51                         //ASTNode sum = astForSum(amount1, amount2);
    5247
    53                        
    54                         node.replaceChild(child, streamBeingAdvanced);
    55                         IntegerConstantNode integerConstantNode = Helpers.makeIntegerConstantNode(amount1+amount2, node.getToken());
    56                         if(node.nChildren()==2) {
    57                                 node.appendChild(integerConstantNode);
    58                         }
    59                         assert node.nChildren()==3;
    60                         node.replaceChild(node.child(2), integerConstantNode);
     48                        translateAdvanceNode(node, child, streamBeingAdvanced, amount1,
     49                                        amount2);
    6150                       
    6251                }
    6352               
    64                
    65 //              private ASTNode astForSum(ASTNode amount1, ASTNode amount2) {
    66 //                      Token token = amount1.getToken();       // used for its location only.
    67 //                     
    68 //                      // optimize when both amounts are constant.
    69 //                      // this if can be removed if tree is later subject to an
    70 //                      // optimizer that does this anyway.
    71 //                      if(isIntConstant(amount1) && isIntConstant(amount2)) {
    72 //                              int sum = valueOf(amount1) + valueOf(amount2);
    73 //                              return makeIntegerConstantNode(sum, token);
    74 //                      }
    75 //                     
    76 //                      BinaryOperatorNode sumNode = new BinaryOperatorNode(newPlusToken(token));
    77 //                      sumNode.appendChild(amount1);
    78 //                      sumNode.appendChild(amount2);
    79 //                      return sumNode;
    80 //              }
    81 //              private LextantToken newPlusToken(Token token) {
    82 //                      return makeLextantToken(Lextant.PLUS, token);
    83 //              }
    8453        }
    8554       
     
    9766                return node instanceof IntegerConstantNode;
    9867        }
    99        
    100        
     68               
    10169        ///////////////////////////////////////////////////////////////////
    10270        // intelligence about calls to advance()
     
    10775                assert isAdvance(node);
    10876                return node.child(1);
    109         }
    110         // given that node is an advance, advance by how much?  (expressed as an AST node)
    111 //      private static ASTNode advanceAmount(FunctionInvocationNode node) {
    112 //              assert isAdvance(node);
    113 //              if(node.nChildren()==2) {
    114 //                      return Helpers.makeIntegerConstantNode(1, node.getToken());
    115 //              }
    116 //              assert node.nChildren()==3;
    117 //              return node.child(2);
    118 //      }
    119         private static void updateAdvanceNode(FunctionInvocationNode node, ASTNode streamBeingAdvanced, int amount1, int amount2) {
    120                 assert isAdvance(node);
    121                 node.replaceChild(node.child(1), streamBeingAdvanced);
    122                 IntegerConstantNode integerConstantNode = Helpers.makeIntegerConstantNode(amount1 + amount2, node.getToken());
    123                 node.appendChild(integerConstantNode);
    124 
    12577        }
    12678
     
    14496                return Helpers.isBuiltInCall(node, "Advance");
    14597        }
     98       
     99        private static void translateAdvanceNode(FunctionInvocationNode node,
     100                        FunctionInvocationNode child, ASTNode streamBeingAdvanced,
     101                        int amount1, int amount2) {
     102                node.replaceChild(child, streamBeingAdvanced);
     103                IntegerConstantNode integerConstantNode = Helpers.makeIntegerConstantNode(amount1+amount2, node.getToken());
     104                if(node.nChildren()==2) {
     105                        node.appendChild(integerConstantNode);
     106                }
     107                assert node.nChildren()==3;
     108                node.replaceChild(node.child(2), integerConstantNode);
     109        }
     110       
    146111}
Note: See TracChangeset for help on using the changeset viewer.