Changeset 2579


Ignore:
Timestamp:
Oct 28, 2012, 1:59:35 PM (6 years ago)
Author:
ksherdy
Message:

Updated simple driver.

Location:
proto/pablo/src/compiler
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • proto/pablo/src/compiler/PabloApplication.java

    r2388 r2579  
    77
    88public class PabloApplication {
    9 
    10         private static final int EXIT_CODE_FOR_ERROR = 1;
    11         protected static String outputDirectory = "output/";
    12         protected static String inputFilename = null;
    139       
    1410        public PabloApplication() {
     
    1612        }
    1713       
    18        
    19         protected static void checkArguments(String[] args, String applicationName) {
    20                 int length = args.length;
    21                 boolean inputFilenameFound = false;
    22                
    23                 for(int i=0; i<length; i++) {
    24                         String arg = args[i];
    25                        
    26                         if(arg.equals("-o")) {
    27                                 if(i==length-1) {
    28                                         exitWithUsageMessage(applicationName);
    29                                 }
    30                                 arg = args[++i];
    31                                 outputDirectory = arg + "/";
    32                         }
    33                         else if(!inputFilenameFound) {
    34                                 inputFilename = arg;
    35                                 inputFilenameFound = true;
    36                         }
    37                         else {
    38                                 exitWithUsageMessage(applicationName);
    39                         }
    40                 }
    41                
    42                 if(!inputFilenameFound) {
    43                         exitWithUsageMessage(applicationName);
    44                 }
    45         }
    46         private static void exitWithUsageMessage(String applicationName) {
    47                 System.err.println("usage: " + applicationName + " filename [-o outputDirectory]");
    48                 System.exit(EXIT_CODE_FOR_ERROR);
    49         }
    5014}
  • proto/pablo/src/compiler/PabloCompiler.java

    r2444 r2579  
    2323@SuppressWarnings("unused")
    2424public class PabloCompiler extends PabloApplication {
     25       
     26        protected static final int EXIT_CODE_FOR_ERROR = 1;
     27        protected static String outputDirectory = "output/";
     28        protected static String inputFilename = null;           
     29       
    2530        /** Compiles a Pablo file.
    2631         * @param args
     
    104109                return ScatterLogger.hasErrors();
    105110        }
     111       
     112        protected static void checkArguments(String[] args, String applicationName) {
     113                int length = args.length;
     114                boolean inputFilenameFound = false;
     115               
     116                for(int i=0; i<length; i++) {
     117                        String arg = args[i];
     118                       
     119                        if(arg.equals("-o")) {
     120                                if(i==length-1) {
     121                                        exitWithUsageMessage(applicationName);
     122                                }
     123                                arg = args[++i];
     124                                outputDirectory = arg + "/";
     125                        }
     126                        else if(!inputFilenameFound) {
     127                                inputFilename = arg;
     128                                inputFilenameFound = true;
     129                        }
     130                        else {
     131                                exitWithUsageMessage(applicationName);
     132                        }
     133                }
     134               
     135                if(!inputFilenameFound) {
     136                        exitWithUsageMessage(applicationName);
     137                }
     138        }
     139       
     140        private static void exitWithUsageMessage(String applicationName) {
     141                System.err.println("usage: " + applicationName + " filename [-o outputDirectory]");
     142                System.exit(EXIT_CODE_FOR_ERROR);
     143        }       
    106144}
    107145
  • proto/pablo/src/compiler/PabloCompilerTestHarness.java

    r2463 r2579  
    66package  compiler;
    77
     8import java.io.File;
    89import java.io.FileNotFoundException;
    9 import java.util.Map;
    10 
    11 import  lexicalAnalyzer.LexicalController;
     10import java.util.*;
     11
     12import lexicalAnalyzer.LexicalController;
    1213import parser.Parser;
    1314// import semanticAnalyzer.SampleSemanticAnalyzer;
     
    2425@SuppressWarnings("unused")
    2526public class PabloCompilerTestHarness extends PabloApplication {
     27
     28        protected static final int EXIT_CODE_FOR_ERROR = 1;
     29        protected static String outputDirectory = "output/";
     30        protected static String testDirectoryName = null;
     31       
     32        public enum Test {
     33            ADVANCECOMBINER("AdvanceCombiner"),
     34            ADVANCENCOUNTER("AdvanceNCounter"),
     35            AUGMENTEDASSIGNMENT("AugmentedAssignment"),
     36            BITWISE2IDISA("Bitwise2IDISA"),
     37            CARRYCOUNTER("CarryCounter"),
     38            CARRYINTROCICO("CarryIntroCiCo"),
     39            CARRYINTROCI("CarryIntroCi"),
     40            CARRYINITTOONELIST("CarryInitToOneList"),
     41            STREAMFUNCTIONVISITOR("StreamFunctionVisitor");
     42           
     43            private final String directoryName;
     44           
     45            Test(String directoryName) {
     46                this.directoryName = directoryName;
     47            }
     48           
     49            public String directory() { return directoryName; }
     50        }
     51       
    2652        /** Compiles a Pablo file.
    2753         * @param args
    2854         * @throws FileNotFoundException
    29          */
     55         */     
     56       
    3057        public static void main(String[] args) throws FileNotFoundException {
    31                 checkArguments(args, "PabloCompiler");
    32                
    33                 Tokens.setPrintLevel(Tokens.Level.FULL);
    34                 compile(inputFilename);
    35         }
    36        
    37         /** analyzes a file specified by filename.
    38          * @param filename the name of the file to be analyzed.
    39          * @throws FileNotFoundException
    40          */
    41         public static void compile(String filename) throws FileNotFoundException {
    42                                
    43                 LexicalController lexController     = LexicalController.make(filename);
    44                 ASTNode syntaxTree    = Parser.parse(lexController);
    45                 //
    46                 // Quick-and-dirty.
    47                 // May not be required if Visitors are written against entire AST versus
    48                 // individual function definitions.
    49                 //
    50                
    51                 StreamFunctionVisitor streamFunctionVisitor = new StreamFunctionVisitor(syntaxTree);
    52                 Map<String, ASTNode> streamFunctionMap = streamFunctionVisitor.makeStreamFunctionMap();
    53                
    54                 for (Map.Entry<String, ASTNode> entry : streamFunctionMap.entrySet()) {
    55                        
     58                               
     59                checkArguments(args, "PabloCompilerTestHarness");
     60                Tokens.setPrintLevel(Tokens.Level.FULL);       
     61                File testBase = new File(testDirectoryName);
     62
     63                for(Test test: Test.values()) {
     64                        String dir = new String();
     65                        ArrayList<File> files = new ArrayList<File>();
     66                        dir = testBase.getAbsolutePath() + File.separator + test.directory();
     67                        files = matchFiles(new File (dir), ".pablo");
     68                       
     69                        for(File file: files) {
     70                                String fileAbsolutePath = file.getAbsolutePath();
     71                                System.out.println("Running: " + fileAbsolutePath);
     72                               
     73                                switch(test) {
     74                                        case ADVANCECOMBINER:
     75                                                advanceCombinerTest(fileAbsolutePath);
     76                                        break;
     77                                case ADVANCENCOUNTER:
     78                                        break;
     79                                case AUGMENTEDASSIGNMENT:                                       
     80                                                augmentedAssignmentTest(fileAbsolutePath);
     81                                        break;
     82                                case BITWISE2IDISA:
     83                                                bitwise2IDISATest(fileAbsolutePath);
     84                                        break;                                 
     85                                case CARRYCOUNTER:
     86                                        break;                                 
     87                                case CARRYINTROCICO:
     88                                                carryIntroTest(fileAbsolutePath, true, true);
     89                                        break;
     90                                case CARRYINTROCI:
     91                                                carryIntroTest(fileAbsolutePath, true, false);
     92                                        break; 
     93                                case CARRYINITTOONELIST:
     94                                        break;                                 
     95                                case STREAMFUNCTIONVISITOR:
     96                                        break;
     97                                default:
     98                                        break;
     99                                }
     100                        }
     101                }               
     102                        System.out.print("Tests complete.");
     103        }
     104       
     105        /**
     106         * @param fileAbsolutePath
     107         * @throws FileNotFoundException
     108         */
     109        public static void advanceCombinerTest(String fileAbsolutePath) throws FileNotFoundException {
     110                               
     111                LexicalController lexController = LexicalController.make(fileAbsolutePath);
     112                ASTNode syntaxTree = Parser.parse(lexController);
     113               
     114                StreamFunctionVisitor streamFunctionVisitor = new StreamFunctionVisitor(syntaxTree);
     115                Map<String, ASTNode> streamFunctionMap = streamFunctionVisitor.makeStreamFunctionMap();
     116               
     117                for (Map.Entry<String, ASTNode> entry : streamFunctionMap.entrySet()) {                                         
    56118                    AdvanceCombiner advanceCombiner = new AdvanceCombiner(entry.getValue());
    57                     advanceCombiner.transform();
    58 //                  CarryCounter carryCounter = new CarryCounter(entry.getValue());
    59 //                  AdvanceNCounter advNCounter = new AdvanceNCounter(entry.getValue());
    60                        
    61 //                      System.out.println(entry.getKey());
    62 //                      System.out.println("Carry Count = " + carryCounter.count());
    63 //                      System.out.println("Adv n Count = " + advNCounter.count());
    64 //                      System.out.println();
    65 
    66 //                      Bitwise2IDISA bitwiseToIDISA = new Bitwise2IDISA(entry.getValue());
    67 //                      bitwiseToIDISA.transform();
    68 //
    69 //                      AugmentedAssignmentRemoval augmentedAssignmentRemoval = new AugmentedAssignmentRemoval(entry.getValue());
    70 //                      augmentedAssignmentRemoval.transform();
    71 
    72 //                      CarryIntro carryIntro = new CarryIntro(entry.getValue());
    73 //                      carryIntro.transform(true, false);                     
    74                 }
    75 
    76                 ASTTest astTest = new ASTTest(syntaxTree);
    77                 astTest.compareFunctionInvocationNodes();
    78                
    79                 System.out.print(syntaxTree);           
    80                
    81 //              ASTNode decoratedTree = SemanticAnalyzer.analyze(syntaxTree);
    82 //              generateCodeIfNoErrors(filename, decoratedTree);
    83         }
    84 
     119                    advanceCombiner.transform();                           
     120                }   
     121               
     122                ASTTest astTest = new ASTTest(syntaxTree);
     123                astTest.compareAssignmentNodes();
     124        }
     125
     126        /**
     127         * @param fileAbsolutePath
     128         * @throws FileNotFoundException
     129         */
     130        public static void bitwise2IDISATest(String fileAbsolutePath) throws FileNotFoundException {
     131                               
     132                LexicalController lexController = LexicalController.make(fileAbsolutePath);
     133                ASTNode syntaxTree = Parser.parse(lexController);
     134               
     135                StreamFunctionVisitor streamFunctionVisitor = new StreamFunctionVisitor(syntaxTree);
     136                Map<String, ASTNode> streamFunctionMap = streamFunctionVisitor.makeStreamFunctionMap();
     137               
     138                for (Map.Entry<String, ASTNode> entry : streamFunctionMap.entrySet()) {                                         
     139                        Bitwise2IDISA bitwiseToIDISA = new Bitwise2IDISA(entry.getValue());
     140                        bitwiseToIDISA.transform();                         
     141                }
     142               
     143                ASTTest astTest = new ASTTest(syntaxTree);
     144                astTest.compareAssignmentNodes();
     145               
     146        }
     147
     148        /**
     149         * @param fileAbsolutePath
     150         * @throws FileNotFoundException
     151         */
     152        public static void augmentedAssignmentTest(String fileAbsolutePath) throws FileNotFoundException {
     153                               
     154                LexicalController lexController = LexicalController.make(fileAbsolutePath);
     155                ASTNode syntaxTree = Parser.parse(lexController);
     156               
     157                StreamFunctionVisitor streamFunctionVisitor = new StreamFunctionVisitor(syntaxTree);
     158                Map<String, ASTNode> streamFunctionMap = streamFunctionVisitor.makeStreamFunctionMap();
     159               
     160                for (Map.Entry<String, ASTNode> entry : streamFunctionMap.entrySet()) {                                                                 
     161                        AugmentedAssignment augmentedAssignment = new AugmentedAssignment(entry.getValue());   
     162                        augmentedAssignment.transform();
     163                }   
     164               
     165                ASTTest astTest = new ASTTest(syntaxTree);
     166                astTest.compareAssignmentNodes();
     167        }
     168       
     169        /**
     170         * @param fileAbsolutePath
     171         * @throws FileNotFoundException - Final Block
     172         */
     173        public static void carryIntroTest(String fileAbsolutePath, boolean ciMode, boolean coMode) throws FileNotFoundException {
     174                LexicalController lexController = LexicalController.make(fileAbsolutePath);
     175                ASTNode syntaxTree = Parser.parse(lexController);
     176               
     177                StreamFunctionVisitor streamFunctionVisitor = new StreamFunctionVisitor(syntaxTree);
     178                Map<String, ASTNode> streamFunctionMap = streamFunctionVisitor.makeStreamFunctionMap();
     179               
     180                for (Map.Entry<String, ASTNode> entry : streamFunctionMap.entrySet()) {                                         
     181                        CarryIntro carryIntro = new CarryIntro(entry.getValue());
     182                        carryIntro.transform(ciMode, coMode);                   
     183                }   
     184               
     185                ASTTest astTest = new ASTTest(syntaxTree);
     186                astTest.compareAssignmentNodes();
     187               
     188        }       
     189       
     190//  CarryCounter carryCounter = new CarryCounter(node);
     191//  AdvanceNCounter advNCounter = new AdvanceNCounter(node);
     192                           
     193//      System.out.println(entry.getKey());
     194//      System.out.println("Carry Count = " + carryCounter.count());
     195//      System.out.println("Adv n Count = " + advNCounter.count());
     196//      System.out.println();
     197
     198       
    85199        private static void generateCodeIfNoErrors(String filename, ASTNode decoratedTree)
    86200                        throws FileNotFoundException {
     
    104218        private static void generateAndPrintCode(ASTNode decoratedTree)
    105219                        throws FileNotFoundException {
    106 //              CodeGenerator generator = new CodeGenerator(outputDirectory, decoratedTree);
    107 //              generator.generate();
     220                //      CodeGenerator generator = new CodeGenerator(outputDirectory, decoratedTree);
     221                //      generator.generate();
    108222        }
    109223
     
    111225                return ScatterLogger.hasErrors();
    112226        }
     227
     228        protected static void checkArguments(String[] args, String applicationName) {
     229                int length = args.length;
     230                boolean inputDirectoryFound = false;
     231               
     232                for(int i=0; i<length; i++) {
     233
     234                        String arg = args[i];
     235                       
     236                        if(arg.equals("-o")) {
     237                                if(i==length-1) {
     238                                        exitWithUsageMessage(applicationName);
     239                                }
     240                                arg = args[++i];
     241                                outputDirectory = arg + "/";
     242                        }
     243                        else if(!inputDirectoryFound) {
     244                                testDirectoryName = arg;
     245                       
     246                                if (! new File(testDirectoryName).isDirectory()) {
     247                                        System.err.println("Input directory does not exist.");
     248                                        exitWithUsageMessage(applicationName);
     249                                }
     250                       
     251                                inputDirectoryFound = true;
     252                        }
     253                        else {
     254                                exitWithUsageMessage(applicationName);
     255                        }                       
     256                }
     257        }
     258       
     259        private static void exitWithUsageMessage(String applicationName) {
     260                System.err.println("usage: " + applicationName + " inputDirectory [-o outputDirectory]");
     261                System.exit(EXIT_CODE_FOR_ERROR);
     262        }       
     263
     264        public static ArrayList<File> matchFiles(File file, String suffix) {
     265               
     266                ArrayList<File> list = new ArrayList<File>();
     267               
     268                if(file.isFile() &&  file.getName().endsWith(suffix)) {
     269                        list.add(file);
     270                        return list;
     271                }
     272               
     273                if(file.isDirectory()) {
     274                        File [] files = file.listFiles();
     275                        for(File f : file.listFiles()) {
     276                                list.addAll(matchFiles(f, suffix));
     277                        }
     278                }
     279                       
     280                return list;
     281        }       
     282       
    113283}
    114284
  • proto/pablo/src/compiler/lang/pablo/builtins/Carry1.java

    r2436 r2579  
    44
    55    ADVANCE("Advance", 1, "BitBlock_advance_ci_co"),
    6     SCANTOFIRST("ScanToFirst", 1, "BitBlock_scantofirst"),
     6    SCANTOFIRST("ScanToFirst", 2, "BitBlock_scantofirst"),
    77    SCANTHRU("ScanThru", 2, "BitBlock_scanthru_ci_co"),
    88    SCANTO("ScanTo", 2, "BitBlock_scanto_ci_co"),
  • proto/pablo/src/compiler/lang/pablo/builtins/CarryN.java

    r2444 r2579  
    55    ADVANCE32("Advance32", 1, "BitBlock_advance_n_<32>"),
    66    ADVANCE("Advance", 2, "BitBlock_advance_n_<%d>");
     7   
    78        private final String pabloName;
    89        private final int argCount;
Note: See TracChangeset for help on using the changeset viewer.