Changeset 2935


Ignore:
Timestamp:
Mar 18, 2013, 11:04:54 PM (5 years ago)
Author:
ksherdy
Message:

Added comments to application generation code. Minor refactoring for understandability.

Location:
proto/pabloj/trunk/src/applicationGenerator
Files:
1 deleted
5 edited
3 moved

Legend:

Unmodified
Added
Removed
  • proto/pabloj/trunk/src/applicationGenerator/ApplicationGenerator.java

    r2924 r2935  
     1/*
     2 * High-level module that captures the logic to generates application code based on the application configuration.
     3 *
     4 * TODO
     5 * 
     6 * (1) The symbol table used in this module should be a 'PabloS' symbol
     7 *     table that is passed from transformer to transformer.
     8 *   
     9 *     Basic approach:
     10 *     
     11 *     (i)  Gather information in 'visitor' passes over the PabloS AST.
     12 *     (ii) Use gathered information in subsequent passes over the PabloS AST.
     13 *     
     14 *     Care must be taken to gather information ahead of transformation passes that
     15 *     alter the AST structure.
     16 *   
     17 * <ksherdy at sfu dot ca>
     18 */
     19
    120package applicationGenerator;
    221
    3 //import ast.StartSymbolNode;
    4 
    522import java.io.File;
    6 import java.io.FileNotFoundException;
    7 import java.io.FileOutputStream;
    8 import java.io.PrintStream;
    9 
    1023import applicationGenerator.helpers.FileUtil;
    11 
    1224import compiler.codeGenerator.visitors.CPPUnparser;
    1325
     
    1931import compiler.transformers.pabloS.CarryInfoSetVisitor;
    2032import compiler.transformers.pabloS.PabloSTransformer;
    21 import compiler.symbols.*;
     33import compiler.symbolTable.*;
    2234
    2335public class ApplicationGenerator {
    2436                       
    25     private CompilerConfig compilerConfig;
    26    
    27         //////////////////////////////////////////////////////////////////////////////////
    28         // construction
    29        
    30         public ApplicationGenerator(CompilerConfig applicationConfiguration) {
     37    private Configuration applicationConfiguration;
     38       
     39        public ApplicationGenerator(Configuration applicationConfiguration) {
    3140                pabloS.tokens.Tokens.setPrintLevel(pabloS.tokens.Tokens.Level.FULL);           
    32                 this.compilerConfig = applicationConfiguration;
     41                this.applicationConfiguration = applicationConfiguration;
    3342        }
    34        
    35         //////////////////////////////////////////////////////////////////////////////////
    36         // code generation
    37        
     43               
    3844        //      private void generateLoggingPackage() {
    3945        //              LoggingPackageGenerator logging = new LoggingPackageGenerator(root, outputDirectory, LOGGING_DIRECTORY);
     
    4551                SymbolTable symbolTable                         = new SymbolTable();   
    4652               
    47                 // Transformation configuration
     53                // Transformation configurations to support multiple backends
    4854                Builtins2Lang builtins2Lang             = null;
    4955                CarrySetBuiltins2Lang carrySet2Lang = null;
     
    5157               
    5258               
    53                 if(compilerConfig.targetLang.contentEquals(CompilerConfig.CLANG)) {
     59                if(applicationConfiguration.targetLang.contentEquals(Configuration.CLANG)) {
    5460                        //builtins2Lang = new Builtins2C();
    5561                        //carrySet2Lang = new CarrySet2C();
    5662                        //unparser = new CUnparser();
    5763                } else { // default C++
    58                         builtins2Lang = new Builtins2CPP();
     64                        builtins2Lang = new PabloSBuiltins2CPP();
    5965                        carrySet2Lang = new CarrySetBuiltins2CPP();
    6066                        unparser          = new CPPUnparser(symbolTable);
     
    6268
    6369                // Parse
    64                 pabloS.ast.ASTNode syntaxTree = Parser.parse(compilerConfig.inputFile);
     70                pabloS.ast.ASTNode syntaxTree = Parser.parse(applicationConfiguration.inputFile);
    6571
    66                 // Build Carry Information Set symbol table
    67                 // TODO - carry_count, advance_n_count, add symbol table to root node
     72                // Gather carry information set
     73                // TODO - refactor - carry_count, advance_n_count, add symbol table to root node
     74                CarryInfoSetVisitor carryInfoSetVisitor = new CarryInfoSetVisitor(syntaxTree, symbolTable); 
     75                carryInfoSetVisitor.visit();
    6876               
    69                 CarryInfoSetVisitor carryInfoSetVisitor = new CarryInfoSetVisitor(syntaxTree, symbolTable);
    70                 carryInfoSetVisitor.visit();
    71                        
    72                 // AST Transform
     77                // Replace PabloS builtins and Carry Set builtins with target language strings.
    7378                PabloSTransformer pabloSXFormer = new PabloSTransformer(syntaxTree);
    7479                pabloSXFormer.setBuiltins2Lang(builtins2Lang);
    7580                pabloSXFormer.setCarrySet2Lang(carrySet2Lang);
     81
     82                // Transform PabloS global functions in non-final block mode
    7683                pabloSXFormer.setFinalBlockMode(false);
    7784                pabloS.ast.ASTNode decoratedTree = pabloSXFormer.xForm();
    7885               
    79                 // Optimized AST transformation
     86                // Transform PabloS global functions in final block mode
    8087                pabloSXFormer.setFinalBlockMode(true);
    8188                pabloS.ast.ASTNode optDecoratedTree = pabloSXFormer.xForm();
     
    8592                pabloB.ast.ASTNode pabloBASTTree = pabloS2PabloBXFormer.XForm(decoratedTree, optDecoratedTree);
    8693               
    87        
    88                 String outputDirectory          = ensureEndsWith(compilerConfig.outputDirectory + compilerConfig.targetLang, File.separator);
    89                 String templateDirectory        = ensureEndsWith(compilerConfig.templateDirectory, File.separator);
    90                 String templateFilePath         = templateDirectory + compilerConfig.templateFile;
    91                 String targetFilePath           = outputDirectory + FileUtil.replaceFileNameExtension(new File(compilerConfig.templateFile).getName(), ".hpp"); 
     94                // Set up file paths
     95                String outputDirectory          = FileUtil.ensureEndsWith(applicationConfiguration.outputDirectory, File.separator);
     96                outputDirectory                         = FileUtil.ensureEndsWith(outputDirectory + applicationConfiguration.targetLang, File.separator);
    9297               
    93                 HeaderTemplateContentsGenerator contentsGenerator =
    94                                 new HeaderTemplateContentsGenerator((pabloB.ast.ProgramNode)pabloBASTTree,
    95                                                                                                         unparser,
    96                                                                                                         outputDirectory,
    97                                                                                                         templateFilePath,
    98                                                                                                         targetFilePath);       
     98                String templateDirectory        = FileUtil.ensureEndsWith(applicationConfiguration.templateDirectory, File.separator);
     99                String templateFilePath         = templateDirectory + applicationConfiguration.templateFileName;
    99100               
    100                 contentsGenerator.generate();
     101                String outputFilePath           = outputDirectory + applicationConfiguration.outputFileName; 
    101102               
    102                 /*
    103                 String global = CodeGenerator.makeStructDecls((ProgramNode)syntaxTree, unparser);
    104                 global +=  CodeGenerator.makeStreamFuncDecls((ProgramNode)syntaxTree, unparser);
    105                 String temp = CodeGenerator.makeStructDefs((ProgramNode)syntaxTree, unparser);
    106                 */     
    107                                        
    108 //              parser.generateFile(new TemplateContentsGenerator(this.root, srcDirectory), "Parser.java"); // "Parser.java"
    109 //              parser.copyTemplate("ReverseAccessibleArrayList");
    110 //              parser.copyTemplate("RevList");
    111                                
    112                
     103                HeaderTemplateContentsGenerator templateContentsGenerator
     104                                                                        = new HeaderTemplateContentsGenerator((pabloB.ast.ProgramNode) pabloBASTTree,
     105                                                                                                                                                        unparser,
     106                                                                                                                                                        outputDirectory,
     107                                                                                                                                                        templateFilePath,
     108                                                                                                                                                        outputFilePath);       
     109                templateContentsGenerator.generate();
    113110               
    114111                printCompletionMessage();
     
    119116        }
    120117
    121         private static String ensureEndsWith(String string, String suffix) {
    122                 if(string.endsWith(suffix)) {
    123                         return string;
    124                 } else {
    125                         return string + suffix;
    126                 }
    127         }
     118
    128119               
    129120}
  • proto/pabloj/trunk/src/applicationGenerator/Configuration.java

    r2933 r2935  
    11/**
    2  * Application configuration POD (plain old data).
     2 * Application configuration object.
    33 *
    4  * Specifies the application configuration to the application generator.
     4 * Specifies application directory structure defaults.
    55 *
    66 * @author Ken Herdy <ksherdy at sfu dot ca>
     
    99package applicationGenerator;
    1010
    11 public class CompilerConfig {
     11public class Configuration {
    1212
    1313        // Warning Message
     
    1616        public static final int EXIT_CODE_FOR_ERROR     = 1;
    1717       
    18         // Compiler directory structure
     18        // Default directory structure
    1919        public static final String OUTPUT_DIRECTORY             = "output/";
    2020        public static final String TEMPLATES_DIRECTORY  = "input/templates/";
     
    2424        // Options
    2525        public String inputFile;
    26     public String templateFile;
    27     public String templateDirectory;
    28     public String outputFile;           
    29         public String outputDirectory;   
    30 
     26        public String templateDirectory;
     27        public String templateFileName;
     28        public String outputDirectory; 
     29    public String outputFileName;       
     30         
    3131        public String targetLang;
    3232               
     
    3434        public Boolean addAssertBitBlockAlignStmts;
    3535        public Boolean addDumpStmts;
    36         public String errorRoutine;     
     36        public String   errorRoutine;   
    3737
    3838}
  • proto/pabloj/trunk/src/applicationGenerator/ConfigurationFactory.java

    r2933 r2935  
     1/*
     2 * Configuration factory. Sets default options.
     3 *
     4 * @author <ksherdy at sfu dot ca>
     5 *
     6 */
     7
    18package applicationGenerator;
    29
     
    512import org.apache.commons.cli.CommandLine;
    613
    7 public class CompilerConfigFactory {
     14import applicationGenerator.helpers.FileUtil;
    815
    9     public static CompilerConfig generate(CommandLine cli) {
     16public class ConfigurationFactory {
    1017
    11         CompilerConfig compilerConfig = new CompilerConfig();
     18    public static Configuration generate(CommandLine cli) {
     19
     20        Configuration configuration = new Configuration();
    1221       
    13         compilerConfig.inputFile = cli.getOptionValue("i");
     22        configuration.inputFile = cli.getOptionValue("i");
    1423
    1524        // set defaults
    16         compilerConfig.outputDirectory = cli.getOptionValue("O", CompilerConfig.OUTPUT_DIRECTORY);
    17         compilerConfig.targetLang = cli.getOptionValue("x", CompilerConfig.CPPLANG);
     25        configuration.outputDirectory = cli.getOptionValue("O", Configuration.OUTPUT_DIRECTORY);
     26        configuration.targetLang = cli.getOptionValue("x", Configuration.CPPLANG);
    1827       
    19         if (compilerConfig.targetLang.equals(CompilerConfig.CLANG)) { // C language
    20                 compilerConfig.templateFile = cli.getOptionValue("t", "pablo_definitions.template");
    21                 compilerConfig.templateDirectory = cli.getOptionValue("T", CompilerConfig.TEMPLATES_DIRECTORY + CompilerConfig.CLANG + File.separator);
    22                 compilerConfig.outputFile = cli.getOptionValue("o", "code.c");
    23                 //compilerConfig.targetDirectory = cli.getOptionValue("O", CompilerConfig.CLANG);
     28        if (configuration.targetLang.equals(Configuration.CLANG)) { // C language
     29                configuration.templateFileName = cli.getOptionValue("t", "pablo_definitions.template");
     30                configuration.templateDirectory = FileUtil.ensureEndsWith(cli.getOptionValue("T", Configuration.TEMPLATES_DIRECTORY + Configuration.CLANG), File.separator);
     31                configuration.outputFileName = cli.getOptionValue("o", FileUtil.replaceFileNameExtension(new File(configuration.templateFileName).getName(), ".h"));
     32               
     33                //compilerConfig.outputDirectory = cli.getOptionValue("O", CompilerConfig.CLANG);
    2434               
    2535        } else { // C++ language - default
    26                 compilerConfig.templateFile = cli.getOptionValue("t", "pablo_definitions.template");
    27                 compilerConfig.templateDirectory = cli.getOptionValue("T", CompilerConfig.TEMPLATES_DIRECTORY + CompilerConfig.CPPLANG + File.separator);
    28                 compilerConfig.outputFile = cli.getOptionValue("o", "code.cpp");
    29                 //compilerConfig.targetDirectory = cli.getOptionValue("O", CompilerConfig.CPPLANG);
     36                configuration.templateFileName = cli.getOptionValue("t", "pablo_definitions.template");
     37                configuration.templateDirectory = FileUtil.ensureEndsWith(cli.getOptionValue("T", Configuration.TEMPLATES_DIRECTORY + Configuration.CPPLANG), File.separator);
     38                configuration.outputFileName = cli.getOptionValue("o", FileUtil.replaceFileNameExtension(new File(configuration.templateFileName).getName(), ".hpp"));
     39               
     40                //compilerConfig.outputDirectory = cli.getOptionValue("O", CompilerConfig.CPPLANG);
    3041        }
    3142       
    3243        // general defaults
    33         compilerConfig.addAssertBitBlockAlignStmts = false;
     44        configuration.addAssertBitBlockAlignStmts = false;
    3445        if(cli.hasOption("a")) {
    35                 compilerConfig.addAssertBitBlockAlignStmts = true;
     46                configuration.addAssertBitBlockAlignStmts = true;
    3647        }
    3748       
    38         compilerConfig.addDumpStmts = false;
     49        configuration.addDumpStmts = false;
    3950        if(cli.hasOption("d")) {
    40                 compilerConfig.addDumpStmts = true;
     51                configuration.addDumpStmts = true;
    4152        }
    4253       
    43         compilerConfig.errorRoutine = cli.getOptionValue("e", "raise_assert");
     54        configuration.errorRoutine = cli.getOptionValue("e", "raise_assert");
    4455       
    45                 return compilerConfig;
     56                return configuration;
    4657       
    4758    }
  • proto/pabloj/trunk/src/applicationGenerator/ConfigurationOptions.java

    r2933 r2935  
    22 * Command line options.
    33 *
     4 * TODO
     5 *
     6 * Additional options:
     7 *
     8 * (1) output directory "O"
     9 * (2) template directory "T"
     10 *
    411 * @author Ken Herdy <ksherdy at sfu dot ca>
     12 *
    513 */
    614package applicationGenerator;
     
    1119import org.apache.commons.cli.Options;
    1220
    13 public class CompilerOptions { 
     21public class ConfigurationOptions {     
    1422       
    1523          public static Options createOptions() {
     
    4250                    OptionBuilder.isRequired(false);
    4351                    OptionBuilder.withLongOpt("output");
    44                     OptionBuilder.withDescription("Pablo output name.");
     52                    OptionBuilder.withDescription("Pablo output file.");
    4553                        option = OptionBuilder.create("o");
    4654                        options.addOption(option);
    47                        
    48                         // Output base directory "O"
    49                        
    50                         // Output directory "L"
    51                        
    52                         // Template directory "T"
    53                        
     55                                               
    5456                    OptionBuilder.hasArg(true);
    5557                    OptionBuilder.isRequired(false);
     
    8587          public static void usageMessage(Options options) {
    8688                  HelpFormatter h = new HelpFormatter();
    87                   h.printHelp("java " + CompilerConfig.COMPILERNAME + "\n", options);   
     89                  h.printHelp("java " + Configuration.COMPILERNAME + "\n", options);   
    8890          }       
    8991}
  • proto/pabloj/trunk/src/applicationGenerator/HeaderTemplateContentsGenerator.java

    r2917 r2935  
     1/*
     2 * Generates a target language output header file from a PabloB ProgramNode.
     3 *
     4 * @author <ksherdy at sfu dot ca>
     5 *
     6 */
     7
    18package applicationGenerator;
    29
     
    512import applicationGenerator.helpers.FileUtil;
    613import compiler.ast.pabloB.Accessors;
    7 import compiler.codeGenerator.visitors.CPPUnparser;
    814import compiler.codeGenerator.visitors.Unparser;
    9 import compiler.symbols.SymbolTable;
    1015import compiler.template.FileTemplate;
    1116import compiler.template.Template;
    12 
    1317import java.io.File;
    1418import java.io.IOException;
     
    3438                Template template = new FileTemplate(templateName, templateFilePath);
    3539               
    36                 template.set("warningComment", CompilerConfig.WARNING_MESSAGE);
     40                template.set("warningComment", Configuration.WARNING_MESSAGE);
    3741               
    3842                String globalDefinitions = makeGlobalDefinitions();
  • proto/pabloj/trunk/src/applicationGenerator/PabloJ.java

    r2917 r2935  
    11/**
    2  * Compiler entry point.
     2 * PabloJ application generator entry point.
    33 * 
    44 * Parses command line arguments.
    5  * Constructs configuration object.
     5 * Constructs an application configuration object.
    66 * Generates target application.
    77 *
     
    2020        public static void main(String[] args) {
    2121               
    22                 Options options = CompilerOptions.createOptions();
     22                Options options = ConfigurationOptions.createOptions();
    2323               
    2424                try {
     
    2626                        CommandLineParser parser = new PosixParser();
    2727                        CommandLine cli = parser.parse(options, args); 
    28                         CompilerConfig applicationConfig = CompilerConfigFactory.generate(cli);
     28                        Configuration applicationConfig = ConfigurationFactory.generate(cli);
    2929                        ApplicationGenerator applicationGenerator = new ApplicationGenerator(applicationConfig);
    3030                        applicationGenerator.generate();
     
    3333                       
    3434                        e.printStackTrace();                   
    35                         CompilerOptions.usageMessage(options);
    36                         System.exit(CompilerConfig.EXIT_CODE_FOR_ERROR);
     35                        ConfigurationOptions.usageMessage(options);
     36                        System.exit(Configuration.EXIT_CODE_FOR_ERROR);
    3737                }       
    3838               
  • proto/pabloj/trunk/src/applicationGenerator/TemplateContentsGenerator.java

    r2917 r2935  
    11/**
    2  * Generates target language output file.
     2 * ABC to generates target language output file.
    33 *
    44 * @author Ken Herdy <ksherdy at sfu dot ca>
  • proto/pabloj/trunk/src/applicationGenerator/helpers/FileUtil.java

    r2917 r2935  
     1/*
     2 * File utility helpers.
     3 *
     4 * @author <ksherdy at sfu dot ca>
     5 */
     6
    17package applicationGenerator.helpers;
    28
     
    2430        }       
    2531       
     32        public static String ensureEndsWith(String string, String suffix) {
     33                if(string.endsWith(suffix)) {
     34                        return string;
     35                } else {
     36                        return string + suffix;
     37                }
     38        }
    2639       
    2740}
Note: See TracChangeset for help on using the changeset viewer.