Changeset 3243 for proto/pabloj


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

refactored BuiltinTranslator? to use polymorphic dispatch on the enum Action rather than explicit dispatch. Most functionality is now in the enum rather than the outer class.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/carry/BuiltinTranslator.java

    r3242 r3243  
    1212import toolchain.pabloS.ast.Generators;
    1313import toolchain.pabloS.lang.PabloSBuiltin;
    14 import toolchain.pabloS.lang.PabloSBuiltin.CarryType;
    1514import toolchain.pabloS.lang.BuiltinCallUtil;
    1615
     
    2625                actions.put(PabloSBuiltin.ADVANCE_THEN_SCAN_TO, Action.ADVANCE_THEN_SCANTO_ACTION);
    2726        }
     27        private static final Action DEFAULT_ACTION = Action.CARRY_ACTION;
     28       
    2829        private enum Action {
    29                 CARRY_ACTION,
    30                 SCANTO_ACTION,
    31                 ADVANCE_THEN_SCANTO_ACTION,
    32                 ADVANCEN_ACTION,
    33                 ATEOF_ACTION,
    34                 INFILE_ACTION,
    35                 MASK_ACTION;
     30                CARRY_ACTION { 
     31                        public void translate(PabloSBuiltin translatedBuiltin, FuncCallNode node, Counter counter, Context context) {
     32                                List<ASTNode> arguments = Accessors.argsList(node);
     33
     34                                replaceCallWithCarryCall(node,
     35                                                context.getCarrySetIdentifier(),
     36                                                context.getCode(translatedBuiltin),
     37                                                arguments,
     38                                                counter.callOrMask(node, context),
     39                                                counter.valueNode(node));
     40
     41                                counter.increment();
     42                        }
     43                },
     44
     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);
     49
     50                                List<ASTNode> arguments = Accessors.argsList(node);
     51
     52                                String templateCode = context.getCode(builtin);
     53                                String formattedAdvanceN = String.format(templateCode, value);
     54
     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);
     116
     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               
     131
     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);
     149                }
     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                }               
    36158        }
    37         private static final Action DEFAULT_ACTION = Action.CARRY_ACTION;
     159       
    38160       
    39161        private BuiltinTranslator() {}          // non-instantiated.           
    40162
    41163        // static public interface
    42         static public void action(FuncCallNode node, Counter advance1Counter, Counter advanceNCounter, Context context) {
     164        public static void action(FuncCallNode node, Counter advance1Counter, Counter advanceNCounter, Context context) {
    43165                if(BuiltinCallUtil.isBuiltInCall(node)) {
    44166                        PabloSBuiltin builtin = BuiltinCallUtil.builtin(node);
     
    47169                }
    48170        }       
    49         static private Counter selectCounter(PabloSBuiltin builtin, Counter counter, Counter advanceNCounter) {
    50                 return usesAdvanceNCounter(builtin) ? advanceNCounter : counter;
    51         }
    52         static private boolean usesAdvanceNCounter(PabloSBuiltin builtin) {
    53                 return builtin.getCarryType() == CarryType.N ;
     171        private static Counter selectCounter(PabloSBuiltin builtin, Counter advance1Counter, Counter advanceNCounter) {
     172                return builtin.isCarryN() ? advanceNCounter : advance1Counter;
    54173        }
    55174
    56         static private void action(PabloSBuiltin builtin, FuncCallNode node, Counter counter, Context context) {
     175        private static void action(PabloSBuiltin builtin, FuncCallNode node, Counter counter, Context context) {
    57176                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;
    64                
    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;               
    67                 }
     177                action.translate(builtin, node, counter, context);
    68178        }
    69        
    70179        private static Action actionFor(PabloSBuiltin builtin) {
    71180                if(actions.containsKey(builtin)) {
     
    74183                return DEFAULT_ACTION;
    75184        }
    76        
    77         static private void carryAction(PabloSBuiltin translatedBuiltin, FuncCallNode node, Counter counter, Context context) {
    78                 List<ASTNode> arguments = Accessors.argsList(node);
    79                
    80                 replaceCallWithCarryCall(node,
    81                                 context.getCarrySetIdentifier(),
    82                                 context.getCode(translatedBuiltin),
    83                                 arguments,
    84                                 counter.callOrMask(node, context),
    85                                 counter.valueNode(node));
    86                
    87                 counter.increment();
    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) {
    109                 ASTNode argument = Accessors.argument(node, 1);
    110                 translateArgument(context, argument);
    111                 ASTNode replacement = Generators.makeCompoundIdentifierNode(BuiltinCallUtil.BUILTIN_PACKAGE_NAME,
    112                                                                                                                                         translatedBuiltin.pabloSName(), node);
    113                
    114                 node.replaceChild(Accessors.nameNode(node), replacement);
    115                 carryAction(translatedBuiltin, node, counter, context);
    116         }
    117        
    118         private static void translateArgument(Context context, ASTNode argument) {
    119                 if(context.isFinalBlockMode()) {
    120                         ASTNode replacement = Generators.makeSIMDEOFMaskAndCNodeFuncCall(argument.deepCopy(), context.getBuiltinEncoder());
    121                         argument.updateSelf(replacement);
    122                 }
    123                 else {
    124                         ASTNode replacement = Generators.makeSIMDNotFuncCall(argument.deepCopy(), context.getBuiltinEncoder());
    125                         argument.updateSelf(replacement);                       
    126                 }
    127         }               
    128        
    129        
    130         private static void atEOFAction(PabloSBuiltin builtin, FuncCallNode node, Counter counter, Context context) {
    131                 if(context.isFinalBlockMode()) {
    132                         ASTNode argNode = Accessors.argument(node, 0);
    133                         ASTNode replacementNode = Generators.makeSIMDAndCEOFMaskFuncCall(argNode, context.getBuiltinEncoder());
    134                         node.updateSelf(replacementNode);
    135                 }
    136                 else {                         
    137                         node.updateSelf(Counter.mask(node));                   
    138                 }
    139         }
    140        
    141         private static void infileAction(PabloSBuiltin builtin, FuncCallNode node, Counter counter, Context context) {
    142                 if(context.isFinalBlockMode()) {                                       
    143                         ASTNode argNode = Accessors.argument(node, 0);
    144                         ASTNode replacementNode = Generators.makeSIMDAndEOFMaskFuncCall(argNode, context.getBuiltinEncoder());
    145                         node.updateSelf(replacementNode);
    146                 } else {
    147                         node.updateSelf(Accessors.argument(node,0));
    148                 }
    149         }                       
    150         private static void maskAction(PabloSBuiltin builtin, FuncCallNode node, Counter counter, Context context) {
    151                 node.updateSelf(Counter.mask(node));
    152         }
    153        
    154         /*
    155          * Makes CarrySet builtin call.
    156          * e.g. pablo.Advance(X,Y,Z) => carry_set_n.Advance(X,Y,Z,foo,carryInt)
    157          */
    158         private static void replaceCallWithCarryCall(FuncCallNode node,
    159                         String carryPackageName, String carryBuiltin,
    160                         List<ASTNode> arguments,
    161                         ASTNode call, IntegerConstantNode carry) {
    162        
    163                 List<ASTNode> args = makeCarryCallArgs(arguments, call, carry);
    164                
    165                 FuncCallNode replacementNode = Generators.makeFuncCallNode(
    166                                 carryPackageName,
    167                                 carryBuiltin,
    168                                 node,
    169                                 args);
    170                
    171                 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;
    180         }       
    181185}
Note: See TracChangeset for help on using the changeset viewer.