c2d16124949e68e7e20c68ec03a2d55d3fbd9e63
[repair.git] / Repair / RepairCompiler / MCC / Compiler.java
1 package MCC;
2
3 import java.io.*;
4 import java.util.*;
5 import MCC.IR.*;
6
7 /**
8  * The main compiler module, which does the following:
9  * <ul>
10  *  <li>
11  *   nothing.
12  *  </li> 
13  * <ul>
14  *
15  * @author <b>Daniel Roy</b> droy (at) mit (dot) edu
16  * @version %I, %G 
17  */
18
19 public class Compiler {
20     /* Set this flag to false to turn repairs off */
21     public static boolean REPAIR=true;
22     
23     public static void main(String[] args) {
24         State state = null;
25         boolean success = true;
26         CLI cli = new CLI();
27         cli.parse(args);
28         printArgInfo(cli); // prints debugging information and warning
29
30         state = new State();
31         State.currentState = state;
32         State.debug = cli.debug;
33         State.verbose = cli.verbose;
34         State.infile = cli.infile;
35         State.outfile = cli.outfile;
36
37         /*
38          * added: terminates with an error message if no input file
39          * specified at command line
40          */
41
42         System.out.println("\nMCC v0.0.1 - MIT LCS (Author: Daniel Roy, Brian Demsky)");
43
44         if (cli.infile == null) {
45             System.err.println("\nError: no input file specified");
46             System.exit(-1);
47         }
48         
49         if (cli.target == CLI.ASSEMBLY || cli.target == CLI.DEFAULT) {
50             if (state.debug) {
51                 System.out.println("Compiling " + cli.infile + ".");
52             }
53
54             success = scan(state) || error(state, "Scanning failed, not attempting to parse.");
55             success = parse(state) || error(state, "Parsing failed, not attempting semantic analysis.");
56             success = semantics(state) || error(state, "Semantic analysis failed, not attempting variable initialization.");
57
58
59             Termination termination=null;
60             /* Check partition constraints */
61             (new ImplicitSchema(state)).update();
62             termination=new Termination(state);
63
64             state.printall();
65             (new DependencyBuilder(state)).calculate();
66             
67             try {
68                 Vector nodes = new Vector(state.constraintnodes.values());
69                 nodes.addAll(state.rulenodes.values());
70
71                 FileOutputStream dotfile;
72                 dotfile = new FileOutputStream(cli.infile + ".dependencies.edgelabels.dot");
73                 GraphNode.useEdgeLabels = true;
74                 GraphNode.DOTVisitor.visit(dotfile, nodes);
75                 dotfile.close();
76
77                 dotfile = new FileOutputStream(cli.infile + ".dependencies.dot");
78                 GraphNode.useEdgeLabels = false;
79                 GraphNode.DOTVisitor.visit(dotfile, nodes);                
80                 dotfile.close();
81             } catch (Exception e) {
82                 e.printStackTrace();
83                 System.exit(-1);
84             }
85             
86             try {
87                 FileOutputStream gcode = new FileOutputStream(cli.infile + ".cc");
88
89
90                 // do model optimizations
91                 //(new Optimizer(state)).optimize();
92
93
94
95                 FileOutputStream gcode2 = new FileOutputStream(cli.infile + "_aux.cc");
96                 FileOutputStream gcode3 = new FileOutputStream(cli.infile + "_aux.h");
97                 RepairGenerator wg = new RepairGenerator(state,termination);
98                 wg.generate(gcode,gcode2,gcode3, cli.infile + "_aux.h");
99                 gcode2.close();
100                 gcode3.close();
101                 /*              } else {
102                     WorklistGenerator ng = new WorklistGenerator(state);
103                     SetInclusion.worklist=true;
104                     RelationInclusion.worklist=true;
105                     ng.generate(gcode);
106                     }*/
107                 gcode.close();
108             } catch (Exception e) {
109                 e.printStackTrace();
110                 System.exit(-1);
111             }
112             
113             if (state.debug) {
114                 System.out.println("Compilation of " + state.infile + " successful.");
115                 System.out.println("#SUCCESS#");
116             }
117         } else if (cli.target == CLI.INTER) {
118             if (state.debug) {
119                 System.out.println("Semantic analysis for " + cli.infile + ".");
120             }
121
122             success = scan(state) || error(state, "Scanning failed, not attempting to parse.");
123             success = parse(state) || error(state, "Parsing failed, not attempting semantic analysis.");
124             success = semantics(state) || error(state, "Semantic analysis failed.");
125
126             if (state.debug) {
127                 System.out.println("Semantic analysis of " + state.infile + " successful.");
128                 System.out.println("#SUCCESS#");
129             }
130         } else if (cli.target == CLI.PARSE) {
131             if (state.debug) {
132                 System.out.println("Parsing " + cli.infile + ".");
133             }
134
135             success = scan(state) || error(state, "Scanning failed, not attempting to parse.");
136             success = parse(state) || error(state, "Parsing failed.");
137
138             if (state.debug) {
139                 System.out.println("Parsing of " + state.infile + " successful.");
140                 System.out.println("#SUCCESS#");
141             }
142         } else if (cli.target == CLI.SCAN) {
143             if (state.debug) {
144                 System.out.println("Scanning " + cli.infile + ".");
145             }
146
147             success = scan(state) || error(state, "Scanning failed.");
148
149             if (state.debug) {
150                 System.out.println("Scanning of " + state.infile + " successful.");
151                 System.out.println("#SUCCESS#");
152             }
153         }
154     }
155
156     private static void printArgInfo(CLI cli) {
157         if (cli.debug) {
158             System.out.println("Printing debugging information...");
159             System.out.println("Input filename: " + cli.infile);
160             System.out.println("Output filename: " + cli.outfile);
161             System.out.print("Target: ");
162
163             switch(cli.target) {
164             case CLI.ASSEMBLY:
165                 System.out.println("ASSEMBLY");
166                 break;
167             case CLI.DEFAULT:
168                 System.out.println("DEFAULT");
169                 break;
170             case CLI.INTER:
171                 System.out.println("INTER");
172                 break;
173             case CLI.LOWIR:
174                 System.out.println("LOWIR");
175                 break;
176             case CLI.PARSE:
177                 System.out.println("PARSE");
178                 break;
179             case CLI.SCAN:
180                 System.out.println("SCAN");
181                 break;
182             default:
183                 System.out.println("not recognized");
184                 break;
185             }
186
187             for (int i = 0; i < cli.opts.length; i++) {
188                 if (cli.opts[i]) {
189                     System.out.println("Optimization");
190                 }
191             }
192         }
193
194         for (int i = 0; i < cli.extraopts.size(); i++) {
195             System.err.println("Warning: optimization \"" +
196                                cli.extraopts.elementAt(i) +
197                                "\" not recognized");
198         }
199
200         for (int i = 0; i < cli.extras.size(); i++) {
201             System.err.println("Warning: option \"" +
202                                cli.extras.elementAt(i) +
203                                "\" not recognized");
204         }
205     }
206
207     private static boolean error(State state, String error) {
208         System.err.println(error);
209         if (state.debug) {
210             System.out.println("#ERROR#");
211         }
212         System.exit(-1);
213         return false;
214     }
215
216     public static boolean semantics(State state) {
217         SimpleIRErrorReporter er = new SimpleIRErrorReporter();
218         SemanticChecker checker = new SemanticChecker();
219         boolean ok = true;
220
221         try {
222             ok = checker.check(state, er);
223         } catch (Exception e) {
224             er.report(null, e.toString());
225             e.printStackTrace();
226             er.error = true;
227         }
228
229         if (!ok) {
230             er.report(null, "Semantic check failed.");
231         }
232
233         System.out.print(er.toString());
234
235         return !er.error;
236     }
237
238     public static void debugMessage(int level, String s) {
239         if (State.currentState.verbose >= level) {
240             System.err.println(s);
241         }
242     }
243
244     public static boolean parse(State state) {
245         
246         /* parse structure file */
247         try {
248             debugMessage(1, "Parsing structure file");
249             LineCount.reset();
250             FileInputStream infile = new FileInputStream(state.infile + ".struct");
251             TDLParser parser = new TDLParser(new Lexer(infile));
252             parser.filename = state.infile + ".struct";
253             CUP$TDLParser$actions.debug = state.verbose > 1 ;
254             state.ptStructures = (ParseNode) parser.parse().value;
255         } catch (FileNotFoundException fnfe) {
256             System.err.println("Unable to open file: " + state.infile + ".struct");
257             System.exit(-1);
258         } catch (Exception e) {
259             //      System.out.println(e);
260             //      e.printStackTrace();
261             return false;
262         }
263
264         /* parse model file */
265         try {
266             debugMessage(1, "Parsing model file");
267             LineCount.reset();
268             FileInputStream infile = new FileInputStream(state.infile + ".model");
269             MDLParser parser = new MDLParser(new Lexer(infile));
270             parser.filename = state.infile + ".model";
271             CUP$MDLParser$actions.debug = state.verbose > 1 ;
272             state.ptModel = (ParseNode) parser.parse().value;
273         } catch (FileNotFoundException fnfe) {
274             System.err.println("Unable to open file: " + state.infile + ".model");
275             System.exit(-1);
276         } catch (Exception e) {
277             //      System.out.println(e);
278             //      e.printStackTrace();
279             return false;
280         }
281
282         /* parse space file */
283         try {
284             debugMessage(1, "Parsing space file");
285             LineCount.reset();
286             FileInputStream infile = new FileInputStream(state.infile + ".space");
287             SDLParser parser = new SDLParser(new Lexer(infile));
288             parser.filename = state.infile + ".space";
289             CUP$SDLParser$actions.debug = state.verbose > 1 ;
290             state.ptSpace = (ParseNode) parser.parse().value;
291         } catch (FileNotFoundException fnfe) {
292             System.err.println("Unable to open file: " + state.infile + ".space");
293             System.exit(-1);
294         } catch (Exception e) {
295             System.out.println(e);
296             e.printStackTrace();
297             return false;
298         }
299
300         /* parse constraints file */
301         try {
302             debugMessage(1, "Parsing constraints file");
303             LineCount.reset();
304             FileInputStream infile = new FileInputStream(state.infile + ".constraints");
305             CDLParser parser = new CDLParser(new Lexer(infile));
306             parser.filename = state.infile + ".constraints";
307             CUP$CDLParser$actions.debug = state.verbose > 1 ;
308             state.ptConstraints = (ParseNode) parser.parse().value;
309         } catch (FileNotFoundException fnfe) {
310             System.err.println("Unable to open file: " + state.infile + ".constraints");
311             System.exit(-1);
312         } catch (Exception e) {
313             //      System.out.println(e);
314             //      e.printStackTrace();
315             return false;
316         }
317
318         boolean success = 
319             !CUP$TDLParser$actions.errors && 
320             !CUP$SDLParser$actions.errors && 
321             !CUP$CDLParser$actions.errors && 
322             !CUP$MDLParser$actions.errors;
323
324                 
325         // if verbosity is on, then output parse trees as .dot files
326         if (success && state.verbose > 0) {
327             try {
328                 FileOutputStream dotfile;
329
330                 dotfile = new FileOutputStream(state.infile + ".struct.dot");
331                 ParseNodeDOTVisitor.visit(dotfile, state.ptStructures);                
332                 dotfile.close();
333
334                 dotfile = new FileOutputStream(state.infile + ".model.dot");
335                 ParseNodeDOTVisitor.visit(dotfile, state.ptModel);                
336                 dotfile.close();
337
338                 dotfile = new FileOutputStream(state.infile + ".space.dot");
339                 ParseNodeDOTVisitor.visit(dotfile, state.ptSpace);                
340                 dotfile.close();
341
342                 dotfile = new FileOutputStream(state.infile + ".constraints.dot");
343                 ParseNodeDOTVisitor.visit(dotfile, state.ptConstraints);                
344                 dotfile.close();
345             } catch (Exception e) {
346                 e.printStackTrace();
347                 return false;
348             }
349         }
350             
351         return success;
352     }
353
354
355     public static boolean scan(State state) {
356         FileInputStream infile = null;
357         Lexer lexer;
358         boolean errors = false;
359         String files[] = { new String(state.infile + ".struct"),
360                            new String(state.infile + ".model"),
361                            new String(state.infile + ".constraints"),
362                            new String(state.infile + ".space") };
363
364
365
366         for (int i = 0; i < files.length; i++) {
367
368             String filename = files[i];
369
370             try {
371                 infile = new FileInputStream(filename);
372             } catch (FileNotFoundException fnfe) {
373                 System.err.println("Unable to open file: " + filename);
374                 System.exit(-1);
375             }
376             
377             lexer = new Lexer(infile);
378
379             
380             try {
381                 while (true) {
382                     java_cup.runtime.Symbol symbol;
383                     
384                     symbol = lexer.next_token();
385                     
386                     if (symbol.sym == Sym.EOF) {
387                         break;
388                     } else if (symbol.sym == Sym.BAD) {
389                         errors = true;
390                     }
391                     
392                     if (State.verbose > 2) {
393                         System.out.println("Got token: " + symbol.value);
394                     }
395                 }
396             } catch (Exception e) {
397                 return false;
398             }
399         }
400
401         return !errors;
402     }
403
404
405 }
406