1
2 package net.sf.zel.vm;
3
4 import java.util.*;
5 import net.sf.zel.instr.*;
6 import net.sf.zel.nr.*;
7 import net.sf.zel.math.*;
8 import java.math.*;
9
10 public class ZCompiler implements ZCompilerConstants {
11
12 private StackedMap symbolTable = new StackedMap();
13
14
15 public static void compile(String xpr, ParsingContext context, String[] varNames) throws ParseException
16 {
17 ZCompiler parser = new ZCompiler(new java.io.ByteArrayInputStream(xpr.getBytes()));
18 if (varNames != null)
19 {
20 for (int i=0 ; i<varNames.length; i++)
21 parser.symbolTable.put(varNames[i], i);
22 }
23 parser.program(context);
24 }
25
26 public static List getReference(String variable) throws ParseException
27 {
28 ZCompiler parser = new ZCompiler(new java.io.ByteArrayInputStream(variable.getBytes()));
29 return parser.variable(NullParsingContext.instance);
30 }
31
32 public static Object getConstant(String constant, ExtendedMathContext mc) throws ParseException
33 {
34 ZCompiler parser = new ZCompiler(new java.io.ByteArrayInputStream(constant.getBytes()));
35 ConstantParsingContext ctx = new ConstantParsingContext(mc);
36 parser.constant(ctx);
37 return ctx.getConstant();
38 }
39
40 public static Object getConstant(String constant) throws ParseException
41 {
42 return getConstant(constant, ExtendedMathContext.CURRENT_EXTENDED_MATH_CONTEXT.get());
43 }
44
45 final public void program(ParsingContext context) throws ParseException {
46 label_1:
47 while (true) {
48 switch (jj_nt.kind) {
49 case MINUS:
50 case NOT:
51 case LPAREN:
52 case CONTEXT:
53 case RETURN:
54 case PRINT:
55 case GLOBAL:
56 case LAMBDA:
57 case GLOBVARMARKER:
58 case ARG:
59 case TRUE:
60 case FALSE:
61 case NULL:
62 case INTEGER:
63 case FLOATING_POINT:
64 case CHARACTER:
65 case STRING:
66 case MATCHEXP:
67 case ID:
68 switch (jj_nt.kind) {
69 case CONTEXT:
70 context(context);
71 break;
72 case PRINT:
73 print(context);
74 break;
75 case MINUS:
76 case NOT:
77 case LPAREN:
78 case RETURN:
79 case GLOBAL:
80 case LAMBDA:
81 case GLOBVARMARKER:
82 case ARG:
83 case TRUE:
84 case FALSE:
85 case NULL:
86 case INTEGER:
87 case FLOATING_POINT:
88 case CHARACTER:
89 case STRING:
90 case MATCHEXP:
91 case ID:
92 zreturn(context);
93 break;
94 default:
95 jj_la1[0] = jj_gen;
96 jj_consume_token(-1);
97 throw new ParseException();
98 }
99 jj_consume_token(SCL);
100 break;
101 case LBRACE:
102 programBlock(context);
103 break;
104 default:
105 jj_la1[1] = jj_gen;
106 jj_consume_token(-1);
107 throw new ParseException();
108 }
109 switch (jj_nt.kind) {
110 case MINUS:
111 case NOT:
112 case LPAREN:
113 case LBRACE:
114 case CONTEXT:
115 case RETURN:
116 case PRINT:
117 case GLOBAL:
118 case LAMBDA:
119 case GLOBVARMARKER:
120 case ARG:
121 case TRUE:
122 case FALSE:
123 case NULL:
124 case INTEGER:
125 case FLOATING_POINT:
126 case CHARACTER:
127 case STRING:
128 case MATCHEXP:
129 case ID:
130 ;
131 break;
132 default:
133 jj_la1[2] = jj_gen;
134 break label_1;
135 }
136 }
137 context.generateCode(net.sf.zel.instr.HALT.instance);
138 }
139
140 final public void programBlock(ParsingContext context) throws ParseException {
141 jj_consume_token(LBRACE);
142 label_2:
143 while (true) {
144 program(context);
145 switch (jj_nt.kind) {
146 case MINUS:
147 case NOT:
148 case LPAREN:
149 case LBRACE:
150 case CONTEXT:
151 case RETURN:
152 case PRINT:
153 case GLOBAL:
154 case LAMBDA:
155 case GLOBVARMARKER:
156 case ARG:
157 case TRUE:
158 case FALSE:
159 case NULL:
160 case INTEGER:
161 case FLOATING_POINT:
162 case CHARACTER:
163 case STRING:
164 case MATCHEXP:
165 case ID:
166 ;
167 break;
168 default:
169 jj_la1[3] = jj_gen;
170 break label_2;
171 }
172 }
173 jj_consume_token(RBRACE);
174 }
175
176
177
178
179 final public void context(ParsingContext context) throws ParseException {
180 List var = null;
181 jj_consume_token(CONTEXT);
182 switch (jj_nt.kind) {
183 case GLOBAL:
184 case GLOBVARMARKER:
185 case MATCHEXP:
186 case ID:
187 var = variable(context);
188 break;
189 default:
190 jj_la1[4] = jj_gen;
191 ;
192 }
193 changeCTX(var, context);
194 }
195
196 final public void print(ParsingContext context) throws ParseException {
197 List var = null;
198 jj_consume_token(PRINT);
199 expression(context);
200 context.generateCode(net.sf.zel.instr.OUT.instance);
201 }
202
203
204
205
206 final public void zreturn(ParsingContext context) throws ParseException {
207 switch (jj_nt.kind) {
208 case RETURN:
209 jj_consume_token(RETURN);
210 break;
211 default:
212 jj_la1[5] = jj_gen;
213 ;
214 }
215 expression(context);
216 }
217
218
219
220
221 final public List variable(ParsingContext context) throws ParseException {
222 List var= new ArrayList();
223 List tmp = null;
224 switch (jj_nt.kind) {
225 case GLOBVARMARKER:
226 jj_consume_token(GLOBVARMARKER);
227 break;
228 default:
229 jj_la1[6] = jj_gen;
230 ;
231 }
232 switch (jj_nt.kind) {
233 case GLOBAL:
234 jj_consume_token(GLOBAL);
235 var.add(token.image);
236 switch (jj_nt.kind) {
237 case DOT:
238 jj_consume_token(DOT);
239 tmp = rec_variable(context);
240 var.addAll(tmp);
241 break;
242 default:
243 jj_la1[7] = jj_gen;
244 ;
245 }
246 break;
247 case MATCHEXP:
248 case ID:
249 tmp = rec_variable(context);
250 var = tmp;
251 break;
252 default:
253 jj_la1[8] = jj_gen;
254 jj_consume_token(-1);
255 throw new ParseException();
256 }
257 {if (true) return var;}
258 throw new Error("Missing return statement in function");
259 }
260
261
262
263
264 final public List rec_variable(final ParsingContext context) throws ParseException {
265 String name;
266 List var= new ArrayList();
267 List rest = null;
268 Object index = null;
269 switch (jj_nt.kind) {
270 case ID:
271 jj_consume_token(ID);
272 name = token.image;
273 var.add(name);
274 break;
275 case MATCHEXP:
276 jj_consume_token(MATCHEXP);
277 String rExp = token.image.substring(1, token.image.length()-1);
278 var.add (new WildCardMatcher(rExp));
279 break;
280 default:
281 jj_la1[9] = jj_gen;
282 jj_consume_token(-1);
283 throw new ParseException();
284 }
285 switch (jj_nt.kind) {
286 case LBRACKET:
287 jj_consume_token(LBRACKET);
288 if (jj_2_1(2)) {
289 jj_consume_token(INTEGER);
290 var.add(parseInteger(token.image));
291 } else {
292 switch (jj_nt.kind) {
293 case STRING:
294 jj_consume_token(STRING);
295 var.add(token.image.substring(1, token.image.length()-1));
296 break;
297 case MATCHEXP:
298 jj_consume_token(MATCHEXP);
299 String rExp = token.image.substring(1, token.image.length()-1);
300 var.add (new WildCardMatcher(rExp));
301 break;
302 case MINUS:
303 case NOT:
304 case LPAREN:
305 case GLOBAL:
306 case LAMBDA:
307 case GLOBVARMARKER:
308 case ARG:
309 case TRUE:
310 case FALSE:
311 case NULL:
312 case INTEGER:
313 case FLOATING_POINT:
314 case CHARACTER:
315 case ID:
316 TmpParsingContext tmpContext = new TmpParsingContext(context);
317 expression(tmpContext);
318 var.add(tmpContext);
319 break;
320 default:
321 jj_la1[10] = jj_gen;
322 jj_consume_token(-1);
323 throw new ParseException();
324 }
325 }
326 jj_consume_token(RBRACKET);
327 break;
328 default:
329 jj_la1[11] = jj_gen;
330 ;
331 }
332 switch (jj_nt.kind) {
333 case DOT:
334 jj_consume_token(DOT);
335 rest = variable(context);
336 var.addAll(rest);
337 break;
338 default:
339 jj_la1[12] = jj_gen;
340 ;
341 }
342 {if (true) return var;}
343 throw new Error("Missing return statement in function");
344 }
345
346 void lodVariable(List var,ParsingContext context) throws ParseException {
347 context.generateCode(net.sf.zel.instr.CPUSH.instance);
348 Iterator i = var.iterator();
349 Object item = i.next();
350 if (item.equals("global"))
351 {
352 context.generateCode(net.sf.zel.instr.CTXG.instance);
353 if (i.hasNext()) item=i.next();
354 context.generateCode(net.sf.zel.instr.LODX.instance, item);
355 }
356 else
357 context.generateCode(net.sf.zel.instr.LODX.instance, item);
358 for (; i.hasNext(); )
359 {
360 context.generateCode(net.sf.zel.instr.CTX.instance);
361 item = i.next();
362 if (item instanceof ParsingContext)
363 {
364 context.generateCode(net.sf.zel.instr.CTXCHG.instance);
365 context.generateCodeAll( ((ParsingContext) item));
366 context.generateCode(net.sf.zel.instr.CTXCHG.instance);
367 context.generateCode(net.sf.zel.instr.LODR.instance );
368 }
369 else
370 context.generateCode(net.sf.zel.instr.LODX.instance, item);
371 }
372 context.generateCode(net.sf.zel.instr.CPOP.instance);
373 }
374
375 void movVariable(List var, ParsingContext context) throws ParseException {
376 context.generateCode(net.sf.zel.instr.CPUSH.instance);
377 Iterator i = var.iterator();
378 Object item = i.next();
379
380 if (item.equals("global"))
381 {
382 context.generateCode(net.sf.zel.instr.CTXG.instance);
383 if (i.hasNext()) item=i.next();
384 if (i.hasNext())
385 {
386 if (item instanceof ParsingContext)
387 {
388 context.generateCode(net.sf.zel.instr.CTXCHG.instance);
389 context.generateCodeAll( ((ParsingContext) item));
390 context.generateCode(net.sf.zel.instr.CTXCHG.instance);
391 context.generateCode(net.sf.zel.instr.ALSC.instance);
392 }
393 else
394 context.generateCode(net.sf.zel.instr.LODXC.instance, item);
395 }
396 else
397 {
398 if (item instanceof ParsingContext)
399 {
400 context.generateCode(net.sf.zel.instr.CTXCHG.instance);
401 context.generateCodeAll( ((ParsingContext) item));
402 context.generateCode(net.sf.zel.instr.CTXCHG.instance);
403 context.generateCode(net.sf.zel.instr.MOVX.instance);
404 }
405 else
406 context.generateCode(net.sf.zel.instr.MOV.instance, item);
407 }
408 }
409 else
410 {
411 if (i.hasNext())
412 {
413 if (item instanceof ParsingContext)
414 {
415 context.generateCode(net.sf.zel.instr.CTXCHG.instance);
416 context.generateCodeAll( ((ParsingContext) item));
417 context.generateCode(net.sf.zel.instr.CTXCHG.instance);
418 context.generateCode(net.sf.zel.instr.ALSC.instance);
419 }
420 else
421 context.generateCode(net.sf.zel.instr.LODXC.instance, item);
422 }
423 else
424 {
425 if (item instanceof ParsingContext)
426 {
427 context.generateCode(net.sf.zel.instr.CTXCHG.instance);
428 context.generateCodeAll( ((ParsingContext) item));
429 context.generateCode(net.sf.zel.instr.CTXCHG.instance);
430 context.generateCode(net.sf.zel.instr.MOVX.instance);
431 }
432 else
433 context.generateCode(net.sf.zel.instr.MOV.instance, item);
434 }
435 }
436 for (; i.hasNext(); )
437 {
438 context.generateCode(net.sf.zel.instr.CTX.instance);
439 item = i.next();
440 if (i.hasNext())
441 {
442 if (item instanceof ParsingContext)
443 {
444 context.generateCode(net.sf.zel.instr.CTXCHG.instance);
445 context.generateCodeAll( ((ParsingContext) item));
446 context.generateCode(net.sf.zel.instr.CTXCHG.instance);
447 context.generateCode(net.sf.zel.instr.ALSC.instance);
448 }
449 else
450 context.generateCode(net.sf.zel.instr.LODXC.instance, item);
451 }
452 else
453 {
454 if (item instanceof ParsingContext)
455 {
456 context.generateCode(net.sf.zel.instr.CTXCHG.instance);
457 context.generateCodeAll( ((ParsingContext) item));
458 context.generateCode(net.sf.zel.instr.CTXCHG.instance);
459 context.generateCode(net.sf.zel.instr.MOVX.instance);
460 }
461 else
462 context.generateCode(net.sf.zel.instr.MOV.instance, item);
463 }
464 }
465 context.generateCode(net.sf.zel.instr.CPOP.instance);
466 }
467
468 void changeCTX(List var, ParsingContext context) throws ParseException {
469 Iterator i = var.iterator();
470 Object item = i.next();
471
472 if (item.equals("global"))
473 {
474 context.generateCode(net.sf.zel.instr.CTXG.instance);
475 if (i.hasNext()) item=i.next();
476 context.generateCode(net.sf.zel.instr.LODX.instance, item);
477 }
478 else
479 context.generateCode(net.sf.zel.instr.LODX.instance, item);
480 for (; i.hasNext(); )
481 {
482 context.generateCode(net.sf.zel.instr.CTX.instance);
483 item = i.next();
484 if (item instanceof ParsingContext)
485 {
486 context.generateCode(net.sf.zel.instr.CTXCHG.instance);
487 context.generateCodeAll( ((ParsingContext) item));
488 context.generateCode(net.sf.zel.instr.CTXCHG.instance);
489 context.generateCode(net.sf.zel.instr.LODR.instance);
490 }
491 else
492 context.generateCode(net.sf.zel.instr.LODX.instance, item);
493 }
494 context.generateCode(net.sf.zel.instr.CTX.instance);
495 }
496
497 final public void expression(ParsingContext context) throws ParseException {
498 ternary(context);
499 }
500
501 final public void ternary(ParsingContext context) throws ParseException {
502 Token x;
503 int jmp1;
504 int jmp2;
505 logical(context);
506 switch (jj_nt.kind) {
507 case CONDITION:
508 x = jj_consume_token(CONDITION);
509 jmp1=context.getAddress()+1;
510 context.generateCode(net.sf.zel.instr.COND.instance, null);
511 ternary(context);
512 jmp2 = context.getAddress()+1;
513 context.generateCode(net.sf.zel.instr.JMP.instance, null);
514 context.generateCodeAt(jmp1, new OperableInteger(context.getAddress()));
515 jj_consume_token(CLM);
516 ternary(context);
517 context.generateCodeAt(jmp2, new OperableInteger(context.getAddress()));
518 break;
519 default:
520 jj_la1[13] = jj_gen;
521 ;
522 }
523 }
524
525 final public void logical(ParsingContext context) throws ParseException {
526 Token x;
527 compare(context);
528 label_3:
529 while (true) {
530 switch (jj_nt.kind) {
531 case AND:
532 case OR:
533 case XOR:
534 ;
535 break;
536 default:
537 jj_la1[14] = jj_gen;
538 break label_3;
539 }
540 switch (jj_nt.kind) {
541 case AND:
542 x = jj_consume_token(AND);
543 break;
544 case OR:
545 x = jj_consume_token(OR);
546 break;
547 case XOR:
548 x = jj_consume_token(XOR);
549 break;
550 default:
551 jj_la1[15] = jj_gen;
552 jj_consume_token(-1);
553 throw new ParseException();
554 }
555 compare(context);
556 switch (x.kind) {
557 case AND:
558 context.generateCode(net.sf.zel.instr.AND.instance);
559 break;
560 case OR:
561 context.generateCode(net.sf.zel.instr.OR.instance);
562 break;
563 case XOR:
564 context.generateCode(net.sf.zel.instr.XOR.instance);
565 break;
566 }
567 }
568 }
569
570 final public void compare(ParsingContext context) throws ParseException {
571 Token x;
572 sum(context);
573 label_4:
574 while (true) {
575 switch (jj_nt.kind) {
576 case GT:
577 case LT:
578 case LE:
579 case GE:
580 case EQ:
581 case NEQ:
582 ;
583 break;
584 default:
585 jj_la1[16] = jj_gen;
586 break label_4;
587 }
588 switch (jj_nt.kind) {
589 case GT:
590 x = jj_consume_token(GT);
591 break;
592 case LT:
593 x = jj_consume_token(LT);
594 break;
595 case GE:
596 x = jj_consume_token(GE);
597 break;
598 case LE:
599 x = jj_consume_token(LE);
600 break;
601 case EQ:
602 x = jj_consume_token(EQ);
603 break;
604 case NEQ:
605 x = jj_consume_token(NEQ);
606 break;
607 default:
608 jj_la1[17] = jj_gen;
609 jj_consume_token(-1);
610 throw new ParseException();
611 }
612 sum(context);
613 switch (x.kind) {
614 case GT:
615 context.generateCode(net.sf.zel.instr.GT.instance);
616 break;
617 case LT:
618 context.generateCode(net.sf.zel.instr.LT.instance);
619 break;
620 case GE:
621 context.generateCode(net.sf.zel.instr.GE.instance);
622 break;
623 case LE:
624 context.generateCode(net.sf.zel.instr.LE.instance);
625 break;
626 case EQ:
627 context.generateCode(net.sf.zel.instr.EQ.instance);
628 break;
629 case NEQ:
630 context.generateCode(net.sf.zel.instr.NEQ.instance);
631 break;
632
633 }
634 }
635 }
636
637 final public void sum(ParsingContext context) throws ParseException {
638 Token x;
639 term(context);
640 label_5:
641 while (true) {
642 switch (jj_nt.kind) {
643 case PLUS:
644 case MINUS:
645 ;
646 break;
647 default:
648 jj_la1[18] = jj_gen;
649 break label_5;
650 }
651 switch (jj_nt.kind) {
652 case PLUS:
653 x = jj_consume_token(PLUS);
654 break;
655 case MINUS:
656 x = jj_consume_token(MINUS);
657 break;
658 default:
659 jj_la1[19] = jj_gen;
660 jj_consume_token(-1);
661 throw new ParseException();
662 }
663 term(context);
664 if ( x.kind == PLUS )
665 context.generateCode(net.sf.zel.instr.ADD.instance);
666 else
667 context.generateCode(net.sf.zel.instr.SUB.instance);
668 }
669 }
670
671 final public void term(ParsingContext context) throws ParseException {
672 Token x;
673 exp(context);
674 label_6:
675 while (true) {
676 switch (jj_nt.kind) {
677 case MULTIPLY:
678 case DIVIDE:
679 case MOD:
680 ;
681 break;
682 default:
683 jj_la1[20] = jj_gen;
684 break label_6;
685 }
686 switch (jj_nt.kind) {
687 case MULTIPLY:
688 x = jj_consume_token(MULTIPLY);
689 break;
690 case DIVIDE:
691 x = jj_consume_token(DIVIDE);
692 break;
693 case MOD:
694 x = jj_consume_token(MOD);
695 break;
696 default:
697 jj_la1[21] = jj_gen;
698 jj_consume_token(-1);
699 throw new ParseException();
700 }
701 exp(context);
702 if ( x.kind == MULTIPLY )
703 context.generateCode(net.sf.zel.instr.MUL.instance);
704 else if ( x.kind == DIVIDE )
705 context.generateCode(net.sf.zel.instr.DIV.instance);
706 else context.generateCode(net.sf.zel.instr.MOD.instance);
707 }
708 }
709
710 final public void exp(ParsingContext context) throws ParseException {
711 unary(context);
712 label_7:
713 while (true) {
714 if (jj_2_2(2147483647)) {
715 ;
716 } else {
717 break label_7;
718 }
719 jj_consume_token(POW);
720 exp(context);
721 context.generateCode(net.sf.zel.instr.POW.instance);
722 }
723 }
724
725 final public void unary(ParsingContext context) throws ParseException {
726 Token x;
727 switch (jj_nt.kind) {
728 case MINUS:
729 case NOT:
730 switch (jj_nt.kind) {
731 case MINUS:
732 x = jj_consume_token(MINUS);
733 break;
734 case NOT:
735 x = jj_consume_token(NOT);
736 break;
737 default:
738 jj_la1[22] = jj_gen;
739 jj_consume_token(-1);
740 throw new ParseException();
741 }
742 element(context);
743 if ( x.kind == MINUS )
744 {
745 context.generateCode(new OperableInteger(-1));
746 context.generateCode(net.sf.zel.instr.MUL.instance);
747 }
748 else
749 {
750 context.generateCode(net.sf.zel.instr.NOT.instance);
751 }
752 break;
753 case LPAREN:
754 case GLOBAL:
755 case LAMBDA:
756 case GLOBVARMARKER:
757 case ARG:
758 case TRUE:
759 case FALSE:
760 case NULL:
761 case INTEGER:
762 case FLOATING_POINT:
763 case CHARACTER:
764 case STRING:
765 case MATCHEXP:
766 case ID:
767 element(context);
768 break;
769 default:
770 jj_la1[23] = jj_gen;
771 jj_consume_token(-1);
772 throw new ParseException();
773 }
774 }
775
776 final public void element(ParsingContext context) throws ParseException {
777 Instruction i = null;
778 String funcName = null;
779 switch (jj_nt.kind) {
780 case TRUE:
781 case FALSE:
782 case NULL:
783 case INTEGER:
784 case FLOATING_POINT:
785 case CHARACTER:
786 case STRING:
787 case MATCHEXP:
788 constant(context);
789 break;
790 case LAMBDA:
791 case ARG:
792 sysFunction(context);
793 break;
794 case GLOBAL:
795 case GLOBVARMARKER:
796 case ID:
797 aVariable(context);
798 break;
799 case LPAREN:
800 jj_consume_token(LPAREN);
801 expression(context);
802 jj_consume_token(RPAREN);
803 break;
804 default:
805 jj_la1[24] = jj_gen;
806 jj_consume_token(-1);
807 throw new ParseException();
808 }
809 }
810
811
812
813
814 final public void aVariable(ParsingContext context) throws ParseException {
815 boolean isFunction = false;
816 boolean isFunctionAssign = false;
817 List var = null;
818 var = variable(context);
819 switch (jj_nt.kind) {
820 case EQUAL:
821 case LPAREN:
822 switch (jj_nt.kind) {
823 case LPAREN:
824 jj_consume_token(LPAREN);
825 context.generateCode(EndParamMarker.instance); isFunction = true;
826 switch (jj_nt.kind) {
827 case MINUS:
828 case NOT:
829 case LPAREN:
830 case GLOBAL:
831 case LAMBDA:
832 case GLOBVARMARKER:
833 case ARG:
834 case TRUE:
835 case FALSE:
836 case NULL:
837 case INTEGER:
838 case FLOATING_POINT:
839 case CHARACTER:
840 case STRING:
841 case MATCHEXP:
842 case ID:
843 expression(context);
844 label_8:
845 while (true) {
846 switch (jj_nt.kind) {
847 case COMMA:
848 ;
849 break;
850 default:
851 jj_la1[25] = jj_gen;
852 break label_8;
853 }
854 jj_consume_token(COMMA);
855 expression(context);
856 }
857 break;
858 default:
859 jj_la1[26] = jj_gen;
860 ;
861 }
862 jj_consume_token(RPAREN);
863 switch (jj_nt.kind) {
864 case EQUAL:
865 jj_consume_token(EQUAL);
866 ternary(context);
867 isFunctionAssign = true;
868 break;
869 default:
870 jj_la1[27] = jj_gen;
871 ;
872 }
873 break;
874 case EQUAL:
875 jj_consume_token(EQUAL);
876 ternary(context);
877 if (var != null)
878 {
879 context.generateCode(net.sf.zel.instr.DUP.instance);
880 movVariable(var, context);
881 }
882 break;
883 default:
884 jj_la1[28] = jj_gen;
885 jj_consume_token(-1);
886 throw new ParseException();
887 }
888 break;
889 default:
890 jj_la1[29] = jj_gen;
891 ;
892 }
893 if (isFunction)
894 {
895 if (isFunctionAssign)
896 {
897 context.process(var);
898 lodVariable(var,context);
899 context.generateCode(net.sf.zel.instr.CACHE.instance);
900 }
901 else
902 {
903 String instrName = ((String) var.get(0)).toUpperCase();
904 try
905 {
906 Instruction i = (Instruction) Class.forName("net.sf.zel.instr.var." + instrName ).getField("instance").get(null);
907 context.generateCode(i);
908 }
909 catch (Exception e)
910 {
911 context.process(var);
912 lodVariable(var,context);
913 context.generateCode(net.sf.zel.instr.CALL.instance);
914 }
915 }
916 }
917 else
918 {
919 Integer local = (Integer) symbolTable.get(var.get(0));
920 if (local != null)
921 {
922 {context.generateCode(local);
923 context.generateCode(net.sf.zel.instr.LODS.instance);}
924 }
925 else
926 {
927 context.process(var);
928 lodVariable(var,context);
929 }
930 }
931 }
932
933 final public void constant(ParsingContext context) throws ParseException {
934 switch (jj_nt.kind) {
935 case FLOATING_POINT:
936 jj_consume_token(FLOATING_POINT);
937 try
938 {
939 context.generateCode( context.getMathContext().createFloatOperableNumber(token.image));
940 } catch (NumberFormatException ee) {
941 {if (true) throw new ParseException(ee.toString());}
942 }
943 break;
944 case INTEGER:
945 jj_consume_token(INTEGER);
946 context.generateCode(parseInteger(token.image));
947 break;
948 case TRUE:
949 jj_consume_token(TRUE);
950 context.generateCode(Boolean.valueOf(true));
951 break;
952 case FALSE:
953 jj_consume_token(FALSE);
954 context.generateCode(Boolean.valueOf(false));
955 break;
956 case CHARACTER:
957 jj_consume_token(CHARACTER);
958 context.generateCode(token.image.substring(1, token.image.length()-1));
959 break;
960 case NULL:
961 jj_consume_token(NULL);
962 context.generateCode(null);
963 break;
964 case STRING:
965 jj_consume_token(STRING);
966 context.generateCode(token.image.substring(1, token.image.length()-1));
967 break;
968 case MATCHEXP:
969 jj_consume_token(MATCHEXP);
970 String rExp = token.image.substring(1, token.image.length()-1);
971 context.process(rExp);
972 context.generateCode(rExp);
973 break;
974 default:
975 jj_la1[30] = jj_gen;
976 jj_consume_token(-1);
977 throw new ParseException();
978 }
979 }
980
981 Number parseInteger(String intStr) throws ParseException {
982 Number obj;
983 if (intStr.endsWith("l") || intStr.endsWith("L"))
984 {
985 try
986 {
987 obj=new OperableLong(Long.decode(intStr));
988 }
989 catch(NumberFormatException ex2)
990 {
991 obj=new OperableBigInteger(new BigInteger(intStr));
992 }
993 }
994 else
995 {
996 try
997 {
998 obj=new OperableInteger(Integer.decode(intStr));
999 }
1000 catch(NumberFormatException e)
1001 {
1002 try
1003 {
1004 obj=new OperableLong(Long.decode(intStr));
1005 }
1006 catch(NumberFormatException ex2)
1007 {
1008 obj= new OperableBigInteger(new BigInteger(intStr));
1009 }
1010 }
1011 }
1012 return obj;
1013 }
1014
1015 final public void sysFunction(ParsingContext context) throws ParseException {
1016 int count = 0;
1017 symbolTable.push();
1018 Program.Type pType = Program.Type.NONDETERMINISTIC;
1019 switch (jj_nt.kind) {
1020 case LAMBDA:
1021 jj_consume_token(LAMBDA);
1022 switch (jj_nt.kind) {
1023 case DETERMINISTIC:
1024 jj_consume_token(DETERMINISTIC);
1025 pType = Program.Type.DETERMINISTIC;
1026 break;
1027 default:
1028 jj_la1[31] = jj_gen;
1029 ;
1030 }
1031 switch (jj_nt.kind) {
1032 case LPAREN:
1033 jj_consume_token(LPAREN);
1034 jj_consume_token(ID);
1035 symbolTable.put(token.image, count++);
1036 label_9:
1037 while (true) {
1038 switch (jj_nt.kind) {
1039 case COMMA:
1040 ;
1041 break;
1042 default:
1043 jj_la1[32] = jj_gen;
1044 break label_9;
1045 }
1046 jj_consume_token(COMMA);
1047 jj_consume_token(ID);
1048 symbolTable.put(token.image, count++);
1049 }
1050 jj_consume_token(RPAREN);
1051 break;
1052 default:
1053 jj_la1[33] = jj_gen;
1054 ;
1055 }
1056 ParsingContext pc = (ParsingContext) context.createSubContext();
1057 programBlock(pc);
1058 ProgramBuilder p=pc.getProgramBuilder();
1059 p.setType(pType);
1060 context.generateCode(p.toProgram());
1061 break;
1062 case ARG:
1063 jj_consume_token(ARG);
1064 jj_consume_token(LPAREN);
1065 expression(context);
1066 context.generateCode(net.sf.zel.instr.LODS.instance);
1067 jj_consume_token(RPAREN);
1068 break;
1069 default:
1070 jj_la1[34] = jj_gen;
1071 jj_consume_token(-1);
1072 throw new ParseException();
1073 }
1074 symbolTable.pop();
1075 }
1076
1077 private boolean jj_2_1(int xla) {
1078 jj_la = xla; jj_lastpos = jj_scanpos = token;
1079 try { return !jj_3_1(); }
1080 catch(LookaheadSuccess ls) { return true; }
1081 finally { jj_save(0, xla); }
1082 }
1083
1084 private boolean jj_2_2(int xla) {
1085 jj_la = xla; jj_lastpos = jj_scanpos = token;
1086 try { return !jj_3_2(); }
1087 catch(LookaheadSuccess ls) { return true; }
1088 finally { jj_save(1, xla); }
1089 }
1090
1091 private boolean jj_3_2() {
1092 if (jj_scan_token(POW)) return true;
1093 return false;
1094 }
1095
1096 private boolean jj_3_1() {
1097 if (jj_scan_token(INTEGER)) return true;
1098 return false;
1099 }
1100
1101
1102 public ZCompilerTokenManager token_source;
1103 JavaCharStream jj_input_stream;
1104
1105 public Token token;
1106
1107 public Token jj_nt;
1108 private Token jj_scanpos, jj_lastpos;
1109 private int jj_la;
1110 private int jj_gen;
1111 final private int[] jj_la1 = new int[35];
1112 static private int[] jj_la1_0;
1113 static private int[] jj_la1_1;
1114 static {
1115 jj_la1_init_0();
1116 jj_la1_init_1();
1117 }
1118 private static void jj_la1_init_0() {
1119 jj_la1_0 = new int[] {0x2100040,0xa100040,0xa100040,0xa100040,0x0,0x0,0x0,0x0,0x0,0x0,0x2100040,0x20000000,0x0,0x200000,0x81800,0x81800,0x7e000,0x7e000,0x60,0x60,0x380,0x380,0x100040,0x2100040,0x2000000,0x80000000,0x2100040,0x800000,0x2800000,0x2800000,0x0,0x0,0x80000000,0x2000000,0x0,};
1120 }
1121 private static void jj_la1_init_1() {
1122 jj_la1_1 = new int[] {0x3d1fbe,0x3d1fbe,0x3d1fbe,0x3d1fbe,0x300090,0x4,0x80,0x1,0x300010,0x300000,0x3d1fb0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3d1fb0,0x3d1fb0,0x0,0x3d1fb0,0x0,0x0,0x0,0x1d1e00,0x40,0x0,0x0,0x120,};
1123 }
1124 final private JJCalls[] jj_2_rtns = new JJCalls[2];
1125 private boolean jj_rescan = false;
1126 private int jj_gc = 0;
1127
1128
1129 public ZCompiler(java.io.InputStream stream) {
1130 this(stream, null);
1131 }
1132
1133 public ZCompiler(java.io.InputStream stream, String encoding) {
1134 try { jj_input_stream = new JavaCharStream(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
1135 token_source = new ZCompilerTokenManager(jj_input_stream);
1136 token = new Token();
1137 token.next = jj_nt = token_source.getNextToken();
1138 jj_gen = 0;
1139 for (int i = 0; i < 35; i++) jj_la1[i] = -1;
1140 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
1141 }
1142
1143
1144 public void ReInit(java.io.InputStream stream) {
1145 ReInit(stream, null);
1146 }
1147
1148 public void ReInit(java.io.InputStream stream, String encoding) {
1149 try { jj_input_stream.ReInit(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
1150 token_source.ReInit(jj_input_stream);
1151 token = new Token();
1152 token.next = jj_nt = token_source.getNextToken();
1153 jj_gen = 0;
1154 for (int i = 0; i < 35; i++) jj_la1[i] = -1;
1155 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
1156 }
1157
1158
1159 public ZCompiler(java.io.Reader stream) {
1160 jj_input_stream = new JavaCharStream(stream, 1, 1);
1161 token_source = new ZCompilerTokenManager(jj_input_stream);
1162 token = new Token();
1163 token.next = jj_nt = token_source.getNextToken();
1164 jj_gen = 0;
1165 for (int i = 0; i < 35; i++) jj_la1[i] = -1;
1166 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
1167 }
1168
1169
1170 public void ReInit(java.io.Reader stream) {
1171 jj_input_stream.ReInit(stream, 1, 1);
1172 token_source.ReInit(jj_input_stream);
1173 token = new Token();
1174 token.next = jj_nt = token_source.getNextToken();
1175 jj_gen = 0;
1176 for (int i = 0; i < 35; i++) jj_la1[i] = -1;
1177 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
1178 }
1179
1180
1181 public ZCompiler(ZCompilerTokenManager tm) {
1182 token_source = tm;
1183 token = new Token();
1184 token.next = jj_nt = token_source.getNextToken();
1185 jj_gen = 0;
1186 for (int i = 0; i < 35; i++) jj_la1[i] = -1;
1187 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
1188 }
1189
1190
1191 public void ReInit(ZCompilerTokenManager tm) {
1192 token_source = tm;
1193 token = new Token();
1194 token.next = jj_nt = token_source.getNextToken();
1195 jj_gen = 0;
1196 for (int i = 0; i < 35; i++) jj_la1[i] = -1;
1197 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
1198 }
1199
1200 private Token jj_consume_token(int kind) throws ParseException {
1201 Token oldToken = token;
1202 if ((token = jj_nt).next != null) jj_nt = jj_nt.next;
1203 else jj_nt = jj_nt.next = token_source.getNextToken();
1204 if (token.kind == kind) {
1205 jj_gen++;
1206 if (++jj_gc > 100) {
1207 jj_gc = 0;
1208 for (int i = 0; i < jj_2_rtns.length; i++) {
1209 JJCalls c = jj_2_rtns[i];
1210 while (c != null) {
1211 if (c.gen < jj_gen) c.first = null;
1212 c = c.next;
1213 }
1214 }
1215 }
1216 return token;
1217 }
1218 jj_nt = token;
1219 token = oldToken;
1220 jj_kind = kind;
1221 throw generateParseException();
1222 }
1223
1224 static private final class LookaheadSuccess extends java.lang.Error { }
1225 final private LookaheadSuccess jj_ls = new LookaheadSuccess();
1226 private boolean jj_scan_token(int kind) {
1227 if (jj_scanpos == jj_lastpos) {
1228 jj_la--;
1229 if (jj_scanpos.next == null) {
1230 jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
1231 } else {
1232 jj_lastpos = jj_scanpos = jj_scanpos.next;
1233 }
1234 } else {
1235 jj_scanpos = jj_scanpos.next;
1236 }
1237 if (jj_rescan) {
1238 int i = 0; Token tok = token;
1239 while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
1240 if (tok != null) jj_add_error_token(kind, i);
1241 }
1242 if (jj_scanpos.kind != kind) return true;
1243 if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
1244 return false;
1245 }
1246
1247
1248
1249 final public Token getNextToken() {
1250 if ((token = jj_nt).next != null) jj_nt = jj_nt.next;
1251 else jj_nt = jj_nt.next = token_source.getNextToken();
1252 jj_gen++;
1253 return token;
1254 }
1255
1256
1257 final public Token getToken(int index) {
1258 Token t = token;
1259 for (int i = 0; i < index; i++) {
1260 if (t.next != null) t = t.next;
1261 else t = t.next = token_source.getNextToken();
1262 }
1263 return t;
1264 }
1265
1266 private java.util.List jj_expentries = new java.util.ArrayList();
1267 private int[] jj_expentry;
1268 private int jj_kind = -1;
1269 private int[] jj_lasttokens = new int[100];
1270 private int jj_endpos;
1271
1272 private void jj_add_error_token(int kind, int pos) {
1273 if (pos >= 100) return;
1274 if (pos == jj_endpos + 1) {
1275 jj_lasttokens[jj_endpos++] = kind;
1276 } else if (jj_endpos != 0) {
1277 jj_expentry = new int[jj_endpos];
1278 for (int i = 0; i < jj_endpos; i++) {
1279 jj_expentry[i] = jj_lasttokens[i];
1280 }
1281 jj_entries_loop: for (java.util.Iterator it = jj_expentries.iterator(); it.hasNext();) {
1282 int[] oldentry = (int[])(it.next());
1283 if (oldentry.length == jj_expentry.length) {
1284 for (int i = 0; i < jj_expentry.length; i++) {
1285 if (oldentry[i] != jj_expentry[i]) {
1286 continue jj_entries_loop;
1287 }
1288 }
1289 jj_expentries.add(jj_expentry);
1290 break jj_entries_loop;
1291 }
1292 }
1293 if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
1294 }
1295 }
1296
1297
1298 public ParseException generateParseException() {
1299 jj_expentries.clear();
1300 boolean[] la1tokens = new boolean[56];
1301 if (jj_kind >= 0) {
1302 la1tokens[jj_kind] = true;
1303 jj_kind = -1;
1304 }
1305 for (int i = 0; i < 35; i++) {
1306 if (jj_la1[i] == jj_gen) {
1307 for (int j = 0; j < 32; j++) {
1308 if ((jj_la1_0[i] & (1<<j)) != 0) {
1309 la1tokens[j] = true;
1310 }
1311 if ((jj_la1_1[i] & (1<<j)) != 0) {
1312 la1tokens[32+j] = true;
1313 }
1314 }
1315 }
1316 }
1317 for (int i = 0; i < 56; i++) {
1318 if (la1tokens[i]) {
1319 jj_expentry = new int[1];
1320 jj_expentry[0] = i;
1321 jj_expentries.add(jj_expentry);
1322 }
1323 }
1324 jj_endpos = 0;
1325 jj_rescan_token();
1326 jj_add_error_token(0, 0);
1327 int[][] exptokseq = new int[jj_expentries.size()][];
1328 for (int i = 0; i < jj_expentries.size(); i++) {
1329 exptokseq[i] = (int[])jj_expentries.get(i);
1330 }
1331 return new ParseException(token, exptokseq, tokenImage);
1332 }
1333
1334
1335 final public void enable_tracing() {
1336 }
1337
1338
1339 final public void disable_tracing() {
1340 }
1341
1342 private void jj_rescan_token() {
1343 jj_rescan = true;
1344 for (int i = 0; i < 2; i++) {
1345 try {
1346 JJCalls p = jj_2_rtns[i];
1347 do {
1348 if (p.gen > jj_gen) {
1349 jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
1350 switch (i) {
1351 case 0: jj_3_1(); break;
1352 case 1: jj_3_2(); break;
1353 }
1354 }
1355 p = p.next;
1356 } while (p != null);
1357 } catch(LookaheadSuccess ls) { }
1358 }
1359 jj_rescan = false;
1360 }
1361
1362 private void jj_save(int index, int xla) {
1363 JJCalls p = jj_2_rtns[index];
1364 while (p.gen > jj_gen) {
1365 if (p.next == null) { p = p.next = new JJCalls(); break; }
1366 p = p.next;
1367 }
1368 p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
1369 }
1370
1371 static final class JJCalls {
1372 int gen;
1373 Token first;
1374 int arg;
1375 JJCalls next;
1376 }
1377
1378 }