Changeset 3277


Ignore:
Timestamp:
Jun 7, 2013, 12:45:38 AM (6 years ago)
Author:
shermer
Message:

More refactoring of application configuration package.
Created enums for SourceLanguage? and Target.
Moved ConfigurationFactory? into Configuration as constructor and then converted public fields to queries. Essentially this turned Configuration into a wrapper for the CLI.

Location:
proto/pabloj/trunk/src/application
Files:
2 added
1 deleted
5 edited

Legend:

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

    r2998 r3277  
    1313import org.apache.commons.cli.CommandLine;
    1414import org.apache.commons.cli.CommandLineParser;
     15import org.apache.commons.cli.HelpFormatter;
    1516import org.apache.commons.cli.Options;
    1617import org.apache.commons.cli.PosixParser;
    1718
    1819import application.config.Configuration;
    19 import application.config.ConfigurationFactory;
    2020import application.config.ConfigurationOptions;
    2121import application.generators.ApplicationGenerator;
     
    3131                        CommandLineParser parser = new PosixParser();
    3232                        CommandLine cli = parser.parse(options, args); 
    33                         Configuration applicationConfig = ConfigurationFactory.generate(cli);
     33                        Configuration applicationConfig = Configuration.make(cli);
    3434                        ApplicationGenerator applicationGenerator = new ApplicationGenerator(applicationConfig);
    3535                        applicationGenerator.generate();
     
    3838                       
    3939                        e.printStackTrace();                   
    40                         ConfigurationOptions.usageMessage(options);
     40                        PabloJ.usageMessage(options);
    4141                        System.exit(Configuration.EXIT_CODE_FOR_ERROR);
    4242                }       
    4343               
    4444        }
    45        
    4645
     46        public static void usageMessage(Options options) {
     47                HelpFormatter h = new HelpFormatter();
     48                h.printHelp("java " + Configuration.COMPILER_NAME + "\n", options);   
     49        }
    4750}
  • proto/pabloj/trunk/src/application/config/Configuration.java

    r3249 r3277  
    99package application.config;
    1010
    11 public class Configuration {
     11import org.apache.commons.cli.CommandLine;
     12import application.helpers.FileUtil;
     13import static application.config.Target.*;
    1214
    13         public static final String PABLOS_EXT = ".pablos";
    14         public static final String PABLOB_EXT = ".pablob";
     15public class Configuration {   
     16        // General definitions used in main application
     17        public  static final String COMPILER_NAME               = "PabloJ";     
     18        public  static final String WARNING_MESSAGE     = "GENERATED CODE. DO NOT MODIFY.";
     19        public  static final int    EXIT_CODE_FOR_ERROR         = 1;
     20
     21        private static final Target DEFAULT_TARGET = CPP_LANG;
     22   
     23        // Default base directories.  Each base directory gets a short target identifier as a directory (e.g. "cpplang/") appended.
     24        // CLI-provided directory names are not base directories and do not get the target short identifier appended.
     25        private static final String DEFAULT_OUTPUT_BASE_DIRECTORY    = "output/";
     26        private static final String DEFAULT_TEMPLATE_BASE_DIRECTORY  = "input/templates/";
     27        private static final String DEFAULT_TEMPLATE_FILENAME        = "pablo_definitions.template";
     28
    1529       
    16         // Warning Message
    17         public static final String COMPILERNAME                 = "PabloJ";     
    18         public static final String WARNING_MESSAGE      = "GENERATED CODE. DO NOT MODIFY.";
    19         public static final int EXIT_CODE_FOR_ERROR     = 1;
     30        // public static factory
     31    public static Configuration make(CommandLine cli) {
     32        return new Configuration(cli);         
     33    }
     34
     35   
     36        private CommandLine cli;
     37        private Target target = DEFAULT_TARGET;
     38        private SourceLanguage source = null;
    2039       
    21         // Default directory structure
    22         public static final String OUTPUT_DIRECTORY             = "output/";
    23         public static final String TEMPLATES_DIRECTORY  = "input/templates/";
    24         public static final String CPPLANG                              = "cpplang";
    25         public static final String CLANG                                        = "clang";
     40    // private constructor
     41        private Configuration(CommandLine cli) {
     42        this.cli = cli;
     43        source = configureSource(cli);
     44        target = configureTarget(cli);
     45        }
     46        private Target configureTarget(CommandLine cli) {
     47                if(cli.hasOption("x")) {
     48                        String targetName = cli.getOptionValue("x");
     49                return Target.forShortName(targetName);
     50                }
     51                return DEFAULT_TARGET;
     52        }
     53        private SourceLanguage configureSource(CommandLine cli) {
     54                if(cli.hasOption("s")) {
     55                        return SourceLanguage.PABLO_S;
     56                }               
     57                if(cli.hasOption("b")) {
     58                        return SourceLanguage.PABLO_B;
     59                }
     60                assert false : "neither pabloS nor pabloB selected.";
     61                return null;
     62        }
     63
    2664       
    27         // Options
    28         public String pabloSFile;
    29         public boolean isPabloSSource;
     65        // source and target queries
     66        public SourceLanguage getSource() {
     67                return source;
     68        }
     69        public String sourceFile() {
     70                return cli.getOptionValue(source.cliFlag());
     71        }
     72        public Target getTarget() {
     73                return target;
     74        }
     75
     76        // special mode queries
     77        public boolean addingDumpStatements() {
     78                return cli.hasOption("d");
     79        }
     80        public boolean addingAlignmentAssertions() {
     81                return cli.hasOption("a");
     82        }       
     83        public boolean isExperimentalMode() {
     84                return cli.hasOption("p");
     85        }
     86        public String getErrorRoutine() {
     87                return cli.getOptionValue("e", "raise_assert");
     88        }
    3089       
    31         public String pabloBFile;
    32         public boolean isPabloBSource;
    3390       
    34         public String templateDirectory;
    35         public String templateFileName;
    36         public String outputDirectory; 
    37     public String outputFileName;       
    38         public String targetLang;
    39                
    40         // Debug Options
    41         public Boolean addAssertBitBlockAlignStmts;
    42         public Boolean addDumpStmts;
    43         public String   errorRoutine;
    44        
    45         // Experimental mode
    46         public boolean isExperimentalMode;
     91        // Template directory and filename queries
     92        private String defaultTemplateDirectory() {
     93                return DEFAULT_TEMPLATE_BASE_DIRECTORY + target.getShortName();
     94        }
     95        public String templateDirectory() {
     96                return FileUtil.directory(cli.getOptionValue("T", defaultTemplateDirectory()));
     97        }       
     98        public String templateFileName() {
     99                return cli.getOptionValue("t", DEFAULT_TEMPLATE_FILENAME);
     100        }
     101        public String templateFilePath() {
     102                return templateDirectory() + templateFileName();
     103        }
     104
     105        // Output directory and filename queries
     106        private String defaultOutputDirectory() {
     107                return DEFAULT_OUTPUT_BASE_DIRECTORY + target.getShortName();           // is the +target.getShortName() the same as original?  TS
     108        }
     109        public String outputDirectory() {
     110                return FileUtil.directory(cli.getOptionValue("O", defaultOutputDirectory()));
     111        }
     112        public String outputFileName() {
     113                return cli.getOptionValue("o", FileUtil.replaceExtension(templateFileName(), target.getExtension()));
     114        }
     115        public String outputFilePath() {
     116                return outputDirectory() + outputFileName();
     117        }       
    47118}
    48119
  • proto/pabloj/trunk/src/application/config/ConfigurationOptions.java

    r3273 r3277  
    1414package application.config;
    1515
    16 import org.apache.commons.cli.HelpFormatter;
    1716import org.apache.commons.cli.Option;
    1817import org.apache.commons.cli.OptionBuilder;
     
    2019import org.apache.commons.cli.Options;
    2120
    22 public class ConfigurationOptions {     
    23         public static Options options;
     21public class ConfigurationOptions {
     22        // static interface: ConfigurationOptions.createOptions();
     23        public static Options createOptions() {
     24                ConfigurationOptions instance = new ConfigurationOptions();
     25                return instance.create();
     26        }
     27        private ConfigurationOptions() {}
     28
    2429       
    25         public static Options createOptions() {
    26                 options = new Options();
     30        private static final boolean HAS_ARG = true;
     31        private static final boolean NO_ARG  = false;
     32       
     33        private Options allOptions;
     34       
     35        public Options create() {
     36                allOptions = new Options();
    2737
    28                 addNonrequiredOption("h", "help",         false,  "Pablo help.");
     38                addNonrequiredOption("h", "help",               NO_ARG,  "Pablo help.");
    2939
    30                 OptionGroup optionGroup = makeRequiredOptionGroup(
    31                         nonrequiredOption("s", "pablos",     true, "PabloS input file."),
    32                         nonrequiredOption("b", "pablob",     true, "PabloB input file.")
     40                addrequiredOptionGroup(
     41                        nonrequiredOption("s", "pablos",            HAS_ARG, "PabloS input file."),
     42                        nonrequiredOption("b", "pablob",            HAS_ARG, "PabloB input file.")
    3343                );
    34                 options.addOptionGroup(optionGroup);
    3544
    36                 addNonrequiredOption("t", "template",     true,  "Pablo template file.");       
    37                 addNonrequiredOption("o", "output",       true,  "Pablo output file.");
    38                 addNonrequiredOption("e", "error",        true,  "Name/qualified name of error routine.");     
    39                 addNonrequiredOption("a", "align",        false, "Add ASSERT_BITBLOCK_ALIGN statments.");       
    40                 addNonrequiredOption("d", "dump",         false, "Add SIMD register dump statements.");                                 
    41                 addNonrequiredOption("x", "language",     true,  "Target language. Targets include: 'cpplang', 'clang (not yet supported)'.");
    42                 addNonrequiredOption("p", "experimental", false, "Experimental mode.");                                 
     45                addNonrequiredOption("t", "template",           HAS_ARG, "Pablo template file.");       
     46//              addNonrequiredOption("T", "template directory", HAS_ARG, "Pablo template directory.");
     47                addNonrequiredOption("o", "output",             HAS_ARG, "Pablo output file.");
     48//              addNonrequiredOption("O", "output directory",   HAS_ARG, "Pablo output directory.");   
     49                addNonrequiredOption("e", "error",              HAS_ARG, "Name/qualified name of error routine.");     
     50                addNonrequiredOption("a", "align",              NO_ARG,  "Add ASSERT_BITBLOCK_ALIGN statments.");       
     51                addNonrequiredOption("d", "dump",               NO_ARG,  "Add SIMD register dump statements.");                                 
     52                addNonrequiredOption("x", "language",           HAS_ARG, "Target language. Targets include: 'cpplang', 'clang (not yet supported)'.");
     53                addNonrequiredOption("p", "experimental",       NO_ARG,  "Experimental mode.");                 // TS: unused           
    4354
    44                 return options;
     55                return allOptions;
    4556        }
    4657
    47         private static OptionGroup makeRequiredOptionGroup(Option... options) {
     58        private void addrequiredOptionGroup(Option... options) {
     59                OptionGroup optionGroup = requiredOptionGroup(options);
     60                allOptions.addOptionGroup(optionGroup);
     61        }
     62        private OptionGroup requiredOptionGroup(Option... options) {
    4863                OptionGroup optionGroup = new OptionGroup();
    4964                optionGroup.isRequired();
     
    5469        }
    5570
    56         private static void addNonrequiredOption(String shortOption, String longOption, boolean hasArg, String description) {
     71        private void addNonrequiredOption(String shortOption, String longOption, boolean hasArg, String description) {
    5772                Option option = nonrequiredOption(shortOption, longOption, hasArg, description);
    58                 options.addOption(option);     
     73                allOptions.addOption(option);   
    5974        }
    60 
    6175        private static Option nonrequiredOption(String shortOption, String longOption, boolean hasArg, String description ) {
    6276                OptionBuilder.hasArg(hasArg);
     
    6579                OptionBuilder.withDescription(description);
    6680                return OptionBuilder.create(shortOption);
    67         }
    68        
    69         public static void usageMessage(Options options) {
    70                 HelpFormatter h = new HelpFormatter();
    71                 h.printHelp("java " + Configuration.COMPILERNAME + "\n", options);   
    7281        }         
    7382}
  • proto/pabloj/trunk/src/application/generators/ApplicationGenerator.java

    r3262 r3277  
    2020package application.generators;
    2121
    22 import java.io.File;
    2322import java.util.ArrayList;
    2423import java.util.LinkedHashMap;
     
    3736
    3837import application.config.Configuration;
    39 import application.helpers.FileUtil;
     38import application.config.SourceLanguage;
     39import application.config.Target;
    4040
    4141
     
    6363                toolchain.pabloS.lang.carrySet.CarrySetEncoder carrySetEncoder = null;
    6464                               
    65                 if(applicationConfiguration.targetLang.contentEquals(Configuration.CLANG)) {
     65                if(applicationConfiguration.getTarget() == Target.C_LANG) {
    6666            pabloSbuiltinsEncoder       = new toolchain.pabloS.lang.PabloSBuiltins2C();
    6767            pabloBBuiltinsEncoder       = new toolchain.pabloB.lang.PabloBBuiltins2C();
    6868            carrySetEncoder             = new toolchain.pabloS.lang.carrySet.CarrySetBuiltins2C();
    6969                        unparser                        = new Unparser(new IDISABuiltin2C());                   
    70                 } else if(applicationConfiguration.targetLang.contentEquals(Configuration.CPPLANG)) {
     70                } else if(applicationConfiguration.getTarget() == Target.CPP_LANG) {
    7171                        pabloSbuiltinsEncoder   = new toolchain.pabloS.lang.PabloSBuiltins2CPP();
    7272                        pabloBBuiltinsEncoder   = new toolchain.pabloB.lang.PabloBBuiltins2CPP();
     
    8282                pabloB.ast.ASTNode pabloBAST = null;
    8383               
    84                 if(applicationConfiguration.isPabloSSource) {
    85                         pabloS.ast.ASTNode pabloSAST = ASTGenerator.buildPabloSAST(applicationConfiguration.pabloSFile);
     84                if(applicationConfiguration.getSource() == SourceLanguage.PABLO_S) {
     85                        pabloS.ast.ASTNode pabloSAST = ASTGenerator.buildPabloSAST(applicationConfiguration.sourceFile());
    8686                       
    8787                        // transform PabloS builtins to Carry Set builtins
     
    111111                       
    112112               
    113                 } else if (applicationConfiguration.isPabloBSource) {
     113                } else if (applicationConfiguration.getSource() == SourceLanguage.PABLO_B) {
    114114
    115                         pabloBAST = ASTGenerator.buildPabloBAST(applicationConfiguration.pabloBFile);
     115                        pabloBAST = ASTGenerator.buildPabloBAST(applicationConfiguration.sourceFile());
    116116
    117117                }
     
    121121        pabloBXFormer.setBuiltins2Lang(pabloBBuiltinsEncoder);
    122122       
    123         if(applicationConfiguration.addAssertBitBlockAlignStmts) {
     123        if(applicationConfiguration.addingAlignmentAssertions()) {
    124124            pabloBXFormer.setAddAssertBitBlockAlignStmts(true);
    125125        }
    126126       
    127         if(applicationConfiguration.addDumpStmts) {
     127        if(applicationConfiguration.addingDumpStatements()) {
    128128            pabloBXFormer.setAddDumpStmts(true);
    129129        } 
     
    132132       
    133133                // Set up file paths
    134                 String outputDirectory          = FileUtil.ensureEndsWith(applicationConfiguration.outputDirectory, File.separator);
    135                 outputDirectory                         = FileUtil.ensureEndsWith(outputDirectory + applicationConfiguration.targetLang, File.separator);
    136                
    137                 String templateDirectory        = FileUtil.ensureEndsWith(applicationConfiguration.templateDirectory, File.separator);
    138                 String templateFilePath         = templateDirectory + applicationConfiguration.templateFileName;
    139                
    140                 String outputFilePath           = outputDirectory + applicationConfiguration.outputFileName; 
     134//              String templateDirectory        = applicationConfiguration.getTemplateDirectory();
     135                String templateFilePath         = applicationConfiguration.templateFilePath();
     136
     137                String outputDirectory          = applicationConfiguration.outputDirectory();
     138                String outputFilePath           = applicationConfiguration.outputFilePath();
    141139               
    142140                HeaderTemplateContentsGenerator templateContentsGenerator
  • proto/pabloj/trunk/src/application/helpers/FileUtil.java

    r2998 r3277  
    1414                return replaceFileNameExtension(fileName, "");
    1515        }
    16        
    17         public static String replaceFileNameExtension(String fileName, String ext) {
    18 
     16        public static String replaceExtension(String fileName, String extension) {
     17                String name = lastSegment(fileName);
     18                return  FileUtil.replaceFileNameExtension(name, extension);
     19        }
     20        private static String lastSegment(String fileName) {
     21                return new File(fileName).getName();
     22        }
     23        public static String replaceFileNameExtension(String fileName, String extension) {
    1924                int index = fileName.lastIndexOf('.');
    2025                if (index > 0) {
    21                 return fileName.substring(0, index) + ext;
     26                return fileName.substring(0, index) + extension;
    2227                } else {
    23                         return fileName + ext;
     28                        return fileName + extension;
    2429                }
    2530        }
     
    3035        }       
    3136       
     37        public static String directory(String rawName) {
     38                return ensureEndsWith(rawName, File.separator);
     39        }
    3240        public static String ensureEndsWith(String string, String suffix) {
    3341                if(string.endsWith(suffix)) {
Note: See TracChangeset for help on using the changeset viewer.