Changeset 2686


Ignore:
Timestamp:
Nov 22, 2012, 2:55:23 PM (6 years ago)
Author:
ksherdy
Message:

Structure Pablo to target language into phases (parse, semantic analysis, unparse, template write).

Location:
proto/pablo
Files:
9 edited
5 moved

Legend:

Unmodified
Added
Removed
  • proto/pablo/ReadMe.txt

    r2668 r2686  
    9494         
    9595   Pending.     
     96   
     975. Decision to analyze a list of AST nodes in the semantic analyzer.
     98   Perhaps this should be skipped we should simply push processing up to the program node level.
     99   This may reduce future code changes.
     100   Plan to add a graph type to the compiler to organize the stream program generation.
     101
     1026. Decision to call AST transformer a 'semantic analyzer'.
     103
     1047. Add a symbol table and type checking to rid the compiler of the upper case naming
     105   convention for stream function and stream structures.
     106   
     1078. Pass around a configuration object or have setters on the semantic analyzer object.     
     108
     1099. ApplicationConfigurationFactory generates an ApplicationConfiguration object. Not sure if this oject
     110   should be a singleton.
     111   
     11210. Semantic analyzer. Add Scatter logging.   
  • proto/pablo/input/grammar/scatter/pablo.scatter

    r2660 r2686  
    8585        typeDef                 ->  TYPEDEF type identifier ;
    8686       
    87         DeclList                ->  identifier (COMMA identifier)* ; // TODO - support or support via 'source' Func definitions
     87        DeclList                ->  identifier (COMMA identifier)* ; // TODO
    8888       
    8989   
  • proto/pablo/src/application/ApplicationConfig.java

    r2684 r2686  
    11package application;
    22
    3 public class ApplicationConfiguration {
     3public class ApplicationConfig {
    44
     5        public static final String CLANG = "clang";
     6        public static final String CPPLANG = "cpplang";
     7               
    58        public Boolean addAssertBitBlockAlignStmts;
    69        public Boolean addDumpStmts;
     
    1013    public String templateFile;
    1114    public String outputFile;           
    12         public String outputDirectory;                     
     15        public String outputDirectory;   
     16       
     17        public String targetLang;
    1318}
  • proto/pablo/src/application/ApplicationConfigFactory.java

    r2684 r2686  
    33import org.apache.commons.cli.CommandLine;
    44
    5 public class ApplicationConfigurationFactory {
     5// Generates an application configuration object.
     6
     7public class ApplicationConfigFactory {
    68       
    7         public static final String CLANG = "clang";
    8         public static final String CPPLANG = "cpplang";
    9                
    10     public static ApplicationConfiguration generate(CommandLine cli) {
     9    public static ApplicationConfig generate(CommandLine cli) {
    1110
    12         ApplicationConfiguration applicationConfiguration = new ApplicationConfiguration();
     11        ApplicationConfig applicationConfiguration = new ApplicationConfig();
    1312       
    1413        applicationConfiguration.inputFile = cli.getOptionValue("i");
    1514
    16         // specific defaults
    17         String target = cli.getOptionValue("x", CPPLANG);
     15        // target lang specific defaults
     16        applicationConfiguration.targetLang = cli.getOptionValue("x", ApplicationConfig.CPPLANG);
    1817       
    19         if (target.equals(CLANG)) { // C
     18        if (applicationConfiguration.targetLang.equals(ApplicationConfig.CLANG)) { // C
    2019                applicationConfiguration.templateFile = cli.getOptionValue("t", "template.c");
    2120                applicationConfiguration.outputFile = cli.getOptionValue("o", "code.c");
    22                 applicationConfiguration.outputDirectory = cli.getOptionValue("O", CLANG);
     21                applicationConfiguration.outputDirectory = cli.getOptionValue("O", ApplicationConfig.CLANG);
    2322        } else { // CPP
    2423                applicationConfiguration.templateFile = cli.getOptionValue("t", "template.cpp");
    2524                applicationConfiguration.outputFile = cli.getOptionValue("o", "code.cpp");
    26                 applicationConfiguration.outputDirectory = cli.getOptionValue("O", CPPLANG);
     25                applicationConfiguration.outputDirectory = cli.getOptionValue("O", ApplicationConfig.CPPLANG);
    2726        }
    2827       
    29         // general
     28        // general defaults
    3029        applicationConfiguration.addAssertBitBlockAlignStmts = false;
    3130        if(cli.hasOption("a")) {
  • proto/pablo/src/application/ApplicationGenerator.java

    r2670 r2686  
    22
    33//import ast.StartSymbolNode;
     4import ast.ASTNode;
     5import compiler.lang.pablo.*;
     6import compiler.lang.carryset.*;
     7import compiler.semanticAnalyzer.SemanticAnalyzer;
     8import compiler.syntacticAnalyzer.SyntacticAnalysisFailedException;
     9import compiler.syntacticAnalyzer.SyntacticAnalyzer;
     10
    411import tokens.Tokens;
    512
     
    1118    private static final String APPLICATIONS_DIRECTORY     = "applications";
    1219       
    13     private ApplicationConfiguration applicationConfiguration;
     20    private ApplicationConfig applicationConfig;
    1421   
    1522        //////////////////////////////////////////////////////////////////////////////////
    1623        // construction
    1724       
    18         public ApplicationGenerator(ApplicationConfiguration applicationConfiguration) {
     25        public ApplicationGenerator(ApplicationConfig applicationConfiguration) {
    1926                Tokens.setPrintLevel(Tokens.Level.FULL);
    20                 this.applicationConfiguration = applicationConfiguration;
     27                this.applicationConfig = applicationConfiguration;
    2128                OutputCodeFolder.setWarningMessage(generatedCodeWarning);
    2229        }
     
    3037//      }
    3138               
    32         public void generate() {
     39        public void generate() throws SyntacticAnalysisFailedException {
    3340
    3441//              OutputCodeFolder parser = new OutputCodeFolder(outputDirectory, srcDirectory);         
     42
     43                Builtins2Lang builtins2Lang = null;
     44                CarrySet2Lang carrySet2Lang = null;
     45               
     46                if(applicationConfig.targetLang.contentEquals(ApplicationConfig.CLANG)) {
     47                        //builtins2Lang = new Builtins2C();
     48                        //carrySet2Lang = new CarrySet2C();                             
     49                } else {
     50                        builtins2Lang = new Builtins2CPP();
     51                        carrySet2Lang = new CarrySet2CPP();             
     52                }
    3553               
    3654                // Parse
     55                ASTNode syntaxTree = SyntacticAnalyzer.parse(applicationConfig.inputFile);
     56                               
     57                // Analyze
     58                SemanticAnalyzer semanticAnalyzer = new SemanticAnalyzer(syntaxTree, builtins2Lang,     carrySet2Lang);
     59                semanticAnalyzer.setAddDumpStmts(applicationConfig.addDumpStmts);
     60                semanticAnalyzer.setAddAssertBitBlockAlignStmts(applicationConfig.addAssertBitBlockAlignStmts);
     61                ASTNode decoratedTree = semanticAnalyzer.analyze();
    3762               
    38                 // Transform AST
    39                
    40                 // Generate
     63                // Generate
    4164                                       
    4265//              parser.generateFile(new TemplateContentsGenerator(this.root, srcDirectory), "Parser.java"); // "Parser.java"
    4366//              parser.copyTemplate("ReverseAccessibleArrayList");
    4467//              parser.copyTemplate("RevList");
     68               
     69                // Fill Template
     70               
    4571                printCompletionMessage();
    46         }
    47                        
    48         // parameterize on Target Language
    49         private void transformAST() {
    50                
    51         }
    52        
    53         // parameterize on Target Language
    54         private void unParser() {
    55                
    5672        }
    5773       
  • proto/pablo/src/application/Pablo.java

    r2670 r2686  
    1111import parser.Parser;
    1212import logging.ScatterLogger;
    13 import compiler.lang.carryset.CarrySet2CPP;
    14 import compiler.lang.carryset.CarrySet2Lang;
     13import compiler.lang.carryset.*;
    1514import compiler.lang.idisa.*;
    16 import compiler.lang.pablo.Builtins2CPP;
    17 import compiler.lang.pablo.Builtins2Lang;
    18 import compiler.visitors.*;
    19 //import semanticAnalyzer.SampleSemanticAnalyzer;
    20 //import codeGeneration.CodeGenerator;
     15import compiler.lang.pablo.*;
    2116
    2217import org.apache.commons.cli.CommandLine;
     
    2823 
    2924@SuppressWarnings("unused")
     25
    3026public class Pablo {
    3127       
     
    3329        public static final int EXIT_CODE_FOR_ERROR = 1;
    3430                       
    35         public static void main(String[] args) throws FileNotFoundException {
    36        
    37                
     31        public static void main(String[] args) {
    3832               
    3933                Options options = ApplicationOptions.createOptions();
     
    4236                        CommandLineParser parser = new PosixParser();
    4337                        CommandLine cli = parser.parse(options, args); 
    44                         ApplicationConfiguration applicationConfiguration = ApplicationConfigurationFactory.generate(cli);
    45                         ApplicationGenerator applicationGenerator = new ApplicationGenerator(applicationConfiguration);
     38                        ApplicationConfig applicationConfig = ApplicationConfigFactory.generate(cli);
     39                        ApplicationGenerator applicationGenerator = new ApplicationGenerator(applicationConfig);
     40                        applicationGenerator.generate();
    4641                } catch (Exception e) {
    4742                        ApplicationOptions.exitWithUsageMessage(options);
    48                 }
    49                
     43                }       
    5044        }
    51        
    52        
    53 /*             
    54                 StreamFuncVisitor streamFuncVisitor = new StreamFuncVisitor(syntaxTree);
    55                 Map<String, ASTNode> streamFuncMap = streamFuncVisitor.makeStreamFuncMap();
    56                
    57                 Builtins2Lang builtins2CPP = new Builtins2CPP();
    58                 CarrySet2Lang carrySet2CPP = new CarrySet2CPP();
    59                
    60                 for (Map.Entry<String, ASTNode> entry : streamFuncMap.entrySet()) {
    61                        
    62                     ASTNode value = entry.getValue();
    63                        
    64                     AdvanceCombinerXFormer advanceCombiner = new AdvanceCombinerXFormer(value);
    65                     advanceCombiner.XForm();
    66                                        
    67                     AugAssignXFormer AugAssign = new AugAssignXFormer(value);
    68                         AugAssign.XForm();
    69                        
    70                         CarryIntroXFormer carryQIntro = new CarryIntroXFormer(value, carrySet2CPP);
    71                         carryQIntro.XForm(true, false);
    72                        
    73                         Pablo2CarryXFormer pablo2CarryQ = new Pablo2CarryXFormer(value, builtins2CPP, carrySet2CPP);
    74                         pablo2CarryQ.XForm(true, false);                   
    75                    
    76                         AssertZeroXFormer assertZeroXFormer = new AssertZeroXFormer(value, builtins2CPP);
    77                         assertZeroXFormer.XForm();
    78                        
    79                         Bitwise2IDISAXFormer bitwiseToIDISA = new Bitwise2IDISAXFormer(value);
    80                         bitwiseToIDISA.XForm();
    81 
    82                         if(PabloCompiler.addDumpStmts) {
    83                                 DumpAssignStmtsXFormer dumpAssignStmtsXFormer = new DumpAssignStmtsXFormer(value, builtins2CPP); 
    84                                 dumpAssignStmtsXFormer.XForm();
    85                         }
    86                        
    87                         if(PabloCompiler.addAssertBitBlockAlignStmts) {
    88                                 AssertBitBlockAlignStmtsXFormer assertBitBlockAlignStmtsXFormer = new AssertBitBlockAlignStmtsXFormer(value, builtins2CPP, carrySet2CPP); 
    89                                 assertBitBlockAlignStmtsXFormer.XForm();
    90                         }                       
    91                        
    92                         Unparser cPPUnparser = new CPPUnparser(value);
    93                         String code = cPPUnparser.getCode();
    94                         System.out.print(code);
    95                        
    96                 }
    97 
    98 //              ASTNode decoratedTree = SemanticAnalyzer.analyze(syntaxTree);
    99 //              generateCodeIfNoErrors(filename, decoratedTree);
    100         }
    101 */
    102 
    103                
    10445}
    105 
  • proto/pablo/src/ast/ASTNode.java

    r2660 r2686  
    125125        }
    126126    }
    127        
    128        
     127        public void insertAfterChild(ASTNode node, ASTNode successor) {
     128                int index = children.indexOf(node);
     129                insertChildAfter(index, successor);
     130                successor.setParent(this);
     131    }
     132    private void insertChildAfter(int index, ASTNode successor) {
     133            if(index == children.size()-1) {
     134                    children.add(successor);
     135            } else {
     136                    children.add(index+1, successor);
     137            }       
     138    }   
     139
    129140////////////////////////////////////////////////////////////////////////////////////
    130141// Iterable<ASTNode> pathToRoot
     
    140151                return result;
    141152        }
    142     public void insertAfterChild(ASTNode node, ASTNode successor) {
    143         int index = children.indexOf(node);
    144         insertChildAfter(index, successor);
    145         successor.setParent(this);
    146         }
    147        
    148         private void insertChildAfter(int index, ASTNode successor) {
    149                 if(index == children.size()-1) {
    150                         children.add(successor);
    151                 } else {
    152                         children.add(index+1, successor);
    153                 }       
    154         }               
    155153       
    156154       
  • proto/pablo/src/compiler/ast/Accessors.java

    r2675 r2686  
    22
    33import ast.*;
     4
     5import java.util.ArrayList;
    46import java.util.List;
    57
     
    1921                return 0 == node.nChildren();
    2022        }
    21 
     23       
    2224        ////////////////////////////////////////////////////////////////////////////
    2325        // Type Decls
  • proto/pablo/src/compiler/semanticAnalyzer/SemanticAnalyzer.java

    r2672 r2686  
    11package compiler.semanticAnalyzer;
     2
     3import compiler.ast.Accessors;
     4import compiler.codeGenerator.visitors.CPPUnparser;
     5import compiler.codeGenerator.visitors.Unparser;
     6import compiler.lang.carryset.CarrySet2Lang;
     7import compiler.lang.pablo.Builtins2Lang;
     8import compiler.semanticAnalyzer.visitors.*;
     9
     10import ast.ASTNode;
     11import ast.ProgramNode;
    212
    313public class SemanticAnalyzer {
    414
    5 }
     15        private ASTNode root;
     16        private Builtins2Lang builtins2Lang;
     17        private CarrySet2Lang carrySet2Lang;
     18       
     19        private boolean addDumpStmts;
     20        private boolean addAssertBitBlockAlignStmts;
     21       
     22        //////////////////////////////////////////////////////////////
     23        // static interface
     24               
     25        public static ASTNode analyze(ASTNode root, Builtins2Lang builtins2Lang, CarrySet2Lang carrySet2Lang) {
     26                SemanticAnalyzer analyzer = new SemanticAnalyzer(root, builtins2Lang, carrySet2Lang);           
     27                return analyzer.analyze();
     28        }       
     29
     30        public static ASTNode analyze(ASTNode root, Builtins2Lang builtins2Lang, CarrySet2Lang carrySet2Lang, boolean addDumpStmts, boolean addAssertBitBlockAlignStmts) {
     31                SemanticAnalyzer analyzer = new SemanticAnalyzer(root, builtins2Lang, carrySet2Lang);
     32                analyzer.setAddDumpStmts(addDumpStmts);
     33                analyzer.setAddAssertBitBlockAlignStmts(addAssertBitBlockAlignStmts);
     34                return analyzer.analyze();
     35        }               
     36       
     37        //////////////////////////////////////////////////////////////
     38        // constructor and helpers
     39       
     40        public SemanticAnalyzer(ASTNode root, Builtins2Lang builtins2Lang, CarrySet2Lang carrySet2Lang) {               
     41                this.root = root;
     42                this.builtins2Lang = builtins2Lang;
     43                this.carrySet2Lang = carrySet2Lang;
     44               
     45                this.setAddDumpStmts(false);
     46                this.setAddAssertBitBlockAlignStmts(false);
     47        }       
     48
     49        //////////////////////////////////////////////////////////////
     50        // analysis
     51        public ASTNode analyze() {
     52               
     53            AdvanceCombinerXFormer advanceCombiner = new AdvanceCombinerXFormer(root);
     54            advanceCombiner.XForm();
     55                               
     56            AugAssignXFormer AugAssign = new AugAssignXFormer(root);
     57                AugAssign.XForm();
     58               
     59                CarryIntroXFormer carryQIntro = new CarryIntroXFormer(root, carrySet2Lang);
     60                carryQIntro.XForm(true, false);
     61               
     62                Pablo2CarryXFormer pablo2CarryQ = new Pablo2CarryXFormer(root, builtins2Lang, carrySet2Lang);
     63                pablo2CarryQ.XForm(true, false);                   
     64           
     65                AssertZeroXFormer assertZeroXFormer = new AssertZeroXFormer(root, builtins2Lang);
     66                assertZeroXFormer.XForm();
     67               
     68                Bitwise2IDISAXFormer bitwiseToIDISA = new Bitwise2IDISAXFormer(root);
     69                bitwiseToIDISA.XForm();
     70       
     71               
     72                if(isAddDumpStmts()) {
     73                        DumpAssignStmtsXFormer dumpAssignStmtsXFormer = new DumpAssignStmtsXFormer(root, builtins2Lang); 
     74                        dumpAssignStmtsXFormer.XForm();
     75                }
     76               
     77                if(isAddAssertBitBlockAlignStmts()) {
     78                        AssertBitBlockAlignStmtsXFormer assertBitBlockAlignStmtsXFormer = new AssertBitBlockAlignStmtsXFormer(root, builtins2Lang, carrySet2Lang); 
     79                        assertBitBlockAlignStmtsXFormer.XForm();
     80                }                                       
     81               
     82                Unparser cPPUnparser = new CPPUnparser(root);
     83                String code = cPPUnparser.getCode();
     84                System.out.print(code);
     85               
     86                return root;
     87        }
     88
     89        public boolean isAddDumpStmts() {
     90                return addDumpStmts;
     91        }
     92
     93        public void setAddDumpStmts(boolean addDumpStmts) {
     94                this.addDumpStmts = addDumpStmts;
     95        }
     96
     97        public boolean isAddAssertBitBlockAlignStmts() {
     98                return addAssertBitBlockAlignStmts;
     99        }
     100
     101        public void setAddAssertBitBlockAlignStmts(boolean addAssertBitBlockAlignStmts) {
     102                this.addAssertBitBlockAlignStmts = addAssertBitBlockAlignStmts;
     103        }
     104       
     105}               
     106
  • proto/pablo/src/compiler/semanticAnalyzer/visitors/CarryIntroXFormer.java

    r2672 r2686  
    1212public class CarryIntroXFormer {
    1313               
    14         private ASTNode ASTTree; // FuncDefNode
    15        
     14        private ASTNode ASTTree;
    1615        private CarrySet2Lang carrySet2Lang;
    1716               
    1817    public CarryIntroXFormer(ASTNode node, CarrySet2Lang carrySet2Lang) {
    19         assert node instanceof FuncDefNode;
    2018        this.ASTTree = node;
    2119        this.carrySet2Lang = carrySet2Lang;
  • proto/pablo/src/compiler/semanticAnalyzer/visitors/Pablo2CarryXFormer.java

    r2672 r2686  
    1616public class Pablo2CarryXFormer {
    1717               
     18        private ASTNode ASTTree;       
     19       
    1820        private Builtins2Lang builtins2Lang;
    1921        private CarrySet2Lang carrySet2Lang;
    20        
    21         private ASTNode ASTTree; // FuncDefNode
    2222       
    2323    //    def __init__(self, carryvar="carryQ", carryin = "_ci", carryout = "_co"):
     
    2727       
    2828    public Pablo2CarryXFormer(ASTNode node, Builtins2Lang builtins2Lang, CarrySet2Lang carrySet2Lang) {
    29         assert node instanceof FuncDefNode;
    3029        this.ASTTree = node;
    3130        this.builtins2Lang = builtins2Lang;
  • proto/pablo/src/compiler/syntacticAnalyzer/SyntacticAnalysisFailedException.java

    r2685 r2686  
    1 package compiler.parser;
     1package compiler.syntacticAnalyzer;
    22
    3 public class ASTGenerationFailedException extends Exception {
     3public class SyntacticAnalysisFailedException extends Exception {
    44
    55}
  • proto/pablo/src/compiler/syntacticAnalyzer/SyntacticAnalyzer.java

    r2685 r2686  
    44//
    55
    6 package  compiler.parser;
     6package  compiler.syntacticAnalyzer;
    77
    88import parser.*;
     
    1111import lexicalAnalyzer.LexicalController;
    1212import logging.ScatterLogger;
    13 import compiler.parser.ASTGenerator;
     13import compiler.syntacticAnalyzer.SyntacticAnalyzer;
    1414
    15 public class ASTGenerator {
     15public class SyntacticAnalyzer {
    1616       
    17         static public ASTNode generateAST(String inputFile) throws ASTGenerationFailedException {                       
     17        static public ASTNode parse(String inputFile) throws SyntacticAnalysisFailedException {                         
    1818
    1919                LexicalController lexController = LexicalController.make(inputFile);
     
    2121       
    2222                if(thereAreErrors()) {
    23                         throw new ASTGenerationFailedException();
     23                        throw new SyntacticAnalysisFailedException();
    2424                }
    2525               
Note: See TracChangeset for help on using the changeset viewer.