Changeset 3384 for proto/pabloj/trunk


Ignore:
Timestamp:
Jul 4, 2013, 7:37:56 PM (6 years ago)
Author:
ksherdy
Message:

Partial check in marked for reversion. Progress towards S->S, S->B, B->B translation organization.

Location:
proto/pabloj/trunk
Files:
1 added
1 deleted
11 edited

Legend:

Unmodified
Added
Removed
  • proto/pabloj/trunk/output/cpplang/pablo_definitions.hpp

    r3381 r3384  
    732732        Parse_CtCDPI()
    733733        {
    734                 carry_set_0.setCarry(carry_set_0.carryFlip(2),2);
    735734        }
    736735       
     
    756755                w = simd_or(lex.Hyphen,lex.QMark);
    757756                BitBlock v1;
    758                 carry_set_0.getPending64(0) = bitblock::srli<127>(pablo_blk_Advance_n_<1>(v,1,carry_set_0.getPending64(0),v1));
     757                carry_set_0.getPending64(0) = bitblock::srli<127>(pablo_blk_Advance_n_<v>(1,carry_set_0.getPending64(0),v1));
    759758                BitBlock w1;
    760                 carry_set_0.getPending64(1) = bitblock::srli<127>(pablo_blk_Advance_n_<1>(w,1,carry_set_0.getPending64(1),w1));
     759                carry_set_0.getPending64(1) = bitblock::srli<127>(pablo_blk_Advance_n_<w>(1,carry_set_0.getPending64(1),w1));
    761760                BitBlock LAngle_scope;
    762761                LAngle_scope = simd_andc(v1,w1);
     
    973972                w = simd_or(lex.Hyphen,lex.QMark);
    974973                BitBlock v1;
    975                 carry_set_0.getPending64(0) = bitblock::srli<127>(pablo_blk_Advance_n_<1>(v,1,carry_set_0.getPending64(0),v1));
     974                carry_set_0.getPending64(0) = bitblock::srli<127>(pablo_blk_Advance_n_<v>(1,carry_set_0.getPending64(0),v1));
    976975                BitBlock w1;
    977                 carry_set_0.getPending64(1) = bitblock::srli<127>(pablo_blk_Advance_n_<1>(w,1,carry_set_0.getPending64(1),w1));
     976                carry_set_0.getPending64(1) = bitblock::srli<127>(pablo_blk_Advance_n_<w>(1,carry_set_0.getPending64(1),w1));
    978977                BitBlock LAngle_scope;
    979978                LAngle_scope = simd_andc(v1,w1);
     
    11681167        }
    11691168       
    1170         CarryDeclare(carry_set_0,17,2);
     1169        CarryDeclare(carry_set_0,30,2);
    11711170};
    11721171 
     
    14921491        }
    14931492       
    1494         CarryDeclare(carry_set_0,13,0);
     1493        CarryDeclare(carry_set_0,20,0);
    14951494};
    14961495 
  • proto/pabloj/trunk/src/application/generators/ApplicationGenerator.java

    r3355 r3384  
    1818
    1919import toolchain.pabloS.ast.Accessors;
     20import toolchain.pabloS.transformer.visitors.pabloS2PabloB.PabloS2PabloBController;
    2021import toolchain.pabloS.transformer.visitors.pabloS2PabloB.PabloS2PabloBXFormer;
     22import toolchain.pabloS.transformer.visitors.pabloS2pabloS.PabloS2SPabloController;
    2123import toolchain.pabloS.transformer.visitors.pabloS2pabloS.SomeNameStreamFunctionPropertySet;
    2224import toolchain.pabloS.transformer.visitors.pabloS2pabloS.SomeNameStreamFunctionPropertySetFactory;
     
    7173                if(applicationConfiguration.getSource() == SourceLanguage.PABLO_S) {
    7274                    //////////////////////////////////////////////////////////////
    73                     // Parse
     75                    // Parse PabloS input
    7476                    pabloS.ast.ASTNode pabloSAST = ASTGenerator.buildPabloSAST(applicationConfiguration.sourceFile());
    7577                                               
    7678            //////////////////////////////////////////////////////////////
    77             // S2S Transform
    78                         pabloS.ast.ASTNode decoratedTree = toolchain.pabloS.transformer.visitors.pabloS2pabloS.PabloS2SPabloController.accept(pabloSAST);
    79                         pabloS.ast.ASTNode finalDecoratedTree = toolchain.pabloS.transformer.visitors.pabloS2pabloS.PabloS2SPabloController.accept(pabloSAST);
    80 
    81                         ArrayList<pabloS.ast.FuncDefNode> funcDefNodes = StreamFunctionDefs.forTree(pabloSAST);
    82                         Map<String, SomeNameStreamFunctionPropertySet> streamFunctionPropertySetMap = new LinkedHashMap<String, SomeNameStreamFunctionPropertySet>();
    83                        
    84                         for(pabloS.ast.FuncDefNode funcDefNode : funcDefNodes) {
    85                             SomeNameStreamFunctionPropertySet value = SomeNameStreamFunctionPropertySetFactory.apply(funcDefNode);
    86                             String key = Accessors.funcName(funcDefNode);
    87                             streamFunctionPropertySetMap.put(key, value);
    88                         }
     79            // PabloS to PabloS transformations
     80                        pabloS.ast.ASTNode decoratedTree             = PabloS2SPabloController.accept(pabloSAST);
     81                        pabloS.ast.ASTNode finalBlockDecoratedTree   = PabloS2SPabloController.accept(pabloSAST);
    8982                                               
    9083                        // Transform PabloS global functions in non-final block mode
    91                         decoratedTree = toolchain.pabloS.transformer.visitors.pabloS2PabloB.PabloS2PabloBController.accept(decoratedTree);
     84                        decoratedTree = PabloS2PabloBController.accept(decoratedTree);                       // <-- delete with S2B impl
    9285                       
    9386            // Transform PabloS global functions in final block mode
    94                         toolchain.pabloS.transformer.visitors.pabloS2PabloB.PabloS2PabloBController.setFinalBlockMode(true);
     87                        PabloS2PabloBController.setFinalBlockMode(true);                                     // <-- delete with S2B impl
     88                        finalBlockDecoratedTree = PabloS2PabloBController.accept(finalBlockDecoratedTree);   // <-- delete with S2B impl
    9589                       
    96                         finalDecoratedTree = toolchain.pabloS.transformer.visitors.pabloS2PabloB.PabloS2PabloBController.accept(finalDecoratedTree);
    97                         PabloS2PabloBXFormer.setStreamFunctionPropertySetMap(streamFunctionPropertySetMap);
     90            //////////////////////////////////////////////////////////////
     91            // PabloS to PabloB transformation
    9892                        PabloS2PabloBXFormer.setPabloSBuiltinEncoder(pabloSbuiltinsEncoder);
    9993                        PabloS2PabloBXFormer.setCarrySetEncoder(carrySetEncoder);
    100 
    101             //////////////////////////////////////////////////////////////
    102             // S2B Transform
    103                         pabloBAST = PabloS2PabloBXFormer.apply(decoratedTree, finalDecoratedTree);
     94                        pabloBAST = PabloS2PabloBXFormer.apply(decoratedTree, finalBlockDecoratedTree);
    10495                       
    10596                } else if (applicationConfiguration.getSource() == SourceLanguage.PABLO_B) {
    106 
    107                         pabloBAST = ASTGenerator.buildPabloBAST(applicationConfiguration.sourceFile());
     97            //////////////////////////////////////////////////////////////
     98            // Parse PabloB input
     99                    pabloBAST = ASTGenerator.buildPabloBAST(applicationConfiguration.sourceFile());
    108100                }
    109101
    110102        //////////////////////////////////////////////////////////////
    111         // B2B Transform
     103        // PabloB to PabloB transformations
    112104                PabloB2PabloBController.setBuiltins2Lang(pabloBBuiltinsEncoder);
    113105       
  • proto/pabloj/trunk/src/toolchain/pabloB/ast/Accessors.java

    r3375 r3384  
    4747        // Initialization
    4848        ////////////////////////////////////////////////////////////////////////////
    49        
    50         ////////////////////////////////////////////////////////////////////////////
    51         // Kernel Definition
    52         ////////////////////////////////////////////////////////////////////////////                   
     49                       
    5350        public static FuncDefNode funcDefNode(KernelDefNode node) {
    5451                return (FuncDefNode) node.child(1);
    5552        }
    5653       
    57         public static boolean hasOptFuncDef(KernelDefNode node) {
     54        public static boolean hasFinalBlockFuncDef(KernelDefNode node) {
    5855                if(node.nChildren() > 2 && (node.child(3) instanceof FuncDefNode)) {
    5956                        return true;
     
    6259        }       
    6360       
    64         public static FuncDefNode optFuncDefNode(KernelDefNode node) {
    65                 assert hasOptFuncDef(node);
     61        public static FuncDefNode finalBlockFuncDefNode(KernelDefNode node) {
     62                assert hasFinalBlockFuncDef(node);
    6663                return (FuncDefNode) node.child(2);
    6764        }
     
    7067            return node.child(0);
    7168        }
     69       
     70    public static FuncDefNode funcDefForName(ASTNode node, String name) {
     71
     72        if(node instanceof FuncDefNode) {
     73            if(name(node).equals(name)) {
     74                return (FuncDefNode)node;
     75            }
     76        }
     77
     78        FuncDefNode result = null;
     79
     80        for(ASTNode child : node.getChildren()) {
     81            result = funcDefForName(child, name);
     82            if (result != null) {
     83                return result;
     84            }
     85        }
     86       
     87        return null; 
     88    }
    7289
    7390        ////////////////////////////////////////////////////////////////////////////
  • proto/pabloj/trunk/src/toolchain/pabloB/ast/Generators.java

    r3379 r3384  
    105105        ////////////////////////////////////////////////////////////////////////////
    106106        // Kernel
    107         public static KernelDefNode makeKernelDef(String identifier,
    108                         InitDefNode stateDefNode,
     107        public static KernelDefNode makeKernelDef(Locator locator,
     108                        String name,
     109                        InitDefNode initDefNode,
    109110                        FuncDefNode funcDefNode,
    110                         FuncDefNode optFuncDefNode,
    111                         Locator locator) {
     111                        FuncDefNode optFuncDefNode) {
    112112               
    113113                        LextantToken token = Generators.makeLextantToken(locator, Lextant.KERNEL);
    114114                        KernelDefNode kernelDefNode = new KernelDefNode(token);
    115                         pabloB.ast.IdentifierNode identifierNode = Generators.makeIdentifierNode(locator, identifier);         
     115                        pabloB.ast.IdentifierNode identifierNode = Generators.makeIdentifierNode(locator, name);               
    116116                       
    117117                        kernelDefNode.appendChild(identifierNode);
    118                         kernelDefNode.appendChild(stateDefNode);
     118                        kernelDefNode.appendChild(initDefNode);
    119119                        kernelDefNode.appendChild(funcDefNode.deepCopy());
    120120                        kernelDefNode.appendChild(optFuncDefNode.deepCopy());
     
    382382//    }
    383383
    384     public static ASTNode makeGetCarryCall(Locator locator, int index, Context context) {
     384    public static ASTNode makeGetCarryCall(Locator locator, Context context, int index) {
    385385        return Generators.makeFuncCallNode(
    386386                locator,
     
    390390    }
    391391
    392     public static ASTNode makePending64Call(Locator locator, int index, Context context) {
     392    public static ASTNode makePending64Call(Locator locator, Context context, int index) {
    393393        return Generators.makeFuncCallNode(
    394394                locator,
  • proto/pabloj/trunk/src/toolchain/pabloB/ast/Mutators.java

    r3208 r3384  
    33import pabloB.ast.ASTNode;
    44import pabloB.ast.BlockStmtNode;
     5import pabloB.ast.FuncDefNode;
     6import pabloB.ast.IdentifierNode;
    57
    68public class Mutators {         
     
    1517                parent.insertAfterChild(node, newNode);
    1618        }
     19       
     20        static public void rename(FuncDefNode node, String newName) {
     21            IdentifierNode doBlockIdentifier = Generators.makeIdentifierNode(node, newName);
     22            node.replaceChild(Accessors.funcIdentifier(node), doBlockIdentifier);   
     23        }
    1724
    1825}
  • proto/pabloj/trunk/src/toolchain/pabloB/codeGenerator/visitors/Unparser.java

    r3370 r3384  
    114114                code.addAll(funcDefCodeStore, 0);
    115115               
    116                 if(Accessors.hasOptFuncDef(node)) {
     116                if(Accessors.hasFinalBlockFuncDef(node)) {
    117117                        CodeStore optFuncDefCodeStore = childResults.get(3);
    118118                        // optFuncDefCodeStore.prependToFirst("IDISA_INLINE ");
     
    121121
    122122                CodeStore carryDeclareCodeStore;
    123                 if(Accessors.hasOptFuncDef(node)) {
    124                         carryDeclareCodeStore = childResults.get(4);
     123                if(Accessors.hasFinalBlockFuncDef(node)) {
     124                    carryDeclareCodeStore = childResults.get(4);
    125125                } else {
    126126                        carryDeclareCodeStore = childResults.get(3);
  • proto/pabloj/trunk/src/toolchain/pabloS/ast/Accessors.java

    r3359 r3384  
    4343                return funcDefs;
    4444        }
     45       
     46        public static List<String> funcDefNames(ProgramNode node) {
     47
     48            assert node instanceof ProgramNode;
     49           
     50            List<String> names = new ArrayList<String>();
     51           
     52            for(FuncDefNode funcDef : funcDefs(node)) {
     53                names.add(name(funcDef));
     54            }
     55            return names;
     56        }
     57       
     58    public static FuncDefNode funcDefForName(ASTNode node, String name) {
     59
     60        if(node instanceof FuncDefNode) {
     61            if(name(node).equals(name)) {
     62                return (FuncDefNode)node;
     63            }
     64        }
     65
     66        FuncDefNode result = null;
     67
     68        for(ASTNode child : node.getChildren()) {
     69            result = funcDefForName(child, name);
     70            if (result != null) {
     71                return result;
     72            }
     73        }
     74       
     75        return null; 
     76    }
    4577               
    4678        public static boolean isTerminal(ASTNode node) {
  • proto/pabloj/trunk/src/toolchain/pabloS/lang/PabloSBuiltin.java

    r3375 r3384  
    55
    66import toolchain.pabloS.lang.signatures.FunctionSignature;
     7import toolchain.pabloS.lang.PabloSBuiltinTranslator;
     8import static toolchain.pabloS.lang.signatures.SignatureShorthand.*;
    79import static toolchain.pabloS.lang.PabloSBuiltinTranslator.*;
    8 import static toolchain.pabloS.lang.signatures.SignatureShorthand.*;
    910
    1011public enum PabloSBuiltin {
  • proto/pabloj/trunk/src/toolchain/pabloS/lang/PabloSBuiltinTranslator.java

    r3381 r3384  
    2020import toolchain.pabloB.ast.Generators;
    2121
     22import toolchain.pabloS.lang.BuiltinCallUtil;
     23import toolchain.pabloS.lang.PabloSBuiltin;
    2224import toolchain.pabloS.transformer.visitors.infoSet.Counter;
    2325import toolchain.pabloS.transformer.visitors.pabloS2PabloB.Context;
    2426
    25 // BuiltinTranslators translate a builtin call from pabloS to pabloB during the
    26 // CarryIntroTransformer visit of the ast.
    27 //
     27// BuiltinTranslators translate a builtin call from pabloS to pabloB 'pablo_blk_call' AST node
     28
    2829// The enum values follow the Command pattern, with the benefit of the client not
    2930// having to instantiate the commands.
     
    3233   
    3334        CARRY_TRANSLATION {     
    34                 public ASTNode translate(PabloSBuiltin builtin, pabloS.ast.FuncCallNode snode, Context context, List<ASTNode> childResults, int carry1Position) {
     35                public ASTNode translate(PabloSBuiltin builtin, pabloS.ast.FuncCallNode snode, Context context, List<ASTNode> args) {
    3536           
    3637                    Locator locator = Generators.makeToken(snode.getToken());
    3738                   
    38             String pabloBlkCallFuncName                         = context.getCode(builtin);
    39            
    40             ASTNode getCarryCall = Generators.makeGetCarryCall(locator, carry1Position, context);
    41             ASTNode returnValue = childResults.get(0);
    42             ASTNode[] pabloBlkFuncCallArgs = listAsArray(locator, childResults, getCarryCall, returnValue);
    43            
    44             ASTNode pabloBlkFuncCall = Generators.makeFuncCallNode(locator, pabloBlkCallFuncName, pabloBlkFuncCallArgs);
    45            
    46             ASTNode srliValue       = Generators.makeIntegerConstantNode(locator, BITBLOCK_SIZE - 1);
    47            
     39            String pabloBlkCallFuncName     = context.getCode(builtin);
     40            ASTNode pabloBlkFuncCall        = Generators.makeFuncCallNode(locator, pabloBlkCallFuncName, arrayFromList(args));
     41            ASTNode srliValue               = Generators.makeIntegerConstantNode(locator, BITBLOCK_SIZE - 1);
    4842           
    4943            return Generators.makeIdisaFuncCallNode(locator, BITBLOCK_SRLI, BITBLOCK_SIZE, srliValue, pabloBlkFuncCall);
     
    5246
    5347        ADVANCEN_TRANSLATION {
    54                 public ASTNode translate(PabloSBuiltin builtin, pabloS.ast.FuncCallNode snode, Context context, List<ASTNode> childResults, int carryNPosition) {
    55                     Locator locator = Generators.makeToken(snode.getToken());
     48                public ASTNode translate(PabloSBuiltin builtin, pabloS.ast.FuncCallNode snode, Context context, List<ASTNode> args) {
     49                    Locator locator = Generators.makeTextLocation(snode.getLocation());
    5650                       
    57                         pabloS.ast.ASTNode formatValue = toolchain.pabloS.ast.Accessors.argument(snode, 1);
    58                     String value = toolchain.pabloS.ast.Accessors.lexeme(formatValue);
    59                     String templateCode = context.getCode(builtin);
    60                     String pabloBlkCallFuncName = String.format(templateCode, value);         
    61            
    62             ASTNode getCarryCall = Generators.makePending64Call(locator, carryNPosition, context);
    63             ASTNode returnValue = childResults.get(0);
    64            
    65             List<ASTNode> pabloBlkArgs = new ArrayList();
    66             //
    67             //
    68             //
    69             //
    70             //
    71             ASTNode[] pabloBlkFuncCallArgs = listFromArray(locator, removeAdvanceNConstantArg(childResults), getCarryCall, returnValue);
    72            
    73             ASTNode pabloBlkFuncCall = Generators.makeFuncCallNode(locator, pabloBlkCallFuncName, pabloBlkFuncCallArgs);
    74             ASTNode srliValue       = Generators.makeIntegerConstantNode(locator, BITBLOCK_SIZE - 1);
     51                    ASTNode formatValue       = args.remove(0);
     52                    String value              = Accessors.lexeme(formatValue);
     53                    String templateCode       = context.getCode(builtin);
     54
     55                    String pabloBlkCallFuncName   = String.format(templateCode, value);         
     56                    ASTNode pabloBlkFuncCall      = Generators.makeFuncCallNode(locator, pabloBlkCallFuncName, arrayFromList(args));
     57                    ASTNode srliValue             = Generators.makeIntegerConstantNode(locator, BITBLOCK_SIZE - 1);
    7558                   
    7659                    return Generators.makeIdisaFuncCallNode(locator, BITBLOCK_SRLI, BITBLOCK_SIZE, srliValue, pabloBlkFuncCall);
    7760                }
    78 
    79         private List<ASTNode> removeAdvanceNConstantArg(List<ASTNode> childResults) {
    80                 List<ASTNode> args = new ArrayList<ASTNode>();
    81                 for(int i=1; i<childResults.size(); i++) {
    82                         args.add(childResults.get(i));
    83                 }
    84             return args;
    85         }
    8661        },
    8762       
    8863        SCANTO_TRANSLATION {
    89         public ASTNode translate(PabloSBuiltin builtin, pabloS.ast.FuncCallNode snode, Context context, List<ASTNode> childResults, int carry1Position) {
    90             return scanToTranslate(PabloSBuiltin.SCAN_THRU, snode, context, childResults, carry1Position);
     64        public ASTNode translate(PabloSBuiltin builtin, pabloS.ast.FuncCallNode snode, Context context, List<ASTNode> args) {
     65            return scanToTranslate(PabloSBuiltin.SCAN_THRU, snode, context, args);
    9166        }
    9267    },
    9368
    9469    ADVANCE_THEN_SCANTO_TRANSLATION {
    95         public ASTNode translate(PabloSBuiltin builtin, pabloS.ast.FuncCallNode snode, Context context, List<ASTNode> childResults, int carry1Position) {
    96             return scanToTranslate(PabloSBuiltin.ADVANCE_THEN_SCAN_THRU, snode, context, childResults, carry1Position);
     70        public ASTNode translate(PabloSBuiltin builtin, pabloS.ast.FuncCallNode snode, Context context, List<ASTNode> args) {
     71            return scanToTranslate(PabloSBuiltin.ADVANCE_THEN_SCAN_THRU, snode, context, args);
    9772        }
    9873    },
    9974   
    10075    ASSERT_ZERO_TRANSLATION {
    101         public ASTNode translate(PabloSBuiltin builtin, pabloS.ast.FuncCallNode snode, Context context,  List<ASTNode> childResults) {
     76        public ASTNode translate(PabloSBuiltin builtin, pabloS.ast.FuncCallNode snode, Context context, List<ASTNode> args) {
    10277           
    10378            Locator locator = Generators.makeToken(snode.getToken());
    10479           
    105             FuncCallArgListNode args = (FuncCallArgListNode) childResults.get(1);
    106             ASTNode errorStream      = args.child(0);
    107             ASTNode errorMsg         = args.child(1);
     80            ASTNode errorStream                     = args.get(0);
     81            ASTNode errorMsg                        = args.get(1);
    10882           
    10983            String assert0CallName                  = context.getBuiltinEncoder().getName(PabloSBuiltin.ASSERT_ZERO);
    11084
    111             ASTNode assert0Call                     = Generators.makeFuncCallNode(locator,
    112                     assert0CallName,
    113                     errorStream,             
    114                     errorMsg);
     85            ASTNode assert0Call                     = Generators.makeFuncCallNode(locator, assert0CallName, errorStream, errorMsg);
    11586
    11687            BlockStmtNode blockStmt                 = Generators.makeBlockStmtNode(locator, assert0Call);
    117             IfStmtNode replacement                  = Generators.makeIfStmtNode(locator,
    118                     errorStream.deepCopy(),
    119                     blockStmt);
     88            IfStmtNode replacement                  = Generators.makeIfStmtNode(locator, errorStream.deepCopy(), blockStmt);
    12089
    12190            surroundConditionWithBitBlockAny(replacement, Accessors.condition(replacement));
     
    12796   
    12897    ATEOF_TRANSLATION {
    129         public ASTNode translate(PabloSBuiltin builtin, pabloS.ast.FuncCallNode snode, Context context, List<ASTNode> childResults) {
    130            
     98        public ASTNode translate(PabloSBuiltin builtin, pabloS.ast.FuncCallNode snode, Context context, List<ASTNode> args) {
    13199            Locator locator = Generators.makeToken(snode.getToken());
    132100           
    133             FuncCallArgListNode args = (FuncCallArgListNode) childResults.get(1);
    134             ASTNode arg0 = args.child(0);
    135            
    136101            if(context.isFinalBlockMode()) {
    137                 return Generators.makeSIMDAndCEOFMaskFuncCall(locator, arg0);
     102                return Generators.makeSIMDAndCEOFMaskFuncCall(locator, args.get(0));
    138103
    139104            } else {             
    140105                FieldWidthNode fieldWidth = Generators.makeIdisaFieldWidthNode(locator, 1);
    141106                ASTNode value = Generators.makeIntegerConstantNode(locator, 0);
    142                
    143107                return Generators.makeIdisaFuncCallNode(locator, SIMD_CONSTANT, fieldWidth, value);       
    144108            }
     
    147111
    148112    INFILE_TRANSLATION {
    149         public ASTNode translate(PabloSBuiltin builtin, pabloS.ast.FuncCallNode snode, Context context, List<ASTNode> childResults) {
    150            
     113               
     114        public ASTNode translate(PabloSBuiltin builtin, pabloS.ast.FuncCallNode snode, Context context, List<ASTNode> args) {
    151115            Locator locator = Generators.makeToken(snode.getToken());
    152116           
    153             FuncCallArgListNode args = (FuncCallArgListNode) childResults.get(1);
    154             ASTNode arg0 = args.child(0);
    155            
    156117            if(context.isFinalBlockMode()) {
    157                 return Generators.makeSIMDAndEOFMaskFuncCall(locator, arg0);
     118                return Generators.makeSIMDAndEOFMaskFuncCall(locator, args.get(0));
    158119            } else {
    159                 return arg0;
     120                return args.get(0);
    160121            }
    161122        }
     
    163124
    164125    MASK_TRANSLATION {
    165         public ASTNode translate(PabloSBuiltin builtin, pabloS.ast.FuncCallNode snode, Context context, List<ASTNode> childResults) {
     126        public ASTNode translate(PabloSBuiltin builtin, pabloS.ast.FuncCallNode snode, Context context, List<ASTNode> args) {
    166127           
    167128            Locator locator = Generators.makeToken(snode.getToken());
    168 
    169             FuncCallArgListNode args    = (FuncCallArgListNode) childResults.get(1);
    170             IntegerConstantNode n       = (IntegerConstantNode)args.child(0);
     129            IntegerConstantNode n       = (IntegerConstantNode)args.get(0);
    171130            ASTNode fieldWidth          = Generators.makeIdisaFieldWidthNode(locator, Accessors.intValue(n));
    172             ASTNode maskValue           = args.child(1);
    173            
     131            ASTNode maskValue           = args.get(1);
    174132            return Generators.makeIdisaFuncCallNode(locator, SIMD_CONSTANT, (FieldWidthNode) fieldWidth, maskValue);
    175133        }
    176134    };
    177    
    178     private static ASTNode scanToTranslate(PabloSBuiltin builtin, pabloS.ast.FuncCallNode snode, Context context, List<ASTNode> childResults, int carry1Position) {
     135
     136    public ASTNode translate(PabloSBuiltin builtin, pabloS.ast.FuncCallNode node, Context context, List<ASTNode> args) {
     137        assert false : "'pablo_blk_' PabloSBuiltin translate not implemented for PabloSBuitin: " + this.name();
     138        return null;
     139    }
     140
     141    // Helpers
     142   
     143    private static ASTNode scanToTranslate(PabloSBuiltin builtin, pabloS.ast.FuncCallNode snode, Context context, List<ASTNode> args) {
    179144        pabloS.ast.ASTNode argument = toolchain.pabloS.ast.Accessors.argument(snode, 1);
    180145        translateArgument(context, argument);
     
    183148
    184149        snode.replaceChild(toolchain.pabloS.ast.Accessors.nameNode(snode), replacement);
    185         return CARRY_TRANSLATION.translate(builtin, snode, context, childResults, carry1Position);
     150        return CARRY_TRANSLATION.translate(builtin, snode, context, args);
    186151    }
    187152   
     
    190155            pabloS.ast.ASTNode replacement = toolchain.pabloS.ast.Generators.makeSIMDEOFMaskAndCNodeFuncCall(argument.deepCopy(), context.getBuiltinEncoder());
    191156            argument.updateSelf(replacement);
    192         }
    193         else {
     157        } else {
    194158            pabloS.ast.ASTNode replacement = toolchain.pabloS.ast.Generators.makeSIMDNotFuncCall(argument.deepCopy(), context.getBuiltinEncoder());
    195159            argument.updateSelf(replacement);           
    196160        }
    197161    }   
    198    
    199     // TODO - KH: Added to support multiple 'translate' signatures. May be a poor use of Java.
    200     public void translate(PabloSBuiltin builtin, pabloS.ast.FuncCallNode node, Context context) {
    201         assert false : "General PabloSBuiltin translate not implemented for PabloSBuitin: " + this.name();
    202     }
    203    
    204     public void translate(PabloSBuiltin builtin, pabloS.ast.FuncCallNode node, Counter counter, Context context) {
    205         assert false : "General PabloSBuiltin translate not implemented for PabloSBuitin: " + this.name();
    206     }
    207    
    208         public ASTNode translate(PabloSBuiltin builtin, pabloS.ast.FuncCallNode node, Context context, List<ASTNode> childResults, int carry1Position) {
    209             assert false : "'pablo_blk_' PabloSBuiltin translate not implemented for PabloSBuitin: " + this.name();
    210             return null;
    211         }
    212162
    213         public ASTNode translate(PabloSBuiltin builtin, pabloS.ast.FuncCallNode node, Context context, List<ASTNode> childResults) {
    214             assert false : "'pablo_blk_' PabloSBuiltin translate not implemented for PabloSBuitin: " + this.name();
    215             return null;
    216         }
    217        
    218         private static ASTNode[] listFromArray(List<ASTNode> list) {
    219         return list.toArray(new ASTNode [list.size()]);
    220     }
    221 
    222     // helper methods
    223163    private static void surroundConditionWithBitBlockAny(ASTNode node, ASTNode condition) {
    224164        Locator locator = node;
     
    227167    }   
    228168
     169    private static ASTNode[] arrayFromList(List<ASTNode> list) {
     170        return list.toArray(new ASTNode [list.size()]);
     171    }
     172   
    229173}
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/infoSet/PropertyInfoSet.java

    r3380 r3384  
    2626
    2727    public PropertyInfoSet(int carry1Position, int carryNPosition, int carry1Count, int carryNCount, int lookAhead, int lookBehind) { 
     28       
     29        this(carry1Position, carryNPosition, carry1Count, carryNCount, lookAhead, lookBehind, new ArrayList<Integer>());
     30       
     31        this.carry1InitialValues(new ArrayList<Integer>());
     32    }
     33   
     34    public PropertyInfoSet(int carry1Position, int carryNPosition, int carry1Count, int carryNCount, int lookAhead, int lookBehind, ArrayList<Integer> carry1InitialValues) { 
    2835        this.carry1Position(carry1Position);
    2936        this.carryNPosition(carryNPosition);
     
    3239        this.lookAhead(lookAhead);
    3340        this.lookBehind(lookBehind);
    34         this.carry1InitialValues(new ArrayList<Integer>());
     41        this.carry1InitialValues(carry1InitialValues);
    3542    }
    3643   
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/pabloS2PabloB/PabloS2PabloBXFormer.java

    r3381 r3384  
    1616import pabloB.ast.*;
    1717import pabloB.inputHandler.*;
     18import pabloB.tokens.Token;
    1819import toolchain.pabloB.lang.KernelState;
    1920import toolchain.pabloB.ast.Accessors;
    2021import toolchain.pabloB.ast.Generators;
     22import toolchain.pabloB.ast.Mutators;
    2123import static toolchain.pabloB.lang.types.PrimitiveType.BITBLOCK_SIZE;
    2224import static toolchain.pabloB.lang.idisa.IDISABuiltin.*;
     
    2628import toolchain.pabloS.lang.PabloSBuiltin;
    2729import toolchain.pabloS.lang.PabloSBuiltinEncoder;
     30import toolchain.pabloS.lang.carrySet.CarrySetEncoder;
    2831import toolchain.pabloS.lang.PabloSBuiltinTranslator;
    29 import toolchain.pabloS.lang.carrySet.CarrySetEncoder;
    30 
    31 
    32 import toolchain.pabloS.transformer.visitors.infoSet.InfoSetMap;
     32
     33import toolchain.pabloS.transformer.visitors.infoSet.PropertyInfoSetMapBuilder;
    3334import toolchain.pabloS.transformer.visitors.infoSet.PropertyInfoSet;
    34 import toolchain.pabloS.transformer.visitors.pabloS2pabloS.SomeNameStreamFunctionPropertySet;
    3535
    3636public class PabloS2PabloBXFormer {
    3737
    38     private static final String DO_BLOCK                = "do_block";
    39     private static final String DO_OPT_BLOCK    = "do_final_block";
    40 
    41     public static Boolean       PABLO2PABLOB_XFORM_SUPPORT = false;
    42     public static String        PABLO2PABLOB_XFORM_SUPPORT_MSG = "PabloS to PabloB node transformation not supported.";
    43 
    44     private static Map<String, SomeNameStreamFunctionPropertySet> streamFunctionPropertySetMap;
     38    private static final String DO_BLOCK                    = "do_block";
     39    private static final String DO_FINAL_BLOCK    = "do_final_block";
     40
    4541    private static PabloSBuiltinEncoder builtinEncoder;
    4642    private static CarrySetEncoder carrySetEncoder;
     
    4844    Map<ASTNode, PropertyInfoSet> propertyInfoSetMap;
    4945
    50     public static void setStreamFunctionPropertySetMap(Map<String, SomeNameStreamFunctionPropertySet> map) {
    51         streamFunctionPropertySetMap = map;
    52     }
    53 
    5446    public static void setPabloSBuiltinEncoder(PabloSBuiltinEncoder encoder) {
    5547        builtinEncoder = encoder;
     
    6052    }
    6153
    62     public static pabloB.ast.ASTNode apply(pabloS.ast.ASTNode sASTree, pabloS.ast.ASTNode sFinalASTree) {
     54    public static ASTNode apply(pabloS.ast.ASTNode pabloSASTree, pabloS.ast.ASTNode pabloSFinalBlockASTree) {
    6355
    6456        //////////////////////////////////////////////////////////////
    6557        // Prepare
    66         Map<pabloS.ast.ASTNode, PropertyInfoSet> infoSetMap = InfoSetMap.forTree(sASTree);
    67         Map<pabloS.ast.ASTNode, PropertyInfoSet> finalInfoSetMap = InfoSetMap.forTree(sFinalASTree);
    68 
    69         ASTNode ASTree          = sASTree.accept(new ASTBuilder(infoSetMap,false));        // TODO - KH: context object stuff, property info set, ...
    70         ASTNode finalASTree      = sFinalASTree.accept(new ASTBuilder(finalInfoSetMap, true));
    71 
    72         Map<String, FuncDefNode> map         = makeFuncDefMap(ASTree);
    73         Map<String, FuncDefNode> finalMap        = makeFuncDefMap(finalASTree );
    74 
    75         for (Map.Entry<String, FuncDefNode> entry : map.entrySet())
    76         {       
    77             FuncDefNode funcDefNode                 = entry.getValue();
    78             FuncDefNode finalFuncDefNode            = finalMap.get(entry.getKey());
    79 
    80             Locator locator = funcDefNode;
    81 
    82             IdentifierNode doBlockIdentifier        = Generators.makeIdentifierNode(locator, DO_BLOCK);
    83             funcDefNode.replaceChild(Accessors.funcIdentifier(funcDefNode), doBlockIdentifier);
    84 
    85             IdentifierNode doFinalBlockIdentifier   = Generators.makeIdentifierNode(locator, DO_OPT_BLOCK);
    86             finalFuncDefNode.replaceChild(Accessors.funcIdentifier(finalFuncDefNode), doFinalBlockIdentifier);                 
    87 
    88             String kernelName = entry.getKey();                 
    89             SomeNameStreamFunctionPropertySet streamFunctionPropertySet = streamFunctionPropertySetMap.get(kernelName);
    90 
    91             ////////////////////////////////////////////////////////////
    92             // Kernel state parameters
    93             ////////////////////////////////////////////////////////////
    94             InitDefNode stateDefNode = Generators.makeInitDefNode(funcDefNode);                 
    95 
    96             ////////////////////////////////////////////////////////////
    97             // Carry1
    98             IdentifierNode propertyName                 = Generators.makeIdentifierNode(locator, KernelState.CARRY1_INITIAL_VALUES.name());
    99             PropertyValueNode propertyValue     = Generators.makePropertyValueNode(locator, streamFunctionPropertySet.getCarry1InitValues());
    100             KernelPropertyNode property             = Generators.makeKernelPropertyNode(propertyName, propertyValue);
    101             stateDefNode.appendChild(property);
    102 
    103             ////////////////////////////////////////////////////////////
    104             // Carry1 Count
    105             propertyName        = Generators.makeIdentifierNode(locator, KernelState.CARRY1_COUNT.name());
    106             propertyValue       = Generators.makePropertyValueNode(locator, streamFunctionPropertySet.carry1Count());
    107             property            = Generators.makeKernelPropertyNode(propertyName, propertyValue);
    108             stateDefNode.appendChild(property);
    109 
    110             ////////////////////////////////////////////////////////////
    111             // CarryN
    112             propertyName       = Generators.makeIdentifierNode(locator, KernelState.CARRYN_INITIAL_VALUES.name());
    113             propertyValue      = Generators.makePropertyValueNode(locator, streamFunctionPropertySet.getCarryNInitValues());
    114             property           = Generators.makeKernelPropertyNode(propertyName, propertyValue);
    115             stateDefNode.appendChild(property);
    116 
    117             ////////////////////////////////////////////////////////////
    118             // CarryN count                     
    119             propertyName       = Generators.makeIdentifierNode(locator, KernelState.CARRYN_COUNT.name());
    120             propertyValue      = Generators.makePropertyValueNode(locator, streamFunctionPropertySet.carryNCount());
    121             property           = Generators.makeKernelPropertyNode(propertyName, propertyValue);
    122             stateDefNode.appendChild(property);
    123 
    124             ////////////////////////////////////////////////////////////
    125             // TODO - KH: LookAhead
    126             propertyName       = Generators.makeIdentifierNode(locator, KernelState.LOOK_AHEAD.name());
    127             propertyValue      = Generators.makePropertyValueNode(locator, 0);
    128             property           = Generators.makeKernelPropertyNode(propertyName, propertyValue);
    129             stateDefNode.appendChild(property);
    130 
    131             ////////////////////////////////////////////////////////////
    132             // TODO - KH: LookBehind
    133             propertyName        = Generators.makeIdentifierNode(locator, KernelState.LOOK_BEHIND.name());
    134             propertyValue       = Generators.makePropertyValueNode(locator, 0);
    135             property            = Generators.makeKernelPropertyNode(propertyName, propertyValue);
    136             stateDefNode.appendChild(property);
    137 
    138             KernelDefNode kernelDefNode =
    139                     Generators.makeKernelDef(kernelName,
    140                             stateDefNode,
    141                             funcDefNode,
    142                             finalFuncDefNode,
    143                             locator);
    144 
    145             ////////////////////////////////////////////////////////////           
    146             // Add CarryFlip call to Kernel init           
     58        Map<pabloS.ast.ASTNode, PropertyInfoSet> propInfoSetMap                         = PropertyInfoSetMapBuilder.forTree(pabloSASTree);
     59        Map<pabloS.ast.ASTNode, PropertyInfoSet> finalBlockPropInfoSetMap               = PropertyInfoSetMapBuilder.forTree(pabloSFinalBlockASTree);
     60
     61        ASTNode pabloBASTree                = pabloSASTree.accept(new PabloS2PabloBTranslator(propInfoSetMap, false));                    // TODO - KH: context object stuff, property info set, ...
     62        ASTNode pabloBFinalBlockASTree      = pabloSFinalBlockASTree.accept(new PabloS2PabloBTranslator(finalBlockPropInfoSetMap, true));
     63
     64        List<pabloS.ast.FuncDefNode> funcDefs = toolchain.pabloS.ast.Accessors.funcDefs((pabloS.ast.ProgramNode) pabloSASTree);
     65       
     66        for(pabloS.ast.FuncDefNode funcDef : funcDefs) {
     67
    14768            Context context = new Context(builtinEncoder,carrySetEncoder); // default context
    148 
    149             Integer [] carry1InitValue = streamFunctionPropertySet.getCarry1InitValues();
    150             for(int i = 0; i < carry1InitValue.length; i++) {   
    151                 if(carry1InitValue[i] > 0) {
    152                     FuncCallNode setCarryFuncCall = Generators.makeCarryFlipCall(locator, i, context);
    153                     stateDefNode.appendChild(setCarryFuncCall);
    154                 }
    155             }
    156 
    157             ////////////////////////////////////////////////////////////           
    158             // Add CarryDeclare call to Kernel   
    159             FuncCallNode carryDeclareCall = Generators.makeCarryDeclareCall(locator,
    160                     streamFunctionPropertySet.carry1Count(),
    161                     streamFunctionPropertySet.carryNCount(),
    162                     context);
    163             kernelDefNode.appendChild(carryDeclareCall);
    164 
    165             // Add Kernel onto the generated PabloB AST
    166             funcDefNode.updateSelf(kernelDefNode);
    167 
    168         }
    169 
    170         return ASTree;
    171     }
    172 
    173     /*
    174      * Recursively builds function name to function definition node map via DFS.
    175      */
    176     private static Map<String, FuncDefNode> makeFuncDefMap(ASTNode node) {
    177 
    178         if(node instanceof FuncDefNode) {
    179             Map<String, FuncDefNode> map = new HashMap<String, FuncDefNode>();
    180             String key = toolchain.pabloB.ast.Accessors.name((FuncDefNode)node);
    181             FuncDefNode value = (FuncDefNode)node;
    182             map.put(key, value);
    183             return map;
    184         }
    185 
    186         Map<String, FuncDefNode> map = new HashMap<String, FuncDefNode>();
    187 
    188         for(ASTNode child : node.getChildren()) {
    189             map.putAll(makeFuncDefMap(child));
    190         }
    191 
    192         return map;     
    193     }   
    194 
    195     /*
    196      * pabloS to pabloB node builder
    197      */
    198     private static class ASTBuilder extends pabloS.ast.ASTVisitor.Default<ASTNode> {
     69           
     70            String kernelName = toolchain.pabloS.ast.Accessors.name(funcDef);
     71            Locator locator = Generators.makeTextLocation(funcDef.getLocation());
     72            PropertyInfoSet propInfoSet = propInfoSetMap.get(funcDef);
     73            InitDefNode initDef = makeInitDefNode(locator, propInfoSet);
     74            addCarryInitFuncCall(locator, context, propInfoSet, initDef);
     75           
     76            FuncDefNode doBlockFuncDef = Accessors.funcDefForName(pabloBASTree, kernelName);
     77            FuncDefNode doFinalBlockFuncDef = Accessors.funcDefForName(pabloBFinalBlockASTree, kernelName);
     78           
     79            Mutators.rename(doBlockFuncDef, DO_BLOCK);              // <-- if not final block
     80            Mutators.rename(doFinalBlockFuncDef, DO_FINAL_BLOCK);   // <-- if final block
     81                       
     82            KernelDefNode kernelDef =
     83                    Generators.makeKernelDef(locator,
     84                            kernelName,
     85                            initDef,
     86                            doBlockFuncDef,
     87                            doFinalBlockFuncDef);
     88           
     89            addCarryDeclareFuncCall(locator, context, propInfoSet, kernelDef);
     90           
     91            doBlockFuncDef.updateSelf(kernelDef);
     92           
     93        }
     94
     95        return pabloBASTree;
     96    }
     97
     98    private static void addCarryInitFuncCall(Locator locator, Context context,
     99            PropertyInfoSet propInfoSet, InitDefNode kernelDef) {
     100       
     101        Integer [] carry1InitValue = arrayFromList(propInfoSet.carry1InitialValues());
     102        for(int i = 0; i < carry1InitValue.length; i++) {   
     103            if(carry1InitValue[i] > 0) {
     104                FuncCallNode setCarryFuncCall = Generators.makeCarryFlipCall(locator, i, context);
     105                kernelDef.appendChild(setCarryFuncCall);
     106            }
     107        }
     108    }
     109   
     110    private static void addCarryDeclareFuncCall(Locator locator,
     111            Context context, PropertyInfoSet propInfoSet,
     112            KernelDefNode initDef) {
     113        FuncCallNode carryDeclareCall = Generators.makeCarryDeclareCall(locator,
     114                propInfoSet.carry1Count(),
     115                propInfoSet.carryNCount(),
     116                context);
     117        initDef.appendChild(carryDeclareCall);
     118    }
     119
     120 
     121
     122    private static InitDefNode makeInitDefNode(Locator locator,
     123            PropertyInfoSet propInfoSet) {
     124       
     125        InitDefNode initDef = Generators.makeInitDefNode(locator);         
     126       
     127        // kernel properties
     128        IdentifierNode propertyName         = Generators.makeIdentifierNode(locator, KernelState.CARRY1_INITIAL_VALUES.name());
     129        PropertyValueNode propertyValue     = Generators.makePropertyValueNode(locator, arrayFromList(propInfoSet.carry1InitialValues()));
     130        KernelPropertyNode property         = Generators.makeKernelPropertyNode(propertyName, propertyValue);
     131        initDef.appendChild(property);
     132
     133        propertyName        = Generators.makeIdentifierNode(locator, KernelState.CARRY1_COUNT.name());
     134        propertyValue       = Generators.makePropertyValueNode(locator, propInfoSet.carry1Count());
     135        property            = Generators.makeKernelPropertyNode(propertyName, propertyValue);
     136        initDef.appendChild(property);
     137
     138        ////////////////////////////////////////////////////////////
     139        // CarryN
     140        // propertyName       = Generators.makeIdentifierNode(locator, KernelState.CARRYN_INITIAL_VALUES.name());
     141        // propertyValue      = Generators.makePropertyValueNode(locator, propInfoSet.getCarryNInitValues());
     142        // property           = Generators.makeKernelPropertyNode(propertyName, propertyValue);
     143        // stateDefNode.appendChild(property);
     144
     145        propertyName       = Generators.makeIdentifierNode(locator, KernelState.CARRYN_COUNT.name());
     146        propertyValue      = Generators.makePropertyValueNode(locator, propInfoSet.carryNCount());
     147        property           = Generators.makeKernelPropertyNode(propertyName, propertyValue);
     148        initDef.appendChild(property);
     149
     150        propertyName       = Generators.makeIdentifierNode(locator, KernelState.LOOK_AHEAD.name());
     151        propertyValue      = Generators.makePropertyValueNode(locator, propInfoSet.lookAhead());
     152        property           = Generators.makeKernelPropertyNode(propertyName, propertyValue);
     153        initDef.appendChild(property);
     154
     155        propertyName        = Generators.makeIdentifierNode(locator, KernelState.LOOK_BEHIND.name());
     156        propertyValue       = Generators.makePropertyValueNode(locator, propInfoSet.lookBehind());
     157        property            = Generators.makeKernelPropertyNode(propertyName, propertyValue);
     158        initDef.appendChild(property);
     159       
     160        return initDef;
     161    }
     162   
     163    private static Integer[] arrayFromList(List<Integer> list) {
     164        return list.toArray(new Integer [list.size()]);
     165    }
     166   
     167    private static class PabloS2PabloBTranslator extends pabloS.ast.ASTVisitor.Default<ASTNode> {
    199168
    200169        private Map<pabloS.ast.ASTNode, PropertyInfoSet> infoSetMap;
    201170        private Context context;
    202        
    203         ASTBuilder(Map<pabloS.ast.ASTNode, PropertyInfoSet> infoSetMap, boolean finalBlockMode) { // TODO - KH: reorganize this part, static interface, etc ...
    204            
     171
     172        PabloS2PabloBTranslator(Map<pabloS.ast.ASTNode, PropertyInfoSet> infoSetMap, boolean finalBlockMode) { // TODO - KH: reorganize this part, static interface, etc ...
     173
    205174            this.infoSetMap = infoSetMap;
    206            
     175
    207176            context = new Context(builtinEncoder, carrySetEncoder, true, finalBlockMode, 0);
    208177        }
    209        
     178
    210179        // General case.
    211180        @Override
     
    233202            }
    234203        }
    235        
     204
    236205        ////////////////////////////////////////////////////////////////////////////////////
    237206        // Special PabloS to PabloB translation cases.
    238         ////////////////////////////////////////////////////////////////////////////////////
    239 
    240         ////////////////////////////////////////////////////////////////////////////////////
    241         // Translates PabloS stream type to PabloB bitblock type   
     207        //
     208
    242209        // TODO - KH: Handle field width attributes on PabloS stream types
    243         //
    244210        public ASTNode visitLeave(pabloS.ast.StreamTypeNode snode, List<ASTNode> childResults) {
    245211
     
    257223        public ASTNode visitLeave(pabloS.ast.FuncCallNode snode, List<ASTNode> childResults) {
    258224
    259             if (BuiltinCallUtil.isCarryNone(snode)) { //
    260                
     225            if (BuiltinCallUtil.isCarryNone(snode)) {
     226
    261227                PabloSBuiltin builtin = BuiltinCallUtil.builtin(snode);
    262228                PabloSBuiltinTranslator translator = builtin.getTranslator();
    263                                
    264                 return translator.translate(builtin, snode, context, childResults);
    265                
     229
     230                ASTNode funcCallArgsList = childResults.get(1);
     231                List<ASTNode> args = funcCallArgsList.getChildren();
     232
     233                return translator.translate(builtin, snode, context, args);
     234
    266235            } else {
    267                
     236
    268237                ASTNode replacement  = new FuncCallNode(Generators.makeToken(snode.getToken()));
    269238                appendChildResults(replacement, childResults);
    270                
     239
    271240                return replacement;
    272241            }
     
    276245            ASTNode replacement = new IntegerConstantNode(Generators.makeToken(snode.getToken()));
    277246            int value = new Integer(replacement.getToken().getLexeme());
    278             ((IntegerConstantNode)replacement).setValue(value); // set integer constant value
     247            ((IntegerConstantNode)replacement).setValue(value);
    279248            appendChildResults(replacement, childResults);
    280249            return replacement;
     
    286255            pabloS.ast.ASTNode lhsS = toolchain.pabloS.ast.Accessors.lhs(snode);
    287256            pabloS.ast.ASTNode rhsS = toolchain.pabloS.ast.Accessors.rhs(snode);
    288            
     257
    289258            ASTNode replacement = null;
    290259
     
    329298
    330299            if(token.isLextant(pabloS.lexicalAnalyzer.Lextant.NOT)) {
    331                 pabloB.inputHandler.TextLocation locator = Generators.makeTextLocation(token.getLocation());
     300                Locator locator = Generators.makeTextLocation(snode.getLocation());
    332301                ASTNode operand = childResults.get(0);
    333302                replacement = Generators.makeIdisaFuncCallNode(locator, SIMD_NOT, BITBLOCK_SIZE, Generators.arguments(operand));
     
    341310        public ASTNode visitLeave(pabloS.ast.IfStmtNode snode, List<ASTNode> childResults) {
    342311
    343             pabloB.tokens.Token pabloBToken = Generators.makeToken(snode.getToken());
     312            Token pabloBToken = Generators.makeToken(snode.getToken());
    344313            IfStmtNode replacement = new IfStmtNode(pabloBToken);
    345314            appendChildResults(replacement, childResults);
    346            
     315
    347316            surroundConditionWithBitBlockAny(replacement, Accessors.condition(replacement));
    348317            return replacement;
    349318        }
    350        
     319
    351320        public ASTNode visitLeave(pabloS.ast.WhileStmtNode snode, List<ASTNode> childResults) {
    352321
    353             pabloB.tokens.Token pabloBToken = Generators.makeToken(snode.getToken());
     322            Token pabloBToken = Generators.makeToken(snode.getToken());
    354323            WhileStmtNode replacement = new WhileStmtNode(pabloBToken);
    355324            appendChildResults(replacement, childResults);
    356            
    357            
     325
     326
    358327            surroundConditionWithBitBlockAny(replacement, Accessors.condition(replacement));
    359328            return replacement;
    360329        }
    361        
     330
    362331        public ASTNode visitLeave(pabloS.ast.AssignNode snode, List<ASTNode> childResults) {
    363332
    364                 pabloS.ast.ASTNode rhs = toolchain.pabloS.ast.Accessors.rhs(snode);
    365 
    366                 if(BuiltinCallUtil.isCarry(rhs)) {
    367 
    368                     Locator locator = Generators.makeToken(snode.getToken());
    369                    
    370                         int carryPosition = 0;
    371                         ASTNode carryCall = null;
    372 
    373                         if(BuiltinCallUtil.isCarry1(rhs)) {
    374 
    375                                         carryPosition = infoSetMap.get(rhs).carry1Position();
    376                                         carryCall = Generators.makeGetCarryCall(locator, carryPosition, context);
    377 
    378                         } else if(BuiltinCallUtil.isCarryN(rhs)) {
    379                                
    380                                         carryPosition = infoSetMap.get(rhs).carryNPosition();
    381                                         carryCall = Generators.makePending64Call(locator, carryPosition, context);
    382                         }
    383                        
    384                         ASTNode getCarryCall = Generators.makeGetCarryCall(locator, carryPosition, context);
    385                         ASTNode lhs = childResults.get(0);
    386                         getCarryCall.appendChild(lhs);
    387 
    388                         PabloSBuiltin builtin = BuiltinCallUtil.builtin(rhs);
    389                         PabloSBuiltinTranslator translator = builtin.getTranslator();
    390                         ASTNode pabloBlkFuncCall = translator.translate(builtin, (pabloS.ast.FuncCallNode) rhs, context, childResults, carryPosition);
    391 
    392                         ASTNode replacement = Generators.makeAssignNode(locator, carryCall, pabloBlkFuncCall);
    393 
    394                         return replacement;
    395 
    396                 } 
    397        
    398         ASTNode replacement  = new AssignNode(Generators.makeToken(snode.getToken()));
    399         appendChildResults(replacement, childResults);
    400         return replacement;
    401     }   
    402    
    403     private static void surroundConditionWithBitBlockAny(ASTNode node, ASTNode condition) {
    404         Locator locator = node;
    405         ASTNode replacement = Generators.makeIdisaFuncCallNode(locator, BITBLOCK_ANY, BITBLOCK_SIZE, Generators.arguments(condition.deepCopy()));
    406         node.replaceChild(condition, replacement);
    407     }
    408     }
    409    
    410 /*     
    411         @SuppressWarnings("unused")
    412         private static pabloS.ast.FuncDefNode searchForFuncDefByName(pabloS.ast.ASTNode node, String name) {
    413 
    414                 if(node instanceof pabloS.ast.FuncDefNode) {
    415                         if(toolchain.pabloS.ast.Accessors.funcName((pabloS.ast.FuncDefNode)node).equals(name)) {
    416                                 return (pabloS.ast.FuncDefNode)node;
    417                         }
    418                 }
    419                
    420                 pabloS.ast.FuncDefNode result = null;
    421                
    422                 for(pabloS.ast.ASTNode child : node.getChildren()) {
    423                         result = searchForFuncDefByName(child, name);
    424                         if (result != null) {
    425                                 break;
    426                         }
    427                 }
    428                
    429                 return result; 
    430         }
    431 */
     333            pabloS.ast.ASTNode rhs = toolchain.pabloS.ast.Accessors.rhs(snode);
     334
     335            if(BuiltinCallUtil.isCarry(rhs)) {
     336
     337                Locator locator = Generators.makeTextLocation(snode.getLocation());
     338
     339                ASTNode funcCallArgsList = childResults.get(1).child(1);
     340                List<ASTNode> args = funcCallArgsList.getChildren();
     341
     342                ASTNode carryCall = null;
     343                if(BuiltinCallUtil.isCarry1(rhs)) {
     344                    int carry1Position = infoSetMap.get(rhs).carry1Position();
     345                    carryCall = Generators.makeGetCarryCall(locator, context, carry1Position);
     346
     347                } else if(BuiltinCallUtil.isCarryN(rhs)) {
     348                    int carryNPosition = infoSetMap.get(rhs).carryNPosition();
     349                    carryCall = Generators.makePending64Call(locator, context, carryNPosition);
     350                }
     351
     352                args.add(carryCall);
     353
     354                ASTNode returnValue = childResults.get(0);
     355                args.add(returnValue);
     356
     357                PabloSBuiltin builtin = BuiltinCallUtil.builtin(rhs);
     358                PabloSBuiltinTranslator translator = builtin.getTranslator();
     359                ASTNode pabloBlkFuncCall = translator.translate(builtin, (pabloS.ast.FuncCallNode) rhs, context, args);
     360
     361                ASTNode replacement = Generators.makeAssignNode(locator, carryCall, pabloBlkFuncCall);
     362
     363                return replacement;
     364
     365            } 
     366
     367            ASTNode replacement  = new AssignNode(Generators.makeToken(snode.getToken()));
     368            appendChildResults(replacement, childResults);
     369            return replacement;
     370        }   
     371
     372        // helpers
     373        private static void surroundConditionWithBitBlockAny(ASTNode node, ASTNode condition) {
     374            Locator locator = node;
     375            ASTNode replacement = Generators.makeIdisaFuncCallNode(locator, BITBLOCK_ANY, BITBLOCK_SIZE, Generators.arguments(condition.deepCopy()));
     376            node.replaceChild(condition, replacement);
     377        }
     378    }
     379
     380
     381
    432382}
    433383
Note: See TracChangeset for help on using the changeset viewer.