Changeset 3297


Ignore:
Timestamp:
Jun 11, 2013, 5:39:09 PM (6 years ago)
Author:
ksherdy
Message:

Partial Tempify builtins impl.

Location:
proto/pabloj/trunk/src/toolchain/pabloS/transformer
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/Transformer.java

    r3287 r3297  
    5858
    5959               
    60                 // decoratedTree = TempifyCarryBuiltinCalls.apply(decoratedTree);
     60                //decoratedTree = TempifyCarryBuiltinCalls.apply(decoratedTree);
    6161               
    6262                decoratedTree = ExpandAugmentedAssignments.apply(decoratedTree);
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/carry/TempifyCarryBuiltinCalls.java

    r3287 r3297  
    99import java.util.ArrayList;
    1010import java.util.Collections;
     11import java.util.LinkedHashMap;
     12import java.util.Map;
    1113
    1214import pabloS.ast.*;
     
    2931
    3032        Labeller labeller = new Labeller();
    31         ArrayList<IdentifierNode> carryBuiltinCallTemps = new ArrayList<IdentifierNode>();
    32         ArrayList<AssignNode> carryBuiltinCallAssigns = new ArrayList<AssignNode>();
    33        
    34         Tempifier() {
    35                 this(0);
    36         }
    37        
    38         Tempifier(int nextValue) {
    39                 labeller.setNextValue(nextValue);
    40         }
     33        Map<BlockStmtNode, ArrayList<LocalVarDeclNode>> localVarDeclTemps;
     34        Map<BlockStmtNode, ArrayList<AssignNode> > assignStmtTemps;
    4135       
    4236        public void visitEnter(FuncDefNode node) {
    4337                labeller.reset();
    44                 carryBuiltinCallTemps.clear();
    45                 carryBuiltinCallAssigns.clear();
     38            localVarDeclTemps = new LinkedHashMap<BlockStmtNode, ArrayList<LocalVarDeclNode>>();
     39            assignStmtTemps = new LinkedHashMap<BlockStmtNode, ArrayList<AssignNode>>();
    4640        }
    4741       
    48         public void visitLeave(FuncDefNode node) {
    49             Locator locator = node.getToken();
    50             Collections.reverse(carryBuiltinCallTemps);
    51             for(IdentifierNode temp : carryBuiltinCallTemps) {
    52                 LocalVarDeclNode tempDecl = makeTempLocalVarDecl(locator, temp);
    53                 Accessors.blockStmtNode(node).insertChild(tempDecl);
     42        public void visitEnter(BlockStmtNode node) {
     43            labeller.reset();
     44        }
     45       
     46        public void visitLeave(BlockStmtNode node) {
     47           
     48            if(assignStmtTemps.containsKey(node)) {
     49                Collections.reverse(assignStmtTemps.get(node));
     50                for(AssignNode assignStmt : assignStmtTemps.get(node)) {
     51                    node.insertChild(assignStmt);
     52                }
     53                assignStmtTemps.remove(node);
     54            }
     55           
     56            if(localVarDeclTemps.containsKey(node)) {
     57                Collections.reverse(localVarDeclTemps.get(node));
     58                for(LocalVarDeclNode localVarDecl : localVarDeclTemps.get(node)) {
     59                    node.insertChild(localVarDecl);
     60                }
     61                localVarDeclTemps.remove(node);
    5462            }
    5563        }
    56        
    57         public void visitLeave(BlockStmtNode node) {
    58             insertAssignsAfterNode(node);
     64
     65        public void visitLeave(FuncCallNode node) {
     66                if(BuiltinCallUtil.isCarry(node)) {
     67                   
     68                    BlockStmtNode blockStmt          = (BlockStmtNode)getEnclosingBlockStmt(node);
     69                        Locator locator                  = blockStmt.getToken();
     70                        IdentifierNode name              = Generators.makeIdentifierNode(locator, labeller.newLabel());
     71                        LocalVarDeclNode localVarDecl    = makeTempLocalVarDecl(locator, name);
     72                        AssignNode assignStmt            = Generators.makeAssignNode(locator, name, node);
     73                       
     74                        bindLocalVarDeclToBlockStmt(blockStmt, localVarDecl);
     75                bindAssignStmtToBlockStmt(blockStmt, assignStmt);
     76                       
     77                }
     78        }
     79
     80        private void bindAssignStmtToBlockStmt(BlockStmtNode blockStmt,
     81                AssignNode assignStmt) {
     82            if(!assignStmtTemps.containsKey(blockStmt)) {
     83                assignStmtTemps.put(blockStmt, new ArrayList<AssignNode>());
     84            }
     85            ArrayList<AssignNode> assignStmtList = assignStmtTemps.get(blockStmt);
     86            assignStmtList.add(assignStmt);
    5987        }
    6088
    61         public void visitLeave(IfStmtNode node) {
    62                 //ASTNode condition = Accessors.condition(node);
    63                 //TempifyCarryBuiltinCalls.apply(condition);
    64                 //insertAssignsBeforeNode(node);
     89        private void bindLocalVarDeclToBlockStmt(BlockStmtNode blockStmt,
     90                LocalVarDeclNode localVarDecl) {
     91            if(!localVarDeclTemps.containsKey(blockStmt)) {
     92                localVarDeclTemps.put(blockStmt, new ArrayList<LocalVarDeclNode>());
     93            }
     94            ArrayList<LocalVarDeclNode> localVarDeclList = localVarDeclTemps.get(blockStmt);
     95            localVarDeclList.add(localVarDecl);
     96        }
     97       
     98        private boolean hasEnclosingBlockStmt(ASTNode node) {
     99           
     100            ASTNode current = node.getParent();
     101           
     102            while(current != ASTNode.NO_PARENT) {
     103                if(current instanceof BlockStmtNode) {
     104                    return true;
     105                }
     106                current = current.getParent();
     107            }
     108           
     109            return false;
     110           
     111        }       
     112       
     113        private ASTNode getEnclosingBlockStmt(ASTNode node) {
     114           
     115            ASTNode current = node.getParent();
     116           
     117            while(current != ASTNode.NO_PARENT) {
     118                if(current instanceof BlockStmtNode) {
     119                    return current;
     120                }
     121                current = current.getParent();
     122            }
     123
     124            assert false: "getEnclosingBlockStmt() called on node of improper type.";
     125            return ASTNode.NO_PARENT; // KH: ASTNODE.NO_ANCESTOR ?
     126           
    65127        }
    66128       
    67         public void visitLeave(WhileStmtNode node) {
    68                 //ASTNode condition = Accessors.condition(node);
    69                 //TempifyCarryBuiltinCalls.apply(condition);
    70                 //insertAssignsBeforeNode(node);
    71         }
    72        
    73         public void visitLeave(LocalVarDeclNode node) {
    74             //insertAssignsBeforeNode(node);
    75         }
    76        
    77         public void visitLeave(AssignNode node) {
    78             //insertAssignsBeforeNode(node);
    79         }
    80                                
    81 
    82         public void visitLeave(FuncCallNode node) {
    83                 if(isCarryBuiltinCallAndAssignRhs(node)) {
    84                         Locator locator = node.getToken();
    85                         IdentifierNode temp = Generators.makeIdentifierNode(locator, labeller.newLabel());
    86                         AssignNode carryBuiltinCallAssign = Generators.makeAssignNode(locator, temp, node);
    87                        
    88                         carryBuiltinCallTemps.add(temp);
    89                         carryBuiltinCallAssigns.add(carryBuiltinCallAssign);
    90 
    91                 }
    92         }
    93        
    94                 private void insertAssignsAfterNode(ASTNode node) {
    95                 for(AssignNode assign : carryBuiltinCallAssigns) {
    96                         node.insertBeforeChild(node.child(0), assign);
    97                 }
    98                 carryBuiltinCallAssigns.clear();
    99                 }
    100                
    101129                private LocalVarDeclNode makeTempLocalVarDecl(Locator locator, IdentifierNode temp) {
    102130                        StreamTypeNode streamType = Generators.makeStreamType(locator);
     
    107135                        return tempLocalVarDecl;
    108136                }
    109        
    110         private boolean isCarryBuiltinCallAndAssignRhs(FuncCallNode node) {
    111                 return (BuiltinCallUtil.isCarry(node) && Accessors.isAssignmentRhs(node));
    112         }       
    113137    }
     138   
     139  //KH: messes up iterator, infinite loop
     140//  public void visitLeave(IfStmtNode node) {
     141//      ASTNode condition = Accessors.condition(node);
     142//      TempifyCarryBuiltinCalls.apply(condition);
     143//      insertAssignsBeforeNode(node);
     144//  }
     145// 
     146//  public void visitLeave(WhileStmtNode node) {
     147//      ASTNode condition = Accessors.condition(node);
     148//      TempifyCarryBuiltinCalls.apply(condition);
     149//      insertAssignsBeforeNode(node);
     150//  }
     151// 
     152//  public void visitLeave(LocalVarDeclNode node) {
     153//      insertAssignsBeforeNode(node);
     154//  }
     155// 
     156//  public void visitLeave(AssignNode node) {
     157//      insertAssignsBeforeNode(node);
     158//  }
     159 
     160//KH: messes up iterator, infinite loop
     161//
     162//private void insertAssignsBeforeNode(ASTNode node) {
     163//    for(AssignNode assign : carryBuiltinCallAssigns) {
     164//        Mutators.insertStatementBefore(node, assign);
     165//    }
     166//    carryBuiltinCallAssigns.clear();
     167//}   
    114168}
    115169
Note: See TracChangeset for help on using the changeset viewer.