source: proto/pablo/src/compiler/PabloCompilerTestHarness.java @ 2660

Last change on this file since 2660 was 2660, checked in by ksherdy, 6 years ago

Shortened variable names for sanity.

File size: 8.7 KB
Line 
1//
2// This code is modified scatter parser-generator code.
3// See applications.SampleCompiler.java.
4//
5
6package  compiler;
7
8import java.io.File;
9import java.io.FileNotFoundException;
10import java.util.*;
11
12import lexicalAnalyzer.LexicalController;
13import parser.Parser;
14// import semanticAnalyzer.SampleSemanticAnalyzer;
15// import codeGeneration.CodeGenerator;
16
17import  tokens.Tokens;
18import  ast.ASTNode;
19import  logging.ScatterLogger;
20
21import compiler.lang.carry.CarrySet2CPP;
22import compiler.lang.carry.CarrySet2Lang;
23import compiler.lang.idisa.*;
24import compiler.lang.pablo.Builtins2CPP;
25import compiler.lang.pablo.Builtins2Lang;
26import compiler.visitors.*;
27import compiler.test.*;
28
29@SuppressWarnings("unused")
30public class PabloCompilerTestHarness extends PabloApplication {
31
32        protected static final int EXIT_CODE_FOR_ERROR = 1;
33        protected static String outputDirectory = "output/";
34        protected static String testDirectoryName = null;
35       
36       
37        public enum Test {
38            ADVANCECOMBINER("AdvanceCombinerXFormer", true),
39            ADVANCENCOUNTER("AdvanceNCounterVisitor", true),
40            AugAssign("AugAssignXFormer", true),
41            BITWISE2IDISA("Bitwise2IDISAXFormer", true),
42            CARRYCOUNTER("CarryCounterVisitor", true),
43            PABLO2CARRYQCICO("Pablo2CarryQCiCoXFormer", true),
44            PABLO2CARRYQCI("Pablo2CarryQCiXFormer", true),
45            CARRYINITTOONELIST("CarryInitToOneListVisitor", true),
46            STREAMFuncVISITOR("StreamFuncVisitor", true);
47            //CARRYQINTROXFORMER("",true); // TODO
48            //ASSERTZERO("",true);// TODO
49           
50            private final String directoryName;
51            private boolean addTest = false;
52           
53            Test(String directoryName, boolean addTest) {
54                this.directoryName = directoryName;
55                this.addTest = addTest;
56            }
57           
58            public String directory() { return directoryName; }
59            public boolean addTest() { return addTest; }
60        }
61       
62        /** Compiles a Pablo file.
63         * @param args
64         * @throws FileNotFoundException
65         */     
66       
67        public static void main(String[] args) throws FileNotFoundException {
68                               
69                checkArgs(args, "PabloCompilerTestHarness");
70                Tokens.setPrintLevel(Tokens.Level.FULL);       
71                File testBase = new File(testDirectoryName);
72
73                for(Test test: Test.values()) {
74                       
75                        if (test.addTest()) {
76                       
77                                String dir = new String();
78                                ArrayList<File> files = new ArrayList<File>();
79                                dir = testBase.getAbsolutePath() + File.separator + test.directory();
80                                files = matchFiles(new File (dir), ".pablo");
81                               
82                                for(File file: files) {
83                                        String fileAbsolutePath = file.getAbsolutePath();
84                                        System.out.println("Running: " + fileAbsolutePath);
85                                       
86                                        switch(test) {
87                                                case ADVANCECOMBINER:
88                                                        advanceCombinerTest(fileAbsolutePath);
89                                                        break;
90                                                case ADVANCENCOUNTER:
91                                                        break;
92                                                case AugAssign:                                 
93                                                                AugAssignTest(fileAbsolutePath);
94                                                        break;
95                                                case BITWISE2IDISA:
96                                                                bitwise2IDISATest(fileAbsolutePath);
97                                                        break;                                 
98                                                case CARRYCOUNTER:
99                                                        break;                                 
100                                                case PABLO2CARRYQCICO:
101                                                                carryIntroTest(fileAbsolutePath, true, true);
102                                                        break;
103                                                case PABLO2CARRYQCI:
104                                                                carryIntroTest(fileAbsolutePath, true, false);
105                                                        break; 
106                                                case CARRYINITTOONELIST:
107                                                        break;                                 
108                                                case STREAMFuncVISITOR:
109                                                        break;
110                                                default:
111                                                        break;
112                                        }
113                                }
114                        }
115                }
116               
117                System.out.print("Tests complete.");
118        }
119       
120        /**
121         * @param fileAbsolutePath
122         * @throws FileNotFoundException
123         */
124        public static void advanceCombinerTest(String fileAbsolutePath) throws FileNotFoundException {
125                               
126                LexicalController lexController = LexicalController.make(fileAbsolutePath);
127                ASTNode syntaxTree = Parser.parse(lexController);
128               
129                StreamFuncVisitor streamFuncVisitor = new StreamFuncVisitor(syntaxTree);
130                Map<String, ASTNode> streamFuncMap = streamFuncVisitor.makeStreamFuncMap();
131               
132                for (Map.Entry<String, ASTNode> entry : streamFuncMap.entrySet()) {                                             
133                    AdvanceCombinerXFormer advanceCombiner = new AdvanceCombinerXFormer(entry.getValue());
134                    advanceCombiner.XForm();                       
135                }   
136               
137                ASTTest astTest = new ASTTest(syntaxTree);
138                astTest.compareAssignNodes();
139        }
140
141        /**
142         * @param fileAbsolutePath
143         * @throws FileNotFoundException
144         */
145        public static void bitwise2IDISATest(String fileAbsolutePath) throws FileNotFoundException {
146                               
147                LexicalController lexController = LexicalController.make(fileAbsolutePath);
148                ASTNode syntaxTree = Parser.parse(lexController);
149               
150                StreamFuncVisitor streamFuncVisitor = new StreamFuncVisitor(syntaxTree);
151                Map<String, ASTNode> streamFuncMap = streamFuncVisitor.makeStreamFuncMap();
152               
153                for (Map.Entry<String, ASTNode> entry : streamFuncMap.entrySet()) {                                             
154                        Bitwise2IDISAXFormer bitwiseToIDISA = new Bitwise2IDISAXFormer(entry.getValue());
155                        bitwiseToIDISA.XForm();                     
156                }
157               
158                ASTTest astTest = new ASTTest(syntaxTree);
159                astTest.compareAssignNodes();
160               
161        }
162
163        /**
164         * @param fileAbsolutePath
165         * @throws FileNotFoundException
166         */
167        public static void AugAssignTest(String fileAbsolutePath) throws FileNotFoundException {
168                               
169                LexicalController lexController = LexicalController.make(fileAbsolutePath);
170                ASTNode syntaxTree = Parser.parse(lexController);
171               
172                StreamFuncVisitor streamFuncVisitor = new StreamFuncVisitor(syntaxTree);
173                Map<String, ASTNode> streamFuncMap = streamFuncVisitor.makeStreamFuncMap();
174               
175                for (Map.Entry<String, ASTNode> entry : streamFuncMap.entrySet()) {                                                                     
176                        AugAssignXFormer AugAssign = new AugAssignXFormer(entry.getValue());   
177                        AugAssign.XForm();
178                }   
179               
180                ASTTest astTest = new ASTTest(syntaxTree);
181                astTest.compareAssignNodes();
182        }
183       
184        /**
185         * @param fileAbsolutePath
186         * @throws FileNotFoundException - Final Block
187         */
188        public static void carryIntroTest(String fileAbsolutePath, boolean ciMode, boolean coMode) throws FileNotFoundException {
189                LexicalController lexController = LexicalController.make(fileAbsolutePath);
190                ASTNode syntaxTree = Parser.parse(lexController);
191               
192               
193                StreamFuncVisitor streamFuncVisitor = new StreamFuncVisitor(syntaxTree);
194                Map<String, ASTNode> streamFuncMap = streamFuncVisitor.makeStreamFuncMap();
195               
196                Builtins2Lang builtins2CPP = new Builtins2CPP();
197               
198                for (Map.Entry<String, ASTNode> entry : streamFuncMap.entrySet()) {     
199                        ASTNode value = entry.getValue();                               
200                        CarrySet2Lang carrySet2CPP = new CarrySet2CPP();
201                        Pablo2CarryXFormer pablo2CarryQ = new Pablo2CarryXFormer(value, builtins2CPP, carrySet2CPP);
202                        pablo2CarryQ.XForm(ciMode, coMode);                     
203                       
204                }   
205               
206                ASTTest astTest = new ASTTest(syntaxTree);
207                astTest.compareAssignNodes();
208               
209        }       
210       
211//  CarryCounter carryCounter = new CarryCounter(node);
212//  AdvanceNCounter advNCounter = new AdvanceNCounter(node);
213                           
214//      System.out.println(entry.getKey());
215//      System.out.println("Carry Count = " + carryCounter.count());
216//      System.out.println("Adv n Count = " + advNCounter.count());
217//      System.out.println();
218
219       
220        private static void generateCodeIfNoErrors(String filename, ASTNode decoratedTree)
221                        throws FileNotFoundException {
222                if(thereAreErrors()) {
223                        stopProcessing();
224                } 
225                else {
226                        generateAndPrintCode(decoratedTree);
227                }
228        }
229
230        // stopProcessing -- inform user and clean up.
231        private static void stopProcessing() {
232                informUserNoCodeGenerated();
233        }
234        private static void informUserNoCodeGenerated() {
235                System.err.println("program has errors.  no parser produced.");
236        }
237       
238        // normal code generation.
239        private static void generateAndPrintCode(ASTNode decoratedTree) 
240                        throws FileNotFoundException {
241                //      CodeGenerator generator = new CodeGenerator(outputDirectory, decoratedTree);
242                //      generator.generate();
243        }
244
245        private static boolean thereAreErrors() {
246                return ScatterLogger.hasErrors();
247        }
248
249        protected static void checkArgs(String[] args, String applicationName) {
250                int length = args.length;
251                boolean inputDirectoryFound = false;
252               
253                for(int i=0; i<length; i++) {
254
255                        String arg = args[i];
256                       
257                        if(arg.equals("-o")) {
258                                if(i==length-1) {
259                                        exitWithUsageMessage(applicationName);
260                                }
261                                arg = args[++i];
262                                outputDirectory = arg + "/";
263                        }
264                        else if(!inputDirectoryFound) {
265                                testDirectoryName = arg;
266                       
267                                if (! new File(testDirectoryName).isDirectory()) {
268                                        System.err.println("Input directory does not exist.");
269                                        exitWithUsageMessage(applicationName);
270                                }
271                       
272                                inputDirectoryFound = true;
273                        }
274                        else {
275                                exitWithUsageMessage(applicationName);
276                        }                       
277                }
278        }
279       
280        private static void exitWithUsageMessage(String applicationName) {
281                System.err.println("usage: " + applicationName + " inputDirectory [-o outputDirectory]");
282                System.exit(EXIT_CODE_FOR_ERROR);
283        }       
284
285        public static ArrayList<File> matchFiles(File file, String suffix) {
286               
287                ArrayList<File> list = new ArrayList<File>();
288               
289                if(file.isFile() &&  file.getName().endsWith(suffix)) {
290                        list.add(file);
291                        return list;
292                }
293               
294                if(file.isDirectory()) {
295                        File [] files = file.listFiles();
296                        for(File f : file.listFiles()) {
297                                list.addAll(matchFiles(f, suffix));
298                        }
299                }
300                       
301                return list;
302        }       
303       
304}
305
Note: See TracBrowser for help on using the repository browser.