Changeset 3244


Ignore:
Timestamp:
May 30, 2013, 4:45:44 PM (6 years ago)
Author:
shermer
Message:

Completed transformation of BuiltinTranslator?.
The declarative (map) part was moved to be a field on PabloSBuiltin.
Other static methods were inlined.
Made BuiltinTranslator? itself the enum and eliminated the member enum Action.
Changed naming to agree with "translator" rather than "action" concept.

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

Legend:

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

    r3242 r3244  
    77import toolchain.pabloS.lang.type.PrimitiveType;
    88import static toolchain.pabloS.lang.type.StreamType.STREAM;
     9import static toolchain.pabloS.transformer.visitors.carry.BuiltinTranslator.*;
     10import toolchain.pabloS.transformer.visitors.carry.BuiltinTranslator;
    911
    1012public enum PabloSBuiltin {
    11     ADVANCE(               "Advance",             CarryType.One, sig_S_S()  ),
    12     SCAN_TO_FIRST(         "ScanToFirst",         CarryType.One, sig_S_S(),  InitialValue.One ),
    13     SCAN_THRU(             "ScanThru",            CarryType.One, sig_SS_S() ),
    14     SCAN_TO(               "ScanTo",              CarryType.One, sig_SS_S() ),
    15     SPAN_UP_TO(            "SpanUpTo",            CarryType.One, sig_SS_S() ),
    16     INCLUSIVE_SPAN(        "InclusiveSpan",       CarryType.One, sig_SS_S() ),
    17     EXCLUSIVE_SPAN(        "ExclusiveSpan",       CarryType.One, sig_SS_S() ),
    18     ADVANCE_THEN_SCAN_THRU("AdvanceThenScanThru", CarryType.One, sig_SS_S()  ),
    19     ADVANCE_THEN_SCAN_TO(  "AdvanceThenScanTo",   CarryType.One, sig_SS_S()  ),
     13    ADVANCE(               "Advance",             CarryType.One, CARRY_TRANSLATION,  sig_S_S()  ),
     14    SCAN_TO_FIRST(         "ScanToFirst",         CarryType.One, CARRY_TRANSLATION,  sig_S_S(),  InitialValue.One ),
     15    SCAN_THRU(             "ScanThru",            CarryType.One, CARRY_TRANSLATION,  sig_SS_S() ),
     16    SCAN_TO(               "ScanTo",              CarryType.One, SCANTO_TRANSLATION, sig_SS_S() ),
     17    SPAN_UP_TO(            "SpanUpTo",            CarryType.One, CARRY_TRANSLATION,  sig_SS_S() ),
     18    INCLUSIVE_SPAN(        "InclusiveSpan",       CarryType.One, CARRY_TRANSLATION,  sig_SS_S() ),
     19    EXCLUSIVE_SPAN(        "ExclusiveSpan",       CarryType.One, CARRY_TRANSLATION,  sig_SS_S() ),
     20    ADVANCE_THEN_SCAN_THRU("AdvanceThenScanThru", CarryType.One, CARRY_TRANSLATION,  sig_SS_S()  ),
     21    ADVANCE_THEN_SCAN_TO(  "AdvanceThenScanTo",   CarryType.One, ADVANCE_THEN_SCANTO_TRANSLATION, sig_SS_S()  ),
    2022   
    21     ADVANCE_N(    "AdvanceN",  CarryType.N,    sig_SI_S() ),   
    22     ADVANCE_32(   "Advance32", CarryType.N,    sig_S_S()  ),
     23    ADVANCE_N(    "AdvanceN",  CarryType.N,    ADVANCEN_TRANSLATION, sig_SI_S() ),   
     24    ADVANCE_32(   "Advance32", CarryType.N,    CARRY_TRANSLATION,    sig_S_S()  ),
    2325
    24     MASK(         "Mask",      CarryType.None, sig_II_S() ),   
    25     AT_EOF(       "atEOF",     CarryType.None, sig_S_S()  ),
    26     IN_FILE(      "inFile",    CarryType.None, sig_S_S()  ),
    27     ASSERT_ZERO(  "assert_0",  CarryType.None, sig_ST_V() ),   
    28     EOF_MASK(     "EOF_mask",  CarryType.None, sig_V_S()  ), // deprecated
    29     NULL_BUILTIN( "NULL",      CarryType.None, sig_V_V()  );
     26    MASK(         "Mask",      CarryType.None, MASK_TRANSLATION,     sig_II_S() ),   
     27    AT_EOF(       "atEOF",     CarryType.None, ATEOF_TRANSLATION,    sig_S_S()  ),
     28    IN_FILE(      "inFile",    CarryType.None, INFILE_TRANSLATION,   sig_S_S()  ),
     29    ASSERT_ZERO(  "assert_0",  CarryType.None, CARRY_TRANSLATION,    sig_ST_V() ),     
     30    EOF_MASK(     "EOF_mask",  CarryType.None, CARRY_TRANSLATION,    sig_V_S()  ), // deprecated
     31    NULL_BUILTIN( "NULL",      CarryType.None, CARRY_TRANSLATION,    sig_V_V()  );
    3032
    3133    public enum CarryType{One, N, None};
     
    3739        @SuppressWarnings("unused")
    3840        private final FunctionSignature signature;
     41        private final BuiltinTranslator translator;
    3942
    4043       
    41         private PabloSBuiltin(String name, CarryType carryType, FunctionSignature signature, InitialValue initialValue) {
     44        private PabloSBuiltin(String name, CarryType carryType, BuiltinTranslator translator, FunctionSignature signature, InitialValue initialValue) {
    4245                this.name = name;
    4346                this.carryType = carryType;
     47                this.translator = translator;
    4448                this.signature = signature;
    4549                this.initialValue = initialValue;
    4650        }
    4751
    48         private PabloSBuiltin(String name, CarryType carryType, FunctionSignature signature) {
    49                 this(name, carryType, signature, InitialValue.Zero);
     52        private PabloSBuiltin(String name, CarryType carryType, BuiltinTranslator translator, FunctionSignature signature) {
     53                this(name, carryType, translator, signature, InitialValue.Zero);
    5054        }
    5155       
     
    107111        public final boolean isCarryN() { return carryType == CarryType.N; }
    108112        public final InitialValue getInitialValue() { return initialValue; }
     113        public final BuiltinTranslator getTranslator() { return translator; }
    109114}
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/carry/BuiltinTranslator.java

    r3243 r3244  
    22
    33import java.util.ArrayList;
    4 import java.util.HashMap;
    54import java.util.List;
    6 import java.util.Map;
    75
    86import pabloS.ast.ASTNode;
     
    1412import toolchain.pabloS.lang.BuiltinCallUtil;
    1513
    16 public class BuiltinTranslator {
    17        
    18         private static Map<PabloSBuiltin, Action> actions = new HashMap<PabloSBuiltin, Action>();
    19         static {
    20                 actions.put(PabloSBuiltin.ADVANCE_N, Action.ADVANCEN_ACTION);
    21                 actions.put(PabloSBuiltin.AT_EOF, Action.ATEOF_ACTION);
    22                 actions.put(PabloSBuiltin.IN_FILE, Action.INFILE_ACTION);
    23                 actions.put(PabloSBuiltin.MASK, Action.MASK_ACTION);
    24                 actions.put(PabloSBuiltin.SCAN_TO, Action.SCANTO_ACTION);
    25                 actions.put(PabloSBuiltin.ADVANCE_THEN_SCAN_TO, Action.ADVANCE_THEN_SCANTO_ACTION);
    26         }
    27         private static final Action DEFAULT_ACTION = Action.CARRY_ACTION;
    28        
    29         private enum Action {
    30                 CARRY_ACTION { 
    31                         public void translate(PabloSBuiltin translatedBuiltin, FuncCallNode node, Counter counter, Context context) {
    32                                 List<ASTNode> arguments = Accessors.argsList(node);
     14// BuiltinTranslators translate a builtin call from pabloS to pabloB during the
     15// CarryIntroTransformer visit of the ast.
     16//
     17// The enum values follow the Command pattern, with the benefit of the client not
     18// having to instantiate the commands.
    3319
    34                                 replaceCallWithCarryCall(node,
    35                                                 context.getCarrySetIdentifier(),
    36                                                 context.getCode(translatedBuiltin),
    37                                                 arguments,
    38                                                 counter.callOrMask(node, context),
    39                                                 counter.valueNode(node));
     20public enum BuiltinTranslator {
     21        CARRY_TRANSLATION {     
     22                public void translate(PabloSBuiltin translatedBuiltin, FuncCallNode node, Counter counter, Context context) {
     23                        List<ASTNode> arguments = Accessors.argsList(node);
    4024
    41                                 counter.increment();
     25                        replaceCallWithCarryCall(node,
     26                                        context.getCarrySetIdentifier(),
     27                                        context.getCode(translatedBuiltin),
     28                                        arguments,
     29                                        counter.callOrMask(node, context),
     30                                        counter.valueNode(node));
     31
     32                        counter.increment();
     33                }
     34        },
     35
     36        ADVANCEN_TRANSLATION {
     37                public void translate(PabloSBuiltin builtin, FuncCallNode node, Counter counter, Context context) {
     38                        ASTNode formatValue = Accessors.argument(node, 1);
     39                        String value = Accessors.lexeme(formatValue);
     40
     41                        List<ASTNode> arguments = Accessors.argsList(node);
     42
     43                        String templateCode = context.getCode(builtin);
     44                        String formattedAdvanceN = String.format(templateCode, value);
     45
     46                        replaceCallWithCarryCall(node,
     47                                        context.getCarrySetIdentifier(),
     48                                        formattedAdvanceN,
     49                                        arguments.subList(0, arguments.size()-1),
     50                                        counter.callOrMask(node, context),
     51                                        counter.valueNode(node));
     52                        counter.increment();   
     53                }
     54        },
     55
     56        ATEOF_TRANSLATION {
     57                public void translate(PabloSBuiltin builtin, FuncCallNode node, Counter counter, Context context) {
     58                        if(context.isFinalBlockMode()) {
     59                                ASTNode argNode = Accessors.argument(node, 0);
     60                                ASTNode replacementNode = Generators.makeSIMDAndCEOFMaskFuncCall(argNode, context.getBuiltinEncoder());
     61                                node.updateSelf(replacementNode);
    4262                        }
    43                 },
     63                        else {                         
     64                                node.updateSelf(Counter.mask(node));                   
     65                        }
     66                }
     67        },
    4468
    45                 ADVANCEN_ACTION {
    46                         public void translate(PabloSBuiltin builtin, FuncCallNode node, Counter counter, Context context) {
    47                                 ASTNode formatValue = Accessors.argument(node, 1);
    48                                 String value = Accessors.lexeme(formatValue);
     69        INFILE_TRANSLATION {
     70                public void translate(PabloSBuiltin builtin, FuncCallNode node, Counter counter, Context context) {
     71                        if(context.isFinalBlockMode()) {                                       
     72                                ASTNode argNode = Accessors.argument(node, 0);
     73                                ASTNode replacementNode = Generators.makeSIMDAndEOFMaskFuncCall(argNode, context.getBuiltinEncoder());
     74                                node.updateSelf(replacementNode);
     75                        } else {
     76                                node.updateSelf(Accessors.argument(node,0));
     77                        }
     78                }               
     79        },
    4980
    50                                 List<ASTNode> arguments = Accessors.argsList(node);
     81        MASK_TRANSLATION {
     82                public void translate(PabloSBuiltin builtin, FuncCallNode node, Counter counter, Context context) {
     83                        node.updateSelf(Counter.mask(node));
     84                }
     85        },
    5186
    52                                 String templateCode = context.getCode(builtin);
    53                                 String formattedAdvanceN = String.format(templateCode, value);
     87        SCANTO_TRANSLATION {
     88                public void translate(PabloSBuiltin translatedBuiltin, FuncCallNode node, Counter counter, Context context) {
     89                        scanToTranslate(PabloSBuiltin.SCAN_THRU, node, counter, context);
     90                }
     91        },
    5492
    55                                 replaceCallWithCarryCall(node,
    56                                                 context.getCarrySetIdentifier(),
    57                                                 formattedAdvanceN,
    58                                                 arguments.subList(0, arguments.size()-1),
    59                                                 counter.callOrMask(node, context),
    60                                                 counter.valueNode(node));
    61                                 counter.increment();   
    62                         }
    63                 },
    64                
    65                 ATEOF_ACTION {
    66                         public void translate(PabloSBuiltin builtin, FuncCallNode node, Counter counter, Context context) {
    67                                 if(context.isFinalBlockMode()) {
    68                                         ASTNode argNode = Accessors.argument(node, 0);
    69                                         ASTNode replacementNode = Generators.makeSIMDAndCEOFMaskFuncCall(argNode, context.getBuiltinEncoder());
    70                                         node.updateSelf(replacementNode);
    71                                 }
    72                                 else {                         
    73                                         node.updateSelf(Counter.mask(node));                   
    74                                 }
    75                         }
    76                 },
    77                
    78                 INFILE_ACTION {
    79                         public void translate(PabloSBuiltin builtin, FuncCallNode node, Counter counter, Context context) {
    80                                 if(context.isFinalBlockMode()) {                                       
    81                                         ASTNode argNode = Accessors.argument(node, 0);
    82                                         ASTNode replacementNode = Generators.makeSIMDAndEOFMaskFuncCall(argNode, context.getBuiltinEncoder());
    83                                         node.updateSelf(replacementNode);
    84                                 } else {
    85                                         node.updateSelf(Accessors.argument(node,0));
    86                                 }
    87                         }               
    88                 },
    89                
    90                 MASK_ACTION {
    91                         public void translate(PabloSBuiltin builtin, FuncCallNode node, Counter counter, Context context) {
    92                                 node.updateSelf(Counter.mask(node));
    93                         }
    94                 },
    95                
    96                 SCANTO_ACTION {
    97                         public void translate(PabloSBuiltin translatedBuiltin, FuncCallNode node, Counter counter, Context context) {
    98                                 scanToTranslate(PabloSBuiltin.SCAN_THRU, node, counter, context);
    99                         }
    100                 },
    101                
    102                 ADVANCE_THEN_SCANTO_ACTION {
    103                         public void translate(PabloSBuiltin translatedBuiltin, FuncCallNode node, Counter counter, Context context) {
    104                                 scanToTranslate(PabloSBuiltin.ADVANCE_THEN_SCAN_THRU, node, counter, context);
    105                         }
    106                 };
    107                
    108                 abstract public void translate(PabloSBuiltin translatedBuiltin, FuncCallNode node, Counter counter, Context context);
    109                
    110                 // helper methods
    111                 private static void scanToTranslate(PabloSBuiltin translatedBuiltin, FuncCallNode node, Counter counter, Context context) {
    112                         ASTNode argument = Accessors.argument(node, 1);
    113                         translateArgument(context, argument);
    114                         ASTNode replacement = Generators.makeCompoundIdentifierNode(BuiltinCallUtil.BUILTIN_PACKAGE_NAME,
    115                                         translatedBuiltin.pabloSName(), node);
     93        ADVANCE_THEN_SCANTO_TRANSLATION {
     94                public void translate(PabloSBuiltin translatedBuiltin, FuncCallNode node, Counter counter, Context context) {
     95                        scanToTranslate(PabloSBuiltin.ADVANCE_THEN_SCAN_THRU, node, counter, context);
     96                }
     97        };
    11698
    117                         node.replaceChild(Accessors.nameNode(node), replacement);
    118                         CARRY_ACTION.translate(translatedBuiltin, node, counter, context);
    119                 }       
    120                 private static void translateArgument(Context context, ASTNode argument) {
    121                         if(context.isFinalBlockMode()) {
    122                                 ASTNode replacement = Generators.makeSIMDEOFMaskAndCNodeFuncCall(argument.deepCopy(), context.getBuiltinEncoder());
    123                                 argument.updateSelf(replacement);
    124                         }
    125                         else {
    126                                 ASTNode replacement = Generators.makeSIMDNotFuncCall(argument.deepCopy(), context.getBuiltinEncoder());
    127                                 argument.updateSelf(replacement);                       
    128                         }
    129                 }       
    130                
     99        abstract public void translate(PabloSBuiltin translatedBuiltin, FuncCallNode node, Counter counter, Context context);
    131100
    132                 // Makes CarrySet builtin call.
    133                 // e.g. pablo.Advance(X,Y,Z) => carry_set_n.Advance(X,Y,Z,foo,carryInt)
    134                
    135                 private static void replaceCallWithCarryCall(FuncCallNode node,
    136                                 String carryPackageName, String carryBuiltin,
    137                                 List<ASTNode> arguments,
    138                                 ASTNode call, IntegerConstantNode carry) {
    139                
    140                         List<ASTNode> args = makeCarryCallArgs(arguments, call, carry);
    141                        
    142                         FuncCallNode replacementNode = Generators.makeFuncCallNode(
    143                                         carryPackageName,
    144                                         carryBuiltin,
    145                                         node,
    146                                         args);
    147                        
    148                         node.updateSelf(replacementNode);
     101        // helper methods
     102        private static void scanToTranslate(PabloSBuiltin translatedBuiltin, FuncCallNode node, Counter counter, Context context) {
     103                ASTNode argument = Accessors.argument(node, 1);
     104                translateArgument(context, argument);
     105                ASTNode replacement = Generators.makeCompoundIdentifierNode(BuiltinCallUtil.BUILTIN_PACKAGE_NAME,
     106                                translatedBuiltin.pabloSName(), node);
     107
     108                node.replaceChild(Accessors.nameNode(node), replacement);
     109                CARRY_TRANSLATION.translate(translatedBuiltin, node, counter, context);
     110        }       
     111        private static void translateArgument(Context context, ASTNode argument) {
     112                if(context.isFinalBlockMode()) {
     113                        ASTNode replacement = Generators.makeSIMDEOFMaskAndCNodeFuncCall(argument.deepCopy(), context.getBuiltinEncoder());
     114                        argument.updateSelf(replacement);
    149115                }
    150 
    151                 private static List<ASTNode> makeCarryCallArgs(List<ASTNode> arguments,
    152                                 ASTNode call, IntegerConstantNode carry) {
    153                         List<ASTNode> args = new ArrayList<ASTNode>(arguments);
    154                         args.add(call);
    155                         args.add(carry);
    156                         return args;
    157                 }               
    158         }
    159        
    160        
    161         private BuiltinTranslator() {}          // non-instantiated.           
    162 
    163         // static public interface
    164         public static void action(FuncCallNode node, Counter advance1Counter, Counter advanceNCounter, Context context) {
    165                 if(BuiltinCallUtil.isBuiltInCall(node)) {
    166                         PabloSBuiltin builtin = BuiltinCallUtil.builtin(node);
    167                         Counter counter = selectCounter(builtin, advance1Counter, advanceNCounter);
    168                         action(builtin, node, counter, context);
     116                else {
     117                        ASTNode replacement = Generators.makeSIMDNotFuncCall(argument.deepCopy(), context.getBuiltinEncoder());
     118                        argument.updateSelf(replacement);                       
    169119                }
    170120        }       
    171         private static Counter selectCounter(PabloSBuiltin builtin, Counter advance1Counter, Counter advanceNCounter) {
    172                 return builtin.isCarryN() ? advanceNCounter : advance1Counter;
     121
     122
     123        // Makes CarrySet builtin call.
     124        // e.g. pablo.Advance(X,Y,Z) => carry_set_n.Advance(X,Y,Z,foo,carryInt)
     125
     126        private static void replaceCallWithCarryCall(FuncCallNode node,
     127                        String carryPackageName, String carryBuiltin,
     128                        List<ASTNode> arguments,
     129                        ASTNode call, IntegerConstantNode carry) {
     130
     131                List<ASTNode> args = makeCarryCallArgs(arguments, call, carry);
     132
     133                FuncCallNode replacementNode = Generators.makeFuncCallNode(
     134                                carryPackageName,
     135                                carryBuiltin,
     136                                node,
     137                                args);
     138
     139                node.updateSelf(replacementNode);
    173140        }
    174141
    175         private static void action(PabloSBuiltin builtin, FuncCallNode node, Counter counter, Context context) {
    176                 Action action = actionFor(builtin);
    177                 action.translate(builtin, node, counter, context);
    178         }
    179         private static Action actionFor(PabloSBuiltin builtin) {
    180                 if(actions.containsKey(builtin)) {
    181                         return actions.get(builtin);
    182                 }
    183                 return DEFAULT_ACTION;
    184         }
     142        private static List<ASTNode> makeCarryCallArgs(List<ASTNode> arguments,
     143                        ASTNode call, IntegerConstantNode carry) {
     144                List<ASTNode> args = new ArrayList<ASTNode>(arguments);
     145                args.add(call);
     146                args.add(carry);
     147                return args;
     148        }               
    185149}
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/carry/CarryIntroXFormer.java

    r3242 r3244  
    1111import toolchain.pabloS.ast.Generators;
    1212import toolchain.pabloS.lang.*;
     13import toolchain.pabloS.transformer.visitors.carry.BuiltinTranslator;
    1314
    1415/*
     
    153154               
    154155                public void visitLeave(FuncCallNode node) {
    155                         BuiltinTranslator.action(node, carryCounter, advanceNCounter, context);
    156                 }
    157 
     156                        if(BuiltinCallUtil.isBuiltInCall(node)) {
     157                                PabloSBuiltin builtin = BuiltinCallUtil.builtin(node);
     158                                Counter counter = selectCounter(builtin, carryCounter, advanceNCounter);
     159                                BuiltinTranslator translator = builtin.getTranslator();
     160                                translator.translate(builtin, node, counter, context);
     161                        }       
     162                }
     163
     164                private static Counter selectCounter(PabloSBuiltin builtin, Counter advance1Counter, Counter advanceNCounter) {
     165                        return builtin.isCarryN() ? advanceNCounter : advance1Counter;
     166                }
    158167
    159168               
     
    413422                }               
    414423        }
     424
     425
    415426}       
Note: See TracChangeset for help on using the changeset viewer.