Changeset 3378 for proto


Ignore:
Timestamp:
Jul 2, 2013, 7:54:07 PM (6 years ago)
Author:
ksherdy
Message:

Partial checkin marked for reversion.

Location:
proto/pabloj/trunk/src/toolchain
Files:
4 edited

Legend:

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

    r3375 r3378  
    198198        if(args.length > 0) {
    199199            for(ASTNode child: args) {
    200                 Accessors.idisaFuncCallArgListNode(node).appendChild(child);
     200                Accessors.idisaFuncCallArgListNode(node).appendChild(child.deepCopy());
    201201            }
    202202            Accessors.idisaFuncCallArgListNode(node).setToken(args[0].getToken());
     
    267267                if(args.length > 0) {
    268268                        for(ASTNode child: args) {
    269                                 Accessors.funcCallArgsListNode(node).appendChild(child);
     269                                Accessors.funcCallArgsListNode(node).appendChild(child.deepCopy());
    270270                        }
    271271                        Accessors.funcCallArgsListNode(node).setToken(args[0].getToken());
     
    373373    }
    374374   
     375    ///////////////////////////////////////////////////////////////////
     376    // Carry builtin calls   
     377   
     378//    public static ASTNode makeGetCallCarryForBuiltin(Locator locator, PabloSBuiltin builtin, int index, Context context) {
     379//        if(builtin.isCarryN()) {
     380//            return makePending64Call(locator, index, context);
     381//        } else {
     382//            return makeGetCarryCall(locator, index, context);
     383//        }
     384//    }
     385
     386    public static ASTNode makeGetCarryCall(Locator locator, int index, Context context) {
     387        return Generators.makeFuncCallNode(
     388                locator,
     389                context.getCarrySetIdentifier(),
     390                context.getCarrySetEncoder().getName(CarrySetBuiltin.GETCARRY),
     391                Generators.makeIntegerConstantNode(locator, index));
     392    }
     393
     394    public static ASTNode makePending64Call(Locator locator, int index, Context context) {
     395        return Generators.makeFuncCallNode(
     396                locator,
     397                context.getCarrySetIdentifier(),
     398                context.getCarrySetEncoder().getName(CarrySetBuiltin.PENDING64),
     399                Generators.makeIntegerConstantNode(locator, index));
     400    }   
     401   
    375402    public static FuncCallNode makeCarryFlipCall(Locator locator, int index, Context context) {
    376403       
  • proto/pabloj/trunk/src/toolchain/pabloS/ast/Generators.java

    r3375 r3378  
    103103        private static void addFuncCallArgs(FuncCallNode node, ASTNode ... args) {
    104104            for(ASTNode child: args) {
    105                 Accessors.argsListNode(node).appendChild(child);
     105                Accessors.argsListNode(node).appendChild(child.deepCopy());
    106106            }
    107107            Accessors.argsListNode(node).setToken(args[0].getToken());
     
    280280    ///////////////////////////////////////////////////////////////////
    281281    // Carry builtin calls
     282       
     283        // TODO - KH: remove all Carry builtin calls from the PabloS generators
     284       
    282285    public static ASTNode makeGetCallCarryForBuiltin(Locator locator, PabloSBuiltin builtin, int index, Context context) {
    283286        if(builtin.isCarryN()) {
  • proto/pabloj/trunk/src/toolchain/pabloS/lang/PabloSBuiltinTranslator.java

    r3375 r3378  
    11package toolchain.pabloS.lang;
    22
     3import static toolchain.pabloB.lang.idisa.IDISABuiltin.SIMD_CONSTANT;
    34import static toolchain.pabloB.lang.idisa.IDISABuiltin.BITBLOCK_ANY;
    4 import static toolchain.pabloB.lang.idisa.IDISABuiltin.SIMD_CONSTANT;
     5import static toolchain.pabloB.lang.idisa.IDISABuiltin.BITBLOCK_SRLI;
    56import static toolchain.pabloB.lang.types.PrimitiveType.BITBLOCK_SIZE;
    67
    7 import java.util.ArrayList;
     8
    89import java.util.List;
    910
     
    1415import pabloS.ast.FuncCallNode;
    1516//import pabloS.inputHandler.Locator;
    16 import toolchain.pabloB.lang.idisa.IDISABitBlockBuiltins;
    17 import toolchain.pabloS.ast.Accessors;
    18 import toolchain.pabloS.ast.Generators;
     17
     18import toolchain.pabloB.ast.Accessors;
     19import toolchain.pabloB.ast.Generators;
     20
    1921import toolchain.pabloS.transformer.visitors.infoSet.Counter;
    2022import toolchain.pabloS.transformer.visitors.pabloS2PabloB.Context;
     
    2931   
    3032        CARRY_TRANSLATION {     
    31                 public void translate(PabloSBuiltin builtin, pabloS.ast.FuncCallNode snode, Counter counter, Context context, pabloS.ast.ASTNode returnValue) {
    32             List<pabloS.ast.ASTNode> arguments = Accessors.argsList(snode);
    33             pabloS.inputHandler.Locator locator = snode;
    34             replaceCallWithPabloBlkCall(snode,
    35                                         context.getCode(builtin),
    36                                         arguments,
    37                                         Generators.makeGetCallCarryForBuiltin(locator, builtin, counter.value(), context),
    38                                         returnValue);
    39             //surroundWithIDISASRLI(snode, locator, snode);
     33                public ASTNode translate(PabloSBuiltin builtin, pabloS.ast.FuncCallNode snode, Context context, List<ASTNode> childResults, int carry1Position) {
     34           
     35                    Locator locator = Generators.makeToken(snode.getToken());
     36                   
     37            String pabloBlkCallFuncName                         = context.getCode(builtin);
     38           
     39            ASTNode getCarryCall = Generators.makeGetCarryCall(locator, carry1Position, context);
     40            ASTNode returnValue = childResults.get(0);
     41            ASTNode[] pabloBlkFuncCallArgs = makePabloBlkArgs(locator, childResults, getCarryCall, returnValue);
     42           
     43            ASTNode pabloBlkFuncCall = Generators.makeFuncCallNode(locator, pabloBlkCallFuncName, pabloBlkFuncCallArgs);
     44           
     45            ASTNode immediatValue       = Generators.makeIntegerConstantNode(locator, BITBLOCK_SIZE - 1);
     46           
     47           
     48            return Generators.makeIdisaFuncCallNode(locator, BITBLOCK_SRLI, BITBLOCK_SIZE, immediatValue, pabloBlkFuncCall);
    4049                }
    4150        },
     
    4352        ADVANCEN_TRANSLATION {
    4453                public void translate(PabloSBuiltin builtin, pabloS.ast.FuncCallNode snode, Counter counter, Context context, pabloS.ast.ASTNode returnValue) {
    45                     pabloS.ast.ASTNode formatValue = Accessors.argument(snode, 1);
    46                     String value = Accessors.lexeme(formatValue);
     54                    pabloS.ast.ASTNode formatValue = toolchain.pabloS.ast.Accessors.argument(snode, 1);
     55                    String value = toolchain.pabloS.ast.Accessors.lexeme(formatValue);
    4756                    List<pabloS.ast.ASTNode> arguments = removeAdvanceNConstantArg(snode);
    4857
     
    5059                    String formattedAdvanceN = String.format(templateCode, value);         
    5160                    pabloS.inputHandler.Locator locator = snode;
     61
    5262                   
    53                     replaceCallWithPabloBlkCall(snode,
    54                                                 formattedAdvanceN,
    55                                                 arguments,
    56                                                 Generators.makeGetCallCarryForBuiltin(locator, builtin, counter.value(), context), 
    57                                                 returnValue);
    58                     //surroundWithIDISASRLI(snode, locator, snode);
     63                   
     64//                  makePabloBlkFuncCall(snode,
     65//                          formattedAdvanceN,
     66//                          arguments,
     67//                          toolchain.pabloS.ast.Generators.makeGetCallCarryForBuiltin(locator, builtin, counter.value(), context), 
     68//                          returnValue);
     69
    5970                }
    6071
    6172        private List<pabloS.ast.ASTNode> removeAdvanceNConstantArg(pabloS.ast.FuncCallNode node) {
    62             List<pabloS.ast.ASTNode> arguments = Accessors.argsList(node);
     73            List<pabloS.ast.ASTNode> arguments = toolchain.pabloS.ast.Accessors.argsList(node);
    6374                    arguments.remove(arguments.size()-1);
    6475            return arguments;
     
    6778       
    6879        SCANTO_TRANSLATION {
    69         public void translate(PabloSBuiltin translatedBuiltin, FuncCallNode snode, Counter counter, Context context, pabloS.ast.ASTNode returnValue) {
     80        public void translate(PabloSBuiltin builtin, FuncCallNode snode, Counter counter, Context context, pabloS.ast.ASTNode returnValue) {
    7081            scanToTranslate(PabloSBuiltin.SCAN_THRU, snode, counter, context, returnValue);
    7182        }
     
    7384
    7485    ADVANCE_THEN_SCANTO_TRANSLATION {
    75         public void translate(PabloSBuiltin translatedBuiltin, FuncCallNode snode, Counter counter, Context context, pabloS.ast.ASTNode returnValue) {
     86        public void translate(PabloSBuiltin builtin, FuncCallNode snode, Counter counter, Context context, pabloS.ast.ASTNode returnValue) {
    7687            scanToTranslate(PabloSBuiltin.ADVANCE_THEN_SCAN_THRU, snode, counter, context, returnValue);
    7788        }
     
    7990   
    8091    ASSERT_ZERO_TRANSLATION {
    81         public ASTNode translate(PabloSBuiltin translatedBuiltin, pabloS.ast.FuncCallNode snode, Context context,  List<ASTNode> childResults) {
    82            
    83             Locator locator = toolchain.pabloB.ast.Generators.makeToken(snode.getToken());
     92        public ASTNode translate(PabloSBuiltin builtin, pabloS.ast.FuncCallNode snode, Context context,  List<ASTNode> childResults) {
     93           
     94            Locator locator = Generators.makeToken(snode.getToken());
    8495           
    8596            FuncCallArgListNode args = (FuncCallArgListNode) childResults.get(1);
     
    89100            String assert0CallName                  = context.getBuiltinEncoder().getName(PabloSBuiltin.ASSERT_ZERO);
    90101
    91 
    92             ASTNode assert0Call                     = toolchain.pabloB.ast.Generators.makeFuncCallNode(locator,
     102            ASTNode assert0Call                     = Generators.makeFuncCallNode(locator,
    93103                    assert0CallName,
    94104                    errorStream,             
    95105                    errorMsg);
    96106
    97             BlockStmtNode blockStmt                 = toolchain.pabloB.ast.Generators.makeBlockStmtNode(locator, assert0Call);
    98             IfStmtNode replacement                  = toolchain.pabloB.ast.Generators.makeIfStmtNode(locator,
     107            BlockStmtNode blockStmt                 = Generators.makeBlockStmtNode(locator, assert0Call);
     108            IfStmtNode replacement                  = Generators.makeIfStmtNode(locator,
    99109                    errorStream.deepCopy(),
    100110                    blockStmt);
    101111
    102             surroundConditionWithBitBlockAny(replacement, toolchain.pabloB.ast.Accessors.condition(replacement));
     112            surroundConditionWithBitBlockAny(replacement, Accessors.condition(replacement));
    103113
    104114            return replacement;
     
    110120        public ASTNode translate(PabloSBuiltin builtin, pabloS.ast.FuncCallNode snode, Context context, List<ASTNode> childResults) {
    111121           
    112             Locator locator = toolchain.pabloB.ast.Generators.makeToken(snode.getToken());
     122            Locator locator = Generators.makeToken(snode.getToken());
    113123           
    114124            FuncCallArgListNode args = (FuncCallArgListNode) childResults.get(1);
     
    116126           
    117127            if(context.isFinalBlockMode()) {
    118                 return toolchain.pabloB.ast.Generators.makeSIMDAndCEOFMaskFuncCall(locator, arg0);
     128                return Generators.makeSIMDAndCEOFMaskFuncCall(locator, arg0);
    119129
    120130            } else {             
    121                 FieldWidthNode fieldWidth = toolchain.pabloB.ast.Generators.makeIdisaFieldWidthNode(locator, 1);
    122                 ASTNode value = toolchain.pabloB.ast.Generators.makeIntegerConstantNode(locator, 0);
     131                FieldWidthNode fieldWidth = Generators.makeIdisaFieldWidthNode(locator, 1);
     132                ASTNode value = Generators.makeIntegerConstantNode(locator, 0);
    123133               
    124                 return toolchain.pabloB.ast.Generators.makeIdisaFuncCallNode(locator, SIMD_CONSTANT, fieldWidth, value);       
     134                return Generators.makeIdisaFuncCallNode(locator, SIMD_CONSTANT, fieldWidth, value);       
    125135            }
    126136        }
     
    130140        public ASTNode translate(PabloSBuiltin builtin, pabloS.ast.FuncCallNode snode, Context context, List<ASTNode> childResults) {
    131141           
    132             Locator locator = toolchain.pabloB.ast.Generators.makeToken(snode.getToken());
     142            Locator locator = Generators.makeToken(snode.getToken());
    133143           
    134144            FuncCallArgListNode args = (FuncCallArgListNode) childResults.get(1);
     
    136146           
    137147            if(context.isFinalBlockMode()) {
    138                 return toolchain.pabloB.ast.Generators.makeSIMDAndEOFMaskFuncCall(locator, arg0);
     148                return Generators.makeSIMDAndEOFMaskFuncCall(locator, arg0);
    139149            } else {
    140150                return arg0;
     
    144154
    145155    MASK_TRANSLATION {
    146         public ASTNode translate(PabloSBuiltin translatedBuiltin, pabloS.ast.FuncCallNode snode, Context context, List<ASTNode> childResults) {
    147            
    148             Locator locator = toolchain.pabloB.ast.Generators.makeToken(snode.getToken());
    149 
    150             FuncCallArgListNode args = (FuncCallArgListNode) childResults.get(1);
    151             IntegerConstantNode n = (IntegerConstantNode)args.child(0);
    152             ASTNode fieldWidth  = toolchain.pabloB.ast.Generators.makeIdisaFieldWidthNode(locator, toolchain.pabloB.ast.Accessors.intValue(n));
    153             ASTNode value       = args.child(1);
    154            
    155             return toolchain.pabloB.ast.Generators.makeIdisaFuncCallNode(locator, SIMD_CONSTANT, (FieldWidthNode) fieldWidth, value);
     156        public ASTNode translate(PabloSBuiltin builtin, pabloS.ast.FuncCallNode snode, Context context, List<ASTNode> childResults) {
     157           
     158            Locator locator = Generators.makeToken(snode.getToken());
     159
     160            FuncCallArgListNode args    = (FuncCallArgListNode) childResults.get(1);
     161            IntegerConstantNode n       = (IntegerConstantNode)args.child(0);
     162            ASTNode fieldWidth          = Generators.makeIdisaFieldWidthNode(locator, Accessors.intValue(n));
     163            ASTNode maskValue           = args.child(1);
     164           
     165            return Generators.makeIdisaFuncCallNode(locator, SIMD_CONSTANT, (FieldWidthNode) fieldWidth, maskValue);
    156166        }
    157167    };
    158168   
    159     private static void scanToTranslate(PabloSBuiltin translatedBuiltin, pabloS.ast.FuncCallNode snode, Counter counter, Context context, pabloS.ast.ASTNode returnValue) {
    160         pabloS.ast.ASTNode argument = Accessors.argument(snode, 1);
    161         translateArgument(context, argument);
    162         pabloS.ast.ASTNode replacement = Generators.makeCompoundIdentifierNode(snode,
    163                 BuiltinCallUtil.BUILTIN_PACKAGE_NAME, translatedBuiltin.pabloSName());
    164 
    165         snode.replaceChild(Accessors.nameNode(snode), replacement);
    166         CARRY_TRANSLATION.translate(translatedBuiltin, snode, counter, context, returnValue);
     169    private static void scanToTranslate(PabloSBuiltin builtin, pabloS.ast.FuncCallNode snode, Counter counter, Context context, pabloS.ast.ASTNode returnValue) {
     170//        pabloS.ast.ASTNode argument = Accessors.argument(snode, 1);
     171//        translateArgument(context, argument);
     172//        pabloS.ast.ASTNode replacement = Generators.makeCompoundIdentifierNode(snode,
     173//                BuiltinCallUtil.BUILTIN_PACKAGE_NAME, translatedBuiltin.pabloSName());
     174//
     175//        snode.replaceChild(Accessors.nameNode(snode), replacement);
     176//        CARRY_TRANSLATION.translate(translatedBuiltin, snode, counter, context, returnValue);
    167177    }
    168178   
    169179    private static void translateArgument(Context context, pabloS.ast.ASTNode argument) {
    170180        if(context.isFinalBlockMode()) {
    171             pabloS.ast.ASTNode replacement = Generators.makeSIMDEOFMaskAndCNodeFuncCall(argument.deepCopy(), context.getBuiltinEncoder());
     181            pabloS.ast.ASTNode replacement = toolchain.pabloS.ast.Generators.makeSIMDEOFMaskAndCNodeFuncCall(argument.deepCopy(), context.getBuiltinEncoder());
    172182            argument.updateSelf(replacement);
    173183        }
    174184        else {
    175             pabloS.ast.ASTNode replacement = Generators.makeSIMDNotFuncCall(argument.deepCopy(), context.getBuiltinEncoder());
     185            pabloS.ast.ASTNode replacement = toolchain.pabloS.ast.Generators.makeSIMDNotFuncCall(argument.deepCopy(), context.getBuiltinEncoder());
    176186            argument.updateSelf(replacement);           
    177187        }
     
    179189   
    180190    // TODO - KH: Added to support multiple 'translate' signatures. May be a poor use of Java.
    181     public void translate(PabloSBuiltin translatedBuiltin, pabloS.ast.FuncCallNode node, Context context) {
     191    public void translate(PabloSBuiltin builtin, pabloS.ast.FuncCallNode node, Context context) {
    182192        assert false : "General PabloSBuiltin translate not implemented for PabloSBuitin: " + this.name();
    183193    }
    184194   
    185     public void translate(PabloSBuiltin translatedBuiltin, pabloS.ast.FuncCallNode node, Counter counter, Context context) {
     195    public void translate(PabloSBuiltin builtin, pabloS.ast.FuncCallNode node, Counter counter, Context context) {
    186196        assert false : "General PabloSBuiltin translate not implemented for PabloSBuitin: " + this.name();
    187197    }
    188198   
    189         public void translate(PabloSBuiltin translatedBuiltin, pabloS.ast.FuncCallNode node, Counter counter, Context context, pabloS.ast.ASTNode returnValue) {
     199        public ASTNode translate(PabloSBuiltin builtin, pabloS.ast.FuncCallNode node, Context context, List<ASTNode> childResults, int carry1Position) {
    190200            assert false : "'pablo_blk_' PabloSBuiltin translate not implemented for PabloSBuitin: " + this.name();
     201            return null;
    191202        }
    192203
    193         public ASTNode translate(PabloSBuiltin translatedBuiltin, pabloS.ast.FuncCallNode node, Context context, List<ASTNode> childResults) {
     204        public ASTNode translate(PabloSBuiltin builtin, pabloS.ast.FuncCallNode node, Context context, List<ASTNode> childResults) {
    194205            assert false : "'pablo_blk_' PabloSBuiltin translate not implemented for PabloSBuitin: " + this.name();
    195206            return null;
    196207        }
    197208       
    198         // helper methods
     209        private static ASTNode[] makePabloBlkArgs(Locator locator,
     210            List<ASTNode> childResults, ASTNode getCarryCallForBuiltin, ASTNode returnValue) {
     211        FuncCallArgListNode funcCallArgList    = (FuncCallArgListNode)childResults.get(1).child(1);
     212        List<ASTNode> args = funcCallArgList.getChildren();
     213        args.add(getCarryCallForBuiltin);
     214        args.add(returnValue);
     215       
     216        ASTNode argsAsArray [] = args.toArray(new ASTNode [args.size()]);
     217        return argsAsArray;
     218    }
     219
     220    // helper methods
    199221    private static void surroundConditionWithBitBlockAny(ASTNode node, ASTNode condition) {
    200222        Locator locator = node;
    201        
    202         ASTNode replacement = toolchain.pabloB.ast.Generators.makeIdisaFuncCallNode(locator, BITBLOCK_ANY, BITBLOCK_SIZE, toolchain.pabloB.ast.Generators.arguments(condition.deepCopy()));
    203        
     223        ASTNode replacement = Generators.makeIdisaFuncCallNode(locator, BITBLOCK_ANY, BITBLOCK_SIZE, Generators.arguments(condition.deepCopy()));
    204224        node.replaceChild(condition, replacement);
    205225    }   
    206        
    207     private static void replaceCallWithPabloBlkCall (
    208             pabloS.ast.FuncCallNode snode,
    209             String carryBuiltin,                           
    210             List<pabloS.ast.ASTNode> arguments,                       
    211             pabloS.ast.ASTNode call,                                   
    212             pabloS.ast.ASTNode returnValue) {
    213        
    214         pabloS.ast.ASTNode [] args = makePabloBlkCallArgs(arguments, call, returnValue.deepCopy());
    215        
    216         pabloS.inputHandler.Locator locator = snode;
    217         FuncCallNode pabloBlkFuncCall = Generators.makeFuncCallNode(
    218                 locator,
    219                 carryBuiltin,
    220                 args);
    221                
    222         surroundWithIdisasSRLI(locator, snode, pabloBlkFuncCall);
    223        
    224     }
    225 
    226     private static void surroundWithIdisasSRLI(pabloS.inputHandler.Locator locator,
    227             pabloS.ast.FuncCallNode snode, FuncCallNode pabloBlkFuncCall) {
    228         FuncCallNode idisaSRLI = makeIDISASRLI(locator, pabloBlkFuncCall);
    229         snode.updateSelf(idisaSRLI);
    230     }
    231 
    232     private static FuncCallNode makeIDISASRLI( pabloS.inputHandler.Locator locator, FuncCallNode snode) {
    233         return Generators.makeFuncCallNode(locator,
    234                 IDISABitBlockBuiltins.SRLI.IDISALexeme(),
    235                 snode.deepCopy()); // TODO - KH: IDISA
    236     }   
    237        
    238     private static pabloS.ast.ASTNode [] makePabloBlkCallArgs(List<pabloS.ast.ASTNode> arguments,
    239             pabloS.ast.ASTNode call, pabloS.ast.ASTNode returnValue) {
    240         List<pabloS.ast.ASTNode> args = new ArrayList<pabloS.ast.ASTNode>(arguments);
    241         args.add(call);
    242         args.add(returnValue);
    243         return args.toArray(new pabloS.ast.ASTNode [args.size()]);
    244     }   
    245    
     226
    246227}
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/pabloS2PabloB/PabloS2PabloBXFormer.java

    r3376 r3378  
    361361       
    362362        public ASTNode visitLeave(pabloS.ast.AssignNode snode, List<ASTNode> childResults) {
    363        
     363
    364364            pabloS.ast.ASTNode rhs = toolchain.pabloS.ast.Accessors.rhs(snode);
    365            
     365
    366366            if(BuiltinCallUtil.isCarry(rhs)) {
    367367               
    368                
    369                
    370                 int carry1;
    371                 //try {
    372                     System.out.println("Looking up...");
    373                     System.out.println(rhs);
     368                if(infoSetMap.containsKey(rhs)) {
     369
     370                    int carry1Position = infoSetMap.get(rhs).carry1Position();
     371                                       
     372                    PabloSBuiltin builtin = BuiltinCallUtil.builtin(rhs);
     373                    PabloSBuiltinTranslator translator = builtin.getTranslator();
     374                    ASTNode replacement = translator.translate(builtin, (pabloS.ast.FuncCallNode) rhs, context, childResults, carry1Position);
    374375                   
    375                     if(this.infoSetMap.containsKey(snode)) {
     376//                   
     377//                    pabloS.inputHandler.Locator locator = snode;
     378////                    snode.appendChild(toolchain.pabloS.ast.Generators.makeGetCallCarryForBuiltin(locator, builtin, carry1, context));
    376379                   
    377                         //    System.out.println(snode);
    378                        
    379                     } else {
    380                        
    381                         System.out.println("NOT FOUND");
    382                        
    383                         System.out.println(snode);
    384                        
    385                     }
    386                    
    387                 ASTNode replacement  = new AssignNode(Generators.makeToken(snode.getToken()));
    388                 appendChildResults(replacement, childResults);
    389                 return replacement;               
    390                
    391             } else {
    392                 ASTNode replacement  = new AssignNode(Generators.makeToken(snode.getToken()));
    393                 appendChildResults(replacement, childResults);
    394                 return replacement;
    395             }
    396            
    397 
    398            
    399         }
    400        
    401     }   
     380//                    ASTNode replacement  = new AssignNode(Generators.makeToken(snode.getToken()));
     381//                    appendChildResults(replacement, childResults);
     382                    return replacement;
     383                     
     384                }
     385            }
     386           
     387            ASTNode replacement  = new AssignNode(Generators.makeToken(snode.getToken()));
     388            appendChildResults(replacement, childResults);
     389            return replacement;
     390        }   
    402391   
    403392    private static void surroundConditionWithBitBlockAny(ASTNode node, ASTNode condition) {
    404393        Locator locator = node;
    405        
    406        
    407394        ASTNode replacement = Generators.makeIdisaFuncCallNode(locator, BITBLOCK_ANY, BITBLOCK_SIZE, Generators.arguments(condition.deepCopy()));
    408        
    409395        node.replaceChild(condition, replacement);
    410396    }
    411 
     397    }
    412398   
    413399/*     
Note: See TracChangeset for help on using the changeset viewer.