gitweb on Svarog

projekti pod git sistemom za održavanje verzija -- projects under the git version control system
projects / mjc2wsl.git / blob
? search:


751ce7f7d54524be722c974d5fcbfe4b78f05dbf
[mjc2wsl.git] / src / com / qumaster / transformations / mjc2wsl / mjc2wsl.java
1 package com.qumaster.transformations.mjc2wsl;
2 /*
3 Copyright (C) 2014 Doni Pracner
4
5 This file is part of mjc2wsl.
6
7 mjc2wsl is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
11
12 mjc2wsl is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with mjc2wsl. If not, see <http://www.gnu.org/licenses/>.
19 */
20 import java.io.*;
21 import java.util.*;
22
23 import com.qumaster.transformations.TransMessages;
24
25 /**
26 * This program converts file from compiled MicroJava bytecode to WSL language
27 * which is a part of the FermaT Transformation system. MicroJava is a subset
28 * used in Compiler Construction courses by Hanspeter Moessenboeck, not
29 * "Java ME".
30 *
31 * @author Doni Pracner, http://perun.dmi.rs/pracner http://quemaster.com
32 */
33 public class mjc2wsl{
34 //default version name, used if the file is not found
35 private static String versionN = "0.1.x";
36
37 private String versionFile = "version.properties";
38
39 private TransMessages messages = new TransMessages();
40
41 private boolean genPauseAfterEachAddress=false,
42 genPrintForEachAddress = false,
43 genPrintEStackOnChange = false;
44
45 private boolean genPopPush=false;
46
47 private boolean genInlinePrint=false;
48
49 /** Constant used for marking a regular comment from the original file */
50 public static final char C_REG = ' ';
51 /**
52 * Constant used for marking when original code is inserted in the file,
53 * next to the translations
54 */
55 public static final char C_OC = '#';
56 /** Constant used for marking special messages from the translator */
57 public static final char C_SPEC = '&';
58 /** Constant used for marking error messages from the translator */
59 public static final char C_ERR = '!';
60
61 /** instruction code in MicroJava bytecode. */
62 public static final int
63 load = 1,
64 load_0 = 2,
65 load_1 = 3,
66 load_2 = 4,
67 load_3 = 5,
68 store = 6,
69 store_0 = 7,
70 store_1 = 8,
71 store_2 = 9,
72 store_3 = 10,
73 getstatic = 11,
74 putstatic = 12,
75 getfield = 13,
76 putfield = 14,
77 const_0 = 15,
78 const_1 = 16,
79 const_2 = 17,
80 const_3 = 18,
81 const_4 = 19,
82 const_5 = 20,
83 const_m1 = 21,
84 const_ = 22,
85 add = 23,
86 sub = 24,
87 mul = 25,
88 div = 26,
89 rem = 27,
90 neg = 28,
91 shl = 29,
92 shr = 30,
93 inc = 31,
94 new_ = 32,
95 newarray = 33,
96 aload = 34,
97 astore = 35,
98 baload = 36,
99 bastore = 37,
100 arraylength = 38,
101 pop = 39,
102 dup = 40,
103 dup2 = 41,
104 jmp = 42,
105 jeq = 43,
106 jne = 44,
107 jlt = 45,
108 jle = 46,
109 jgt = 47,
110 jge = 48,
111 call = 49,
112 return_ = 50,
113 enter = 51,
114 exit = 52,
115 read = 53,
116 print = 54,
117 bread = 55,
118 bprint = 56,
119 trap = 57;
120
121 private boolean originalInComments = false;
122
123 private Properties versionData;
124
125 private String getVersion() {
126 if (versionData == null) {
127 versionData = new Properties();
128 try {
129 versionData.load(getClass().getResourceAsStream(versionFile));
130 } catch (IOException e) {
131 e.printStackTrace();
132 }
133 }
134 String ver = versionData.getProperty("version");
135 if (ver != null)
136 return ver;
137 else
138 return versionN;
139 }
140
141 MicroJavaInput mjInput = new MicroJavaInput();
142
143 private PrintWriter out = null;
144
145
146 private void pr(int i){
147 out.print(i);
148 }
149
150 private void pr(char i){
151 out.print(i);
152 }
153
154 private void pr(String i){
155 out.print(i);
156 }
157
158 private void prl(String i){
159 out.println(i);
160 }
161
162 public String createStandardStart(){
163 return createStandardStart(10);
164 }
165
166 public String createStandardStart(int numWords){
167 StringBuilder ret = new StringBuilder(
168 "C:\" This file automatically converted from microjava bytecode\";\n"
169 +"C:\" with mjc2wsl v "+getVersion()+"\";\n");
170
171 ret.append("\nBEGIN");
172 ret.append("\nVAR <\n\t");
173 ret.append("mjvm_locals := ARRAY(1,0),");
174 ret.append("\n\tmjvm_statics := ARRAY("+numWords+",0),");
175 ret.append("\n\tmjvm_arrays := < >,");
176 ret.append("\n\tmjvm_flag_jump := 0,");
177 ret.append("\n\tmjvm_objects := < >,");
178 ret.append("\n\tmjvm_estack := < >, mjvm_mstack := < > > :");
179
180 return ret.toString();
181 }
182
183 public String createAsciiString(){
184 StringBuilder ret = new StringBuilder("C:\"char array for ascii code conversions\";");
185 ret.append("\nascii := \"????????????????????????????????\"++\n");
186 ret.append("\" !\"++Quote++\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\";\n");
187
188 return ret.toString();
189 }
190
191 public String createStandardEnd(){
192 StringBuilder ret = new StringBuilder("SKIP\nENDVAR\n");
193 ret.append("\nWHERE\n");
194
195 ret.append("\nFUNCT CHR(num) ==:\n");
196 ret.append("\t@List_To_String(< num >)\n");
197 ret.append("END\n");
198
199 if (!genInlinePrint) {
200 ret.append("\nPROC Print_MJ(val, format VAR)==\n");
201 ret.append(createComment("print spacing", C_SPEC));
202 ret.append("\n\tIF format>1 THEN\n\t\tFOR i:=2 TO ");
203 ret.append("format STEP 1 DO PRINFLUSH(\" \") OD\n");
204 ret.append("\tFI;\n\tPRINFLUSH(val)\nEND\n");
205
206 ret.append("\nPROC Print_MJ_CHAR(val, format VAR)==\n");
207 ret.append(createComment("print spacing", C_SPEC));
208 ret.append("\n\tIF format>1 THEN\n\t\tFOR i:=2 TO ");
209 ret.append("format STEP 1 DO PRINFLUSH(\" \") OD\n");
210 ret.append("\tFI;\n\tPRINFLUSH(CHR(val))\n");
211 ret.append("END\n");
212 }
213
214 ret.append("\nEND");
215 return ret.toString();
216 }
217
218 private String createStartVar(String... vars){
219 StringBuilder ret = new StringBuilder("VAR < ");
220 ret.append(vars[0] + " := 0");
221 for (int i=1; i<vars.length; i++)
222 ret.append(", "+ vars[i] +" := 0");
223 ret.append(" > : ");
224
225 return ret.toString();
226 }
227
228 private String createEndVar(){
229 return "ENDVAR;";
230 }
231
232 private String createLocal(int i) {
233 // arrays start at 1 in WSL, so we need an offset
234 return "mjvm_locals[" + (i + 1) + "]";
235 }
236
237 private String createStatic(int i) {
238 return "mjvm_statics[" + (i + 1) + "]";
239 }
240
241 private String createArray(int i) {
242 return "mjvm_arrays[" + i + "]";
243 }
244
245 private String createArray(String i) {
246 return "mjvm_arrays[" + i + "]";
247 }
248
249 private String createObject(String i) {
250 return "mjvm_objects[" + i + "]";
251 }
252
253 /**
254 * Creates a WSL comment with care to quote chars.
255 */
256 public static String createComment(String str){
257 return createComment(str, C_REG);
258 }
259
260 /**
261 * Creates a WSL comment with care to quote chars, of the
262 * given type. Types are given as char constants. They can be
263 * default comments, comments that contain the original code
264 * in them, or additional comments regarding the translation
265 * process.
266 */
267 public static String createComment(String str, char type) {
268 return "C:\"" + type + str.replace("\"", "''") + "\";";
269 }
270
271 // generalised stack operations
272
273 private String createToStack(String stack, String var){
274 if (genPopPush)
275 return "PUSH("+stack+"," + var + ");";
276 else
277 return stack + " := <" + var + " > ++ " + stack +";";
278 }
279
280 private String createFromStack(String stack, String var){
281 if (genPopPush)
282 return "POP("+ var + ", "+stack+");";
283 else
284 return var + ":= HEAD("+stack+"); "+stack+" := TAIL("+stack+");";
285 }
286 //Expression stack
287
288 private String createToEStack(int i) {
289 return createToEStack(i+"");
290 }
291
292 private String createToEStack(String i) {
293 String res = createToStack("mjvm_estack", i);
294 if (genPrintEStackOnChange)
295 res += "PRINT(\"eStack\",mjvm_estack);";
296 return res;
297 }
298
299 private String createFromEStack(String st) {
300 String res = createFromStack("mjvm_estack",st);
301 if (genPrintEStackOnChange)
302 res += "PRINT(\"eStack\",mjvm_estack);";
303 return res;
304 }
305
306 private String createPopEStack() {
307 String res = "mjvm_estack := TAIL(mjvm_estack);";
308 if (genPrintEStackOnChange)
309 res += "PRINT(\"eStack\",mjvm_estack);";
310 return res;
311 }
312
313 private String createTopTwoEStack() {
314 return createFromEStack("tempa") + "\n" + createFromEStack("tempb");
315 }
316
317 private String createTopEStack() {
318 return createFromEStack("tempa");
319 }
320
321 //Method stack
322
323 private String createToMStack(int i) {
324 return createToMStack(i+"");
325 }
326
327 private String createToMStack(String i) {
328 return createToStack("mjvm_mstack", i);
329 }
330
331 private String createFromMStack(String st) {
332 return createFromStack("mjvm_mstack", st);
333 }
334
335 public void convertStream(InputStream ins) throws Exception{
336 mjInput.setStream(ins);
337 //process start
338 mjInput.processHeader(this);
339
340 prl(createStandardStart(mjInput.getNumberOfWords(this)));
341 prl("SKIP;\n ACTIONS a" + (14 + mjInput.getMainAdr(this)) + " :");
342 int op = mjInput.get();
343 while (op >= 0) {
344 prl(" a" + mjInput.getCounter() + " ==");
345 if (originalInComments)
346 prl(createComment(mjInput.describeOpCode(op), C_OC));
347 if (genPrintForEachAddress) {
348 prl("PRINT(\"a" + mjInput.getCounter() + "\");");
349 if (genPauseAfterEachAddress)
350 prl("debug_disposable_string := @Read_Line(Standard_Input_Port);");
351 }
352 switch (op) {
353 case load: {
354 prl(createToEStack(createLocal(mjInput.get())));
355 break;
356 }
357 case load_0:
358 case load_1:
359 case load_2:
360 case load_3: {
361 prl(createStartVar("tempa"));
362 prl("tempa :="+createLocal(op - load_0)+";");
363 prl(createToEStack("tempa"));
364 prl(createEndVar());
365 break;
366 }
367 case store: {
368 prl(createFromEStack(createLocal(mjInput.get())));
369 break;
370 }
371 case store_0:
372 case store_1:
373 case store_2:
374 case store_3: {
375 prl(createStartVar("tempa"));
376 prl(createFromEStack("tempa"));
377 prl(createLocal(op - store_0)+" := tempa;");
378 prl(createEndVar());
379 break;
380 }
381
382 case getstatic: {
383 prl(createToEStack(createStatic(mjInput.get2())));
384 break;
385 }
386 case putstatic: {
387 prl(createFromEStack(createStatic(mjInput.get2())));
388 break;
389 }
390
391 case getfield: {
392 int f = mjInput.get2();
393 prl(createStartVar("tempa"));
394 prl(createTopEStack());
395 prl(createToEStack(createObject("tempa") + "[" + (f + 1) + "]"));
396 prl(createEndVar());
397 break;
398 }
399 case putfield: {
400 int f = mjInput.get2();
401 prl(createStartVar("tempa", "tempb"));
402 prl(createTopTwoEStack());
403 prl(createObject("tempb") + "[" + (f + 1) + "]:=tempa;");
404 prl(createEndVar());
405 break;
406 }
407
408 case const_: {
409 prl(createToEStack(mjInput.get4()));
410 break;
411 }
412
413 case const_m1: {
414 prl(createToEStack(-1));
415 break;
416 }
417
418 case const_0:
419 case const_1:
420 case const_2:
421 case const_3:
422 case const_4:
423 case const_5: {
424 prl(createToEStack(op - const_0));
425 break;
426 }
427
428 case add: {
429 prl(createStartVar("tempa", "tempb", "tempres"));
430 prl(createTopTwoEStack());
431 prl("tempres := tempb + tempa;");
432 prl(createToEStack("tempres"));
433 prl(createEndVar());
434 break;
435 }
436 case sub: {
437 prl(createStartVar("tempa", "tempb", "tempres"));
438 prl(createTopTwoEStack());
439 prl("tempres := tempb - tempa;");
440 prl(createToEStack("tempres"));
441 prl(createEndVar());
442 break;
443 }
444 case mul: {
445 prl(createStartVar("tempa", "tempb", "tempres"));
446 prl(createTopTwoEStack());
447 prl("tempres := tempb * tempa;");
448 prl(createToEStack("tempres"));
449 prl(createEndVar());
450 break;
451 }
452 case div: {
453 prl(createStartVar("tempa", "tempb", "tempres"));
454 prl(createTopTwoEStack());
455 prl("IF tempa = 0 THEN ERROR(\"division by zero\") FI;");
456 prl("tempres := tempb DIV tempa;");
457 prl(createToEStack("tempres"));
458 prl(createEndVar());
459 break;
460 }
461 case rem: {
462 prl(createStartVar("tempa", "tempb", "tempres"));
463 prl(createTopTwoEStack());
464 prl("IF tempa = 0 THEN ERROR(\"division by zero\") FI;");
465 prl("tempres := tempb MOD tempa;");
466 prl(createToEStack("tempres"));
467 prl(createEndVar());
468 break;
469 }
470
471 case neg: {
472 prl(createStartVar("tempa"));
473 prl(createTopEStack());
474 prl(createToEStack("-tempa"));
475 prl(createEndVar());
476 break;
477 }
478
479 case shl: {
480 prl(createStartVar("tempa", "tempb"));
481 prl(createTopTwoEStack());
482 prl("VAR <tempres :=tempb, i:=1 >:");
483 prl("\tFOR i:=1 TO tempa STEP 1 DO tempres := tempres * 2 OD;");
484 prl(createToEStack("tempres"));
485 prl("ENDVAR;");
486 prl(createEndVar());
487 break;
488 }
489 case shr: {
490 prl(createStartVar("tempa", "tempb"));
491 prl(createTopTwoEStack());
492 prl("VAR <tempres :=tempb, i:=1 >:");
493 prl("\tFOR i:=1 TO tempa STEP 1 DO tempres := tempres DIV 2 OD;");
494 prl(createToEStack("tempres"));
495 prl("ENDVAR;");
496 prl(createEndVar());
497 break;
498 }
499
500 case inc: {
501 int b1 = mjInput.get(), b2 = mjInput.get();
502 prl(createLocal(b1) + " := " + createLocal(b1) + " + " + b2 + ";");
503 break;
504 }
505
506 case new_: {
507 int size = mjInput.get2();
508 // TODO maybe objects and arrays should be in the same list?
509 prl("mjvm_objects := mjvm_objects ++ < ARRAY(" + size
510 + ",0) >;");
511 prl(createToEStack("LENGTH(mjvm_objects)"));
512 break;
513 }
514 case newarray: {
515 mjInput.get();// 0 - bytes, 1 - words; ignore for now
516 // TODO take into consideration 0/1
517 prl(createStartVar("tempa"));
518 prl(createTopEStack());
519 prl("mjvm_arrays := mjvm_arrays ++ < ARRAY(tempa,0) >;");
520 prl(createToEStack("LENGTH(mjvm_arrays)"));
521 prl(createEndVar());
522 break;
523 }
524
525 case aload:
526 case baload: {
527 prl(createStartVar("tempa", "tempb"));
528 prl(createTopTwoEStack());
529 prl(createToEStack(createArray("tempb") + "[tempa+1]"));
530 prl(createEndVar());
531 break;
532 }
533 case astore:
534 case bastore: {
535 prl(createStartVar("tempa", "tempb", "tempres"));
536 prl(createFromEStack("tempres"));
537 prl(createTopTwoEStack());
538 prl("mjvm_arrays[tempb][tempa+1]:=tempres;");
539 prl(createEndVar());
540 break;
541 }
542 case arraylength: {
543 prl(createStartVar("tempa", "tempb"));
544 prl(createTopEStack());
545 prl("tempb := LENGTH("+ createArray("tempa") + ");");
546 prl(createToEStack("tempb"));
547 prl(createEndVar());
548 break;
549 }
550
551 case dup: {
552 prl(createStartVar("tempa", "tempb"));
553 prl(createTopEStack());
554 prl(createToEStack("tempa"));
555 prl(createToEStack("tempa"));
556 prl(createEndVar());
557 break;
558 }
559 case dup2: {
560 prl(createStartVar("tempa", "tempb"));
561 prl(createTopTwoEStack());
562 prl(createToEStack("tempb"));
563 prl(createToEStack("tempa"));
564 prl(createToEStack("tempb"));
565 prl(createToEStack("tempa"));
566 prl(createEndVar());
567 break;
568 }
569
570 case pop: {
571 prl(createPopEStack());
572 break;
573 }
574
575 case jmp: {
576 prl("CALL a" + (mjInput.getCounter() + mjInput.get2()) + ";");
577 break;
578 }
579
580 case jeq:
581 case jne:
582 case jlt:
583 case jle:
584 case jgt:
585 case jge: {
586 prl(createStartVar("tempa", "tempb"));
587 prl(createTopTwoEStack());
588 prl("IF tempb " + mjInput.getRelationFor(op)
589 + " tempa THEN mjvm_flag_jump := 1"
590 + " ELSE mjvm_flag_jump := 0"
591 + " FI;");
592 prl(createEndVar());
593 prl("IF mjvm_flag_jump = 1 THEN CALL a"
594 + (mjInput.getCounter() + mjInput.get2())
595 + " ELSE CALL a" + (mjInput.getCounter() + 1)
596 + " FI;");
597
598 break;
599 }
600
601 case call: {
602 prl("CALL a" + (mjInput.getCounter() + mjInput.get2()) + ";");
603 break;
604 }
605
606 case return_: {
607 // we let the actions return
608 // there is nothing to clean up
609 prl("SKIP\n END\n b" + mjInput.getCounter() + " ==");
610 break;
611 }
612 case enter: {
613 int parameters = mjInput.get();
614
615 int locals = mjInput.get();
616 prl(createToMStack("mjvm_locals"));
617 prl("mjvm_locals := ARRAY(" + locals + ",0);");
618 for (int i = parameters - 1; i >= 0; i--)
619 prl(createFromEStack(createLocal(i)));
620 break;
621 }
622 case exit: {
623 prl(createFromMStack("mjvm_locals"));
624 break;
625 }
626
627 // read, print
628 case bread: {
629 // TODO make it a char for read
630 messages.message("char is read like a number", TransMessages.M_WAR);
631 prl(createComment("char is read like a number", C_SPEC));
632 }
633 case read: {
634 prl(createStartVar("tempa"));
635 prl("tempa := @String_To_Num(@Read_Line(Standard_Input_Port));");
636 prl(createToEStack("tempa"));
637 prl(createEndVar());
638 break;
639 }
640
641 // the prints
642 case bprint: {
643 prl(createStartVar("tempa", "tempb"));
644 prl(createTopTwoEStack());
645 if (genInlinePrint){
646 prl(createComment("print spacing and transformation",C_SPEC));
647 prl("PRINFLUSH(SUBSTR(\" \", 0, MIN(10, MAX(0,tempa-1))), @List_To_String(< tempb >));");
648 } else
649 prl("Print_MJ_CHAR(tempb,tempa);");
650 prl(createEndVar());
651 break;
652 }
653 case print: {
654 // TODO printing numbers needs different lengths of spacing
655 prl(createStartVar("tempa", "tempb"));
656
657 prl(createTopTwoEStack());
658 if (genInlinePrint){
659 prl(createComment("print spacing",C_SPEC));
660 prl("PRINFLUSH(SUBSTR(\" \", 0, MIN(10, MAX(0, tempa-SLENGTH(@String(tempb))))), tempb);");
661 }
662 else
663 prl("Print_MJ(tempb,tempa);");
664 prl(createEndVar());
665 break;
666 }
667
668 case trap: {
669 prl("ERROR(\"Runtime error: trap(" + mjInput.get() + ")\");");
670 break;
671 }
672
673 default:
674 prl(createComment("unknown op error: " + op, C_ERR));
675 messages.message("unknown op error: " + op, TransMessages.M_ERR);
676 break;
677 }
678
679 boolean wasJump = mjInput.isJumpCode(op);
680 op = mjInput.get();
681 if (op >= 0)
682 if (wasJump)
683 prl("SKIP\n END");
684 else
685 prl("CALL a" + mjInput.getCounter() + "\n END");
686 }
687 prl("SKIP\n END\nENDACTIONS;\n");
688 pr(createStandardEnd());
689 }
690
691 public void convertFile(File f) {
692 try {
693 convertStream(new FileInputStream(f));
694 } catch (Exception ex) {
695 ex.printStackTrace();
696 }
697 }
698
699 public void printHelp() {
700 printVersion();
701 printUsage();
702 printHelpOutput();
703 printHelpHelp();
704 }
705
706 public void printLongHelp() {
707 printVersion();
708 printUsage();
709 System.out.println();
710 printHelpOutput();
711 System.out.println();
712 printHelpDirectives();
713 System.out.println();
714 printHelpGenerating();
715 System.out.println();
716 printHelpHelp();
717 }
718
719 public void printHelpOutput() {
720 System.out.println("Output options:");
721 System.out.println(" --screen print output to screen");
722 System.out.println(" -o --oc[+-] include original code in comments");
723 System.out.println(" -v verbose, print warning messages");
724 System.out.println(" -q quiet; don't print even the error messages");
725 System.out.println(" -d print detailed debug messages");
726 }
727
728 public void printHelpGenerating() {
729 System.out.println("Options for generating extra code for tracking code execution");
730 System.out.println(" --genEStackPrint generate print for all EStack changes");
731 System.out.println(" --genAddrPrint generate prints after every address of the original code ");
732 System.out.println(" --genAddrPause generate a pause after every address of the original code ");
733 System.out.println(" --genAddr short for --genAddrPrint and --genAddrPause");
734 System.out.println(" --genAll short for applying all code generation");
735 }
736
737 public void printHelpDirectives(){
738 System.out.println("Alternatives for code generation:");
739 System.out.println(" --genPopPush generate POP/PUSH instead of TAIL/HEAD");
740 System.out.println(" --genHeadTail generate TAIL/HEAD instead of POP/PUSH ");
741 System.out.println();
742 System.out.println(" --genInlinePrint generate prints directly instead of procedure calls");
743 System.out.println(" --genProcedurePrint generate prints as custom procedure calls");
744 }
745
746 public void printHelpHelp() {
747 System.out.println("Help and info options");
748 System.out.println(" -h basic help");
749 System.out.println(" --help print more detailed help");
750 System.out.println(" --version or -version print version and exit");
751 }
752
753 public void printUsage(){
754 System.out.println("usage:\n\t mjc2wsl {options} filename [outfile]");
755 }
756
757 public void printVersion() {
758 System.out.println("MicroJava bytecode to WSL converter. v " + getVersion()
759 + ", by Doni Pracner");
760 }
761
762 public String makeDefaultOutName(String inname){
763 String rez = inname;
764 if (inname.endsWith(".obj"))
765 rez = rez.substring(0, rez.length() - 4);
766 return rez + ".wsl";
767 }
768
769 public void run(String[] args) {
770 if (args.length == 0) {
771 printHelp();
772 } else {
773 int i = 0;
774 while (i < args.length && args[i].charAt(0) == '-') {
775 if (args[i].compareTo("-h") == 0) {
776 printHelp();
777 return;
778 } else if (args[i].compareTo("--help") == 0) {
779 printLongHelp();
780 return;
781 } else if (args[i].compareTo("--version") == 0
782 || args[i].compareTo("-version") == 0) {
783 printVersion();
784 return;
785 } else if (args[i].compareTo("-o") == 0
786 || args[i].startsWith("--oc")) {
787 if (args[i].length() == 2)
788 originalInComments = true;
789 else if (args[i].length() == 5)
790 originalInComments = args[i].charAt(4) == '+';
791 else
792 originalInComments = true;
793 } else if (args[i].compareTo("--screen") == 0) {
794 out = new PrintWriter(System.out);
795 } else if (args[i].compareTo("-d") == 0) {
796 messages.setPrintLevel(TransMessages.M_DEB);// print debug info
797 } else if (args[i].compareTo("-v") == 0) {
798 messages.setPrintLevel(TransMessages.M_WAR);// print warnings
799 } else if (args[i].compareTo("-q") == 0) {
800 messages.setPrintLevel(TransMessages.M_QUIET);// no printing
801 } else if (args[i].compareToIgnoreCase("--genEStackPrint") == 0) {
802 genPrintEStackOnChange = true;
803 } else if (args[i].compareToIgnoreCase("--genAddrPause") == 0) {
804 genPauseAfterEachAddress = true;
805 } else if (args[i].compareToIgnoreCase("--genAddrPrint") == 0) {
806 genPrintForEachAddress = true;
807 } else if (args[i].compareToIgnoreCase("--genAddr") == 0) {
808 genPrintForEachAddress = true;
809 genPauseAfterEachAddress = true;
810 } else if (args[i].compareToIgnoreCase("--genAll") == 0) {
811 genPrintEStackOnChange = true;
812 genPrintForEachAddress = true;
813 genPauseAfterEachAddress = true;
814 } else if (args[i].compareToIgnoreCase("--genPopPush") == 0) {
815 genPopPush = true;
816 } else if (args[i].compareToIgnoreCase("--genInlinePrint") == 0) {
817 genInlinePrint = true;
818 } else if (args[i].compareToIgnoreCase("--genHeadTail") == 0) {
819 genPopPush = false;
820 } else if (args[i].compareToIgnoreCase("--genProcedurePrint") == 0) {
821 genInlinePrint = false;
822 }
823 i++;
824 }
825
826 if (i >= args.length) {
827 System.out.println("no filename supplied");
828 System.exit(2);
829 }
830 File f = new File(args[i]);
831
832 if (i + 1 < args.length) {
833 try {
834 out = new PrintWriter(args[i + 1]);
835 } catch (Exception e) {
836 System.err.println("error in opening out file:");
837 e.printStackTrace();
838 }
839 }
840 if (out == null) {
841 // if not set to screen, or a file, make a default filename
842 try {
843 out = new PrintWriter(makeDefaultOutName(args[i]));
844 } catch (Exception e) {
845 System.err.println("error in opening out file:");
846 e.printStackTrace();
847 }
848 }
849 if (f.exists()) {
850 Calendar now = Calendar.getInstance();
851 convertFile(f);
852 long mili = Calendar.getInstance().getTimeInMillis()
853 - now.getTimeInMillis();
854 System.out.println("conversion time:" + mili + " ms");
855 messages.printMessageCounters();
856 out.close();
857 } else
858 System.out.println("file does not exist");
859 }
860 }
861
862 public static void main(String[] args) {
863 new mjc2wsl().run(args);
864 }
865
866
867 }
MicroJava ByteCode to WSL tool
Svarog.pmf.uns.ac.rs/gitweb maintanance Doni Pracner