Ignore:
Timestamp:
May 31, 2013, 7:31:43 PM (6 years ago)
Author:
ksherdy
Message:

PabloS to PabloB simplification. Added explicit Carry Info Set object.

Location:
proto/pabloj/trunk/src
Files:
1 added
3 deleted
7 edited
1 copied
2 moved

Legend:

Unmodified
Added
Removed
  • proto/pabloj/trunk/src/application/config/Configuration.java

    r3172 r3249  
    4141        public Boolean addAssertBitBlockAlignStmts;
    4242        public Boolean addDumpStmts;
    43         public String   errorRoutine;   
     43        public String   errorRoutine;
     44       
     45        // Experimental mode
     46        public boolean isExperimentalMode;
    4447}
    4548
  • proto/pabloj/trunk/src/application/config/ConfigurationFactory.java

    r3166 r3249  
    4848        }
    4949       
    50         // general defaults
     50        // defaults
    5151        configuration.addAssertBitBlockAlignStmts = false;
    5252        if(cli.hasOption("a")) {
     
    6161        configuration.errorRoutine = cli.getOptionValue("e", "raise_assert");
    6262       
     63        configuration.isExperimentalMode = false;
     64        if(cli.hasOption("p")) {
     65                configuration.isExperimentalMode = true;
     66        }
     67       
    6368                return configuration;
    6469       
  • proto/pabloj/trunk/src/application/config/ConfigurationOptions.java

    r3134 r3249  
    9191                        option = OptionBuilder.create("x");
    9292                        options.addOption(option);                             
    93                                                
     93
     94                    OptionBuilder.hasArg(false);
     95                    OptionBuilder.isRequired(false);
     96                    OptionBuilder.withLongOpt("experimental");
     97                    OptionBuilder.withDescription("Experimental mode.");
     98                        option = OptionBuilder.create("p");
     99                        options.addOption(option);                                             
     100                       
    94101                    return options;
    95102                  }
  • proto/pabloj/trunk/src/application/generators/ApplicationGenerator.java

    r3213 r3249  
    2121
    2222import java.io.File;
     23import java.util.ArrayList;
     24import java.util.Map;
    2325
    2426import toolchain.pabloB.codeGenerator.idisa.IDISABuiltin2C;
     
    2729import toolchain.pabloB.codeGenerator.visitors.Unparser;
    2830
    29 import toolchain.pabloB.symbols.SymbolTable;
    30 //import toolchain.pabloS.lang.*;
    3131import toolchain.pabloS.transformer.visitors.PabloS2PabloBXFormer;
    32 import toolchain.pabloS.transformer.visitors.carry.CarryInfoSetVisitor;
     32import toolchain.pabloS.transformer.visitors.StreamFunctions;
     33import toolchain.pabloS.transformer.visitors.carry.CarryInfoSet;
     34import toolchain.pabloS.transformer.visitors.carry.CarryInfoSetFactory;
    3335
    3436import application.config.Configuration;
     
    5153               
    5254        public void generate() throws ASTGeneratorException {
    53 
    54                 SymbolTable symbolTable = new SymbolTable();   
    5555               
    5656                // Transformation configurations to support multiple backends
     
    8282                if(applicationConfiguration.isPabloSSource) {
    8383                        pabloS.ast.ASTNode pabloSAST = ASTGenerator.buildPabloSAST(applicationConfiguration.pabloSFile);
    84        
    85                         //pabloB.ast.ASTNode syntaxTree = Parser.parsePabloB(applicationConfiguration.pabloBFile);
    8684                       
    87                         // Gather carry information set
    88                         // TODO - refactor - carry_count, advance_n_count, add symbol table to root node
    89                         CarryInfoSetVisitor carryInfoSetVisitor = new CarryInfoSetVisitor(pabloSAST, symbolTable); 
    90                         carryInfoSetVisitor.visit();
    91                        
    92                         // Replace PabloS builtins and Carry Set builtins with target language strings.
     85                        // transform PabloS builtins to Carry Set builtins
    9386                        toolchain.pabloS.transformer.Transformer pabloSXFormer = new toolchain.pabloS.transformer.Transformer(pabloSAST);
    9487                        pabloSXFormer.setBuiltins2Lang(pabloSbuiltins2Lang);
    9588                        pabloSXFormer.setCarrySet2Lang(carrySet2Lang);
    96 
     89                       
    9790                        // Transform PabloS global functions in non-final block mode
    9891                        pabloSXFormer.setFinalBlockMode(false);
     
    10295                        pabloSXFormer.setFinalBlockMode(true);
    10396                        pabloS.ast.ProgramNode optDecoratedTree = (pabloS.ast.ProgramNode)pabloSXFormer.xForm();
     97
     98                        // Transform PabloS to PabloB
    10499                       
    105                         // PabloS to PabloB transformation
    106                         PabloS2PabloBXFormer pabloS2PabloBXFormer = new PabloS2PabloBXFormer(symbolTable, carrySet2Lang);
     100
     101                        // 1. List stream functions
     102                        // 2. Map
     103                       
     104                        ArrayList<pabloS.ast.FuncDefNode> funcDefNodes = StreamFunctions.makeList(pabloSAST);
     105                        Map<String, CarryInfoSet> carryInfoSetMap = CarryInfoSetFactory.makeCarryInfoSetMap(funcDefNodes); 
     106                       
     107                        PabloS2PabloBXFormer pabloS2PabloBXFormer = new PabloS2PabloBXFormer(carryInfoSetMap, carrySet2Lang);
    107108                        pabloBAST = pabloS2PabloBXFormer.XForm(decoratedTree, optDecoratedTree);
     109                       
    108110               
    109111                } else if (applicationConfiguration.isPabloBSource) {
     
    114116       
    115117        // PabloB AST Transforms
    116         toolchain.pabloB.semanticAnalyzer.Transformer pabloBXFormer = new toolchain.pabloB.semanticAnalyzer.Transformer(pabloBAST);
     118        toolchain.pabloB.transformer.Transformer pabloBXFormer = new toolchain.pabloB.transformer.Transformer(pabloBAST);
    117119        pabloBXFormer.setBuiltins2Lang(pabloBBuiltins2Lang);
    118120       
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/Transformer.java

    r3213 r3249  
    5353               
    5454                pabloS.ast.ASTNode decoratedTree = ASTTree.deepCopy();
    55 
    56                
    5755               
    5856                decoratedTree = ExpandAugmentedAssignments.apply(decoratedTree);
     
    6260                decoratedTree = ConvertBitwiseBooleanToIDISACalls.apply(decoratedTree);
    6361                //decoratedTree = InitializeStreamDefaults.apply(decoratedTree);
    64                
     62                               
    6563                return decoratedTree;
    6664               
     
    8987        public void setFinalBlockMode(boolean finalBlockMode) {
    9088                this.finalBlockMode = finalBlockMode;
    91         }       
     89        }
    9290       
    9391}               
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/CombineAdvances.java

    r3213 r3249  
    2020public class CombineAdvances {
    2121       
    22         static public ASTNode apply(ASTNode ASTree) {
     22        static public ASTNode apply(ASTNode ASTTree) {
    2323                AdvanceCombinerVisitor combiner = new AdvanceCombinerVisitor();
    24                 ASTree.accept(combiner);
    25                 return ASTree;                          // root ASTree does not change
     24                ASTTree.accept(combiner);
     25                return ASTTree;                         // root ASTree does not change
    2626        }   
    2727   
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/PabloS2PabloBXFormer.java

    r3240 r3249  
    1212import java.util.Map;
    1313
    14 import pabloB.ast.ASTNode;
    1514import pabloB.ast.FuncCallNode;
    1615import pabloS.ast.ASTVisitor.Default;
     
    1918import toolchain.pabloB.lang.carrySet.CarrySetEncoder;
    2019import toolchain.pabloB.lang.carrySet.CarrySetBuiltins;
    21 import toolchain.pabloB.symbols.CarryInfoSetSymbol;
    22 import toolchain.pabloB.symbols.SymbolTable;
    2320import toolchain.pabloS.ast.Accessors;
    2421import toolchain.pabloS.lang.BuiltinCallUtil;
     22import toolchain.pabloS.transformer.visitors.carry.CarryInfoSet;
    2523
    2624public class PabloS2PabloBXFormer {
     
    3533        private pabloS.ast.ASTNode optDecoratedASTTree;                 
    3634       
    37         private SymbolTable pabloSSymbolTable;
     35        private Map<String, CarryInfoSet> carryInfoSetMap;
    3836        private CarrySetEncoder carrySetEncoder;
    3937       
     
    4543         */
    4644 
    47     public PabloS2PabloBXFormer(toolchain.pabloB.symbols.SymbolTable pabloSSymbolTable, CarrySetEncoder carrySetEncoder) {
     45    public PabloS2PabloBXFormer(Map<String, CarryInfoSet> carryInfoSetMap, CarrySetEncoder carrySetEncoder) {
    4846        this.decoratedASTTree = null;
    4947        this.optDecoratedASTTree = null;
    50         this.pabloSSymbolTable = pabloSSymbolTable;
    51        
     48        this.carryInfoSetMap = carryInfoSetMap;
    5249        this.carrySetEncoder = carrySetEncoder;
    5350    }
     
    8380                       
    8481                        String kernelName = entry.getKey();                     
    85                         CarryInfoSetSymbol carryInfoSetSymbol = (CarryInfoSetSymbol) pabloSSymbolTable.get(kernelName);
     82                        CarryInfoSet carryInfoSetSymbol = (CarryInfoSet) carryInfoSetMap.get(kernelName);
    8683                       
    8784                        pabloB.ast.InitDefNode initDefNode = Generators.makeInitDefNode(funcDefNode);                   
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/StreamFunctions.java

    r3247 r3249  
    11/*
    2  * Constructs a map of stream function names to stream function nodes.
     2 * Gathers PabloS stream function definitions as an ArrayList of FuncDefNodes.
    33 *
    44 * @author Ken Herdy <ksherdy at sfu dot ca>
     
    88
    99import java.util.*;
     10import pabloS.ast.*;
    1011
     12public class StreamFunctions extends ArrayList<FuncDefNode> {
     13       
     14        private static final long serialVersionUID = 8639586378925373084L;
    1115
    12 import pabloS.ast.*;
    13 import pabloS.lexicalAnalyzer.LexicalType;
    14 import pabloS.tokens.IdentifierToken;
    15 import toolchain.pabloS.ast.Accessors;
    16 import toolchain.pabloS.ast.Generators;
    17 
    18 
    19 //class StreamFuncVisitor(ast.NodeVisitor):
    20 //    def __init__(self,node):
    21 //        self.streamFuncNode = {}
    22 //        self.generic_visit(node)
    23 //
    24 //    def visit_FuncDef(self, node):                   
    25 //        key = node.name[0].upper() + node.name[1:]
    26 //        self.streamFuncNode[key] = node
    27 
    28 public class StreamFunctionMapGenerator {
    29    
    30     private ASTNode ASTree;
    31    
    32     public StreamFunctionMapGenerator(ASTNode ASTree) {
    33         this.ASTree = ASTree;
    34     }
    35    
    36     public void visit() {
    37         StreamFuncVisitor1 visitor = new StreamFuncVisitor1();
    38         ASTree.accept(visitor);
    39     }   
    40        
    41         public  Map<String, ASTNode> makeStreamFuncMap() {
    42             StreamFuncVisitor1 visitor = new StreamFuncVisitor1();
    43                 ASTree.accept(visitor);
    44                 return ((StreamFuncVisitor1)visitor).streamFuncMap();
     16        public static ArrayList<FuncDefNode> makeList(ASTNode ASTTree) {
     17            Visitor visitor = new Visitor();
     18                ASTTree.accept(visitor);
     19                return visitor.list;
    4520        }
    4621       
    47         private  class StreamFuncVisitor1 extends VoidVisitor.Default {
     22        private static class Visitor extends VoidVisitor.Default {
    4823               
    49                 private LinkedHashMap<String, ASTNode> streamFuncMap = new LinkedHashMap<String, ASTNode>();
    50                
    51                 public Map<String, ASTNode> streamFuncMap() {
    52                         return streamFuncMap;
    53                 }
     24                private ArrayList<FuncDefNode> list = new ArrayList<FuncDefNode>();
    5425                               
    5526                public void visitLeave(FuncDefNode node) {
    56                         // TS: Accessors.funcName() and Accessors.funcIdentifier reference the same node.  Hmmmm.
    57                         String name = Accessors.funcName(node);
    58                         name = Generators.capitalize(name);
    59                         IdentifierToken nameToken = IdentifierToken.make(LexicalType.IDENTIFIER,
    60                                                                                 node.getToken().getLocation(),
    61                                                                                 name);
    62                        
    63                         Accessors.funcIdentifier(node).setToken(nameToken);
    64                         streamFuncMap.put(name, node);                                 
     27                        list.add(node);                                 
    6528                       
    6629                }               
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/carry/CarryInfoSet.java

    r3247 r3249  
    11/*
    2  * Stream Function Carry Information set.
    3  *
    4  * TODO
    5  *
    6  * - Add to 'Binding' class for a general implementation (PabloB).
    7  * - Convenience class that assumes a Stream Function ordering.
    8  * - Poor design, will refactor/remove.
     2 * Carry Information Symbol
    93 *
    104 * @author Ken Herdy <ksherdy at sfu dot ca>
    115 */
    12 package toolchain.pabloB.symbols;
     6package toolchain.pabloS.transformer.visitors.carry;
    137
    148import java.util.ArrayList;
    159
    16 public class CarryInfoSetSymbol extends AbstractSymbol {
     10public class CarryInfoSet {
    1711
    1812        private ArrayList<Integer> carry1 = null;
    1913        private ArrayList<Integer> carryN = null;
    2014       
    21         public CarryInfoSetSymbol () {
     15        public CarryInfoSet () {
    2216                carry1 = new ArrayList<Integer>();
    2317                carryN = new ArrayList<Integer>();
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/carry/CarryInfoSetFactory.java

    r3247 r3249  
    11/*
    2  * Populates PabloB symbol table Kernel state information.
    32 *
    43 * @author Ken Herdy <ksherdy at sfu dot ca>
     
    65package toolchain.pabloS.transformer.visitors.carry;
    76
     7import java.util.List;
     8import java.util.Map;
     9import java.util.LinkedHashMap;
     10
    811import pabloS.ast.*;
    9 import toolchain.pabloB.symbols.CarryInfoSetSymbol;
    10 import toolchain.pabloB.symbols.SymbolTable;
    1112import toolchain.pabloS.ast.Accessors;
    12 import toolchain.pabloS.lang.PabloSBuiltin;
    1313import toolchain.pabloS.lang.BuiltinCallUtil;
    1414
    15 public class CarryInfoSetVisitor {
    16    
    17     private ASTNode ASTTree;
    18     private SymbolTable symbolTable;
    19    
    20     public CarryInfoSetVisitor(ASTNode ASTree, SymbolTable symbolTable) {
    21         this.ASTTree = ASTree;
    22         this.symbolTable = symbolTable;
     15public class CarryInfoSetFactory {     
     16           
     17    public static Map<java.lang.String, CarryInfoSet> makeCarryInfoSetMap(List<pabloS.ast.FuncDefNode> funcDefs) {
     18       
     19        Map<java.lang.String,CarryInfoSet> map = new LinkedHashMap<java.lang.String, CarryInfoSet>();
     20       
     21        for(pabloS.ast.FuncDefNode funcDef : funcDefs) {
     22                CarryInfoSetVisitor visitor = new CarryInfoSetVisitor();
     23                funcDef.accept(visitor);
     24                map.put(Accessors.funcName(funcDef), visitor.carryInfoSet);
     25        }
     26           
     27        return map;
    2328    }
    2429   
    25     public void visit() {
    26         Visitor visitor = new Visitor();
    27         ASTTree.accept(visitor);
    28     }   
     30        static private class CarryInfoSetVisitor extends VoidVisitor.Default {
    2931       
    30         private class Visitor extends VoidVisitor.Default {
    31                
    32                 String key = null;
    33                
    34                 public void visitEnter(FuncDefNode node) {
    35                    
    36                     // base name
    37                    
    38                         key = Accessors.funcName(node);                 
    39                         CarryInfoSetSymbol symbol = new CarryInfoSetSymbol();
    40                         symbolTable.put(key, symbol);
    41                 }       
     32                private CarryInfoSet carryInfoSet = new CarryInfoSet();
    4233               
    4334                public void visitLeave(FuncCallNode node) {
    4435                       
    4536                        if(BuiltinCallUtil.isCarry1(node)) {
    46                                 PabloSBuiltin builtin = BuiltinCallUtil.builtin(node);
    47                                 int initializer = builtin.intInitialValue();
    48                                
    49                                 CarryInfoSetSymbol symbol = (CarryInfoSetSymbol)symbolTable.get(key);
    50                                 symbol.addCarry1(initializer);
     37                                int initializer = BuiltinCallUtil.builtin(node).intInitialValue();
     38                                carryInfoSet.addCarry1(initializer);
    5139                        }
    5240                       
    53                         //      if(PabloSBuiltinsUtil.isCarryN(node)) {
    54                         //      List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
    55                         //      String value = Accessors.integerConstantLexeme((IntegerConstantNode)arguments.get(1));
    56                         //      ((CarryInfoSetSymbol)symbolTable.get(key)).addCarryN(Integer.parseInt(value));
    57                         //      }
     41                        if(BuiltinCallUtil.isCarryN(node)) {
     42                                //int initializer = BuiltinCallUtil.builtin(node).intInitialValue();
     43                                carryInfoSet.addCarryN(0);
     44                        }
    5845                }
    5946        }
Note: See TracChangeset for help on using the changeset viewer.