gitweb on Svarog

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


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