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

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

General refactoring.

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