Changeset 3358 for proto


Ignore:
Timestamp:
Jun 26, 2013, 3:15:29 PM (6 years ago)
Author:
ksherdy
Message:

svn blues, partial commits

Location:
proto/pabloj/trunk/src/toolchain/pabloB
Files:
1 added
4 edited
3 moved

Legend:

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

    r3330 r3358  
    1515
    1616        ////////////////////////////////////////////////////////////////////////////
    17         //
    18         // Narrowest node type returned whenever possible. ASTNode type otherwise.
    19         //
    20         // WARNING: Add addition methods as needed. Do not hard code child index
    21         //                      values in general code.
    22         //
    23         ////////////////////////////////////////////////////////////////////////////
    24 
    25         ////////////////////////////////////////////////////////////////////////////
    2617        // Program
    2718        ////////////////////////////////////////////////////////////////////////////
    28 
    2919        public static List<StructDeclNode> structDeclNodes(ProgramNode node) {
    3020               
     
    5848        ////////////////////////////////////////////////////////////////////////////
    5949       
    60         /* TODO update init section and remove
    61         public static String integerConstantLexeme(StateSizeNode node) {
    62                 return node.child(0).getToken().getLexeme();
    63         }
    64         */                             
    65        
    6650        ////////////////////////////////////////////////////////////////////////////
    6751        // Kernel Definition
     
    8367        }
    8468       
    85         public static String kernelName(KernelDefNode node) {
    86                 return Accessors.name(node.child(0));
     69        public static ASTNode nameNode(KernelDefNode node) {
     70            return node.child(0);
    8771        }
    8872
     
    9074        // Kernel Definition
    9175        ////////////////////////////////////////////////////////////////////////////
    92 
    9376       
    9477        ////////////////////////////////////////////////////////////////////////////
     
    9982        }
    10083       
    101         public static String funcName(FuncDefNode node) {
    102                 return Accessors.name(node.child(1));
    103         }
    104 
     84        public static ASTNode nameNode(FuncDefNode node) {
     85            return node.child(1);
     86        }
     87       
    10588        public static boolean hasParameters(FuncDefNode node) {
    10689                ASTNode child2 = node.child(2);
     
    164147                return node.getToken().getPrintableLexeme();
    165148        }
    166                
     149       
    167150        ////////////////////////////////////////////////////////////////////////////
    168151        // Integer Constant
     
    199182       
    200183    ////////////////////////////////////////////////////////////////////////////
    201     // Name
    202     ////////////////////////////////////////////////////////////////////////////
    203     public static String name(ASTNode node) {
    204        
    205         if(node instanceof FuncCallNode) {
    206             node = funcCallIdentifier((FuncCallNode)node);
    207         }
    208         assert ((node instanceof IdentifierNode) || (node instanceof CompoundIdentifierNode));
    209        
     184    // FuncCallNode
     185    ////////////////////////////////////////////////////////////////////////////
     186   
     187    public static ASTNode nameNode(FuncCallNode node) {
     188        return node.child(0);
     189    }
     190    public static ASTNode argsListNode(FuncCallNode node) {
     191        return node.child(1);
     192    }
     193    public static int argCount(FuncCallNode node) {
     194        ASTNode argList = Accessors.argsListNode(node);
     195        if (argList == null) {
     196            return 0;
     197        }
     198        return argList.nChildren();
     199    }
     200   
     201    public static ASTNode argument(FuncCallNode node, int index) {
     202        if((index + 1) > Accessors.argsListNode(node).getChildren().size()) {
     203            throw new RuntimeException("Function invocation argument out of range.");
     204        }
     205        return Accessors.argsListNode(node).child(index);
     206    }
     207   
     208    public static List<ASTNode> argsList(FuncCallNode node) {
     209        return Accessors.argsListNode(node).getChildren();
     210    }
     211    public static String funcCallName(ASTNode node) {
     212        String name = new String();
    210213        if(node instanceof IdentifierNode) {
    211             return name((IdentifierNode)node);
    212         } else {
    213             return name((CompoundIdentifierNode)node);
    214         }
    215     }
    216 
    217     ////////////////////////////////////////////////////////////////////////////
    218     // IdentifierNode
    219     ////////////////////////////////////////////////////////////////////////////
    220     private static String name(IdentifierNode node) {
    221         return node.getToken().getPrintableLexeme();
    222     }
     214            name = Accessors.name((IdentifierNode)node);
     215        }
     216        else if (node instanceof CompoundIdentifierNode) {
     217            ASTNode pckage = node.child(0);
     218            ASTNode member = node.child(1);
     219            name = Accessors.name((IdentifierNode)pckage);
     220            name += ".";
     221            name += Accessors.name((IdentifierNode)member);
     222        }
     223        else {  // TS: added
     224            assert false: "Accessors.funcCallName() called on node of improper type.";
     225        }
     226        return name;
     227    }   
    223228
    224229    ////////////////////////////////////////////////////////////////////////////
     
    239244    }
    240245
    241 
    242 /* TODO Update init section and remove 
    243  * public static String stateName(ASTNode node) {
    244                 assert node instanceof StateIdentifierNode;
    245                 return node.getToken().getLexeme();
    246         }
    247 */     
    248246        ////////////////////////////////////////////////////////////////////////////
    249247        // Terminals
     
    256254        // StructDeclNode
    257255        ////////////////////////////////////////////////////////////////////////////
    258         public static String structName(StructDeclNode node) {
    259         return Accessors.name(node.child(0));
    260         }
    261 
     256        public static ASTNode nameNode(StructDeclNode node) {
     257            return node.child(0);
     258        }
     259       
    262260        public static StructDeclBodyNode structBody(StructDeclNode node) {
    263261                ASTNode child = node.child(1);
     
    266264        }       
    267265
    268 //  Deprecated 
    269 //     
    270 //      public static boolean hasStructBody(StructTypeNode node) {
    271 //              if (node.nChildren() > 1) {
    272 //                      ASTNode child = node.child(1);
    273 //                      assert child instanceof StructTypeBodyNode;
    274 //                      return true;
    275 //              }
    276 //              return false;
    277 //      }               
     266    ////////////////////////////////////////////////////////////////////////////
     267    // StructMemberNode
     268    ////////////////////////////////////////////////////////////////////////////
     269    public static ASTNode typeNode(StructMemberNode node) {
     270        return node.child(0);
     271    }
     272
     273    public static ASTNode nameNode(StructMemberNode node) {
     274        return (IdentifierNode)(node.child(1));
     275    }
    278276       
    279277        ////////////////////////////////////////////////////////////////////////////
    280278        // StructTypeNode
    281279        ////////////////////////////////////////////////////////////////////////////
    282         public static String structName(StructTypeNode node) {
    283         return Accessors.name(node.child(0));
    284         }       
     280        public static ASTNode nameNode(StructTypeNode node) {
     281            return node.child(0);
     282        }
    285283
    286284        public static String structTypeLexeme(StructTypeNode node) {           
     
    351349                return fullyQualifiedName.split("\\.")[0];
    352350        }
     351
     352    public static String name(IdentifierNode node) {
     353        return node.getToken().getLexeme();
     354    }
     355   
     356    ////////////////////////////////////////////////////////////////////////////
     357    // any node
     358    ////////////////////////////////////////////////////////////////////////////
     359    public static String name(ASTNode node) {
     360        if(node instanceof IdentifierNode) {
     361            return name((IdentifierNode) node);
     362        } else if(node instanceof CompoundIdentifierNode) {
     363            return name((CompoundIdentifierNode) node);
     364        } else if(node instanceof FuncCallNode) {
     365            return funcCallName(nameNode((FuncCallNode)node)); // special case
     366        } else if(node instanceof FuncDefNode) {
     367            return name(nameNode((FuncDefNode)node));
     368        } else if(node instanceof StructDeclNode) {
     369            return name(nameNode((StructDeclNode)node));
     370        } else if(node instanceof StructMemberNode) {
     371            return name(nameNode((StructMemberNode)node));
     372        } else if(node instanceof StructTypeNode) {
     373            return name(nameNode((StructTypeNode)node));
     374        } else if(node instanceof KernelDefNode) {
     375            return name(nameNode((KernelDefNode)node));
     376        }
     377        assert false : "Accessors.name(ASTNode node) method not implemented on node class : " + node.getClass();
     378        return null;
     379    }
     380   
     381    public static String lexeme(ASTNode node) {
     382        return node.getToken().getLexeme();
     383    }           
     384    public static ASTNode headChild(ASTNode node) {
     385        return node.child(0);
     386    }
     387    public static List<ASTNode> tailChildren(ASTNode compound) {
     388        List<ASTNode> children = compound.getChildren();
     389        return children.subList(1, children.size());
     390    }
     391//    public static List<Type> childTypes(ASTNode node) {
     392//        List<Type> result = new ArrayList<Type>(node.nChildren());
     393//        for(ASTNode child: node.getChildren()) {
     394//            result.add(child.getType());
     395//        }
     396//        return result;
     397//    }
    353398       
    354399}
  • proto/pabloj/trunk/src/toolchain/pabloB/ast/Generators.java

    r3347 r3358  
    11/*
    2  * TODO: KS: Continue to migrate 'locator' based PabloS generators from PabloS to PabloB.
     2 *
    33 */
    4 
    54package toolchain.pabloB.ast;
    65
     
    1413import toolchain.pabloB.ast.Accessors;
    1514import toolchain.pabloS.lang.carrySet.CarrySetBuiltin;
    16 import toolchain.pabloS.transformer.visitors.carry.Context;
     15import toolchain.pabloS.transformer.visitors.pabloS2PabloB.Context;
    1716
    1817public class Generators {
     
    2322        public static final String LEXICAL_CONTEXT = "main";   
    2423       
    25         public static pabloB.tokens.Token makePabloBToken(pabloS.tokens.Token sToken) {
     24        public static pabloB.tokens.Token makeToken(pabloS.tokens.Token sToken) {
    2625               
    2726                pabloB.tokens.Token bToken = null;
     
    3029                       
    3130                        bToken = pabloB.tokens.CharacterToken.make(pabloB.lexicalAnalyzer.LexicalType.LEXTANT,
    32                                                                                                                 makePabloBTextLocation(sToken.getLocation()),
     31                                                                                                                makeTextLocation(sToken.getLocation()),
    3332                                                                                                                sToken.getLexeme());
    3433                       
     
    3635
    3736                        bToken = pabloB.tokens.CharacterToken.make(pabloB.lexicalAnalyzer.LexicalType.IGNORE,
    38                                         makePabloBTextLocation(sToken.getLocation()),
     37                                        makeTextLocation(sToken.getLocation()),
    3938                                        sToken.getLexeme());
    4039                       
     
    4645
    4746                        bToken = pabloB.tokens.IdentifierToken.make(pabloB.lexicalAnalyzer.LexicalType.IDENTIFIER,
    48                                         makePabloBTextLocation(sToken.getLocation()),
     47                                        makeTextLocation(sToken.getLocation()),
    4948                                        sToken.getLexeme());                   
    5049                       
     
    5251
    5352                        bToken = pabloB.tokens.IntConstantToken.make(pabloB.lexicalAnalyzer.LexicalType.INTEGER_CONST,
    54                                         makePabloBTextLocation(sToken.getLocation()),
     53                                        makeTextLocation(sToken.getLocation()),
    5554                                        sToken.getLexeme());                                           
    5655                       
    5756                } else if (sToken instanceof pabloS.tokens.LextantToken) {
    5857                       
    59                         bToken = pabloB.tokens.LextantToken.make(makePabloBTextLocation(sToken.getLocation()),
     58                        bToken = pabloB.tokens.LextantToken.make(makeTextLocation(sToken.getLocation()),
    6059                                                                                                        sToken.getLexeme(),
    6160                                                                                                        pabloB.lexicalAnalyzer.Lextant.forLexeme(sToken.getLexeme(), LEXICAL_CONTEXT));                                                                 
     
    6463
    6564                        bToken = pabloB.tokens.NullToken.make(pabloB.lexicalAnalyzer.LexicalType.NONE,
    66                                         makePabloBTextLocation(sToken.getLocation()));                                         
     65                                        makeTextLocation(sToken.getLocation()));                                               
    6766                       
    6867                } else if (sToken instanceof pabloS.tokens.StringConstantToken) {
     
    7271                       
    7372                        bToken = pabloB.tokens.StringConstantToken.make(pabloB.lexicalAnalyzer.LexicalType.STRING,
    74                                         makePabloBTextLocation(sToken.getLocation()),
     73                                        makeTextLocation(sToken.getLocation()),
    7574                                        stringLexeme);                                                                 
    7675                       
     
    7877
    7978                        bToken = pabloB.tokens.WhitespaceToken.make(pabloB.lexicalAnalyzer.LexicalType.IGNORE,
    80                                         makePabloBTextLocation(sToken.getLocation()),
     79                                        makeTextLocation(sToken.getLocation()),
    8180                                        sToken.getLexeme());                           
    8281                       
     
    9089        }
    9190
    92         public static pabloB.inputHandler.TextLocation makePabloBTextLocation(pabloS.inputHandler.TextLocation sTextLocation) {
     91        public static pabloB.inputHandler.TextLocation makeTextLocation(pabloS.inputHandler.TextLocation sTextLocation) {
    9392                pabloB.inputHandler.TextLocation bTextLocation = new pabloB.inputHandler.TextLocation(sTextLocation.getFilename(),
    9493                                                                                                                                                                                                sTextLocation.getLineNumber(),
  • proto/pabloj/trunk/src/toolchain/pabloB/codeGenerator/visitors/Unparser.java

    r3330 r3358  
    167167        }
    168168
    169        
    170 /*      public CodeStore visitLeave(InitBlockNode node, List<CodeStore> childResults) {
    171                 CodeStore code = new CodeStore();
    172                
    173                 // add strings
    174                 if (childResults.isEmpty()) {
    175                         code.addLine(""); // empty if / while
    176                 }
    177                
    178                 for (CodeStore child: childResults) {
    179                         code.addAll(child, 0);
    180                 }               
    181                
    182                 return code;
    183         }
    184 */     
    185         /* TODO - Update init section and remove
    186         public CodeStore visitLeave(StateIdentifierNode node, List<CodeStore> childResults) {           
    187                
    188             // stateIdentifier = Accessors.stateName(node); // synthetic attribute
    189                 CodeStore code = new CodeStore();
    190                 // code.setResultVarName(stateIdentifier);             
    191                 return code;
    192         }
    193         */
    194         /* TODO - Update init section and remove
    195         public CodeStore visitLeave(StateInitStmtNode node, List<CodeStore> childResults) {
    196                
    197                 CodeStore code = new CodeStore();
    198                
    199                 // TODO - Hook for PabloB Kernel init section, state.
    200                
    201 //              code.addFormattedLine("for(int i=0; i<%s; i++)", stateSize);
    202 //              code.addLine("{");
    203 //              code.addAll(stateInitListCodeStore, 0);
    204 //              code.dedentedLine("}");
    205 //              code.addLine("");
    206                
    207                                
    208                 return code;
    209         }       
    210         */
    211         /* TODO - Update init section and remove
    212         public CodeStore visitLeave(StateInitListNode node, List<CodeStore> childResults) {
    213                
    214                 CodeStore code = new CodeStore();
    215 
    216                 // TODO - Hook for PabloB Kernel init section, state.
    217                
    218 //              for(int i=0; i<childResults.size(); i++) {
    219 //                      code.addFormattedLine("%s[%s]=%s;", stateIdentifier, Integer.toString(i), childResults.get(i).getResultVarName(), 0);
    220 //              }
    221                
    222                
    223                 return code;
    224         }
    225         */
    226         /* TODO - Update init section and remove
    227         public CodeStore visitLeave(StateSizeNode node, List<CodeStore> childResults) {
    228                 CodeStore code = new CodeStore();
    229         //      code.setResultVarName(Accessors.integerConstantLexeme(node));
    230                 return code;
    231         }       
    232         */
    233169        public CodeStore visitLeave(FuncDefNode node, List<CodeStore> childResults) {
    234170                       
  • proto/pabloj/trunk/src/toolchain/pabloB/lang/KernelState.java

    r3260 r3358  
    33public enum KernelState {
    44
    5         CARRY1_LIST("Carry1List"),
    6         CARRYN_LIST("CarryNList"),
     5        CARRY1_INITIAL_VALUES("Carry1InitialValues"),
     6        CARRYN_INITIAL_VALUES("CarryNInitialValues"),
    77        CARRY1_COUNT("Carry1Count"),
    88        CARRYN_COUNT("CarryNCount"),
  • proto/pabloj/trunk/src/toolchain/pabloB/transformer/visitors/pabloB2PabloB/AddAlignmentAssertions.java

    r3330 r3358  
    11/*
    2  * Adds BitBlock alignment assertion statements to the AST
     2 * Adds BitBlock alignment assertion statements to the PabloB AST
    33 * after each assignment and variable declaration statement.
    4  *
    5  * TODO - Move to PabloB.
    64 *
    75 * @author Ken Herdy <ksherdy at sfu dot ca>
    86 */
    97
    10 package toolchain.pabloB.transformer.visitors;
     8package toolchain.pabloB.transformer.visitors.pabloB2PabloB;
    119
    1210import pabloB.ast.*;
  • proto/pabloj/trunk/src/toolchain/pabloB/transformer/visitors/pabloB2PabloB/AddAssignmentPrints.java

    r3330 r3358  
    88 */
    99
    10 package toolchain.pabloB.transformer.visitors;
     10package toolchain.pabloB.transformer.visitors.pabloB2PabloB;
    1111
    1212import pabloB.ast.*;
     
    4141                private void addPrintStatement(ASTNode node, ASTNode lhs) {
    4242                   
    43                     if(lhs instanceof FuncCallNode) {
    44                         return;
    45                     }
    46                    
    47                     if(lhs instanceof IdentifierNode) {
    48                         if(lhs.getToken().getLexeme().contains("__")) {
    49                             return;
    50                         }
    51                     }
    52                    
    5343                    FuncCallNode printCall = makePrintCall(node, lhs.deepCopy());       // deepCopy
    5444                        Mutators.insertStatementAfter(node, printCall);                         
    5545                }
    5646
    57                 private FuncCallNode makePrintCall(ASTNode node, ASTNode argument) {
     47                private FuncCallNode makePrintCall(ASTNode node, ASTNode lhs) {
    5848                        String printBitblockCode = encoder.getCode(PabloBBuiltin.PRINT_BITBLOCK);
     49
     50                        ASTNode label = Generators.makeStringConstantNode(node, Accessors.name(lhs));
    5951                       
    60                         ASTNode label = Generators.makeStringConstantNode(node, Accessors.name(argument));
    61                        
    62                         FuncCallNode call = Generators.makeFuncCallNode(node.getToken(), printBitblockCode, label, argument);
     52                        FuncCallNode call = Generators.makeFuncCallNode(node.getToken(), printBitblockCode, label, lhs);
    6353                        return call;
    6454                }
  • proto/pabloj/trunk/src/toolchain/pabloB/transformer/visitors/pabloB2PabloB/PabloB2PabloBController.java

    r3293 r3358  
    55 */
    66
    7 package toolchain.pabloB.transformer;
     7package toolchain.pabloB.transformer.visitors.pabloB2PabloB;
    88
    99import pabloB.ast.ASTNode;
    1010import toolchain.pabloB.lang.*;
    11 import toolchain.pabloB.transformer.visitors.AddAlignmentAssertions;
    12 import toolchain.pabloB.transformer.visitors.AddAssignmentPrints;
    1311
    14 public class Transformer {
    15        
    16         private pabloB.ast.ASTNode ASTTree;
     12public class PabloB2PabloBController {
    1713       
    1814        //private SymbolTable symbolTable;
    1915       
    20         private BuiltinEncoder builtinEncoder;
    21        
    22     private boolean addDumpStmts;
    23     private boolean addAssertBitBlockAlignStmts;
     16        private static BuiltinEncoder builtinEncoder;
     17        private static boolean addDumpStmts;
     18    private static boolean addAssertBitBlockAlignStmts;
     19   
     20    static {
     21        defaults();
     22    }
     23   
     24    private static void defaults() {
     25        addDumpStmts = false;
     26        addAssertBitBlockAlignStmts = false;
     27    }
     28   
    2429    //////////////////////////////////////////////////////////////
    2530        // static interface - transforms AST in default mode only
    2631        //
    27         public static ASTNode analyze(ASTNode root) {
    28                 Transformer analyzer = new Transformer(root);           
    29                 return analyzer.xForm();
    30         }       
    31        
    32         //////////////////////////////////////////////////////////////
    33         // constructor and helpers
    34         public Transformer(ASTNode ASTTree) {
    35                
    36                 this.ASTTree = ASTTree;         
    37                 initDefaults();
    38                 // this.symbolTable = symbolTable;
    39         }       
    40        
    41         private void initDefaults() {
    42                 this.addDumpStmts = false;
    43                 this.addAssertBitBlockAlignStmts = false;
    44         }
    45        
    46         //////////////////////////////////////////////////////////////
    47         // analysis
    48         public ASTNode xForm() {
    49                
    50                 ASTNode decoratedTree = ASTTree.deepCopy();
     32        public static ASTNode accept(ASTNode ASTree) {
     33        ASTNode decoratedTree = ASTree.deepCopy();
    5134
    5235        if(addingAssignmentPrints()) {
     
    5538        if(addingAlignmentAssertions()) {
    5639            decoratedTree = AddAlignmentAssertions.apply(decoratedTree, getBuiltinEncoder()); 
    57         }               
    58                                                                                
    59                 return decoratedTree;
    60                
    61         }
    62 
    63     public boolean addingAssignmentPrints() {
     40        }           
     41                                               
     42        return decoratedTree;
     43        }       
     44       
     45    public static boolean addingAssignmentPrints() {
    6446        return addDumpStmts;
    6547    }
    6648
    67     public void setAddDumpStmts(boolean addDumpStmts) {
    68         this.addDumpStmts = addDumpStmts;
     49    public static void setAddDumpStmts(boolean addStmts) {
     50        addDumpStmts = addStmts;
    6951    }
    7052
    71     public boolean addingAlignmentAssertions() {
     53    public static boolean addingAlignmentAssertions() {
    7254        return addAssertBitBlockAlignStmts;
    7355    }
    7456
    75     public void setAddAssertBitBlockAlignStmts(boolean addAssertBitBlockAlignStmts) {
    76         this.addAssertBitBlockAlignStmts = addAssertBitBlockAlignStmts;
     57    public static void setAddAssertBitBlockAlignStmts(boolean addStmts) {
     58        addAssertBitBlockAlignStmts = addStmts;
    7759    }   
    7860   
    79     public BuiltinEncoder getBuiltinEncoder() {
    80         return this.builtinEncoder;
     61    public static BuiltinEncoder getBuiltinEncoder() {
     62        return builtinEncoder;
    8163    }
    8264
    83     public void setBuiltins2Lang(BuiltinEncoder builtins2Lang) {
    84         this.builtinEncoder = builtins2Lang;
     65    public static void setBuiltins2Lang(BuiltinEncoder encoder) {
     66        builtinEncoder = encoder;
    8567    }
    8668
Note: See TracChangeset for help on using the changeset viewer.