Changeset 3242 for proto/pabloj/trunk


Ignore:
Timestamp:
May 30, 2013, 3:13:15 PM (6 years ago)
Author:
shermer
Message:

Added initial value field to PabloS builtins.
Refactored BuiltinTranslator? to use a map rather than the extraneous enum values. (BuiltinTranslator? will receive further refactoring to use polymorphic rather than explicit dispatch.)
Eliminated looping on those extraneous enum values in CarryIntroXFormer.

Location:
proto/pabloj/trunk/src/toolchain/pabloS
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • proto/pabloj/trunk/src/toolchain/pabloS/lang/PabloSBuiltin.java

    r3234 r3242  
    1010public enum PabloSBuiltin {
    1111    ADVANCE(               "Advance",             CarryType.One, sig_S_S()  ),
    12     SCAN_TO_FIRST(         "ScanToFirst",         CarryType.One, sig_S_S()  ),
     12    SCAN_TO_FIRST(         "ScanToFirst",         CarryType.One, sig_S_S(),  InitialValue.One ),
    1313    SCAN_THRU(             "ScanThru",            CarryType.One, sig_SS_S() ),
    1414    SCAN_TO(               "ScanTo",              CarryType.One, sig_SS_S() ),
     
    2929    NULL_BUILTIN( "NULL",      CarryType.None, sig_V_V()  );
    3030
    31     public enum CarryType{One, N, None};   
     31    public enum CarryType{One, N, None};
     32    public enum InitialValue{ Zero, One };
    3233   
    3334    private final CarryType carryType;
     35    private final InitialValue initialValue;
    3436        private final String name;
    3537        @SuppressWarnings("unused")
    3638        private final FunctionSignature signature;
     39
    3740       
    38         private PabloSBuiltin(String name, CarryType carryType, int argCount) {
    39                 this.carryType = carryType;
    40                 this.name = name;
    41                 this.signature = null;
    42         }
    43         private PabloSBuiltin(String name, CarryType carryType, FunctionSignature signature) {
     41        private PabloSBuiltin(String name, CarryType carryType, FunctionSignature signature, InitialValue initialValue) {
    4442                this.name = name;
    4543                this.carryType = carryType;
    4644                this.signature = signature;
     45                this.initialValue = initialValue;
    4746        }
     47
     48        private PabloSBuiltin(String name, CarryType carryType, FunctionSignature signature) {
     49                this(name, carryType, signature, InitialValue.Zero);
     50        }
     51       
    4852       
    4953        /////////////////////////////////////////////////////////////////
     
    102106        public final boolean isCarry1() { return carryType == CarryType.One; }
    103107        public final boolean isCarryN() { return carryType == CarryType.N; }
    104 
     108        public final InitialValue getInitialValue() { return initialValue; }
    105109}
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/carry/BuiltinTranslator.java

    r3240 r3242  
    22
    33import java.util.ArrayList;
     4import java.util.HashMap;
    45import java.util.List;
     6import java.util.Map;
    57
    68import pabloS.ast.ASTNode;
     
    1315import toolchain.pabloS.lang.BuiltinCallUtil;
    1416
    15 public enum BuiltinTranslator {
    16         ADVANCE(PabloSBuiltin.ADVANCE),
    17         SCANTHRU(PabloSBuiltin.SCAN_THRU),
    18         ADVANCETHENSCANTHRU(PabloSBuiltin.ADVANCE_THEN_SCAN_THRU),
    19         SPANUPTO(PabloSBuiltin.SPAN_UP_TO),
    20         INCLUSIVESPAN(PabloSBuiltin.INCLUSIVE_SPAN),
    21         EXCLUSIVESPAN(PabloSBuiltin.EXCLUSIVE_SPAN),
    22         SCANTOFIRST(PabloSBuiltin.SCAN_TO_FIRST),                       // TODO: verify that this is basicAction and not scanToAction
    23         ADVANCE32(PabloSBuiltin.ADVANCE_32),
    24                 //advance32 came with this in its action, commented out:                //replaceFuncCallNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.ADVANCE32.cPPCode(), carryCall, currentAdvN);         
    25         ADVANCEN(PabloSBuiltin.ADVANCE_N, Action.ADVANCEN_ACTION),
    26         ATEOF(PabloSBuiltin.AT_EOF, Action.ATEOF_ACTION),
    27         INFILE(PabloSBuiltin.IN_FILE, Action.INFILE_ACTION),
    28         MASK(PabloSBuiltin.MASK, Action.MASK_ACTION),
    29         SCANTO(PabloSBuiltin.SCAN_TO, Action.SCANTO_ACTION),
    30         ADVANCETHENSCANTO(PabloSBuiltin.ADVANCE_THEN_SCAN_TO, Action.ADVANCE_THEN_SCANTO_ACTION);
    31 
     17public class BuiltinTranslator {
     18       
     19        private static Map<PabloSBuiltin, Action> actions = new HashMap<PabloSBuiltin, Action>();
     20        static {
     21                actions.put(PabloSBuiltin.ADVANCE_N, Action.ADVANCEN_ACTION);
     22                actions.put(PabloSBuiltin.AT_EOF, Action.ATEOF_ACTION);
     23                actions.put(PabloSBuiltin.IN_FILE, Action.INFILE_ACTION);
     24                actions.put(PabloSBuiltin.MASK, Action.MASK_ACTION);
     25                actions.put(PabloSBuiltin.SCAN_TO, Action.SCANTO_ACTION);
     26                actions.put(PabloSBuiltin.ADVANCE_THEN_SCAN_TO, Action.ADVANCE_THEN_SCANTO_ACTION);
     27        }
    3228        private enum Action {
    3329                CARRY_ACTION,
     
    3935                MASK_ACTION;
    4036        }
    41         private PabloSBuiltin builtin;
    42         private boolean usesAdvanceNCounter;
    43         private BuiltinTranslator.Action actionSelector;
     37        private static final Action DEFAULT_ACTION = Action.CARRY_ACTION;
    4438       
    45        
    46         private BuiltinTranslator(PabloSBuiltin builtin, Action actionSelector) {
    47                 this.builtin = builtin;
    48                 this.usesAdvanceNCounter = (builtin.getCarryType()==CarryType.N);       
    49                 this.actionSelector = actionSelector;
    50         }               
    51         private BuiltinTranslator(PabloSBuiltin builtin) {
    52                 this(builtin, Action.CARRY_ACTION);
     39        private BuiltinTranslator() {}          // non-instantiated.           
     40
     41        // static public interface
     42        static public void action(FuncCallNode node, Counter advance1Counter, Counter advanceNCounter, Context context) {
     43                if(BuiltinCallUtil.isBuiltInCall(node)) {
     44                        PabloSBuiltin builtin = BuiltinCallUtil.builtin(node);
     45                        Counter counter = selectCounter(builtin, advance1Counter, advanceNCounter);
     46                        action(builtin, node, counter, context);
     47                }
     48        }       
     49        static private Counter selectCounter(PabloSBuiltin builtin, Counter counter, Counter advanceNCounter) {
     50                return usesAdvanceNCounter(builtin) ? advanceNCounter : counter;
    5351        }
    54        
    55        
    56         protected PabloSBuiltin getBuiltin() {
    57                 return builtin;
    58         }
    59        
    60         public boolean isCall(FuncCallNode node) {
    61                 return BuiltinCallUtil.isBuiltInCall(node, builtin);
     52        static private boolean usesAdvanceNCounter(PabloSBuiltin builtin) {
     53                return builtin.getCarryType() == CarryType.N ;
    6254        }
    6355
    64         public Counter selectCounter(Counter counter, Counter advanceNCounter) {
    65                 return usesAdvanceNCounter ? advanceNCounter : counter;
    66         }
    67        
    68         public void action(FuncCallNode node, Counter counter, Counter advanceNCounter, Context context) {
    69                 action(node, selectCounter(counter, advanceNCounter), context);
    70         }
    71        
    72         public void action(FuncCallNode node, Counter counter, Context context) {
    73                 switch(actionSelector) {
    74                 case CARRY_ACTION:      carryAction(node, counter, context);    break;
    75                 case ADVANCEN_ACTION:   advanceNAction(node, counter, context); break;
    76                 case ATEOF_ACTION:              atEOFAction(node, counter, context);    break;
    77                 case INFILE_ACTION:             infileAction(node, counter, context);   break;
    78                 case MASK_ACTION:               maskAction(node, counter, context);         break;
     56        static private void action(PabloSBuiltin builtin, FuncCallNode node, Counter counter, Context context) {
     57                Action action = actionFor(builtin);
     58                switch(action) {
     59                case CARRY_ACTION:      carryAction(   builtin, node, counter, context); break;
     60                case ADVANCEN_ACTION:   advanceNAction(builtin, node, counter, context); break;
     61                case ATEOF_ACTION:              atEOFAction(   builtin, node, counter, context); break;
     62                case INFILE_ACTION:             infileAction(  builtin, node, counter, context); break;
     63                case MASK_ACTION:               maskAction(    builtin, node, counter, context); break;
    7964               
    80                 case SCANTO_ACTION:                 scanToAction(node, PabloSBuiltin.SCAN_THRU, counter, context);   break;
    81                 case ADVANCE_THEN_SCANTO_ACTION:    scanToAction(node, PabloSBuiltin.ADVANCE_THEN_SCAN_THRU, counter, context);   break;               
     65                case SCANTO_ACTION:                 scanToAction(PabloSBuiltin.SCAN_THRU,              node, counter, context);   break;
     66                case ADVANCE_THEN_SCANTO_ACTION:    scanToAction(PabloSBuiltin.ADVANCE_THEN_SCAN_THRU, node, counter, context);   break;               
    8267                }
    8368        }
    8469       
    85         private void carryAction(FuncCallNode node, Counter counter, Context context) {
    86                 carryAction(node, counter, context, getBuiltin());
     70        private static Action actionFor(PabloSBuiltin builtin) {
     71                if(actions.containsKey(builtin)) {
     72                        return actions.get(builtin);
     73                }
     74                return DEFAULT_ACTION;
    8775        }
    8876       
    89         public void carryAction(FuncCallNode node, Counter counter, Context context, PabloSBuiltin translation) {
     77        static private void carryAction(PabloSBuiltin translatedBuiltin, FuncCallNode node, Counter counter, Context context) {
    9078                List<ASTNode> arguments = Accessors.argsList(node);
    9179               
    9280                replaceCallWithCarryCall(node,
    9381                                context.getCarrySetIdentifier(),
    94                                 context.getBuiltinEncoder().getCode(translation),
     82                                context.getCode(translatedBuiltin),
    9583                                arguments,
    9684                                counter.callOrMask(node, context),
     
    9886               
    9987                counter.increment();
    100         }               
    101         public void scanToAction(FuncCallNode node, PabloSBuiltin translation, Counter counter, Context context) {
     88        }
     89       
     90        private static void advanceNAction(PabloSBuiltin builtin, FuncCallNode node, Counter counter, Context context) {
     91                ASTNode formatValue = Accessors.argument(node, 1);
     92                String value = Accessors.lexeme(formatValue);
     93
     94                List<ASTNode> arguments = Accessors.argsList(node);
     95
     96                String templateCode = context.getCode(builtin);
     97                String formattedAdvanceN = String.format(templateCode, value);
     98
     99                replaceCallWithCarryCall(node,
     100                                context.getCarrySetIdentifier(),
     101                                formattedAdvanceN,
     102                                arguments.subList(0, arguments.size()-1),
     103                                counter.callOrMask(node, context),
     104                                counter.valueNode(node));
     105                counter.increment();   
     106        }       
     107       
     108        private static void scanToAction(PabloSBuiltin translatedBuiltin, FuncCallNode node, Counter counter, Context context) {
    102109                ASTNode argument = Accessors.argument(node, 1);
    103110                translateArgument(context, argument);
    104111                ASTNode replacement = Generators.makeCompoundIdentifierNode(BuiltinCallUtil.BUILTIN_PACKAGE_NAME,
    105                                                                                                                                                                         translation.pabloSName(), node);
     112                                                                                                                                        translatedBuiltin.pabloSName(), node);
    106113               
    107114                node.replaceChild(Accessors.nameNode(node), replacement);
    108                 carryAction(node, counter, context, translation);
     115                carryAction(translatedBuiltin, node, counter, context);
    109116        }
    110         private void translateArgument(Context context, ASTNode argument) {
     117       
     118        private static void translateArgument(Context context, ASTNode argument) {
    111119                if(context.isFinalBlockMode()) {
    112120                        ASTNode replacement = Generators.makeSIMDEOFMaskAndCNodeFuncCall(argument.deepCopy(), context.getBuiltinEncoder());
     
    118126                }
    119127        }               
    120         public void advanceNAction(FuncCallNode node, Counter counter, Context context) {
    121                 ASTNode formatValue = Accessors.argument(node, 1);
    122                 String value = Accessors.lexeme(formatValue);
    123 
    124                 List<ASTNode> arguments = Accessors.argsListNode(node).getChildren();
    125 
    126                 // TS: TODO: gnarly
    127                 String formattedAdvanceN = String.format(context.getBuiltinEncoder().getCode(getBuiltin()), value);
    128 
    129                 replaceCallWithCarryCall(node,
    130                                 context.getCarrySetIdentifier(),
    131                                 formattedAdvanceN,
    132                                 arguments.subList(0, arguments.size()-1),
    133                                 counter.callOrMask(node, context),
    134                                 counter.valueNode(node));
    135                 counter.increment();   
    136         }               
    137         public void atEOFAction(FuncCallNode node, Counter counter, Context context) {
     128       
     129       
     130        private static void atEOFAction(PabloSBuiltin builtin, FuncCallNode node, Counter counter, Context context) {
    138131                if(context.isFinalBlockMode()) {
    139132                        ASTNode argNode = Accessors.argument(node, 0);
     
    144137                        node.updateSelf(Counter.mask(node));                   
    145138                }
    146         }       
    147         public void infileAction(FuncCallNode node, Counter counter, Context context) {
     139        }
     140       
     141        private static void infileAction(PabloSBuiltin builtin, FuncCallNode node, Counter counter, Context context) {
    148142                if(context.isFinalBlockMode()) {                                       
    149143                        ASTNode argNode = Accessors.argument(node, 0);
     
    154148                }
    155149        }                       
    156         public void maskAction(FuncCallNode node, Counter counter, Context context) {
     150        private static void maskAction(PabloSBuiltin builtin, FuncCallNode node, Counter counter, Context context) {
    157151                node.updateSelf(Counter.mask(node));
    158152        }
     153       
    159154        /*
    160155         * Makes CarrySet builtin call.
    161          * e.g. Advance(X,Y,Z) => carry_set_n.Advance(X,Y,Z,foo,carryInt)
     156         * e.g. pablo.Advance(X,Y,Z) => carry_set_n.Advance(X,Y,Z,foo,carryInt)
    162157         */
    163         static void replaceCallWithCarryCall(FuncCallNode node,
    164                         String carryIdentifier, String carryBuiltin,
     158        private static void replaceCallWithCarryCall(FuncCallNode node,
     159                        String carryPackageName, String carryBuiltin,
    165160                        List<ASTNode> arguments,
    166161                        ASTNode call, IntegerConstantNode carry) {
    167162       
    168                 List<ASTNode> args = new ArrayList<ASTNode>(arguments);
    169                 args.add(call);
    170                 args.add(carry);
     163                List<ASTNode> args = makeCarryCallArgs(arguments, call, carry);
    171164               
    172165                FuncCallNode replacementNode = Generators.makeFuncCallNode(
    173                                 carryIdentifier,
     166                                carryPackageName,
    174167                                carryBuiltin,
    175168                                node,
     
    177170               
    178171                node.updateSelf(replacementNode);
     172        }
     173
     174        private static List<ASTNode> makeCarryCallArgs(List<ASTNode> arguments,
     175                        ASTNode call, IntegerConstantNode carry) {
     176                List<ASTNode> args = new ArrayList<ASTNode>(arguments);
     177                args.add(call);
     178                args.add(carry);
     179                return args;
    179180        }       
    180181}
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/carry/CarryIntroXFormer.java

    r3240 r3242  
    153153               
    154154                public void visitLeave(FuncCallNode node) {
    155                         boolean translated = false;
    156                         for(BuiltinTranslator translator: BuiltinTranslator.values()) {
    157                                 if (translator.isCall(node)) {
    158                                         translator.action(node, carryCounter, advanceNCounter, context);
    159                                         translated = true;
    160                                         break;
    161                                 }
    162                         }
    163                        
    164                         if(!translated) {
    165                                 // do nothing // TODO - allow calls to pass ?
    166                         }                                                                                                                       
     155                        BuiltinTranslator.action(node, carryCounter, advanceNCounter, context);
    167156                }
    168157
Note: See TracChangeset for help on using the changeset viewer.