Changeset 3035 for proto/pabloj


Ignore:
Timestamp:
Apr 16, 2013, 7:51:04 PM (6 years ago)
Author:
ksherdy
Message:

Refactored idisa code. Moved 'codeStore' references out of the Accessors class to preserve Java package boundaries.

Location:
proto/pabloj/trunk/src/toolchain/pabloB
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • proto/pabloj/trunk/src/toolchain/pabloB/ast/Accessors.java

    r3032 r3035  
    301301        // IdisaFuncCallNode
    302302        ////////////////////////////////////////////////////////////////////////////
    303         public static String idisaFullName(IdisaFuncCallNode node,  List<CodeStore> childResults)
     303       
     304        public static IdisaFuncCallArgListNode idisaFuncCallArgListNode(IdisaFuncCallNode node) {
     305                return (IdisaFuncCallArgListNode)node.child(2);
     306        }
     307       
     308        public static String idisaBaseName(String fullyQualifiedName)
     309        {               
     310                return fullyQualifiedName.split("\\.")[1];
     311        }       
     312       
     313        public static String idisaLibraryName(String fullyQualifiedName)
    304314        {
    305                 return childResults.get(0).getResultVarName();
    306         }
    307 
    308         public static String idisaBaseName(IdisaFuncCallNode node,  List<CodeStore> childResults)
    309         {
    310                 String fullName = idisaFullName(node, childResults);           
    311                 return fullName.split("\\.")[1];
    312         }       
    313        
    314         public static String idisaClassName(IdisaFuncCallNode node,  List<CodeStore> childResults)
    315         {
    316                 String fullName = idisaFullName(node, childResults);
    317                 return fullName.split("\\.")[0];
    318         }
     315                return fullyQualifiedName.split("\\.")[0];
     316        }
     317       
    319318}
  • proto/pabloj/trunk/src/toolchain/pabloB/ast/Generators.java

    r3010 r3035  
    3232public class Generators {
    3333
    34         private static final String LEXICAL_CONTEXT = "main";
    35        
    36         public static IdentifierToken makeIdentifierToken(String identifier, Token locationToken) {
    37                 return IdentifierToken.make(LexicalType.IDENTIFIER, locationToken.getLocation(), identifier);
    38         }       
    39        
    40         public static IdentifierNode makeIdentifierNode(String identifier, Token locationToken) {
    41                 IdentifierToken newToken = Generators.makeIdentifierToken(identifier, locationToken);
    42                 return new IdentifierNode(newToken);
    43         }       
    44 
    45         private static Token makeIntegerConstantToken(int n,
    46                         Token locationToken) {
    47                 return  IntConstantToken.makeArtifical(LexicalType.INTEGER_CONST, locationToken.getLocation(), n);
    48         }               
    49        
    50         public static IntegerConstantNode makeIntegerConstantNode(int n, Token locationToken) {
    51                 IntegerConstantNode integerConstantNode = new IntegerConstantNode(makeIntegerConstantToken(n,
    52                                 locationToken));
    53                 integerConstantNode.setValue(n);
    54             return integerConstantNode;
    55         }
    56        
    57         public static LextantToken makeLextantToken(Lextant lextant, Token locationToken) {
    58                 return LextantToken.make(locationToken.getLocation(), lextant.getPrimaryLexeme(), lextant);
    59         }       
    60                
    61         public static InitDefNode makeInitDefNode (Token locationToken) {
    62                
    63                 LextantToken initDefToken = Generators.makeLextantToken(Lextant.KERNEL, locationToken);
    64                 InitDefNode initDefNode = new InitDefNode(initDefToken);
    65                
    66                 LextantToken initBlockToken = Generators.makeLextantToken(Lextant.LCURLY, locationToken);;
    67                 InitBlockNode initBlockNode = new InitBlockNode(initBlockToken);
    68                
    69                 initDefNode.appendChild(initBlockNode);
    70                
    71                 return initDefNode;
    72         }
    73 
    74         public static StateIdentifierNode makeStateIdentifierNode(String identifier, Token locationToken) {
    75                 IdentifierToken newToken = Generators.makeIdentifierToken(identifier, locationToken);
    76                 return new StateIdentifierNode(newToken);
    77         }               
    78        
    79         public static StateInitStmtNode makeStateInitStmtNode(String identifier, Integer [] values, Token locationToken) {
    80                
    81                 StateIdentifierNode identifierNode = Generators.makeStateIdentifierNode(identifier, locationToken);
    82                 IntegerConstantNode stateSize = Generators.makeIntegerConstantNode(values.length, locationToken);
    83                
    84                 StateInitListNode stateInitListNode = new StateInitListNode(Generators.makeIntegerConstantToken(values[0].intValue(), locationToken));
    85                 IntegerConstantNode n0 = Generators.makeIntegerConstantNode(values[0].intValue(), locationToken);
    86                 stateInitListNode.appendChild(n0);
    87                
    88                 for(int i = 1; i < values.length; i++) {
    89                         IntegerConstantNode n = Generators.makeIntegerConstantNode(values[i].intValue(), locationToken);
    90                         stateInitListNode.appendChild(n);
    91                 }
    92                                
    93                 StateInitStmtNode initStmtNode = new StateInitStmtNode(identifierNode.getToken());
    94                
    95                 initStmtNode.appendChild(identifierNode);
    96                 initStmtNode.appendChild(stateSize);
    97                 initStmtNode.appendChild(stateInitListNode);
    98                
    99                 return initStmtNode;
    100                
    101         }
    102        
    103         public static KernelDefNode makeKernelDef(String identifier,
    104                                                                                                 InitDefNode initDefNode,
    105                                                                                                 FuncDefNode funcDefNode,
    106                                                                                                 FuncDefNode optFuncDefNode,
    107                                                                                                 Token locationToken) {
    108                
    109                 LextantToken token = Generators.makeLextantToken(Lextant.KERNEL, locationToken);
    110                 KernelDefNode kernelDefNode = new KernelDefNode(token);
    111                 pabloB.ast.IdentifierNode identifierNode = Generators.makeIdentifierNode(identifier, locationToken);           
    112                
    113                 kernelDefNode.appendChild(identifierNode);
    114                 kernelDefNode.appendChild(initDefNode);
    115                 kernelDefNode.appendChild(funcDefNode.deepCopy());
    116                 kernelDefNode.appendChild(optFuncDefNode.deepCopy());
    117                
    118                 return kernelDefNode;
    119         }       
    120 
    121         public static void addFuncDefNode(KernelDefNode kernelDefNode, FuncDefNode funcDefNode) {
    122                 assert (kernelDefNode.nChildren() == 2);
    123                 kernelDefNode.appendChild(funcDefNode);
    124         }
    125 
    126         public static void addFuncCallNode(KernelDefNode kernelDefNode, FuncCallNode funcCallNode) {
    127                 kernelDefNode.appendChild(funcCallNode);
    128         }       
    129        
    130        
    13134        ////////////////////////////////////////////////////////////////////////////
    132         // Static factories PabloS2PabloB 
    133         //
     35        // PabloS2PabloB Token Conversion 
    13436        ////////////////////////////////////////////////////////////////////////////
    135 
     37        private static final String LEXICAL_CONTEXT = "main";   
     38       
    13639        public static pabloB.tokens.Token makePabloBToken(pabloS.tokens.Token sToken) {
    13740               
     
    208111        }
    209112       
     113        ////////////////////////////////////////////////////////////////////////////
     114        // PabloB Nodes
     115        ////////////////////////////////////////////////////////////////////////////   
     116       
     117        public static KernelDefNode makeKernelDef(String identifier,
     118                        InitDefNode initDefNode,
     119                        FuncDefNode funcDefNode,
     120                        FuncDefNode optFuncDefNode,
     121                        Token locationToken) {
     122               
     123                        LextantToken token = Generators.makeLextantToken(Lextant.KERNEL, locationToken);
     124                        KernelDefNode kernelDefNode = new KernelDefNode(token);
     125                        pabloB.ast.IdentifierNode identifierNode = Generators.makeIdentifierNode(identifier, locationToken);           
     126                       
     127                        kernelDefNode.appendChild(identifierNode);
     128                        kernelDefNode.appendChild(initDefNode);
     129                        kernelDefNode.appendChild(funcDefNode.deepCopy());
     130                        kernelDefNode.appendChild(optFuncDefNode.deepCopy());
     131                       
     132                        return kernelDefNode;
     133        }       
     134       
     135        /*
     136        private static void addFuncDefNode(KernelDefNode kernelDefNode, FuncDefNode funcDefNode) {
     137                assert (kernelDefNode.nChildren() == 2);
     138                kernelDefNode.appendChild(funcDefNode);
     139        }
     140        */
     141       
     142        public static void addFuncCallNode(KernelDefNode kernelDefNode, FuncCallNode funcCallNode) {
     143                kernelDefNode.appendChild(funcCallNode);
     144        }       
     145       
     146        public static InitDefNode makeInitDefNode (Token locationToken) {
     147               
     148                LextantToken initDefToken = Generators.makeLextantToken(Lextant.KERNEL, locationToken);
     149                InitDefNode initDefNode = new InitDefNode(initDefToken);
     150               
     151                LextantToken initBlockToken = Generators.makeLextantToken(Lextant.LCURLY, locationToken);;
     152                InitBlockNode initBlockNode = new InitBlockNode(initBlockToken);
     153               
     154                initDefNode.appendChild(initBlockNode);
     155               
     156                return initDefNode;
     157        }
     158
     159        public static StateInitStmtNode makeStateInitStmtNode(String identifier, Integer [] values, Token locationToken) {
     160               
     161                StateIdentifierNode identifierNode = Generators.makeStateIdentifierNode(identifier, locationToken);
     162                IntegerConstantNode stateSize = Generators.makeIntegerConstantNode(values.length, locationToken);
     163               
     164                StateInitListNode stateInitListNode = new StateInitListNode(Generators.makeIntegerConstantToken(values[0].intValue(), locationToken));
     165                IntegerConstantNode n0 = Generators.makeIntegerConstantNode(values[0].intValue(), locationToken);
     166                stateInitListNode.appendChild(n0);
     167               
     168                for(int i = 1; i < values.length; i++) {
     169                        IntegerConstantNode n = Generators.makeIntegerConstantNode(values[i].intValue(), locationToken);
     170                        stateInitListNode.appendChild(n);
     171                }
     172                               
     173                StateInitStmtNode initStmtNode = new StateInitStmtNode(identifierNode.getToken());
     174               
     175                initStmtNode.appendChild(identifierNode);
     176                initStmtNode.appendChild(stateSize);
     177                initStmtNode.appendChild(stateInitListNode);
     178               
     179                return initStmtNode;
     180               
     181        }
     182
     183        public static StateIdentifierNode makeStateIdentifierNode(String identifier, Token locationToken) {
     184                IdentifierToken newToken = Generators.makeIdentifierToken(identifier, locationToken);
     185                return new StateIdentifierNode(newToken);
     186        }               
     187
     188        public static FuncCallNode makeFuncCallNode(CompoundIdentifierNode compoundIdentifierNode, Token locationToken, ASTNode ...args) {
     189
     190                FuncCallNode node = Generators.makeFuncCallNode(compoundIdentifierNode, locationToken);
     191                List<ASTNode> list = new ArrayList<ASTNode>();
     192                for(ASTNode arg: args) {
     193                        list.add(arg);
     194                }
     195                Generators.addFuncCallsArgs(node, list);               
     196                return node;
     197        }
     198               
     199        public static FuncCallNode makeFuncCallNode(String[] identifiers, Token locationToken, ASTNode ...args) {
     200       
     201                FuncCallNode node = Generators.makeFuncCallNode(identifiers, locationToken);
     202                List<ASTNode> list = new ArrayList<ASTNode>();
     203                for(ASTNode arg: args) {
     204                        list.add(arg);
     205                }
     206                Generators.addFuncCallsArgs(node, list);
     207                return node;
     208        }
     209
    210210        private static void addFuncCallsArgs(FuncCallNode node, List<ASTNode> args) {
    211211               
     
    217217                }               
    218218        }
    219 
    220         public static FuncCallNode makeFuncCallNode(CompoundIdentifierNode compoundIdentifierNode, Token locationToken, ASTNode ...args) {
    221 
    222                 FuncCallNode node = Generators.makeFuncCallNode(compoundIdentifierNode, locationToken);
     219               
     220        /* - Eliminate redundant
     221        public static FuncCallNode makeFuncCallNode(String[] identifiers, Token locationToken) {
     222               
     223                CompoundIdentifierNode identifierNode = Generators.makeCompoundIdentifierNode(identifiers, locationToken);
     224                return Generators.makeFuncCallNode(identifierNode, locationToken);
     225        }
     226        */
     227       
     228        private static FuncCallNode makeFuncCallNode(ASTNode identifier, Token locationToken) {
     229                assert ((identifier instanceof IdentifierNode) || (identifier instanceof CompoundIdentifierNode));
     230
     231                LextantToken token = Generators.makeLextantToken(Lextant.LROUND, locationToken);
     232                FuncCallNode FuncCallNode = new FuncCallNode(token);
     233                FuncCallNode.appendChild(identifier);
     234                FuncCallNode.appendChild(new FuncCallArgListNode(locationToken));
     235
     236                return FuncCallNode;
     237        }               
     238
     239        public static IdisaFuncCallNode makeIdisaFuncCallNode(CompoundIdentifierNode compoundIdentifierNode, Token locationToken, ASTNode ...args) {
     240
     241                IdisaFuncCallNode node = Generators.makeIdisaFuncCallNode(compoundIdentifierNode, locationToken);
    223242                List<ASTNode> list = new ArrayList<ASTNode>();
    224243                for(ASTNode arg: args) {
    225244                        list.add(arg);
    226245                }
    227                 Generators.addFuncCallsArgs(node, list);               
     246                Generators.addIdisaFuncCallsArgs(node, list);           
    228247                return node;
    229248        }
    230249       
    231         public static FuncCallNode makeFuncCallNode(String[] identifiers, Token locationToken, ASTNode ...args) {
    232        
    233                 FuncCallNode node = Generators.makeFuncCallNode(identifiers, locationToken);
    234                 List<ASTNode> list = new ArrayList<ASTNode>();
    235                 for(ASTNode arg: args) {
    236                         list.add(arg);
    237                 }
    238                 Generators.addFuncCallsArgs(node, list);
    239                 return node;
    240         }
    241        
    242         public static FuncCallNode makeFuncCallNode(String[] identifiers, Token locationToken) {
    243                
    244                 CompoundIdentifierNode identifierNode = Generators.makeCompoundIdentifierNode(identifiers, locationToken);
    245                 return Generators.makeFuncCallNode(identifierNode, locationToken);
     250        private static IdisaFuncCallNode makeIdisaFuncCallNode(ASTNode identifier, Token locationToken) {
     251                assert ((identifier instanceof IdentifierNode) || (identifier instanceof CompoundIdentifierNode));
     252
     253                LextantToken token = Generators.makeLextantToken(Lextant.LANGLE, locationToken);
     254                IdisaFuncCallNode idisaFuncCallNode = new IdisaFuncCallNode(token);
     255                idisaFuncCallNode.appendChild(identifier);
     256                idisaFuncCallNode.appendChild(new FuncCallArgListNode(locationToken));
     257
     258                return idisaFuncCallNode;
     259        }               
     260
     261        private static void addIdisaFuncCallsArgs(IdisaFuncCallNode node, List<ASTNode> args) {
     262               
     263                if(args.size() > 0) {
     264                        for(ASTNode child: args) {
     265                                Accessors.idisaFuncCallArgListNode(node).appendChild(child);
     266                        }
     267                        Accessors.idisaFuncCallArgListNode(node).setToken(args.get(0).getToken());
     268                }               
     269        }       
     270       
     271        public static AssignNode makeAssignEqualNode(String [] identifiers, ASTNode rhs, Token locationToken) {
     272               
     273                Token assignEqualToken = Generators.makeLextantToken(Lextant.ASSIGN, locationToken);
     274                AssignNode assignEqualNode = new AssignNode(assignEqualToken);
     275               
     276                CompoundIdentifierNode lhs = Generators.makeCompoundIdentifierNode(identifiers, locationToken);
     277               
     278                assignEqualNode.appendChild(lhs);
     279                assignEqualNode.appendChild(rhs);
     280               
     281                return assignEqualNode;
    246282        }
    247283       
     
    255291                return CompoundIdentifierNode;
    256292        }
    257        
    258         private static FuncCallNode makeFuncCallNode(ASTNode identifier, Token locationToken) {
    259                 assert ((identifier instanceof IdentifierNode) || (identifier instanceof CompoundIdentifierNode));
    260 
    261                 LextantToken token = Generators.makeLextantToken(Lextant.LROUND, locationToken);
    262                 FuncCallNode FuncCallNode = new FuncCallNode(token);
    263                 FuncCallNode.appendChild(identifier);
    264                 FuncCallNode.appendChild(new FuncCallArgListNode(locationToken));
    265 
    266                 return FuncCallNode;
     293
     294        public static IdentifierNode makeIdentifierNode(String identifier, Token locationToken) {
     295                IdentifierToken newToken = Generators.makeIdentifierToken(identifier, locationToken);
     296                return new IdentifierNode(newToken);
     297        }       
     298               
     299        public static IdentifierToken makeIdentifierToken(String identifier, Token locationToken) {
     300                return IdentifierToken.make(LexicalType.IDENTIFIER, locationToken.getLocation(), identifier);
     301        }       
     302       
     303        public static IntegerConstantNode makeIntegerConstantNode(int n, Token locationToken) {
     304                IntegerConstantNode integerConstantNode = new IntegerConstantNode(makeIntegerConstantToken(n,
     305                                locationToken));
     306                integerConstantNode.setValue(n);
     307            return integerConstantNode;
     308        }       
     309       
     310        private static Token makeIntegerConstantToken(int n,    Token locationToken) {
     311                return  IntConstantToken.makeArtifical(LexicalType.INTEGER_CONST, locationToken.getLocation(), n);
    267312        }               
    268        
    269         public static AssignNode makeAssignEqualNode(String [] identifiers, ASTNode rhs, Token locationToken) {
    270                
    271                 Token assignEqualToken = Generators.makeLextantToken(Lextant.ASSIGN, locationToken);
    272                 AssignNode assignEqualNode = new AssignNode(assignEqualToken);
    273                
    274                 CompoundIdentifierNode lhs = Generators.makeCompoundIdentifierNode(identifiers, locationToken);
    275                
    276                 assignEqualNode.appendChild(lhs);
    277                 assignEqualNode.appendChild(rhs);
    278                
    279                 return assignEqualNode;
    280         }
     313
     314        private static LextantToken makeLextantToken(Lextant lextant, Token locationToken) {
     315                return LextantToken.make(locationToken.getLocation(), lextant.getPrimaryLexeme(), lextant);
     316        }       
     317
    281318       
    282319}
  • proto/pabloj/trunk/src/toolchain/pabloB/codeGenerator/visitors/Unparser.java

    r3033 r3035  
    360360                CodeStore code = new CodeStore();
    361361               
    362                 StringBuilder resultVar = new StringBuilder();
    363                
    364                 String fullyQualifiedName = Accessors.idisaFullName(node, childResults);
    365                 String baseName                   = Accessors.idisaBaseName(node, childResults);
    366                 String className                  = Accessors.idisaClassName(node, childResults);
    367                 String fieldWidth                 = childResults.get(1).getResultVarName();
    368                 String arguments                  = childResults.get(2).getResultVarName();
    369                
    370                 IDISABuiltin idisaBuiltin = IDISABuiltin.fromString(fullyQualifiedName);
    371                 assert idisaBuiltin != null : "Unknown IDISA Operation: " + baseName;
     362                String idisaFullyQualifiedName  = childResults.get(0).getResultVarName();
     363                String idisaOperationName               = Accessors.idisaBaseName(idisaFullyQualifiedName);
     364                String idisaPackageName                 = Accessors.idisaLibraryName(idisaFullyQualifiedName);
     365                String fieldWidth                               = childResults.get(1).getResultVarName();
     366                String arguments                                = childResults.get(2).getResultVarName();
     367               
     368                IDISABuiltin idisaBuiltin = IDISABuiltin.fromString(idisaFullyQualifiedName);
     369                assert idisaBuiltin != null : "Unknown IDISA Operation: " + idisaOperationName;
    372370                assert idisaBuiltin.hasSignature(Integer.valueOf(fieldWidth)) : "Unknown IDISA signature.";
    373371               
     
    376374                        = idisaBuiltin.getSignature(Integer.valueOf(fieldWidth)).getIDISABuiltinsGenerator();           
    377375               
    378                 String idisaFuncCallString = idisaBuiltinsGenerator.makeIDISAFuncCall(idisaBuiltins2Lang, baseName, className, fieldWidth, arguments);         
     376                String idisaFuncCallString = idisaBuiltinsGenerator.makeIDISAFuncCall(idisaBuiltins2Lang, idisaOperationName, idisaPackageName, fieldWidth, arguments);         
    379377               
    380378                code.setResultVarName(idisaFuncCallString);             // Function invocation as an expression
  • proto/pabloj/trunk/src/toolchain/pabloB/lang/idisa/IDISABuiltin.java

    r3032 r3035  
    11/*
    2  * IDISA SIMD builtins.
     2  * IDISA SIMD builtins.
    33 *
    44 * Unary        r = simd<w>::op(a)
Note: See TracChangeset for help on using the changeset viewer.