source: proto/pablo/src/application/Test.java @ 2702

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

General refactoring (variable names). Added final block XFormer. Move final block operations atEOF/inFile out of carry intro transformer to final block transformer.

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