gitweb on Svarog

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