Changeset 3117 for proto/pabloj


Ignore:
Timestamp:
May 6, 2013, 2:44:15 PM (6 years ago)
Author:
shermer
Message:

Fixed warnings in PabloS2PabloB.
changed BuiltinTranslatorImp? to BuiltinTranslator?.
cleaning up in CarryIntroXFormer...still in progress.

Location:
proto/pabloj/branches/refactor-experimental
Files:
2 added
4 edited
1 moved

Legend:

Unmodified
Added
Removed
  • proto/pabloj/branches/refactor-experimental

    • Property svn:ignore
      •  

        old new  
        1 .classpath
        2 .project
         1bin
  • proto/pabloj/branches/refactor-experimental/src/toolchain/pabloS/semanticAnalyzer/visitors/PabloS2PabloBXFormer.java

    r3115 r3117  
    1313import pabloB.ast.ASTNode;
    1414import pabloB.ast.FuncCallNode;
    15 import pabloB.ast.IdentifierNode;
    1615import pabloS.ast.ASTVisitor.Default;
    17 import pabloS.lexicalAnalyzer.LexicalType;
    1816import pabloS.lexicalAnalyzer.Lextant;
    19 import pabloS.tokens.IntConstantToken;
    20 import pabloS.tokens.Token;
    2117import toolchain.pabloB.ast.Generators;
    2218import toolchain.pabloB.lang.carrySet.CarrySetEncoder;
  • proto/pabloj/branches/refactor-experimental/src/toolchain/pabloS/semanticAnalyzer/visitors/carry/BuiltinTranslator.java

    r3115 r3117  
    11package toolchain.pabloS.semanticAnalyzer.visitors.carry;
    22
     3import java.util.ArrayList;
    34import java.util.List;
    45
     
    1213import toolchain.pabloS.lang.PabloSBuiltinsUtil;
    1314
    14 public enum BuiltinTranslatorImp {
     15public enum BuiltinTranslator {
    1516        ADVANCE(PabloSBuiltins.ADVANCE),
    1617        SCANTHRU(PabloSBuiltins.SCANTHRU),
     
    3940        private PabloSBuiltins builtin;
    4041        private boolean usesAdvanceNCounter;
    41         private BuiltinTranslatorImp.Action actionSelector;
     42        private BuiltinTranslator.Action actionSelector;
    4243       
    4344       
    44         private BuiltinTranslatorImp(PabloSBuiltins builtin, BuiltinTranslatorImp.Action actionSelector) {
     45        private BuiltinTranslator(PabloSBuiltins builtin, BuiltinTranslator.Action actionSelector) {
    4546                this.builtin = builtin;
    46                 this.usesAdvanceNCounter = (builtin.getCarryType()==CarryType.N);
     47                this.usesAdvanceNCounter = (builtin.getCarryType()==CarryType.N);       
    4748                this.actionSelector = actionSelector;
    4849        }               
    49         private BuiltinTranslatorImp(PabloSBuiltins builtin) {
     50        private BuiltinTranslator(PabloSBuiltins builtin) {
    5051                this(builtin, Action.CARRY_ACTION);
    5152        }
     
    8485                List<ASTNode> arguments = Accessors.funcCallArgsList(node);
    8586               
    86                 CarryIntroXFormer.replaceFuncCallWithCarryCallNode(node,
     87                replaceCallWithCarryCall(node,
    8788                                context.getCarrySetIdentifier(),
    8889                                context.getBuiltinEncoder().getCode(getBuiltin()),
     
    116117                String formattedAdvanceN = String.format(context.getBuiltinEncoder().getCode(getBuiltin()), value);
    117118
    118                 CarryIntroXFormer.replaceFuncCallWithCarryCallNode(node,
     119                replaceCallWithCarryCall(node,
    119120                                context.getCarrySetIdentifier(),
    120121                                formattedAdvanceN,
     
    145146        public void maskAction(FuncCallNode node, Counter counter, Context context) {
    146147                node.updateSelf(Counter.mask(node));
     148        }
     149        /*
     150         * Makes CarrySet builtin call.
     151         * e.g. Advance(X,Y,Z) => carry_set_n.Advance(X,Y,Z,foo,carryInt)
     152         */
     153        static void replaceCallWithCarryCall(FuncCallNode node,
     154                        String carryIdentifier, String carryBuiltin,
     155                        List<ASTNode> arguments,
     156                        ASTNode call, IntegerConstantNode carry) {
     157       
     158                List<ASTNode> args = new ArrayList<ASTNode>(arguments);
     159                args.add(call);
     160                args.add(carry);
     161               
     162                FuncCallNode replacementNode = Generators.makeFuncCallNode(
     163                                new String [] {carryIdentifier, carryBuiltin},
     164                                node,
     165                                args);
     166               
     167                node.updateSelf(replacementNode);
    147168        }       
    148169}
  • proto/pabloj/branches/refactor-experimental/src/toolchain/pabloS/semanticAnalyzer/visitors/carry/CarryIntroXFormer.java

    r3115 r3117  
    11package toolchain.pabloS.semanticAnalyzer.visitors.carry;
    22
    3 import java.util.ArrayList;
    4 import java.util.List;
    53
    64import pabloS.ast.*;
     
    6361 */
    6462
    65 public class CarryIntroXFormer {
    66                
     63public class CarryIntroXFormer {       
    6764        private ASTNode ASTTree;       
    6865        private BuiltinEncoder builtinEncoder;
    6966        private CarrySetEncoder carrySetEncoder;
    70        
    71         private int carrySetDepth;
    72         private String carrySetIdentifier;             
    73        
     67
    7468    public CarryIntroXFormer(ASTNode node, BuiltinEncoder builtinEncoder, CarrySetEncoder carrySetEncoder) {
    7569        this.ASTTree = node;
     
    7872    }   
    7973
    80 
    8174    public void XForm(boolean finalBlockMode, boolean ciMode, int carrySetDepth) {
    82         setCarrySetDepth(carrySetDepth);           
    83         setCarrySetIdentifier(CarrySetEncoder.CARRYSET_BASENAME_PREFIX + getCarrySetDepth());
    84        
    85         XFormer visitor = new XFormer();
    86                 setFinalBlockMode(finalBlockMode);
    87                 visitor.setCiMode(ciMode);
     75        Context context = new Context(ciMode, finalBlockMode, builtinEncoder, carrySetEncoder, carrySetDepth); 
     76        XFormer visitor = new XFormer(context);
    8877                ASTTree.accept(visitor);
    89     }             
    90     public void XForm(boolean finalBlockMode, int carrySetDepth) {
    91         XForm(finalBlockMode, true, carrySetDepth);
    92     }
    93     public void XForm(boolean finalBlockMode, boolean ciMode) {
    94         XForm(finalBlockMode, ciMode, 0);
    95     }                   
     78    }                   
    9679    public void XForm(boolean finalBlockMode) {
    9780        XForm(finalBlockMode, true, 0);
    9881    }
    9982   
    100     /////////////////////////////////////////////////////////////////
    101     // getters and setters
    102         private int getCarrySetDepth() {
    103                 return carrySetDepth;
    104         }
    105 
    106         private void setCarrySetDepth(int carrySetDepth) {
    107                 this.carrySetDepth = carrySetDepth;
    108         }
    109 
    110         private String getCarrySetIdentifier() {
    111                 return carrySetIdentifier;
    112         }
    113 
    114         private void setCarrySetIdentifier(String carrySetIdentifier) {
    115                 this.carrySetIdentifier = carrySetIdentifier;
    116         }
     83   
     84    private class XFormer extends VoidVisitor.Default {
     85        private Context context;
     86        private Counter carryCount    = new Counter(CarrySetBuiltins.GETCARRY);
     87        private Counter advanceNCount = new Counter(CarrySetBuiltins.PENDING64);
    11788       
    118     private Counter carryCount = new Counter(CarrySetBuiltins.GETCARRY);
    119         private Counter advanceNCount = new Counter(CarrySetBuiltins.PENDING64);
    120        
    121         private boolean finalBlockMode;
    122         protected boolean isFinalBlockMode() {
    123                 return finalBlockMode;
    124         }
    125 
    126         protected void setFinalBlockMode(boolean finalBlockMode) {
    127                 this.finalBlockMode = finalBlockMode;
    128         }
    129        
    130         private class XFormer extends VoidVisitor.Default {
    131 
    132                 //private final String ciSuffix = "_ci";
    133                 //private final String coSuffix = "_co";
    134                 //private String [] pendindCarryQName = {CarryQ.CarryQ_PACKAGE_NAME, CarryQ.GETCARRYIN.cPPCode()};
    135                 //private String [] pending64QName = {CarryQ.CarryQ_PACKAGE_NAME, CarryQ.GETPENDING64.cPPCode()};
    136                
    137                 private boolean ciMode;
    138                 //private boolean coMode;
    139                
    140                 //private int lastStmtCarries;
    141        
    142                 XFormer(/*boolean finalBlockModeboolean ciMode , boolean coMode */) {
    143                        
    144                         setFinalBlockMode(false);                                                       
    145                         ciMode = true;                 
    146                         // this.coMode = coMode;
     89                XFormer(Context context) {
     90                        this.context = context;
    14791                       
    14892                        carryCount.reset();
    149                         advanceNCount.reset();
    150                         //this.lastStmtCarries = 0;                                     
    151                 }
    152                 protected boolean isCiMode() {
    153                         return ciMode;
    154                 }
    155 
    156                 protected void setCiMode(boolean ciMode) {
    157                         this.ciMode = ciMode;
    158                 }
     93                        advanceNCount.reset();                                 
     94                }
     95               
    15996
    16097                // xFormers
     
    175112                        //this.lastStmtCarries = 0;
    176113                       
    177                         int carry1Count = (new CarryCounterVisitor(node)).carry1Count();
    178                         int carryNCount = (new CarryCounterVisitor(node)).carryNCount();
     114                       
     115                        CarryCounterVisitor carryCounter = new CarryCounterVisitor(node);
     116                        int carry1Count = carryCounter.carry1Count();
     117                        int carryNCount = carryCounter.carryNCount();
    179118                       
    180119                        if(carry1Count > 0) { 
     
    182121                               
    183122                                FuncCallNode carryAdjustFuncCall = (FuncCallNode) Generators.makeFuncCallNode(
    184                                                 new String [] { getCarrySetIdentifier(), carrySetEncoder.getCode(CarrySetBuiltins.CARRYADJUST)},
    185                                                                                 node.getToken(),
     123                                                                                carrySetFunction(CarrySetBuiltins.CARRYADJUST),
     124                                                                                node,
    186125                                                                                carry1CountNode);
    187126                               
    188127                                BlockStmtNode blockStmtNode = Accessors.blockStmtNode(node);
    189                                 if(!isFinalBlockMode()) {
     128                                if(!context.getFinalBlockMode()) {
    190129                                        blockStmtNode.appendChild(carryAdjustFuncCall);
    191130                                }       
    192131                        }                       
    193132                       
    194                         IdentifierNode carrySetIdentifierNode   =       Generators.makeIdentifierNode(getCarrySetIdentifier(), node.getToken());
     133                        IdentifierNode carrySetIdentifierNode   =       Generators.makeIdentifierNode(context.getCarrySetIdentifier(), node.getToken());
    195134                        IntegerConstantNode carry1CountNode     =       Generators.makeIntegerConstantNode(carry1Count, node.getToken());
    196135                        IntegerConstantNode carryNCountNode     =       Generators.makeIntegerConstantNode(carryNCount, node.getToken());
     
    199138                                                                = (FuncCallNode) Generators.makeFuncCallNode(
    200139                                                                        carrySetEncoder.getCode(CarrySetBuiltins.CARRYDECLARE),
    201                                                                         node.getToken(),
     140                                                                        node,
    202141                                                                        new ASTNode [] {carrySetIdentifierNode, carry1CountNode, carryNCountNode});
    203142                       
    204143                        node.appendChild(carryDeclareFuncCall);
    205144               
    206                 }               
     145                }
     146
     147
    207148               
    208149                public void visitLeave(FuncDefNode node) {
    209                         if(isFinalBlockMode()) {
     150                        if(context.getFinalBlockMode()) {
    210151                                ParameterNode EOFMaskParameter = Generators.makeEOFMaskParameter(builtinEncoder, node.getToken());
    211152                                Generators.appendParameter(node, EOFMaskParameter);
     
    215156                //public void visitLeave(FuncCallNode node) {
    216157                //      if(BuiltinsUtil.isCarryOne(node)) {
    217                 //              this.currentCarry += 1;
     158                //              carryCount.increment();
    218159                //      }                                       
    219160                //}
    220161               
    221162                public void visitLeave(FuncCallNode node) {
    222                         Context context = new Context(ciMode, finalBlockMode, builtinEncoder, carrySetEncoder, carrySetIdentifier);
    223163                        boolean translated = false;
    224                         for(BuiltinTranslatorImp translator: BuiltinTranslatorImp.values()) {
     164                        for(BuiltinTranslator translator: BuiltinTranslator.values()) {
    225165                                if (translator.isCall(node)) {
    226166                                        translator.action(node, carryCount, advanceNCount, context);
     
    266206                        }
    267207                       
    268                         if(!this.isCiMode()) { // not in the context of the 1st iteration of a while loop
     208                        if(!this.context.getCarryInMode()) { // not in the context of the 1st iteration of a while loop
    269209                                return;
    270210                        }
     
    279219                        // else part, append CarryDequeueEnqueue call
    280220                        FuncCallNode carryDequeueEnqueue = (FuncCallNode) Generators.makeFuncCallNode(
    281                                                                 new String [] {getCarrySetIdentifier(), carrySetEncoder.getCode(CarrySetBuiltins.CARRYDEQUEUEENQUEUE)},
     221                                                                carrySetFunction(CarrySetBuiltins.CARRYDEQUEUEENQUEUE),
    282222                                                                node.getToken(),
    283223                                                                carryBaseNode, carryCountNode);
     
    304244                        //          local_carryvar = 'sub' + self.carryvar.id
    305245                       
    306                         if(isFinalBlockMode()) {
     246                        if(context.getFinalBlockMode()) {
    307247                                ASTNode whileConditionNode = Accessors.whileTest(node);
    308248                                ASTNode replacementNode = Generators.makeSIMDAndEOFMaskFuncCall(whileConditionNode, builtinEncoder);
     
    320260                        assert (carryNCount == 0): "Advance(x,n) illegal within an if statement \n";
    321261
    322                         IdentifierNode carrySetIdentifierNode = Generators.makeIdentifierNode(carrySetIdentifier, node.getToken());
     262                        IdentifierNode carrySetIdentifierNode = Generators.makeIdentifierNode(context.getCarrySetIdentifier(), node.getToken());
    323263                       
    324264                        IntegerConstantNode carryBaseNode       =       Generators.makeIntegerConstantNode(carryBase, node.getToken());
     
    346286                        WhileStmtNode innerWhile = node.deepCopy();
    347287                        CarryIntroXFormer xFormer = new CarryIntroXFormer(Accessors.whileBlockStmt(innerWhile), builtinEncoder, carrySetEncoder);
    348                         xFormer.XForm(isFinalBlockMode(), false, (getCarrySetDepth() + 1));     
     288                        xFormer.XForm(context.getFinalBlockMode(), false, (context.getCarrySetDepth() + 1));   
    349289                       
    350290                        IdentifierNode localCarrySetIdentifierNode = Generators.makeIdentifierNode(
    351                                         xFormer.getCarrySetIdentifier(),
    352                                         node.getToken());
    353 
    354                         /*
     291//next arg was:         xFormer.context.getCarrySetIdentifier(),
     292                                        context.getCarrySetIdentifier(context.getCarrySetDepth()+1),
     293                                        node);
     294
     295                                /*
    355296                        CompoundIdentifierNode localCarrySetArrayIdentifierNode = Generators.makeCompoundIdentifierNode(
    356297                                        new String [] {xFormer.context.getCarrySetIdentifier(), CarrySetBuiltins2Lang.CARRYQARRAYNAME},
     
    383324                        ASTNode ifTest = Accessors.whileTest(node).deepCopy();
    384325                       
    385                         if(!isCiMode()) {
     326                        if(!context.getCarryInMode()) {
    386327                                ifTest = Accessors.whileTest(node).deepCopy();
    387328                        } else {                               
     
    395336                       
    396337                        FuncCallNode carryDequeueEnqueue = (FuncCallNode) Generators.makeFuncCallNode(
    397                                         new String [] {carrySetIdentifier, carrySetEncoder.getCode(CarrySetBuiltins.CARRYDEQUEUEENQUEUE)},
     338                                                                        carrySetFunction(CarrySetBuiltins.CARRYDEQUEUEENQUEUE),
    398339                                                                        node.getToken(),
    399340                                                                        carryBaseNode, carry1CountNode);
     
    429370                       
    430371                        FuncCallNode rhs = (FuncCallNode) Generators.makeFuncCallNode(
    431                                         new String [] {getCarrySetIdentifier(), carrySetEncoder.getCode(CarrySetBuiltins.CARRYRANGE)},
     372                                                                        carrySetFunction(CarrySetBuiltins.CARRYRANGE),
    432373                                                                        lhs,
    433374                                                                        carryBaseNode, carryCountNode);
     
    437378                        return replacementIfTestNode;
    438379                }
    439         }
    440         /*
    441          * Makes CarrySet builtin call.
    442          * e.g. Advance(X,Y,Z) => carry_set_n.Advance(X,Y,Z,foo,carry
    443          */
    444         static void replaceFuncCallWithCarryCallNode(FuncCallNode node,
    445                         String carryIdentifier, String carryBuiltin,
    446                         List<ASTNode> arguments,
    447                         ASTNode call, IntegerConstantNode carry) {
    448 
    449                 List<ASTNode> args = new ArrayList<ASTNode>(arguments);
    450                 args.add(call);
    451                 args.add(carry);
    452                
    453                 FuncCallNode replacementNode = Generators.makeFuncCallNode(
    454                                 new String [] {carryIdentifier, carryBuiltin},
    455                                 node,
    456                                 args);
    457                
    458                 node.updateSelf(replacementNode);
     380
     381                // gives the proper array of strings for a carrySetBuiltin call.
     382                private String[] carrySetFunction(CarrySetBuiltins carrySetBuiltin) {
     383                        return new String [] { 
     384                                        context.getCarrySetIdentifier(),
     385                                        context.getCarrySetEncoder().getCode(carrySetBuiltin)
     386                        };
     387                }               
    459388        }
    460389}       
  • proto/pabloj/branches/refactor-experimental/src/toolchain/pabloS/semanticAnalyzer/visitors/carry/Context.java

    r3115 r3117  
    1010        final private BuiltinEncoder builtinEncoder;
    1111        final private CarrySetEncoder carrySetEncoder;
    12         final private String carrySetIdentifier;
     12        final private int carrySetDepth;
    1313       
    1414        public Context(boolean carryInMode, boolean finalBlockMode,
    15                         BuiltinEncoder builtinEncoder, CarrySetEncoder carrySetEncoder, String carrySetIdentifier) {
     15                        BuiltinEncoder builtinEncoder, CarrySetEncoder carrySetEncoder,
     16                        int carrySetDepth) {
    1617                super();
    1718                this.carryInMode = carryInMode;
     
    1920                this.builtinEncoder = builtinEncoder;
    2021                this.carrySetEncoder = carrySetEncoder;
    21                 this.carrySetIdentifier = carrySetIdentifier;
     22                this.carrySetDepth = carrySetDepth;
    2223        }
    2324       
     
    3435                return carrySetEncoder;
    3536        }
     37        public final int getCarrySetDepth() {
     38                return carrySetDepth;
     39        }
    3640        public final String getCarrySetIdentifier() {
    37                 return carrySetIdentifier;
     41                return getCarrySetIdentifier(carrySetDepth);
     42        }
     43        public final String getCarrySetIdentifier(int depth) {
     44                return CarrySetEncoder.CARRYSET_BASENAME_PREFIX + depth;
    3845        }
    3946}
Note: See TracChangeset for help on using the changeset viewer.