Changeset 3280 for proto/pabloj/trunk


Ignore:
Timestamp:
Jun 7, 2013, 2:50:57 PM (6 years ago)
Author:
ksherdy
Message:

Added initial TempifyCarryBuiltins? visitor.

Location:
proto/pabloj/trunk/src/toolchain
Files:
3 edited
1 moved

Legend:

Unmodified
Added
Removed
  • proto/pabloj/trunk/src/toolchain/pabloS/ast/Generators.java

    r3271 r3280  
    3838        }
    3939       
    40         public static LocalVarDeclNode makeLocalVarDeclNode(Locator locator, ASTNode type, IdentifierNode identifier, ASTNode rhs) {
    41                
     40        public static LocalVarDeclNode makeLocalVarDeclNode(Locator locator, ASTNode type, ASTNode lhs, ASTNode rhs) {         
    4241                Token assignToken = Generators.makeLextantToken(locator, Lextant.ASSIGN);
    43                 LocalVarDeclNode localVarDeclNode = new LocalVarDeclNode(assignToken);
    44                
    45                 localVarDeclNode.appendChild(type);
    46                 localVarDeclNode.appendChild(identifier);
    47                 localVarDeclNode.appendChild(rhs);
    48                
    49                 return localVarDeclNode;
     42                LocalVarDeclNode localVarDecl = new LocalVarDeclNode(assignToken);
     43                localVarDecl.appendChild(type);
     44                localVarDecl.appendChild(lhs);
     45                localVarDecl.appendChild(rhs);
     46                return localVarDecl;
     47        }
     48       
     49        public static AssignNode makeAssignNode(Locator locator, ASTNode lhs, ASTNode rhs) {
     50                Token assignToken = Generators.makeLextantToken(locator, Lextant.ASSIGN);
     51                AssignNode assign = new AssignNode(assignToken);
     52                assign.appendChild(lhs);
     53                assign.appendChild(rhs);
     54                return assign;
    5055        }
    5156       
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/carry/CarryIntroXFormer.java

    r3276 r3280  
    9595                Transformer(Context context, int count1Base, int countNBase) {
    9696                        this.context = context;
    97                         this.carryCounter.setValue(count1Base);
    98                         this.advanceNCounter.setValue(countNBase);
     97                        carryCounter.setValue(count1Base);
     98                        advanceNCounter.setValue(countNBase);
    9999                }
    100100               
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/carry/TempifyCarryBuiltinCalls.java

    r3274 r3280  
    11/*
    2  *
     2 * Converting expressions involving built-ins to compiled form. 
     3 * Applied before carry variable insertion.
     4 *
     5 * @author Ken Herdy <ksherdy at sfu dot ca>
    36 */
    47package toolchain.pabloS.transformer.visitors.carry;
    58
    69import java.util.ArrayList;
     10import java.util.Collections;
    711
    812import pabloS.ast.*;
     
    1317import toolchain.util.Labeller;
    1418
    15 public class TempifyCarryXBuiltins {
     19public class TempifyCarryBuiltinCalls {
    1620       
    1721        static public ASTNode apply(ASTNode ASTree) {
    18                 TempifyCarryXBuiltinsVisitor tempifier = new TempifyCarryXBuiltinsVisitor();
     22                Tempifier tempifier = new Tempifier();
    1923                ASTree.accept(tempifier);
    2024                return ASTree;                 
    2125        }   
    2226   
    23     static private class TempifyCarryXBuiltinsVisitor extends VoidVisitor.Default {
    24                
     27    static private class Tempifier extends VoidVisitor.Default {
     28
    2529        Labeller labeller = new Labeller();
    26         ArrayList<IdentifierNode> temps;
     30        ArrayList<IdentifierNode> carryBuiltinCallTemps = new ArrayList<IdentifierNode>();
     31        ArrayList<AssignNode> carryBuiltinCallAssigns = new ArrayList<AssignNode>();
     32       
     33        Tempifier() {
     34                this(0);
     35        }
     36       
     37        Tempifier(int nextValue) {
     38                labeller.setNextValue(nextValue);
     39        }
    2740       
    2841        public void visitEnter(FuncDefNode node) {
    2942                labeller.reset();
     43                carryBuiltinCallTemps.clear();
     44                carryBuiltinCallAssigns.clear();
    3045        }
    3146
    32         public void visitLeave(FuncDefNode node) {
    33                
    34                 Locator locator = node.getToken();
    35                
    36                 for(IdentifierNode temp : temps) {
    37                        
    38                         StreamTypeNode streamType       = Generators.makeStreamType(locator);
    39                         int fieldWidth                          = Accessors.fieldWidth(streamType);
    40                         ASTNode maskCall                        = Generators.makeMaskFuncCall(locator, fieldWidth, 0);   
    41                         Generators.makeLocalVarDeclNode(locator, streamType, temp, maskCall); // KH: locator location may not make sense
    42                 }
    43                
     47        public void visitEnter(IfStmtNode node) {
     48                ASTNode condition = Accessors.condition(node);
     49                TempifyCarryBuiltinCalls.apply(condition);
     50                makeCarryBuiltinCallAssignNodes(node);
    4451        }
    4552       
     53        public void visitLeave(WhileStmtNode node) {
     54                ASTNode condition = Accessors.condition(node);
     55                TempifyCarryBuiltinCalls.apply(condition);
     56                makeCarryBuiltinCallAssignNodes(node);
     57        }
     58       
     59        public void visitLeave(LocalVarDeclNode node) {
     60                makeCarryBuiltinCallAssignNodes(node);
     61        }
     62       
     63        public void visitLeave(AssignNode node) {
     64                makeCarryBuiltinCallAssignNodes(node);
     65        }
     66                               
     67        public void visitLeave(FuncDefNode node) {
     68                Locator locator = node.getToken();
     69                Collections.reverse(carryBuiltinCallTemps);
     70                for(IdentifierNode temp : carryBuiltinCallTemps) {
     71                        LocalVarDeclNode tempDecl = makeTempLocalVarDecl(locator, temp);
     72                        node.insertChild(tempDecl);
     73                }
     74        }
     75               
     76        public void visitLeave(FuncCallNode node) {
     77                if(isCarryBuiltinCallAndAssignRhs(node)) {
     78                        Locator locator = node.getToken();
     79                        IdentifierNode temp = Generators.makeIdentifierNode(locator, labeller.newLabel());
     80                        AssignNode carryBuiltinCallAssign = Generators.makeAssignNode(locator, temp, node);
     81                       
     82                        carryBuiltinCallTemps.add(temp);
     83                        carryBuiltinCallAssigns.add(carryBuiltinCallAssign);
     84                }
     85        }
    4686       
    47         public void visitLeave(FuncCallNode node) {
    48                
    49                 if(BuiltinCallUtil.isCarry1(node)) {
    50 
    51                 }
    52                
    53                 if(BuiltinCallUtil.isCarryN(node)) {
    54 
    55                 }
    56                
    57                
    58         }
     87                private void makeCarryBuiltinCallAssignNodes(ASTNode node) {
     88                        ASTNode parent = node.getParent();
     89                for(AssignNode assign : carryBuiltinCallAssigns) {
     90                        parent.insertAfterChild(parent.lastChild(), assign);
     91                }
     92                carryBuiltinCallAssigns.clear();
     93                }
     94               
     95                private LocalVarDeclNode makeTempLocalVarDecl(Locator locator, IdentifierNode temp) {
     96                        StreamTypeNode type = Generators.makeStreamType(locator);
     97                        ASTNode lhs = temp;
     98                        ASTNode rhs = Generators.makeMaskFuncCall(locator, Accessors.fieldWidth(type), 0);
     99                        LocalVarDeclNode tempLocalVarDecl = Generators.makeLocalVarDeclNode(locator, type, lhs, rhs);
     100                        return tempLocalVarDecl;
     101                }
     102       
     103        private boolean isCarryBuiltinCallAndAssignRhs(FuncCallNode node) {
     104                return (BuiltinCallUtil.isCarry(node) && Accessors.isAssignmentRhs(node));
     105        }       
    59106    }
    60107}
  • proto/pabloj/trunk/src/toolchain/util/Labeller.java

    r3271 r3280  
    99
    1010public class Labeller {
    11         private long nextNumber = 0;
     11        private long nextValue = 0;
    1212        private String labelBase = "temp_";
    1313       
    1414        public String newLabel() {
    15                 return labelBase + nextNumber++;
     15                return labelBase + nextValue++;
    1616        }
    1717        public void setBase(String baseString) {
     
    1919        }
    2020        public void reset() {
    21                 nextNumber = 0;
     21                nextValue = 0;
     22        }
     23        public void setNextValue(long nextValue) {
     24                nextValue = nextValue;
    2225        }
    2326}
Note: See TracChangeset for help on using the changeset viewer.