Changeset 2961


Ignore:
Timestamp:
Mar 23, 2013, 7:43:24 PM (4 years ago)
Author:
ksherdy
Message:

Refactored carry intro xformer.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • proto/pabloj/trunk/src/compilers/pabloS/semanticAnalyzer/visitors/CarryIntroXFormer.java

    r2952 r2961  
    88import pabloS.lexicalAnalyzer.Lextant;
    99
    10 import compilers.pabloB.lang.carry.CarryBuiltins2Lang;
     10import compilers.pabloB.lang.carrySet.CarrySetBuiltins;
     11import compilers.pabloB.lang.carrySet.CarrySetBuiltins2Lang;
    1112import compilers.pabloB.lang.idisa.SIMD;
    1213import compilers.pabloS.ast.Accessors;
     
    1516
    1617/*
    17  * Translates carry dependent PabloS language features to PabloB. The translation process
    18  * parameterized on 'carry' mode and 'final-block' mode.
    19  *
    20  * Target language independent Carry Set builtins calls are appended to the PabloB
    21  * AST in the translation of PabloS 'if' and PabloS 'while' statements translated in
    22  * 'carry-in' mode.
    23  *
    24  * By default, carry-in and carry-out mode are enabled
    25  * for translation of PabloS language constructs
    26  * to PabloB constructs.
    27  *
    28  * For example,
     18 * Translates PabloS builtins and language features to PabloB.
     19 *
     20 * Translation of PabloS builtin depends upon 'final-block' and 'carry' mode.
     21 *
     22 * PabloB carry builtins are appended to the PabloS AST for translation to PabloB.
    2923 *
    3024 * PabloS if statements translate to PabloB syntax as follows.
     
    3832 * if (E) { S* } => if (E) { S* }
    3933 *
    40  * Carry-in mode is enable in the initial iteration of while loops.
    41  * Carry-in mode is disable for the translation of subsequent while loop iterations.
     34 * Carry-in mode is enabled for the initial iteration of while loops.
     35 * Carry-in mode is disabled for the translation of subsequent while loop iterations.
     36 *
    4237 *
    4338 * PabloS while statements translate to PabloB syntax as follows.
     
    6055 *
    6156 * 'carry-in' disabled
     57 *
     58 * e.g. Nested while loops.
     59 *
    6260 *
    6361 * Final-block mode.
     
    7169        private ASTNode ASTTree;       
    7270        private Builtins2Lang builtins2Lang;
    73         private CarryBuiltins2Lang carrySet2Lang;
    74        
    75     public CarryIntroXFormer(ASTNode node, Builtins2Lang builtins2Lang, CarryBuiltins2Lang carrySet2Lang) {
     71        private CarrySetBuiltins2Lang carrySet2Lang;
     72       
     73        private int carrySetDepth;
     74        private String carrySetIdentifier;             
     75       
     76    public CarryIntroXFormer(ASTNode node, Builtins2Lang builtins2Lang, CarrySetBuiltins2Lang carrySet2Lang) {
    7677        this.ASTTree = node;
    7778        this.builtins2Lang = builtins2Lang;
    7879        this.carrySet2Lang = carrySet2Lang;
    7980    }   
     81   
     82    public void XForm(boolean finalBlockMode) {
     83        XForm(finalBlockMode, 0);
     84    }
     85   
     86    public void XForm(boolean finalBlockMode, boolean ciMode) {
     87        XForm(finalBlockMode, ciMode, 0);
     88    }
    8089       
    81     public void XForm(boolean finalBlockMode) {
    82                 XFormer visitor = new XFormer();
     90    public void XForm(boolean finalBlockMode, int carrySetDepth) {
     91        setCarrySetDepth(carrySetDepth);           
     92        setCarrySetIdentifier(CarrySetBuiltins2Lang.CARRYSET_BASENAME_PREFIX + Integer.toString(getCarrySetDepth()));
     93
     94        XFormer visitor = new XFormer();
    8395                visitor.setFinalBlockMode(finalBlockMode);
    8496                ASTTree.accept(visitor);
    8597    }                   
    8698
    87     public void XForm(boolean finalBlockMode, boolean ciMode, String carrySetIdentifier) {
    88                 XFormer visitor = new XFormer();
     99    public void XForm(boolean finalBlockMode, boolean ciMode, int carrySetDepth) {
     100        setCarrySetDepth(carrySetDepth);           
     101        setCarrySetIdentifier(CarrySetBuiltins2Lang.CARRYSET_BASENAME_PREFIX + Integer.toString(getCarrySetDepth()));
     102       
     103        XFormer visitor = new XFormer();
    89104                visitor.setFinalBlockMode(finalBlockMode);
    90105                visitor.setCiMode(ciMode);
    91                 visitor.setCarrySetIdentifier(carrySetIdentifier);
    92106                ASTTree.accept(visitor);
    93107    }     
    94108   
     109        private int getCarrySetDepth() {
     110                return carrySetDepth;
     111        }
     112
     113        private void setCarrySetDepth(int carrySetDepth) {
     114                this.carrySetDepth = carrySetDepth;
     115        }
     116
     117        private String getCarrySetIdentifier() {
     118                return carrySetIdentifier;
     119        }
     120
     121        private void setCarrySetIdentifier(String carrySetIdentifier) {
     122                this.carrySetIdentifier = carrySetIdentifier;
     123        }
     124
    95125        private class XFormer extends VoidVisitor.Default {
    96126
     
    104134                //private boolean coMode;
    105135               
    106                 private String carrySetIdentifier;
    107                
    108136                private int currentCarry;
    109137                private int currentAdvN;
    110138                //private int lastStmtCarries;
    111                                
     139       
    112140                @SuppressWarnings("static-access")
    113141                XFormer(/*boolean finalBlockModeboolean ciMode , boolean coMode */) {
    114142                       
    115                         this.finalBlockMode = false;                                                   
    116                         this.currentCarry = 0;
    117                         this.currentAdvN = 0;
    118                         //this.lastStmtCarries = 0;
    119                        
    120                         this.ciMode = true;                                                                                                     
    121                         //this.coMode = coMode;
    122                         this.carrySetIdentifier = carrySet2Lang.CARRYQNAME;     
     143                        finalBlockMode = false;                                                 
     144                        ciMode = true;                 
     145                        // this.coMode = coMode;
     146                       
     147                        currentCarry = 0;
     148                        currentAdvN = 0;
     149                        //this.lastStmtCarries = 0;                                     
    123150                }
    124151
     
    129156                protected void setCiMode(boolean ciMode) {
    130157                        this.ciMode = ciMode;
    131                 }
    132 
    133                 protected String getCarrySetIdentifier() {
    134                         return carrySetIdentifier;
    135                 }
    136 
    137                 protected void setCarrySetIdentifier(String carrySetIdentifier) {
    138                         this.carrySetIdentifier = carrySetIdentifier;
    139158                }
    140159
     
    164183                        //this.lastStmtCarries = 0;
    165184                       
    166                         int carryCount = (new CarryCounterVisitor(node)).count();
    167                        
    168                         if(carryCount > 0) { 
    169                                
    170                                 IntegerConstantNode carryCountNode =  Generators.makeIntegerConstantNode(carryCount, node.getToken());
    171                                
    172                                 @SuppressWarnings("static-access")
     185                        int carry1Count = (new CarryCounterVisitor(node)).carry1Count();
     186                        int carryNCount = (new CarryCounterVisitor(node)).carryNCount();
     187                       
     188                        if(carry1Count > 0) { 
     189                                IntegerConstantNode carry1CountNode =  Generators.makeIntegerConstantNode(carry1Count, node.getToken());
     190                               
    173191                                FuncCallNode carryAdjustFuncCall = (FuncCallNode) Generators.makeFuncCallNode(
    174                                                 new String [] {carrySet2Lang.CARRYQNAME, carrySet2Lang.getCode(compilers.pabloB.lang.carry.CarryBuiltins.CARRYQADJUST)},
    175                                                 node.getToken(),
    176                                                 new ASTNode [] {carryCountNode});
     192                                                new String [] { getCarrySetIdentifier(),
     193                                                                                carrySet2Lang.getCode(CarrySetBuiltins.CARRYADJUST)},
     194                                                                                node.getToken(),
     195                                                                                new ASTNode [] {carry1CountNode});
    177196                               
    178197                                BlockStmtNode blockStmtNode = Accessors.blockStmtNode(node);
     
    180199                                        blockStmtNode.appendChild(carryAdjustFuncCall);
    181200                                }       
    182                         }               
     201                        }                       
     202                       
     203                        IdentifierNode carrySetIdentifierNode   =       Generators.makeIdentifierNode(getCarrySetIdentifier(), node.getToken());
     204                        IntegerConstantNode carry1CountNode     =       Generators.makeIntegerConstantNode(carry1Count, node.getToken());
     205                        IntegerConstantNode carryNCountNode     =       Generators.makeIntegerConstantNode(carryNCount, node.getToken());
     206                       
     207                        FuncCallNode carryDeclareFuncCall
     208                                                                = (FuncCallNode) Generators.makeFuncCallNode(
     209                                                                        carrySet2Lang.getCode(CarrySetBuiltins.CARRYDECLARE),
     210                                                                        node.getToken(),
     211                                                                        new ASTNode [] {carrySetIdentifierNode, carry1CountNode, carryNCountNode});
     212                       
     213                        node.appendChild(carryDeclareFuncCall);
     214               
    183215                }               
    184216               
     
    200232                        ASTNode replacementNode;
    201233                       
    202                         ASTNode carryCall;
     234                        ASTNode carryAtCallOrConstant;
    203235                        IntegerConstantNode currentCarry = Generators.makeIntegerConstantNode(this.currentCarry, node.getToken());
    204236                       
    205                         ASTNode advNCall;
     237                        ASTNode pending64CallOrConstant;
    206238                        IntegerConstantNode currentAdvN = Generators.makeIntegerConstantNode(this.currentAdvN, node.getToken());
    207239
     
    214246                       
    215247                        if(isCiMode()) {
    216                                 carryCall = Generators.makeFuncCallNode(
    217                                                 new String [] {getCarrySetIdentifier(), carrySet2Lang.getCode(compilers.pabloB.lang.carry.CarryBuiltins.GETCARRYIN)},
     248                                carryAtCallOrConstant = Generators.makeFuncCallNode(
     249                                                new String [] {getCarrySetIdentifier(),
     250                                                                carrySet2Lang.getCode(CarrySetBuiltins.CARRYAT)},
    218251                                                node.getToken(),
    219252                                                new ASTNode [] {currentCarry});
    220253                               
    221                                 advNCall = Generators.makeFuncCallNode(
    222                                                 new String [] {getCarrySetIdentifier(), carrySet2Lang.getCode(compilers.pabloB.lang.carry.CarryBuiltins.GETPENDING64)},
     254                                pending64CallOrConstant = Generators.makeFuncCallNode(
     255                                                new String [] {getCarrySetIdentifier(),
     256                                                                carrySet2Lang.getCode(CarrySetBuiltins.PENDING64)},
    223257                                                node.getToken(),
    224258                                                new ASTNode [] {currentAdvN});
    225259                        } else {
    226                                 carryCall = Generators.makeFuncCallNode(SIMD.CONSTANT.IDISAConstantLexeme("0", "1"), node.getToken());
    227                                 advNCall = Generators.makeFuncCallNode(SIMD.CONSTANT.IDISAConstantLexeme("0", "1"), node.getToken());
     260                                carryAtCallOrConstant = Generators.makeFuncCallNode(SIMD.CONSTANT.IDISAConstantLexeme("0", "1"), node.getToken());
     261                                pending64CallOrConstant = Generators.makeFuncCallNode(SIMD.CONSTANT.IDISAConstantLexeme("0", "1"), node.getToken());
    228262                        }
    229263                                               
     
    235269                        //                    return c
    236270                       
    237                         if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.ADVANCE.pabloSName(), Builtins.ADVANCE.argCount())) {         
    238                                
    239                                 List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
    240                                
    241                                 replaceFuncCallNode(node,
     271                        if (BuiltinsUtil.isCall(node,
     272                                        BuiltinsUtil.BUILTIN_PACKAGE_NAME,
     273                                        Builtins.ADVANCE.pabloSName(),
     274                                        Builtins.ADVANCE.argCount())) {         
     275                               
     276                                List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
     277                               
     278                                replaceFuncCallWithCarryCallNode(node,
    242279                                                getCarrySetIdentifier(),
    243280                                                builtins2Lang.getCode(Builtins.ADVANCE),
    244281                                                arguments,
    245                                                 carryCall,
     282                                                carryAtCallOrConstant,
    246283                                                currentCarry);
    247284                               
     
    255292                        //      return c                                                       
    256293                       
    257                         else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.SCANTHRU.pabloSName(), Builtins.SCANTHRU.argCount())) {                         
    258                                 List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
    259                                
    260                                 replaceFuncCallNode(node,
     294                        else if (BuiltinsUtil.isCall(node,
     295                                        BuiltinsUtil.BUILTIN_PACKAGE_NAME,
     296                                        Builtins.SCANTHRU.pabloSName(),
     297                                        Builtins.SCANTHRU.argCount())) {
     298                               
     299                                List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
     300                               
     301                                replaceFuncCallWithCarryCallNode(node,
    261302                                                getCarrySetIdentifier(),
    262303                                                builtins2Lang.getCode(Builtins.SCANTHRU),
    263304                                                arguments,
    264                                                 carryCall,
     305                                                carryAtCallOrConstant,
    265306                                                currentCarry);
    266307                                this.currentCarry += 1;
     
    274315                        //          return c                   
    275316                       
    276                         else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.ADVANCETHENSCANTHRU.pabloSName(), Builtins.ADVANCETHENSCANTHRU.argCount())) {
    277                                 List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
    278                                
    279                                 replaceFuncCallNode(node,
     317                        else if (BuiltinsUtil.isCall(node,
     318                                        BuiltinsUtil.BUILTIN_PACKAGE_NAME,
     319                                        Builtins.ADVANCETHENSCANTHRU.pabloSName(),
     320                                        Builtins.ADVANCETHENSCANTHRU.argCount())) {
     321                               
     322                                List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
     323                               
     324                                replaceFuncCallWithCarryCallNode(node,
    280325                                                getCarrySetIdentifier(),
    281326                                                builtins2Lang.getCode(Builtins.ADVANCETHENSCANTHRU),
    282327                                                arguments,
    283                                                 carryCall,
     328                                                carryAtCallOrConstant,
    284329                                                currentCarry);
    285330                                this.currentCarry += 1;
     
    293338                        //      return c
    294339                       
    295                         else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.SPANUPTO.pabloSName(), Builtins.SPANUPTO.argCount())) {
    296                                 List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
    297                                
    298                                 replaceFuncCallNode(node,
     340                        else if (BuiltinsUtil.isCall(node,
     341                                        BuiltinsUtil.BUILTIN_PACKAGE_NAME,
     342                                        Builtins.SPANUPTO.pabloSName(),
     343                                        Builtins.SPANUPTO.argCount())) {
     344                               
     345                                List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
     346                               
     347                                replaceFuncCallWithCarryCallNode(node,
    299348                                                getCarrySetIdentifier(),
    300349                                                builtins2Lang.getCode(Builtins.SPANUPTO),
    301350                                                arguments,
    302                                                 carryCall,
     351                                                carryAtCallOrConstant,
    303352                                                currentCarry);                         
    304353                                this.currentCarry += 1;
     
    314363                        //          return c                   
    315364                       
    316                         else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.ADVANCETHENSCANTO.pabloSName(), Builtins.ADVANCETHENSCANTO.argCount())) {
     365                        else if (BuiltinsUtil.isCall(node,
     366                                                BuiltinsUtil.BUILTIN_PACKAGE_NAME,
     367                                                Builtins.ADVANCETHENSCANTO.pabloSName(),
     368                                                Builtins.ADVANCETHENSCANTO.argCount())) {
     369                               
    317370                                ASTNode argNode = Accessors.funcCallArg(node, 1);
    318371                                if(isFinalBlockMode()) {
     
    325378                                List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
    326379                               
    327                                 replaceFuncCallNode(node,
     380                                replaceFuncCallWithCarryCallNode(node,
    328381                                                getCarrySetIdentifier(),
    329382                                                builtins2Lang.getCode(Builtins.ADVANCETHENSCANTHRU),
    330383                                                arguments,
    331                                                 carryCall,
     384                                                carryAtCallOrConstant,
    332385                                                currentCarry);
    333386                                this.currentCarry += 1;
     
    343396                        //            return c
    344397       
    345                         else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.INCLUSIVESPAN.pabloSName(), Builtins.INCLUSIVESPAN.argCount())) {
    346                                 List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
    347                                
    348                                 replaceFuncCallNode(node,
     398                        else if (BuiltinsUtil.isCall(node,
     399                                                BuiltinsUtil.BUILTIN_PACKAGE_NAME,
     400                                                Builtins.INCLUSIVESPAN.pabloSName(),
     401                                                Builtins.INCLUSIVESPAN.argCount())) {
     402                               
     403                                List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
     404                                replaceFuncCallWithCarryCallNode(node,
    349405                                                getCarrySetIdentifier(),
    350406                                                builtins2Lang.getCode(Builtins.INCLUSIVESPAN),
    351407                                                arguments,
    352                                                 carryCall,
     408                                                carryAtCallOrConstant,
    353409                                                currentCarry);
    354410                                this.currentCarry += 1;
     
    364420                        //            return c
    365421       
    366                         else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.EXCLUSIVESPAN.pabloSName(), Builtins.EXCLUSIVESPAN.argCount())) {
    367                                 List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
    368                                
    369                                 replaceFuncCallNode(node,
     422                        else if (BuiltinsUtil.isCall(node,
     423                                        BuiltinsUtil.BUILTIN_PACKAGE_NAME,
     424                                        Builtins.EXCLUSIVESPAN.pabloSName(),
     425                                        Builtins.EXCLUSIVESPAN.argCount())) {
     426                               
     427                                List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
     428                                replaceFuncCallWithCarryCallNode(node,
    370429                                                getCarrySetIdentifier(),
    371430                                                builtins2Lang.getCode(Builtins.EXCLUSIVESPAN),
    372431                                                arguments,
    373                                                 carryCall,
     432                                                carryAtCallOrConstant,
    374433                                                currentCarry);
    375434                                this.currentCarry += 1;
     
    387446                        //            return c
    388447       
    389                         else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.SCANTO.pabloSName(), Builtins.SCANTO.argCount())) {
     448                        else if (BuiltinsUtil.isCall(node,
     449                                                BuiltinsUtil.BUILTIN_PACKAGE_NAME,
     450                                                Builtins.SCANTO.pabloSName(),
     451                                                Builtins.SCANTO.argCount())) {
    390452                               
    391453                                ASTNode argNode = Accessors.funcCallArg(node, 1);
     
    399461                                List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
    400462                               
    401                                 replaceFuncCallNode(node,
     463                                replaceFuncCallWithCarryCallNode(node,
    402464                                                getCarrySetIdentifier(),
    403465                                                builtins2Lang.getCode(Builtins.SCANTHRU),
    404466                                                arguments,
    405                                                 carryCall,
     467                                                carryAtCallOrConstant,
    406468                                                currentCarry);
    407469                                this.currentCarry += 1;
     
    416478                        //            return c
    417479
    418                         else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.SCANTOFIRST.pabloSName(), Builtins.SCANTOFIRST.argCount())) {
    419                         //                      if(finalBlockMode) {
    420                         //                              // TODO - Wrap within simd_andc(scan_class, EOF_mask)
    421                         //                      }
    422                                
    423                                 List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
    424                                
    425                                 replaceFuncCallNode(node,
     480                        else if (BuiltinsUtil.isCall(node,
     481                                                BuiltinsUtil.BUILTIN_PACKAGE_NAME,
     482                                                Builtins.SCANTOFIRST.pabloSName(),
     483                                                Builtins.SCANTOFIRST.argCount())) {
     484
     485                                // TODO - verify
     486                                /*
     487                                ASTNode argNode = Accessors.funcCallArg(node, 0);
     488                                if(isFinalBlockMode()) {
     489                                        replacementNode = Generators.makeSIMDEOFMaskAndCNodeFuncCall(argNode, builtins2Lang);                                                                   
     490                                } else {
     491                                        replacementNode = Generators.makeSIMDNotFuncCall(argNode, builtins2Lang);
     492                                }
     493                                Accessors.funcCallArgsListNode(node).replaceChild(argNode, replacementNode);
     494                                */
     495                                List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
     496                               
     497                                replaceFuncCallWithCarryCallNode(node,
    426498                                                getCarrySetIdentifier(),
    427499                                                builtins2Lang.getCode(Builtins.SCANTOFIRST),
    428500                                                arguments,
    429                                                 carryCall,
     501                                                carryAtCallOrConstant,
    430502                                                currentCarry);
    431503                                this.currentCarry += 1;
     
    438510                        //            self.current_adv_n += 1
    439511                        //            return c
    440                         else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.ADVANCE32.pabloSName(), Builtins.ADVANCE32.argCount())) {
     512                        else if (BuiltinsUtil.isCall(node,
     513                                                BuiltinsUtil.BUILTIN_PACKAGE_NAME,
     514                                                Builtins.ADVANCE32.pabloSName(),
     515                                                Builtins.ADVANCE32.argCount())) {
     516                                // TODO - verify implementation.
     517                               
    441518                                //replaceFuncCallNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.ADVANCE32.cPPCode(), carryCall, currentAdvN);
    442                                 // TODO ==> Verify implementation.
    443                                
    444                                 List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
    445                                
    446                                 replaceFuncCallNode(node,
     519                               
     520                                List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
     521                               
     522                                replaceFuncCallWithCarryCallNode(node,
    447523                                                getCarrySetIdentifier(),
    448524                                                builtins2Lang.getCode(Builtins.ADVANCE32),
    449525                                                arguments,
    450                                                 advNCall,
     526                                                pending64CallOrConstant,
    451527                                                currentAdvN);
    452528                                this.currentAdvN += 1;
     
    459535                        //            self.current_adv_n += 1
    460536                        //            return c         
    461                         else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.ADVANCEN.pabloSName(), Builtins.ADVANCEN.argCount())) {
    462                                 //replaceFuncCallNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.ADVANCEN.cPPCode(), carryCall, currentAdvN);                                 
     537                        else if (BuiltinsUtil.isCall(node,
     538                                                BuiltinsUtil.BUILTIN_PACKAGE_NAME,
     539                                                Builtins.ADVANCEN.pabloSName(),
     540                                                Builtins.ADVANCEN.argCount())) {                                       
    463541                               
    464542                                ASTNode formatValue = Accessors.funcCallArg(node, 1);
     
    469547                                String formattedAdvanceN = String.format(builtins2Lang.getCode(Builtins.ADVANCEN), value);
    470548                               
    471                                 replaceFuncCallNode(node,
     549                                replaceFuncCallWithCarryCallNode(node,
    472550                                                getCarrySetIdentifier(),
    473551                                                formattedAdvanceN,
    474552                                                arguments.subList(0, arguments.size()-1),
    475                                                 advNCall,
     553                                                pending64CallOrConstant,
    476554                                                currentAdvN);           
    477555                                this.currentAdvN += 1;                 
    478556                        }                                       
    479557               
    480                         else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.ATEOF.pabloSName(), Builtins.ATEOF.argCount())) {
     558                        else if (BuiltinsUtil.isCall(node,
     559                                                BuiltinsUtil.BUILTIN_PACKAGE_NAME,
     560                                                Builtins.ATEOF.pabloSName(),
     561                                                Builtins.ATEOF.argCount())) {
    481562                                 
    482563                                if(isFinalBlockMode()) {
     
    494575                        //              return callnode.args[0]
    495576                        //            else: return mkCall('simd_and', [callnode.args[0], ast.Name('EOF_mask', ast.Load())])
    496                         else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.INFILE.pabloSName(), Builtins.INFILE.argCount())) {
     577                        else if (BuiltinsUtil.isCall(node,
     578                                                BuiltinsUtil.BUILTIN_PACKAGE_NAME,
     579                                                Builtins.INFILE.pabloSName(),
     580                                                Builtins.INFILE.argCount())) {
    497581                               
    498582                                if(isFinalBlockMode()) {                                       
     
    548632               
    549633                public void visitEnter(IfStmtNode node) { // current PabloS if statement implementation does not support n-bit CarryTest for Advance(x,n)
    550                         assert (new AdvanceNCounterVisitor(node).count() == 0): "Advance(x,n) within if: illegal\n";
     634                        assert (new AdvanceNCounterVisitor(node).count() == 0): "Advance(x,n) illegal within an if statement \n";
    551635                       
    552636                        int carryBase = this.currentCarry;
    553                         int carryCount = (new CarryCounterVisitor(node)).count();
     637                        int carryCount = (new CarryCounterVisitor(node)).carry1Count();
    554638                                               
    555639                        if(carryCount == 0) {
     
    557641                        }
    558642                       
    559                         if(!this.isCiMode()) { // e.g. not within the context of the 1st iteration of a while loop body
     643                        if(!this.isCiMode()) { // not in the context of the 1st iteration of a while loop
    560644                                return;
    561645                        }
     
    570654                        // else part, append CarryDequeueEnqueue call
    571655                        FuncCallNode carryDequeueEnqueue = (FuncCallNode) Generators.makeFuncCallNode(
    572                                         new String [] {getCarrySetIdentifier(), carrySet2Lang.getCode(compilers.pabloB.lang.carry.CarryBuiltins.CARRYDEQUEUEENQUEUE)},
    573                                         node.getToken(),
    574                                         new ASTNode [] {carryBaseNode, carryCountNode});
     656                                                                new String [] {getCarrySetIdentifier(), carrySet2Lang.getCode(CarrySetBuiltins.CARRYDEQUEUEENQUEUE)},
     657                                                                node.getToken(),
     658                                                                new ASTNode [] {carryBaseNode, carryCountNode});
    575659                       
    576660                        if (Accessors.hasElseBlockStmt(node)) {
     
    582666                        }                               
    583667                }
    584                
     668                               
    585669                public void visitEnter(WhileStmtNode node) {
    586670
     
    600684                                node.replaceChild(whileConditionNode, replacementNode);                                 
    601685                        }
    602                
    603                         assert (new AdvanceNCounterVisitor(node).count() == 0): "Advance(x,n) within if: illegal\n";
    604                        
    605                         int carryBase   = this.currentCarry;
    606                         int carryCount  = (new CarryCounterVisitor(node)).count();                     
    607                
    608                         if(carryCount == 0) {
     686                       
     687                        int carryBase           = this.currentCarry;
     688                        int carry1Count         = (new CarryCounterVisitor(node)).carry1Count();                       
     689                        int carryNCount         = (new CarryCounterVisitor(node)).carryNCount();
     690                       
     691                        if(carry1Count == 0) {
    609692                                return;
    610693                        }
    611                
    612                         IntegerConstantNode carryBaseNode       = Generators.makeIntegerConstantNode(carryBase, node.getToken());
    613                         IntegerConstantNode carryCountNode      = Generators.makeIntegerConstantNode(carryCount, node.getToken());
    614                        
    615                         IdentifierNode localCarryId                     
    616                                                                 = Generators.makeIdentifierNode(compilers.pabloB.lang.carry.CarryBuiltins2Lang.LOCALCARRYQNAME,
    617                                                                                                                                 node.getToken());
    618                        
    619                         CompoundIdentifierNode localCarryQArrayQName   
    620                                                                 = Generators.makeCompoundIdentifierNode(
    621                                                                                 new String [] {compilers.pabloB.lang.carry.CarryBuiltins2Lang.LOCALCARRYQNAME,
    622                                                                                                 compilers.pabloB.lang.carry.CarryBuiltins2Lang.LOCALCARRYQARRAYNAME},
    623                                                                                 node.getToken());
    624                        
    625                         /*
    626 
    627                         StringConstantNode localCarryQArrayQName       
    628                                         = Generators.makeStringConstantNode(
    629                                                         CarrySetBuiltins2Lang.LOCALCARRYQNAME
    630                                                         + "."
    631                                                         + CarrySetBuiltins2Lang.LOCALCARRYQARRAYNAME,
    632                                                         node.getToken());
    633                         */
    634 
     694                       
     695                        assert (carryNCount == 0): "Advance(x,n) illegal within an if statement \n";
     696
     697                        //IdentifierNode carrySetIdentifierNode = Generators.makeIdentifierNode(carrySetIdentifier, node.getToken());
     698                       
     699                        IntegerConstantNode carryBaseNode       =       Generators.makeIntegerConstantNode(carryBase, node.getToken());
     700                        IntegerConstantNode carry1CountNode =   Generators.makeIntegerConstantNode(carry1Count, node.getToken());
     701                        IntegerConstantNode carryNCountNode =   Generators.makeIntegerConstantNode(carryNCount, node.getToken());
     702                       
     703                       
     704                                       
    635705                        //          inner_while = CarryIntro(local_carryvar, '', self.carryout).generic_xfrm(copy.deepcopy(whileNode))
    636706                        //          self.generic_visit(whileNode)
     
    648718
    649719                        //              translate inner while ciMode disabled and local carry object
     720                       
    650721                        WhileStmtNode innerWhile = node.deepCopy();
    651722                        CarryIntroXFormer xFormer = new CarryIntroXFormer(Accessors.whileBlockStmt(innerWhile), builtins2Lang, carrySet2Lang);
    652                         xFormer.XForm(finalBlockMode, false, compilers.pabloB.lang.carry.CarryBuiltins2Lang.LOCALCARRYQNAME);
    653                        
    654                         FuncCallNode localCarryDeclare = (FuncCallNode) Generators.makeFuncCallNode(
    655                                         carrySet2Lang.getCode(compilers.pabloB.lang.carry.CarryBuiltins.LOCALCARRYDECLARE),
     723                        xFormer.XForm(finalBlockMode, false, (getCarrySetDepth() + 1));
     724                       
     725                        IdentifierNode localCarrySetIdentifierNode = Generators.makeIdentifierNode(
     726                                        xFormer.getCarrySetIdentifier(),
     727                                        node.getToken());
     728
     729                        CompoundIdentifierNode localCarrySetArrayIdentifierNode = Generators.makeCompoundIdentifierNode(
     730                                        new String [] {xFormer.getCarrySetIdentifier(), CarrySetBuiltins2Lang.CARRYQARRAYNAME},
     731                                        node.getToken());
     732
     733                       
     734                        FuncCallNode carryDeclareFuncCall
     735                                                                = (FuncCallNode) Generators.makeFuncCallNode(
     736                                                                        carrySet2Lang.getCode(CarrySetBuiltins.CARRYDECLARE),
     737                                                                        node.getToken(),
     738                                                                        new ASTNode [] {localCarrySetIdentifierNode, carry1CountNode, carryNCountNode});
     739                                               
     740                        Accessors.whileBlockStmt(innerWhile).insertChild(carryDeclareFuncCall);
     741
     742                        FuncCallNode carryCombine = (FuncCallNode) Generators.makeFuncCallNode(
     743                                        new String [] {carrySetIdentifier, carrySet2Lang.getCode(CarrySetBuiltins.CARRYCOMBINE)},
    656744                                        node.getToken(),
    657                                         new ASTNode [] {localCarryId, carryCountNode});
    658 
    659                         Accessors.whileBlockStmt(innerWhile).insertChild(localCarryDeclare);
    660 
    661                         FuncCallNode carryCombine = (FuncCallNode) Generators.makeFuncCallNode(
    662                                         new String [] {getCarrySetIdentifier(), carrySet2Lang.getCode(compilers.pabloB.lang.carry.CarryBuiltins.CARRYCOMBINE)},
    663                                         node.getToken(),
    664                                         new ASTNode [] {localCarryQArrayQName, carryBaseNode, carryCountNode});
     745                                        new ASTNode [] {localCarrySetArrayIdentifierNode, carryBaseNode, carry1CountNode}); /////////////////
    665746                       
    666747                        Accessors.whileBlockStmt(innerWhile).appendChild(carryCombine);
     
    680761                                ifTest = Accessors.whileTest(node).deepCopy();
    681762                        } else {                               
    682                                 ifTest = makeBitwiseOrCarryTest(ifTest, carryBaseNode, carryCountNode);
     763                                ifTest = makeBitwiseOrCarryTest(ifTest, carryBaseNode, carry1CountNode);
    683764                        }
    684765                       
     
    689770                       
    690771                        FuncCallNode carryDequeueEnqueue = (FuncCallNode) Generators.makeFuncCallNode(
    691                                         new String [] {getCarrySetIdentifier(), carrySet2Lang.getCode(compilers.pabloB.lang.carry.CarryBuiltins.CARRYDEQUEUEENQUEUE)},
    692                                         node.getToken(),
    693                                         new ASTNode [] {carryBaseNode, carryCountNode});
     772                                        new String [] {carrySetIdentifier, carrySet2Lang.getCode(CarrySetBuiltins.CARRYDEQUEUEENQUEUE)},
     773                                                                        node.getToken(),
     774                                                                        new ASTNode [] {carryBaseNode, carry1CountNode});
    694775                       
    695776                        // else body                   
     
    698779                       
    699780                        IfStmtNode ifStmtNode = Generators.makeIfStmtNode(node.getToken(),
    700                                         ifTest,
    701                                         ifBlockStmtNode,
    702                                         elseBlockStmtNode);
    703                        
     781                                                                                                                                ifTest,
     782                                                                                                                                ifBlockStmtNode,
     783                                                                                                                                elseBlockStmtNode);
    704784                        node.updateSelf(ifStmtNode);
    705                 }
    706        
    707                 // Helpers             
    708                 private void replaceFuncCallNode(FuncCallNode node,
    709                                 String targetPackage, String targetName,
     785                       
     786                       
     787                }
     788               
     789                // Helpers
     790               
     791                /*
     792                 * Makes CarrySet builtin call. Advance(X) => carry_set_n.Advance(
     793                 */
     794                private void replaceFuncCallWithCarryCallNode(FuncCallNode node,
     795                                String carryIdentifier, String carryBuiltin,
    710796                                List<ASTNode> arguments,
    711797                                ASTNode call, IntegerConstantNode carry) {
    712                         FuncCallNode replacementNode;
     798                               
     799                                FuncCallNode replacementNode;
    713800       
    714801                        List<ASTNode> args = new ArrayList<ASTNode>();
     
    721808                       
    722809                        replacementNode = Generators.makeFuncCallNode(
    723                                         new String [] {targetPackage, targetName},
     810                                        new String [] {carryIdentifier, carryBuiltin},
    724811                                        node.getToken(),
    725812                                        args);
     
    727814                        node.updateSelf(replacementNode);
    728815                }
    729        
     816               
     817                /*
     818                 * Makes Bitwise OR of if expression and CARRYRANGE.
     819                 */
    730820                private BinaryOperatorNode makeBitwiseOrCarryTest(ASTNode ifTest,
    731821                                IntegerConstantNode carryBaseNode,
     
    738828                       
    739829                        FuncCallNode rhs = (FuncCallNode) Generators.makeFuncCallNode(
    740                                         new String [] {getCarrySetIdentifier(), carrySet2Lang.getCode(compilers.pabloB.lang.carry.CarryBuiltins.CARRYTEST)},
    741                                         lhs.getToken(),
    742                                         new ASTNode [] {carryBaseNode, carryCountNode});
    743                        
    744                         BinaryOperatorNode replacementIfTestNode = Generators.makeBinaryOperatorNode(lhs,
    745                                                                                                                                         rhs,
    746                                                                                                                                         binaryOperatorToken);
     830                                        new String [] {getCarrySetIdentifier(),
     831                                                                        carrySet2Lang.getCode(CarrySetBuiltins.CARRYRANGE)},
     832                                                                        lhs.getToken(),
     833                                                                        new ASTNode [] {carryBaseNode, carryCountNode});
     834                       
     835                        BinaryOperatorNode replacementIfTestNode = Generators.makeBinaryOperatorNode(lhs, rhs, binaryOperatorToken);
     836                       
    747837                        return replacementIfTestNode;
    748                 }       
    749        
     838                }
    750839        }
    751840}       
Note: See TracChangeset for help on using the changeset viewer.