Ignore:
Timestamp:
Jun 18, 2013, 1:11:04 PM (6 years ago)
Author:
ksherdy
Message:

Added support for pablo_blk style calls.

Location:
proto/pabloj/trunk/src
Files:
2 added
13 edited
1 copied

Legend:

Unmodified
Added
Removed
  • proto/pabloj/trunk/src/test/pabloS/PabloSTestHarness.java

    r3262 r3325  
    4545            COMBINE_ADVANCES(CombineAdvances.class, "CombineAdvances"),
    4646            CONVERT_BITWISE_BOOLEAN_TO_IDISA_CALLS(ConvertBitwiseBooleanToIDISACalls.class, "ConvertBitwiseBooleanToIDISACalls"),
    47             EXPAND_AUGMENTED_ASSIGNMENTS(ExpandAugmentedAssignments.class, "ExpandAugmentedAssignments"),           
    48             CARRY_INTRO_XFORMER_FINAL_BLOCK(CarryIntroXFormer.class, "CarryIntroXFormerFinalBlock"),
    49             CARRY_INTRO_XFORMER_NOT_FINAL_BLOCK(CarryIntroXFormer.class,"CarryIntroXFormerNotFinalBlock");
     47            EXPAND_AUGMENTED_ASSIGNMENTS(ExpandAugmentedAssignments.class, "ExpandAugmentedAssignments");           
     48            //CARRY_INTRO_XFORMER_FINAL_BLOCK(CarryIntroXFormer.class, "CarryIntroXFormerFinalBlock"),
     49            //CARRY_INTRO_XFORMER_NOT_FINAL_BLOCK(CarryIntroXFormer.class,"CarryIntroXFormerNotFinalBlock");
    5050                   
    5151            private Class<?> clazz;
     
    8888                                        switch (this) {
    8989                                               
    90                                         case CARRY_INTRO_XFORMER_FINAL_BLOCK:
    91                                                 m = clazz.getDeclaredMethod(method, ASTNode.class, BuiltinEncoder.class, CarrySetEncoder.class, boolean.class);
    92                                                 m.invoke(null, syntaxTree, new PabloSBuiltins2CPP(), new CarrySetBuiltins2CPP(), true);
    93                                                 break;
    94                                         case CARRY_INTRO_XFORMER_NOT_FINAL_BLOCK:
    95                                                 m = clazz.getDeclaredMethod(method, ASTNode.class, BuiltinEncoder.class, CarrySetEncoder.class, boolean.class);
    96                                                 m.invoke(null, syntaxTree
    97                                                                 ,new PabloSBuiltins2CPP()
    98                                                                 ,new toolchain.pabloS.lang.carrySet.CarrySetBuiltins2CPP(), false);
    99                                                 break;
     90//                                      case CARRY_INTRO_XFORMER_FINAL_BLOCK:
     91//                                              m = clazz.getDeclaredMethod(method, ASTNode.class, BuiltinEncoder.class, CarrySetEncoder.class, boolean.class);
     92//                                              m.invoke(null, syntaxTree, new PabloSBuiltins2CPP(), new CarrySetBuiltins2CPP(), true);
     93//                                              break;
     94//                                      case CARRY_INTRO_XFORMER_NOT_FINAL_BLOCK:
     95//                                              m = clazz.getDeclaredMethod(method, ASTNode.class, BuiltinEncoder.class, CarrySetEncoder.class, boolean.class);
     96//                                              m.invoke(null, syntaxTree
     97//                                                              ,new PabloSBuiltins2CPP()
     98//                                                              ,new toolchain.pabloS.lang.carrySet.CarrySetBuiltins2CPP(), false);
     99//                                              break;
    100100                                        default:
    101101                                                m = clazz.getDeclaredMethod(method, ASTNode.class);
  • proto/pabloj/trunk/src/toolchain/pabloB/ast/Accessors.java

    r3258 r3325  
    209209    ////////////////////////////////////////////////////////////////////////////
    210210    public static String name(ASTNode node) {
     211       
     212        if(node instanceof FuncCallNode) {
     213            node = funcCallIdentifier((FuncCallNode)node);
     214        }
    211215        assert ((node instanceof IdentifierNode) || (node instanceof CompoundIdentifierNode));
    212216       
  • proto/pabloj/trunk/src/toolchain/pabloB/codeGenerator/visitors/Unparser.java

    r3321 r3325  
    152152            }
    153153
     154            code.addLine("");
     155           
    154156            return code;
    155157        }
  • proto/pabloj/trunk/src/toolchain/pabloB/lang/idisa/IDISABitBlockBuiltins.java

    r3010 r3325  
    22 * IDISA BitBlock builtins.
    33 *
    4  * Add IDISA builtins as needed.
     4 * Added IDISA builtins as needed. This file will *not* live on. This is temporary code.
    55 *
    66 * @author Ken Herdy <ksherdy at sfu dot ca>
     
    1313        ANY("any", 1),
    1414        ALL("all", 1),
     15        SRLI("srli<127>",127),
    1516        POPCOUNT("popcount", 1);
    1617               
  • proto/pabloj/trunk/src/toolchain/pabloB/transformer/visitors/AddAssignmentPrints.java

    r3264 r3325  
    4545                // other methods
    4646                private void addPrintStatement(ASTNode node, ASTNode lhs) {
     47                   
     48                    if(lhs instanceof FuncCallNode) {
     49                        return;
     50                    }
     51                   
     52                    if(lhs instanceof IdentifierNode) {
     53                        if(lhs.getToken().getLexeme().contains("__")) {
     54                            return;
     55                        }
     56                    }
     57                   
    4758                    FuncCallNode printCall = makePrintCall(node, lhs.deepCopy());       // deepCopy
    4859                        Mutators.insertStatementAfter(node, printCall);                         
     
    5162                private FuncCallNode makePrintCall(ASTNode node, ASTNode argument) {
    5263                        String printBitblockCode = encoder.getCode(PabloBBuiltin.PRINT_BITBLOCK);
     64                       
    5365                        ASTNode label = Generators.makeStringConstantNode(node, Accessors.name(argument));
    54                         return Generators.makeFuncCallNode(node.getToken(), printBitblockCode, label, argument);
     66                       
     67                        FuncCallNode call = Generators.makeFuncCallNode(node.getToken(), printBitblockCode, label, argument);
     68                        return call;
    5569                }
    5670        }       
  • proto/pabloj/trunk/src/toolchain/pabloS/ast/Accessors.java

    r3312 r3325  
    122122        return false;
    123123    }       
     124
     125        public static ASTNode lhs(LocalVarDeclNode node) {
     126            return node.child(1);
     127        }       
    124128       
    125129        public static ASTNode rhs(LocalVarDeclNode node) {
  • proto/pabloj/trunk/src/toolchain/pabloS/ast/Generators.java

    r3303 r3325  
    4343            localVarDecl.appendChild(type);
    4444            localVarDecl.appendChild(lhs);
     45           
     46           
     47           
    4548            return localVarDecl;
    4649        }
  • proto/pabloj/trunk/src/toolchain/pabloS/ast/Mutators.java

    r3294 r3325  
    2626        parent.insertBeforeChild(node, newNode);
    2727    }
    28 
     28   
    2929}
  • proto/pabloj/trunk/src/toolchain/pabloS/lang/PabloSBuiltin.java

    r3311 r3325  
    55
    66import toolchain.pabloS.lang.signatures.FunctionSignature;
    7 import static toolchain.pabloS.transformer.visitors.carry.BuiltinTranslator.*;
    87import static toolchain.pabloS.lang.signatures.SignatureShorthand.*;
    98import toolchain.pabloS.transformer.visitors.carry.BuiltinTranslator;
     9import static toolchain.pabloS.transformer.visitors.carry.CarryNoneBuiltinTranslator.*;
     10import static toolchain.pabloS.transformer.visitors.carry.CarryBuiltinTranslator.*;
    1011
    1112public enum PabloSBuiltin {
     
    1819    EXCLUSIVE_SPAN(        "ExclusiveSpan",       CarryType.One, CARRY_TRANSLATION,  sig_SS_S() ),
    1920    ADVANCE_THEN_SCAN_THRU("AdvanceThenScanThru", CarryType.One, CARRY_TRANSLATION,  sig_SS_S()  ),
    20     ADVANCE_THEN_SCAN_TO(  "AdvanceThenScanTo",   CarryType.One, ADVANCE_THEN_SCANTO_TRANSLATION, sig_SS_S()  ), // BuiltinTranslator
    21    
     21    ADVANCE_THEN_SCAN_TO(  "AdvanceThenScanTo",   CarryType.One, ADVANCE_THEN_SCANTO_TRANSLATION,  sig_SS_S()  ), // BuiltinTranslator
    2222    ADVANCE_N(    "AdvanceN",  CarryType.N,    ADVANCEN_TRANSLATION, sig_SI_S() ), // AdvNCounterVisitor   
    23     ADVANCE_32(   "Advance32", CarryType.N,    CARRY_TRANSLATION,    sig_S_S()  ),
    2423
    2524    MASK(         "Mask",      CarryType.None, MASK_TRANSLATION,     sig_II_S() ), // visitors.carry.Counter   
  • proto/pabloj/trunk/src/toolchain/pabloS/lang/PabloSBuiltins2C.java

    r3211 r3325  
    1212        pabloS2CCode = new HashMap<PabloSBuiltin, String>();
    1313       
    14         pabloS2CCode.put(PabloSBuiltin.ADVANCE,"BitBlock_advance_ci_co");
    15         pabloS2CCode.put(PabloSBuiltin.SCAN_TO_FIRST, "BitBlock_scantofirst");
    16         pabloS2CCode.put(PabloSBuiltin.SCAN_THRU, "BitBlock_scanthru_ci_co");
    17         pabloS2CCode.put(PabloSBuiltin.SCAN_TO, "BitBlock_scanto_ci_co");
    18         pabloS2CCode.put(PabloSBuiltin.ADVANCE_THEN_SCAN_THRU, "BitBlock_advance_then_scanthru");
    19         pabloS2CCode.put(PabloSBuiltin.ADVANCE_THEN_SCAN_TO, "BitBlock_advance_then_scanto");
    20         pabloS2CCode.put(PabloSBuiltin.SPAN_UP_TO, "BitBlock_span_upto");
    21         pabloS2CCode.put(PabloSBuiltin.INCLUSIVE_SPAN, "BitBlock_inclusive_span");
    22         pabloS2CCode.put(PabloSBuiltin.EXCLUSIVE_SPAN, "BitBlock_exclusive_span");   
    23 
    24         pabloS2CCode.put(PabloSBuiltin.ADVANCE_32, "BitBlock_advance_n_<%s>");
    25         pabloS2CCode.put(PabloSBuiltin.ADVANCE_N, "BitBlock_advance_n_<%s>");
    26 
    27         pabloS2CCode.put(PabloSBuiltin.MASK, "Mask");
    28         pabloS2CCode.put(PabloSBuiltin.AT_EOF, "atEOF");
    29         pabloS2CCode.put(PabloSBuiltin.IN_FILE, "inFile");
    30         pabloS2CCode.put(PabloSBuiltin.ASSERT_ZERO, "assert_0_error"); 
    31         pabloS2CCode.put(PabloSBuiltin.EOF_MASK, "EOF_mask");
    32         pabloS2CCode.put(PabloSBuiltin.NULL_BUILTIN, "null_builtin_error");
     14        pabloS2CCode.put(PabloSBuiltin.ADVANCE,                 "pablo_blk_Advance");
     15        pabloS2CCode.put(PabloSBuiltin.SCAN_TO_FIRST,           "pablo_blk_ScanToFirst");
     16        pabloS2CCode.put(PabloSBuiltin.SCAN_THRU,               "pablo_blk_ScanThru");
     17        pabloS2CCode.put(PabloSBuiltin.SCAN_TO,                 "pablo_blk_ScanTo");
     18        pabloS2CCode.put(PabloSBuiltin.ADVANCE_THEN_SCAN_THRU,  "pablo_blk_AdvanceThenScanThru");
     19        pabloS2CCode.put(PabloSBuiltin.ADVANCE_THEN_SCAN_TO,    "pablo_blk_AdvanceThenScanTo");
     20        pabloS2CCode.put(PabloSBuiltin.SPAN_UP_TO,              "pablo_blk_SpanUpTo");
     21        pabloS2CCode.put(PabloSBuiltin.INCLUSIVE_SPAN,          "pablo_blk_InclusiveSpan");
     22        pabloS2CCode.put(PabloSBuiltin.EXCLUSIVE_SPAN,          "pablo_blk_ExclusiveSpan");   
     23        pabloS2CCode.put(PabloSBuiltin.ADVANCE_N,               "pablo_blk_Advance_n_<%s>");
     24        pabloS2CCode.put(PabloSBuiltin.MASK,                    "Mask");
     25        pabloS2CCode.put(PabloSBuiltin.AT_EOF,                  "atEOF");
     26        pabloS2CCode.put(PabloSBuiltin.IN_FILE,                 "inFile");
     27        pabloS2CCode.put(PabloSBuiltin.ASSERT_ZERO,             "assert_0_error");     
     28        pabloS2CCode.put(PabloSBuiltin.EOF_MASK,                "EOF_mask");
     29        pabloS2CCode.put(PabloSBuiltin.NULL_BUILTIN,            "null_builtin_error");
    3330
    3431        for(PabloSBuiltin builtin : PabloSBuiltin.values()) {
  • proto/pabloj/trunk/src/toolchain/pabloS/lang/PabloSBuiltins2CPP.java

    r3211 r3325  
    2323        pabloS2CPPCode = new HashMap<PabloSBuiltin, String>();
    2424       
    25         pabloS2CPPCode.put(PabloSBuiltin.ADVANCE,"BitBlock_advance_ci_co");
    26         pabloS2CPPCode.put(PabloSBuiltin.SCAN_TO_FIRST, "BitBlock_scantofirst");
    27         pabloS2CPPCode.put(PabloSBuiltin.SCAN_THRU, "BitBlock_scanthru_ci_co");
    28         pabloS2CPPCode.put(PabloSBuiltin.SCAN_TO, "BitBlock_scanto_ci_co");
    29         pabloS2CPPCode.put(PabloSBuiltin.ADVANCE_THEN_SCAN_THRU, "BitBlock_advance_then_scanthru");
    30         pabloS2CPPCode.put(PabloSBuiltin.ADVANCE_THEN_SCAN_TO, "BitBlock_advance_then_scanto");
    31         pabloS2CPPCode.put(PabloSBuiltin.SPAN_UP_TO, "BitBlock_span_upto");
    32         pabloS2CPPCode.put(PabloSBuiltin.INCLUSIVE_SPAN, "BitBlock_inclusive_span");
    33         pabloS2CPPCode.put(PabloSBuiltin.EXCLUSIVE_SPAN, "BitBlock_exclusive_span");   
    34 
    35         pabloS2CPPCode.put(PabloSBuiltin.ADVANCE_32, "BitBlock_advance_n_<%s>");
    36         pabloS2CPPCode.put(PabloSBuiltin.ADVANCE_N, "BitBlock_advance_n_<%s>");
    37 
    38         pabloS2CPPCode.put(PabloSBuiltin.MASK, "Mask");
    39         pabloS2CPPCode.put(PabloSBuiltin.AT_EOF, "atEOF");
    40         pabloS2CPPCode.put(PabloSBuiltin.IN_FILE, "inFile");
    41         pabloS2CPPCode.put(PabloSBuiltin.ASSERT_ZERO, "assert_0_error");       
    42         pabloS2CPPCode.put(PabloSBuiltin.EOF_MASK, "EOF_mask");
    43         pabloS2CPPCode.put(PabloSBuiltin.NULL_BUILTIN, "null_builtin_error");
    44        
     25        pabloS2CPPCode.put(PabloSBuiltin.ADVANCE,                   "pablo_blk_Advance");
     26        pabloS2CPPCode.put(PabloSBuiltin.SCAN_TO_FIRST,             "pablo_blk_ScanToFirst");
     27        pabloS2CPPCode.put(PabloSBuiltin.SCAN_THRU,                 "pablo_blk_ScanThru");
     28        pabloS2CPPCode.put(PabloSBuiltin.SCAN_TO,                   "pablo_blk_ScanTo");
     29        pabloS2CPPCode.put(PabloSBuiltin.ADVANCE_THEN_SCAN_THRU,    "pablo_blk_AdvanceThenScanThru");
     30        pabloS2CPPCode.put(PabloSBuiltin.ADVANCE_THEN_SCAN_TO,      "pablo_blk_AdvanceThenScanTo");
     31        pabloS2CPPCode.put(PabloSBuiltin.SPAN_UP_TO,                "pablo_blk_SpanUpTo");
     32        pabloS2CPPCode.put(PabloSBuiltin.INCLUSIVE_SPAN,            "pablo_blk_InclusiveSpan");
     33        pabloS2CPPCode.put(PabloSBuiltin.EXCLUSIVE_SPAN,            "pablo_blk_ExclusiveSpan");   
     34        pabloS2CPPCode.put(PabloSBuiltin.ADVANCE_N,                 "pablo_blk_Advance_n_<%s>");
     35        pabloS2CPPCode.put(PabloSBuiltin.MASK,                      "Mask");
     36        pabloS2CPPCode.put(PabloSBuiltin.AT_EOF,                    "atEOF");
     37        pabloS2CPPCode.put(PabloSBuiltin.IN_FILE,                   "inFile");
     38        pabloS2CPPCode.put(PabloSBuiltin.ASSERT_ZERO,               "assert_0_error"); 
     39        pabloS2CPPCode.put(PabloSBuiltin.EOF_MASK,                  "EOF_mask");
     40        pabloS2CPPCode.put(PabloSBuiltin.NULL_BUILTIN,              "null_builtin_error");
    4541               
    4642        for(PabloSBuiltin builtin : PabloSBuiltin.values()) {
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/carry/CarryIntroXFormer.java

    r3309 r3325  
    1111import toolchain.pabloS.lang.carrySet.CarrySetBuiltins;
    1212import toolchain.pabloS.lang.carrySet.CarrySetEncoder;
    13 import toolchain.pabloS.transformer.visitors.carry.BuiltinTranslator;
     13import toolchain.pabloS.transformer.visitors.carry.CarryNoneBuiltinTranslator;
    1414
    1515/*
     
    147147        ///////////////////////////////////////////////////////////////////
    148148        // AssignNode
    149                 public void visitLeave(AssignNode node) { // TODO: KS: Factor out duplicate AssignNode/LocalVarDeclNode
     149                public void visitLeave(AssignNode node) {
    150150
    151151                    ASTNode rhs = Accessors.rhs(node);
    152152                    if(BuiltinCallUtil.isCarry(rhs)) {
    153                         FuncCallNode funcCall = (FuncCallNode)rhs;
    154                         PabloSBuiltin builtin = BuiltinCallUtil.builtin(funcCall);
    155                         Counter counter = selectCounter(builtin, carryCounter, advanceNCounter);
    156                         BuiltinTranslator translator = builtin.getTranslator();
    157                         translator.translate(builtin, funcCall, counter, context);
     153                        IdentifierNode lhs = (IdentifierNode) Accessors.lhs(node);
     154                       
     155                FuncCallNode funcCall = (FuncCallNode) rhs;
     156               
     157                PabloSBuiltin builtin = BuiltinCallUtil.builtin(funcCall);
     158                Counter counter = selectCounter(builtin, carryCounter, advanceNCounter);
     159                CarryBuiltinTranslator translator = (CarryBuiltinTranslator) builtin.getTranslator();
     160                IdentifierNode returnValue = lhs;
     161                translator.translate(builtin, funcCall, counter, context, returnValue);
     162               
     163                node.replaceChild(lhs, counter.makeGetCarryCall(node,context));
     164                counter.increment();
    158165                    }
    159166                }
     
    166173                ASTNode rhs = Accessors.rhs(node);
    167174                if(BuiltinCallUtil.isCarry(rhs)) {
    168                     FuncCallNode funcCall = (FuncCallNode)rhs;
     175                    IdentifierNode lhs = (IdentifierNode) Accessors.lhs(node);
     176                   
     177                    FuncCallNode funcCall = (FuncCallNode) rhs;
     178                   
    169179                    PabloSBuiltin builtin = BuiltinCallUtil.builtin(funcCall);
    170180                    Counter counter = selectCounter(builtin, carryCounter, advanceNCounter);
    171                     BuiltinTranslator translator = builtin.getTranslator();
    172                     translator.translate(builtin, funcCall, counter, context);
     181                    CarryBuiltinTranslator translator = (CarryBuiltinTranslator) builtin.getTranslator();
     182                    IdentifierNode returnValue = lhs;
     183                    translator.translate(builtin, funcCall, counter, context, returnValue);
     184                   
     185                    node.replaceChild(lhs, counter.makeGetCarryCall(node,context));
     186                    counter.increment();
    173187                }
    174188            }
     
    182196                                PabloSBuiltin builtin = BuiltinCallUtil.builtin(node);
    183197                                Counter counter = selectCounter(builtin, carryCounter, advanceNCounter);
    184                                 BuiltinTranslator translator = builtin.getTranslator();
     198                                CarryNoneBuiltinTranslator translator = (CarryNoneBuiltinTranslator) builtin.getTranslator();
    185199                                translator.translate(builtin, node, counter, context);
    186200                        }       
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/carry/CarryNoneBuiltinTranslator.java

    r3315 r3325  
    11package toolchain.pabloS.transformer.visitors.carry;
    22
    3 import java.util.ArrayList;
    4 import java.util.List;
    5 
    63import pabloS.ast.ASTNode;
    7 import pabloS.ast.AssignNode;
    84import pabloS.ast.FuncCallNode;
    9 import pabloS.ast.IntegerConstantNode;
    105import toolchain.pabloS.ast.Accessors;
    116import toolchain.pabloS.ast.Generators;
    127import toolchain.pabloS.lang.PabloSBuiltin;
    13 import toolchain.pabloS.lang.BuiltinCallUtil;
    148
    159// BuiltinTranslators translate a builtin call from pabloS to pabloB during the
     
    1913// having to instantiate the commands.
    2014
    21 public enum BuiltinTranslator {
    22         CARRY_TRANSLATION {     
    23                 public void translate(PabloSBuiltin translatedBuiltin, FuncCallNode node, Counter counter, Context context) {
    24                         List<ASTNode> arguments = Accessors.argsList(node);
    25 
    26                         replaceCallWithCarryCall(node,
    27                                         context.getCarrySetIdentifier(),
    28                                         context.getCode(translatedBuiltin),
    29                                         arguments,
    30                                         counter.callOrMask(node, context),
    31                                         counter.valueNode(node));
    32 
    33                         counter.increment();
    34                 }
    35         },
    36 
    37         ADVANCEN_TRANSLATION {
    38                 public void translate(PabloSBuiltin builtin, FuncCallNode node, Counter counter, Context context) {
    39                         ASTNode formatValue = Accessors.argument(node, 1);
    40                         String value = Accessors.lexeme(formatValue);
    41 
    42                         List<ASTNode> arguments = Accessors.argsList(node);
    43 
    44                         String templateCode = context.getCode(builtin);
    45                         String formattedAdvanceN = String.format(templateCode, value);
    46 
    47                         replaceCallWithCarryCall(node,
    48                                         context.getCarrySetIdentifier(),
    49                                         formattedAdvanceN,
    50                                         arguments.subList(0, arguments.size()-1),
    51                                         counter.callOrMask(node, context),
    52                                         counter.valueNode(node));
    53                         counter.increment();   
    54                 }
    55         },
     15public enum CarryNoneBuiltinTranslator implements BuiltinTranslator {
    5616
    5717        ATEOF_TRANSLATION {
     
    6323                        }
    6424                        else {                         
    65                                 node.updateSelf(Counter.mask(node));                   
     25                                node.updateSelf(counter.mask(node));                   
    6626                        }
    6727                }
     
    8242        MASK_TRANSLATION {
    8343                public void translate(PabloSBuiltin builtin, FuncCallNode node, Counter counter, Context context) {
    84                         node.updateSelf(Counter.mask(node));
    85                 }
    86         },
    87 
    88         SCANTO_TRANSLATION {
    89                 public void translate(PabloSBuiltin translatedBuiltin, FuncCallNode node, Counter counter, Context context) {
    90                         scanToTranslate(PabloSBuiltin.SCAN_THRU, node, counter, context);
    91                 }
    92         },
    93 
    94         ADVANCE_THEN_SCANTO_TRANSLATION {
    95                 public void translate(PabloSBuiltin translatedBuiltin, FuncCallNode node, Counter counter, Context context) {
    96                         scanToTranslate(PabloSBuiltin.ADVANCE_THEN_SCAN_THRU, node, counter, context);
     44                        node.updateSelf(counter.mask(node));
    9745                }
    9846        };
    9947
    10048        abstract public void translate(PabloSBuiltin translatedBuiltin, FuncCallNode node, Counter counter, Context context);
    101 
    102         // helper methods
    103         private static void scanToTranslate(PabloSBuiltin translatedBuiltin, FuncCallNode node, Counter counter, Context context) {
    104                 ASTNode argument = Accessors.argument(node, 1);
    105                 translateArgument(context, argument);
    106                 ASTNode replacement = Generators.makeCompoundIdentifierNode(node,
    107                                 BuiltinCallUtil.BUILTIN_PACKAGE_NAME, translatedBuiltin.pabloSName());
    108 
    109                 node.replaceChild(Accessors.nameNode(node), replacement);
    110                 CARRY_TRANSLATION.translate(translatedBuiltin, node, counter, context);
    111         }       
    112         private static void translateArgument(Context context, ASTNode argument) {
    113                 if(context.isFinalBlockMode()) {
    114                         ASTNode replacement = Generators.makeSIMDEOFMaskAndCNodeFuncCall(argument.deepCopy(), context.getBuiltinEncoder());
    115                         argument.updateSelf(replacement);
    116                 }
    117                 else {
    118                         ASTNode replacement = Generators.makeSIMDNotFuncCall(argument.deepCopy(), context.getBuiltinEncoder());
    119                         argument.updateSelf(replacement);                       
    120                 }
    121         }       
    122 
    123 
    124         // Makes CarrySet builtin call.
    125         // e.g. pablo.Advance(X,Y,Z) => carry_set_n.Advance(X,Y,Z,foo,carryInt)
    126 
    127         private static void replaceCallWithCarryCall(FuncCallNode node,
    128                         String carryPackageName, String carryBuiltin,
    129                         List<ASTNode> arguments,
    130                         ASTNode call, IntegerConstantNode carry) {
    131 
    132                 ASTNode [] args = makeCarryCallArgs(arguments, call, carry);
    133 
    134                 FuncCallNode replacementNode = Generators.makeFuncCallNode(
    135                                 node,
    136                                 carryPackageName,
    137                                 carryBuiltin,
    138                                 args);
    139 
    140                 node.updateSelf(replacementNode);
    141         }
    142 
    143 //    // Makes CarrySet builtin call.
    144 //    // e.g. pablo.Advance(X,Y,Z) => Co = pablo_blk(X,Y,Z,Ci,R)  // carry_set_n.Advance(X,Y,Z,foo,carryInt)
    145 //
    146 //    private static void replaceTempAssignWithPabloBlkAssign (
    147 //            AssignNode node,
    148 //            String carryPackageName,                        //  carryPackageName ==> carryPackageName
    149 //            String carryBuiltin,                            //  needed ==> translated to pablo_blk name
    150 //            List<ASTNode> arguments,                        //  needed
    151 //            ASTNode call,                                   //
    152 //            IntegerConstantNode carry)
    153 //        {
    154 //
    155 //        ASTNode [] args = makeCarryCallArgs(arguments, call, carry); // replace for pablo_blk_ and add carryPackageName.getCarry call, also the RV
    156 //
    157 //        FuncCallNode replacementNode = Generators.makeFuncCallNode(
    158 //                node,
    159 //                carryBuiltin,
    160 //                args);
    161 //
    162 //        node.updateSelf(replacementNode);
    163 //    }
    164        
    165         private static ASTNode [] makeCarryCallArgs(List<ASTNode> arguments,
    166                         ASTNode call, IntegerConstantNode carry) {
    167                 List<ASTNode> args = new ArrayList<ASTNode>(arguments);
    168                 args.add(call);
    169                 args.add(carry);
    170                 return args.toArray(new ASTNode [args.size()]);
    171         }               
     49               
    17250}
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/carry/Counter.java

    r3324 r3325  
    3434        public ASTNode callOrMask(Locator locator, Context context) {
    3535                if(context.isCarryInMode()) {
    36                         return call(locator, context);
     36                        return makeGetCarryCall(locator, context);
    3737                }
    3838                else {
     
    4040                }
    4141        }
    42         public ASTNode call(Locator locator, Context context) {
     42        public ASTNode makeGetCarryCall(Locator locator, Context context) {
    4343            return Generators.makeFuncCallNode(
    4444                locator,
     
    4848        }
    4949        public ASTNode mask(Locator locator) {
    50                 IntegerConstantNode zeroConstantNode =  Generators.makeIntegerConstantNode(locator, 0);
    51                 IntegerConstantNode fieldWidthNode =  Generators.makeIntegerConstantNode(locator, 1);
    52                
    53                 return Generators.makeFuncCallNode(locator, BuiltinCallUtil.BUILTIN_PACKAGE_NAME,
    54                                 PabloSBuiltin.MASK.pabloSName(),
    55                                 fieldWidthNode, zeroConstantNode);
     50                return Generators.makeMaskFuncCall(locator, 1, 0);
    5651        }
    5752}
Note: See TracChangeset for help on using the changeset viewer.