1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25 package zeus.concepts;
26
27 import java.util.*;
28 import java.io.*;
29 import zeus.util.*;
30 import zeus.concepts.fn.*;
31
32 public class RestrictionParser implements RestrictionParserConstants {
33
34
35
36
37 final public ValueFunction StringExpression() throws ParseException {
38 ValueFunction fn = null;
39 fn = OrString();
40 jj_consume_token(0);
41 {if (true) return fn;}
42 throw new Error("Missing return statement in function");
43 }
44
45 final public ValueFunction OrString() throws ParseException {
46 ValueFunction x, y;
47 x = AndString();
48 label_1:
49 while (true) {
50 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
51 case UOR:
52 ;
53 break;
54 default:
55 jj_la1[0] = jj_gen;
56 break label_1;
57 }
58 jj_consume_token(UOR);
59 y = AndString();
60 x = new OrFn(x,y);
61 }
62 {if (true) return x;}
63 throw new Error("Missing return statement in function");
64 }
65
66 final public ValueFunction AndString() throws ParseException {
67 ValueFunction x, y;
68 x = UnaryString();
69 label_2:
70 while (true) {
71 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
72 case UAND:
73 ;
74 break;
75 default:
76 jj_la1[1] = jj_gen;
77 break label_2;
78 }
79 jj_consume_token(UAND);
80 y = UnaryString();
81 x = new AndFn(x,y);
82 }
83 {if (true) return x;}
84 throw new Error("Missing return statement in function");
85 }
86
87 final public ValueFunction UnaryString() throws ParseException {
88 Token t;
89 ValueFunction x;
90 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
91 case LE:
92 case GE:
93 case NE:
94 case GT:
95 case LT:
96 case UNOT:
97 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
98 case LE:
99 t = jj_consume_token(LE);
100 break;
101 case GE:
102 t = jj_consume_token(GE);
103 break;
104 case NE:
105 t = jj_consume_token(NE);
106 break;
107 case GT:
108 t = jj_consume_token(GT);
109 break;
110 case LT:
111 t = jj_consume_token(LT);
112 break;
113 case UNOT:
114 t = jj_consume_token(UNOT);
115 break;
116 default:
117 jj_la1[2] = jj_gen;
118 jj_consume_token(-1);
119 throw new ParseException();
120 }
121 x = UnaryString();
122 x = new ConstraintFn(t.image,x);
123 break;
124 case ID:
125 case LITERAL:
126 x = StringLiteral();
127 break;
128 case LBRACKET:
129 jj_consume_token(LBRACKET);
130 x = OrString();
131 jj_consume_token(RBRACKET);
132 break;
133 default:
134 jj_la1[3] = jj_gen;
135 jj_consume_token(-1);
136 throw new ParseException();
137 }
138 {if (true) return x;}
139 throw new Error("Missing return statement in function");
140 }
141
142 final public ValueFunction StringLiteral() throws ParseException {
143 Token t;
144 ValueFunction x = null;
145 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
146 case LITERAL:
147 t = jj_consume_token(LITERAL);
148 x = new IdFn(Misc.literalToString(t.image));
149 break;
150 default:
151 jj_la1[4] = jj_gen;
152 if (jj_2_1(2)) {
153 x = Function();
154 } else {
155 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
156 case ID:
157 t = jj_consume_token(ID);
158 x = new IdFn(t.image);
159 break;
160 default:
161 jj_la1[5] = jj_gen;
162 jj_consume_token(-1);
163 throw new ParseException();
164 }
165 }
166 }
167 {if (true) return x;}
168 throw new Error("Missing return statement in function");
169 }
170
171
172
173
174 final public ValueFunction BooleanLiteral() throws ParseException {
175 Token t;
176 ValueFunction x = null;
177 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
178 case BOOLEAN:
179 t = jj_consume_token(BOOLEAN);
180 x = BoolFn.newBoolFn(t.image);
181 break;
182 case ID:
183 x = Function();
184 break;
185 default:
186 jj_la1[6] = jj_gen;
187 jj_consume_token(-1);
188 throw new ParseException();
189 }
190 {if (true) return x;}
191 throw new Error("Missing return statement in function");
192 }
193
194
195
196
197 final public ValueFunction DateExpression() throws ParseException {
198 ValueFunction x = null;
199 x = OrDate();
200 jj_consume_token(0);
201 {if (true) return x;}
202 throw new Error("Missing return statement in function");
203 }
204
205 final public ValueFunction OrDate() throws ParseException {
206 ValueFunction x = null, y = null;
207 x = AndDate();
208 label_3:
209 while (true) {
210 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
211 case UOR:
212 ;
213 break;
214 default:
215 jj_la1[7] = jj_gen;
216 break label_3;
217 }
218 jj_consume_token(UOR);
219 y = AndDate();
220 x = new OrFn(x,y);
221 }
222 {if (true) return x;}
223 throw new Error("Missing return statement in function");
224 }
225
226 final public ValueFunction AndDate() throws ParseException {
227 ValueFunction x = null, y = null;
228 x = UnaryDate();
229 label_4:
230 while (true) {
231 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
232 case UAND:
233 ;
234 break;
235 default:
236 jj_la1[8] = jj_gen;
237 break label_4;
238 }
239 jj_consume_token(UAND);
240 y = UnaryDate();
241 x = new AndFn(x,y);
242 }
243 {if (true) return x;}
244 throw new Error("Missing return statement in function");
245 }
246
247 final public ValueFunction UnaryDate() throws ParseException {
248 Token t;
249 ValueFunction x = null;
250 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
251 case LE:
252 case GE:
253 case NE:
254 case GT:
255 case LT:
256 case UNOT:
257 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
258 case LE:
259 t = jj_consume_token(LE);
260 break;
261 case GE:
262 t = jj_consume_token(GE);
263 break;
264 case NE:
265 t = jj_consume_token(NE);
266 break;
267 case GT:
268 t = jj_consume_token(GT);
269 break;
270 case LT:
271 t = jj_consume_token(LT);
272 break;
273 case UNOT:
274 t = jj_consume_token(UNOT);
275 break;
276 default:
277 jj_la1[9] = jj_gen;
278 jj_consume_token(-1);
279 throw new ParseException();
280 }
281 x = UnaryDate();
282 x = new ConstraintFn(t.image,x);
283 break;
284 case ID:
285 case DATE:
286 x = DateLiteral();
287 break;
288 case LBRACKET:
289 jj_consume_token(LBRACKET);
290 x = OrDate();
291 jj_consume_token(RBRACKET);
292 break;
293 default:
294 jj_la1[10] = jj_gen;
295 jj_consume_token(-1);
296 throw new ParseException();
297 }
298 {if (true) return x;}
299 throw new Error("Missing return statement in function");
300 }
301
302 final public ValueFunction DateLiteral() throws ParseException {
303 Token t;
304 ValueFunction x = null;
305 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
306 case DATE:
307 t = jj_consume_token(DATE);
308 x = new DateFn(t.image);
309 break;
310 case ID:
311 x = Function();
312 break;
313 default:
314 jj_la1[11] = jj_gen;
315 jj_consume_token(-1);
316 throw new ParseException();
317 }
318 {if (true) return x;}
319 throw new Error("Missing return statement in function");
320 }
321
322
323
324
325 final public ValueFunction TimeExpression() throws ParseException {
326 ValueFunction x = null;
327 x = OrTime();
328 jj_consume_token(0);
329 {if (true) return x;}
330 throw new Error("Missing return statement in function");
331 }
332
333 final public ValueFunction OrTime() throws ParseException {
334 ValueFunction x = null, y = null;
335 x = AndTime();
336 label_5:
337 while (true) {
338 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
339 case UOR:
340 ;
341 break;
342 default:
343 jj_la1[12] = jj_gen;
344 break label_5;
345 }
346 jj_consume_token(UOR);
347 y = AndTime();
348 x = new OrFn(x,y);
349 }
350 {if (true) return x;}
351 throw new Error("Missing return statement in function");
352 }
353
354 final public ValueFunction AndTime() throws ParseException {
355 ValueFunction x = null, y = null;
356 x = UnaryTime();
357 label_6:
358 while (true) {
359 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
360 case UAND:
361 ;
362 break;
363 default:
364 jj_la1[13] = jj_gen;
365 break label_6;
366 }
367 jj_consume_token(UAND);
368 y = UnaryTime();
369 x = new AndFn(x,y);
370 }
371 {if (true) return x;}
372 throw new Error("Missing return statement in function");
373 }
374
375 final public ValueFunction UnaryTime() throws ParseException {
376 Token t;
377 ValueFunction x = null, y = null;
378 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
379 case LE:
380 case GE:
381 case NE:
382 case GT:
383 case LT:
384 case UNOT:
385 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
386 case LE:
387 t = jj_consume_token(LE);
388 break;
389 case GE:
390 t = jj_consume_token(GE);
391 break;
392 case NE:
393 t = jj_consume_token(NE);
394 break;
395 case GT:
396 t = jj_consume_token(GT);
397 break;
398 case LT:
399 t = jj_consume_token(LT);
400 break;
401 case UNOT:
402 t = jj_consume_token(UNOT);
403 break;
404 default:
405 jj_la1[14] = jj_gen;
406 jj_consume_token(-1);
407 throw new ParseException();
408 }
409 x = UnaryTime();
410 x = new ConstraintFn(t.image,x);
411 break;
412 case ID:
413 case TIME:
414 x = TimeLiteral();
415 break;
416 case LBRACKET:
417 jj_consume_token(LBRACKET);
418 x = OrTime();
419 jj_consume_token(RBRACKET);
420 break;
421 default:
422 jj_la1[15] = jj_gen;
423 jj_consume_token(-1);
424 throw new ParseException();
425 }
426 {if (true) return x;}
427 throw new Error("Missing return statement in function");
428 }
429
430 final public ValueFunction TimeLiteral() throws ParseException {
431 Token t;
432 ValueFunction x = null;
433 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
434 case TIME:
435 t = jj_consume_token(TIME);
436 x = new TimeFn(t.image);
437 break;
438 case ID:
439 x = Function();
440 break;
441 default:
442 jj_la1[16] = jj_gen;
443 jj_consume_token(-1);
444 throw new ParseException();
445 }
446 {if (true) return x;}
447 throw new Error("Missing return statement in function");
448 }
449
450
451
452
453 final public ValueFunction IntegerExpression() throws ParseException {
454 ValueFunction x = null;
455 x = OrInteger();
456 jj_consume_token(0);
457 {if (true) return x;}
458 throw new Error("Missing return statement in function");
459 }
460
461 final public ValueFunction OrInteger() throws ParseException {
462 ValueFunction x = null, y = null;
463 x = AndInteger();
464 label_7:
465 while (true) {
466 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
467 case UOR:
468 ;
469 break;
470 default:
471 jj_la1[17] = jj_gen;
472 break label_7;
473 }
474 jj_consume_token(UOR);
475 y = AndInteger();
476 x = new OrFn(x,y);
477 }
478 {if (true) return x;}
479 throw new Error("Missing return statement in function");
480 }
481
482 final public ValueFunction AndInteger() throws ParseException {
483 ValueFunction x = null, y = null;
484 x = AdditiveInteger();
485 label_8:
486 while (true) {
487 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
488 case UAND:
489 ;
490 break;
491 default:
492 jj_la1[18] = jj_gen;
493 break label_8;
494 }
495 jj_consume_token(UAND);
496 y = AdditiveInteger();
497 x = new AndFn(x,y);
498 }
499 {if (true) return x;}
500 throw new Error("Missing return statement in function");
501 }
502
503 final public ValueFunction AdditiveInteger() throws ParseException {
504 Token t;
505 ValueFunction x = null, y = null;
506 x = MultiplicativeInteger();
507 label_9:
508 while (true) {
509 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
510 case PLUS:
511 case MINUS:
512 ;
513 break;
514 default:
515 jj_la1[19] = jj_gen;
516 break label_9;
517 }
518 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
519 case PLUS:
520 t = jj_consume_token(PLUS);
521 break;
522 case MINUS:
523 t = jj_consume_token(MINUS);
524 break;
525 default:
526 jj_la1[20] = jj_gen;
527 jj_consume_token(-1);
528 throw new ParseException();
529 }
530 y = MultiplicativeInteger();
531 x = new ArithmeticFn(x,y,t.image);
532 }
533 {if (true) return x;}
534 throw new Error("Missing return statement in function");
535 }
536
537 final public ValueFunction MultiplicativeInteger() throws ParseException {
538 Token t;
539 ValueFunction x = null, y = null;
540 x = UnaryInteger();
541 label_10:
542 while (true) {
543 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
544 case MULTIPLY:
545 case DIVIDE:
546 case REMAINDER:
547 ;
548 break;
549 default:
550 jj_la1[21] = jj_gen;
551 break label_10;
552 }
553 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
554 case MULTIPLY:
555 t = jj_consume_token(MULTIPLY);
556 break;
557 case DIVIDE:
558 t = jj_consume_token(DIVIDE);
559 break;
560 case REMAINDER:
561 t = jj_consume_token(REMAINDER);
562 break;
563 default:
564 jj_la1[22] = jj_gen;
565 jj_consume_token(-1);
566 throw new ParseException();
567 }
568 y = UnaryInteger();
569 x = new ArithmeticFn(x,y,t.image);
570 }
571 {if (true) return x;}
572 throw new Error("Missing return statement in function");
573 }
574
575 final public ValueFunction UnaryInteger() throws ParseException {
576 Token t;
577 ValueFunction x = null;
578 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
579 case PLUS:
580 case MINUS:
581 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
582 case PLUS:
583 t = jj_consume_token(PLUS);
584 break;
585 case MINUS:
586 t = jj_consume_token(MINUS);
587 break;
588 default:
589 jj_la1[23] = jj_gen;
590 jj_consume_token(-1);
591 throw new ParseException();
592 }
593 x = UnaryInteger();
594 x = new ArithmeticFn(new IntFn("0"),x,t.image);
595 break;
596 case LE:
597 case GE:
598 case NE:
599 case GT:
600 case LT:
601 case UNOT:
602 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
603 case LE:
604 t = jj_consume_token(LE);
605 break;
606 case GE:
607 t = jj_consume_token(GE);
608 break;
609 case NE:
610 t = jj_consume_token(NE);
611 break;
612 case GT:
613 t = jj_consume_token(GT);
614 break;
615 case LT:
616 t = jj_consume_token(LT);
617 break;
618 case UNOT:
619 t = jj_consume_token(UNOT);
620 break;
621 default:
622 jj_la1[24] = jj_gen;
623 jj_consume_token(-1);
624 throw new ParseException();
625 }
626 x = UnaryInteger();
627 x = new ConstraintFn(t.image,x);
628 break;
629 case INTEGER:
630 t = jj_consume_token(INTEGER);
631 x = new IntFn(t.image);
632 break;
633 case LBRACKET:
634 jj_consume_token(LBRACKET);
635 x = OrInteger();
636 jj_consume_token(RBRACKET);
637 break;
638 case ID:
639 x = Function();
640 break;
641 default:
642 jj_la1[25] = jj_gen;
643 jj_consume_token(-1);
644 throw new ParseException();
645 }
646 {if (true) return x;}
647 throw new Error("Missing return statement in function");
648 }
649
650
651
652
653 final public ValueFunction RealExpression() throws ParseException {
654 ValueFunction x = null, y = null;
655 x = OrReal();
656 jj_consume_token(0);
657 {if (true) return x;}
658 throw new Error("Missing return statement in function");
659 }
660
661 final public ValueFunction OrReal() throws ParseException {
662 ValueFunction x = null, y = null;
663 x = AndReal();
664 label_11:
665 while (true) {
666 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
667 case UOR:
668 ;
669 break;
670 default:
671 jj_la1[26] = jj_gen;
672 break label_11;
673 }
674 jj_consume_token(UOR);
675 y = AndReal();
676 x = new OrFn(x,y);
677 }
678 {if (true) return x;}
679 throw new Error("Missing return statement in function");
680 }
681
682 final public ValueFunction AndReal() throws ParseException {
683 ValueFunction x = null, y = null;
684 x = AdditiveReal();
685 label_12:
686 while (true) {
687 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
688 case UAND:
689 ;
690 break;
691 default:
692 jj_la1[27] = jj_gen;
693 break label_12;
694 }
695 jj_consume_token(UAND);
696 y = AdditiveReal();
697 x = new AndFn(x,y);
698 }
699 {if (true) return x;}
700 throw new Error("Missing return statement in function");
701 }
702
703 final public ValueFunction AdditiveReal() throws ParseException {
704 Token t;
705 ValueFunction x = null, y = null;
706 x = MultiplicativeReal();
707 label_13:
708 while (true) {
709 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
710 case PLUS:
711 case MINUS:
712 ;
713 break;
714 default:
715 jj_la1[28] = jj_gen;
716 break label_13;
717 }
718 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
719 case PLUS:
720 t = jj_consume_token(PLUS);
721 break;
722 case MINUS:
723 t = jj_consume_token(MINUS);
724 break;
725 default:
726 jj_la1[29] = jj_gen;
727 jj_consume_token(-1);
728 throw new ParseException();
729 }
730 y = MultiplicativeReal();
731 x = new ArithmeticFn(x,y,t.image);
732 }
733 {if (true) return x;}
734 throw new Error("Missing return statement in function");
735 }
736
737 final public ValueFunction MultiplicativeReal() throws ParseException {
738 Token t;
739 ValueFunction x = null, y = null;
740 x = UnaryReal();
741 label_14:
742 while (true) {
743 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
744 case MULTIPLY:
745 case DIVIDE:
746 case REMAINDER:
747 ;
748 break;
749 default:
750 jj_la1[30] = jj_gen;
751 break label_14;
752 }
753 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
754 case MULTIPLY:
755 t = jj_consume_token(MULTIPLY);
756 break;
757 case DIVIDE:
758 t = jj_consume_token(DIVIDE);
759 break;
760 case REMAINDER:
761 t = jj_consume_token(REMAINDER);
762 break;
763 default:
764 jj_la1[31] = jj_gen;
765 jj_consume_token(-1);
766 throw new ParseException();
767 }
768 y = UnaryReal();
769 x = new ArithmeticFn(x,y,t.image);
770 }
771 {if (true) return x;}
772 throw new Error("Missing return statement in function");
773 }
774
775 final public ValueFunction UnaryReal() throws ParseException {
776 Token t;
777 ValueFunction x = null;
778 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
779 case PLUS:
780 case MINUS:
781 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
782 case PLUS:
783 t = jj_consume_token(PLUS);
784 break;
785 case MINUS:
786 t = jj_consume_token(MINUS);
787 break;
788 default:
789 jj_la1[32] = jj_gen;
790 jj_consume_token(-1);
791 throw new ParseException();
792 }
793 x = UnaryReal();
794 x = new ArithmeticFn(new IntFn("0"),x,t.image);
795 break;
796 case LE:
797 case GE:
798 case NE:
799 case GT:
800 case LT:
801 case UNOT:
802 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
803 case LE:
804 t = jj_consume_token(LE);
805 break;
806 case GE:
807 t = jj_consume_token(GE);
808 break;
809 case NE:
810 t = jj_consume_token(NE);
811 break;
812 case GT:
813 t = jj_consume_token(GT);
814 break;
815 case LT:
816 t = jj_consume_token(LT);
817 break;
818 case UNOT:
819 t = jj_consume_token(UNOT);
820 break;
821 default:
822 jj_la1[33] = jj_gen;
823 jj_consume_token(-1);
824 throw new ParseException();
825 }
826 x = UnaryReal();
827 x = new ConstraintFn(t.image,x);
828 break;
829 case INTEGER:
830 t = jj_consume_token(INTEGER);
831 x = new RealFn(t.image);
832 break;
833 case REAL:
834 t = jj_consume_token(REAL);
835 x = new RealFn(t.image);
836 break;
837 case LBRACKET:
838 jj_consume_token(LBRACKET);
839 x = OrReal();
840 jj_consume_token(RBRACKET);
841 break;
842 case ID:
843 x = Function();
844 break;
845 default:
846 jj_la1[34] = jj_gen;
847 jj_consume_token(-1);
848 throw new ParseException();
849 }
850 {if (true) return x;}
851 throw new Error("Missing return statement in function");
852 }
853
854
855
856
857 final public ValueFunction VectorLiteral() throws ParseException {
858 Vector data = new Vector();
859 ValueFunction x = null;
860 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
861 case LCURLY:
862 jj_consume_token(LCURLY);
863 data = ExpressionList();
864 jj_consume_token(RCURLY);
865 x = new VectorFn(data);
866 break;
867 case ID:
868 x = Function();
869 break;
870 default:
871 jj_la1[35] = jj_gen;
872 jj_consume_token(-1);
873 throw new ParseException();
874 }
875 {if (true) return x;}
876 throw new Error("Missing return statement in function");
877 }
878
879
880
881
882 final public Vector ExpressionList() throws ParseException {
883 Vector data = new Vector();
884 ValueFunction fn = null;
885 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
886 case LE:
887 case GE:
888 case NE:
889 case GT:
890 case LT:
891 case PLUS:
892 case MINUS:
893 case NOT:
894 case UNOT:
895 case LBRACKET:
896 case LCURLY:
897 case IF:
898 case ID:
899 case BOOLEAN:
900 case INTEGER:
901 case REAL:
902 case DATE:
903 case TIME:
904 case LITERAL:
905 fn = Expression();
906 data.addElement(fn);
907 label_15:
908 while (true) {
909 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
910 case COMMA:
911 ;
912 break;
913 default:
914 jj_la1[36] = jj_gen;
915 break label_15;
916 }
917 jj_consume_token(COMMA);
918 fn = Expression();
919 data.addElement(fn);
920 }
921 break;
922 default:
923 jj_la1[37] = jj_gen;
924 ;
925 }
926 {if (true) return data;}
927 throw new Error("Missing return statement in function");
928 }
929
930 final public ValueFunction Function() throws ParseException {
931 Vector data = null;
932 Token t;
933 t = jj_consume_token(ID);
934 jj_consume_token(LBRACKET);
935 data = ExpressionList();
936 jj_consume_token(RBRACKET);
937 {if (true) return new DefinedFn(t.image,data);}
938 throw new Error("Missing return statement in function");
939 }
940
941
942
943
944 final public ValueFunction Expression() throws ParseException {
945 ValueFunction fn = null;
946 fn = ConditionalOrExpression();
947 {if (true) return fn;}
948 throw new Error("Missing return statement in function");
949 }
950
951 final public ValueFunction ConditionalOrExpression() throws ParseException {
952 ValueFunction x = null, y = null;
953 x = ConditionalAndExpression();
954 label_16:
955 while (true) {
956 if (jj_2_2(2147483647)) {
957 ;
958 } else {
959 break label_16;
960 }
961 jj_consume_token(OR);
962 y = ConditionalAndExpression();
963 x = new LogicalOrFn(x,y);
964 }
965 {if (true) return x;}
966 throw new Error("Missing return statement in function");
967 }
968
969 final public ValueFunction ConditionalAndExpression() throws ParseException {
970 ValueFunction x = null, y = null;
971 x = InclusiveOrExpression();
972 label_17:
973 while (true) {
974 if (jj_2_3(2147483647)) {
975 ;
976 } else {
977 break label_17;
978 }
979 jj_consume_token(AND);
980 y = InclusiveOrExpression();
981 x = new LogicalAndFn(x,y);
982 }
983 {if (true) return x;}
984 throw new Error("Missing return statement in function");
985 }
986
987 final public ValueFunction InclusiveOrExpression() throws ParseException {
988 ValueFunction x = null, y = null;
989 x = AndExpression();
990 label_18:
991 while (true) {
992 if (jj_2_4(2147483647)) {
993 ;
994 } else {
995 break label_18;
996 }
997 jj_consume_token(UOR);
998 y = AndExpression();
999 x = new OrFn(x,y);
1000 }
1001 {if (true) return x;}
1002 throw new Error("Missing return statement in function");
1003 }
1004
1005 final public ValueFunction AndExpression() throws ParseException {
1006 ValueFunction x = null, y = null;
1007 x = RelationalExpression();
1008 label_19:
1009 while (true) {
1010 if (jj_2_5(2147483647)) {
1011 ;
1012 } else {
1013 break label_19;
1014 }
1015 jj_consume_token(UAND);
1016 y = RelationalExpression();
1017 x = new AndFn(x,y);
1018 }
1019 {if (true) return x;}
1020 throw new Error("Missing return statement in function");
1021 }
1022
1023 final public ValueFunction RelationalExpression() throws ParseException {
1024 ValueFunction x = null, y = null;
1025 Token t;
1026 x = AdditiveExpression();
1027 label_20:
1028 while (true) {
1029 if (jj_2_6(2)) {
1030 ;
1031 } else {
1032 break label_20;
1033 }
1034 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1035 case EQ:
1036 t = jj_consume_token(EQ);
1037 break;
1038 case NE:
1039 t = jj_consume_token(NE);
1040 break;
1041 case LT:
1042 t = jj_consume_token(LT);
1043 break;
1044 case GT:
1045 t = jj_consume_token(GT);
1046 break;
1047 case LE:
1048 t = jj_consume_token(LE);
1049 break;
1050 case GE:
1051 t = jj_consume_token(GE);
1052 break;
1053 default:
1054 jj_la1[38] = jj_gen;
1055 jj_consume_token(-1);
1056 throw new ParseException();
1057 }
1058 y = AdditiveExpression();
1059 x= new ComparisonFn(x,y,t.image);
1060 }
1061 {if (true) return x;}
1062 throw new Error("Missing return statement in function");
1063 }
1064
1065 final public ValueFunction AdditiveExpression() throws ParseException {
1066 ValueFunction x = null, y = null;
1067 Token t;
1068 x = MultiplicativeExpression();
1069 label_21:
1070 while (true) {
1071 if (jj_2_7(2147483647)) {
1072 ;
1073 } else {
1074 break label_21;
1075 }
1076 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1077 case PLUS:
1078 t = jj_consume_token(PLUS);
1079 break;
1080 case MINUS:
1081 t = jj_consume_token(MINUS);
1082 break;
1083 default:
1084 jj_la1[39] = jj_gen;
1085 jj_consume_token(-1);
1086 throw new ParseException();
1087 }
1088 y = MultiplicativeExpression();
1089 x = new ArithmeticFn(x,y,t.image);
1090 }
1091 {if (true) return x;}
1092 throw new Error("Missing return statement in function");
1093 }
1094
1095 final public ValueFunction MultiplicativeExpression() throws ParseException {
1096 ValueFunction x = null, y = null;
1097 Token t;
1098 x = UnaryExpression();
1099 label_22:
1100 while (true) {
1101 if (jj_2_8(2147483647)) {
1102 ;
1103 } else {
1104 break label_22;
1105 }
1106 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1107 case MULTIPLY:
1108 t = jj_consume_token(MULTIPLY);
1109 break;
1110 case DIVIDE:
1111 t = jj_consume_token(DIVIDE);
1112 break;
1113 case REMAINDER:
1114 t = jj_consume_token(REMAINDER);
1115 break;
1116 default:
1117 jj_la1[40] = jj_gen;
1118 jj_consume_token(-1);
1119 throw new ParseException();
1120 }
1121 y = UnaryExpression();
1122 x = new ArithmeticFn(x,y,t.image);
1123 }
1124 {if (true) return x;}
1125 throw new Error("Missing return statement in function");
1126 }
1127
1128 final public ValueFunction UnaryExpression() throws ParseException {
1129 ValueFunction x = null, y = null;
1130 Token t;
1131 Fact f;
1132 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1133 case PLUS:
1134 case MINUS:
1135 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1136 case PLUS:
1137 t = jj_consume_token(PLUS);
1138 break;
1139 case MINUS:
1140 t = jj_consume_token(MINUS);
1141 break;
1142 default:
1143 jj_la1[41] = jj_gen;
1144 jj_consume_token(-1);
1145 throw new ParseException();
1146 }
1147 x = UnaryExpression();
1148 x = new ArithmeticFn(new IntFn("0"),x,t.image);
1149 break;
1150 case NOT:
1151 jj_consume_token(NOT);
1152 x = UnaryExpression();
1153 x = new LogicalNotFn(x);
1154 break;
1155 case LE:
1156 case GE:
1157 case NE:
1158 case GT:
1159 case LT:
1160 case UNOT:
1161 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1162 case LE:
1163 t = jj_consume_token(LE);
1164 break;
1165 case GE:
1166 t = jj_consume_token(GE);
1167 break;
1168 case NE:
1169 t = jj_consume_token(NE);
1170 break;
1171 case GT:
1172 t = jj_consume_token(GT);
1173 break;
1174 case LT:
1175 t = jj_consume_token(LT);
1176 break;
1177 case UNOT:
1178 t = jj_consume_token(UNOT);
1179 break;
1180 default:
1181 jj_la1[42] = jj_gen;
1182 jj_consume_token(-1);
1183 throw new ParseException();
1184 }
1185 x = UnaryExpression();
1186 x = new ConstraintFn(t.image,x);
1187 break;
1188 case LCURLY:
1189 case ID:
1190 case BOOLEAN:
1191 case INTEGER:
1192 case REAL:
1193 case DATE:
1194 case TIME:
1195 case LITERAL:
1196 x = Literal();
1197 break;
1198 case IF:
1199 jj_consume_token(IF);
1200 x = ConditionalOrExpression();
1201 jj_consume_token(THEN);
1202 y = Expression();
1203 x = new ImplyFn(x,y);
1204 if (jj_2_9(2147483647)) {
1205 jj_consume_token(ELSE);
1206 y = Expression();
1207 x = new ElseFn(x,y);
1208 } else {
1209 ;
1210 }
1211 break;
1212 case LBRACKET:
1213 jj_consume_token(LBRACKET);
1214 x = Expression();
1215 jj_consume_token(RBRACKET);
1216 break;
1217 default:
1218 jj_la1[43] = jj_gen;
1219 jj_consume_token(-1);
1220 throw new ParseException();
1221 }
1222 {if (true) return x;}
1223 throw new Error("Missing return statement in function");
1224 }
1225
1226 final public ValueFunction Literal() throws ParseException {
1227 Token t;
1228 ValueFunction x = null;
1229 Vector data = null;
1230 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1231 case INTEGER:
1232 t = jj_consume_token(INTEGER);
1233 x = new IntFn(t.image);
1234 break;
1235 case REAL:
1236 t = jj_consume_token(REAL);
1237 x = new RealFn(t.image);
1238 break;
1239 case DATE:
1240 t = jj_consume_token(DATE);
1241 x = new DateFn(t.image);
1242 break;
1243 case TIME:
1244 t = jj_consume_token(TIME);
1245 x = new TimeFn(t.image);
1246 break;
1247 case LITERAL:
1248 t = jj_consume_token(LITERAL);
1249 x = new IdFn(Misc.literalToString(t.image));
1250 break;
1251 case BOOLEAN:
1252 t = jj_consume_token(BOOLEAN);
1253 x = BoolFn.newBoolFn(t.image);
1254 break;
1255 case LCURLY:
1256 jj_consume_token(LCURLY);
1257 data = ExpressionList();
1258 jj_consume_token(RCURLY);
1259 x = new VectorFn(data);
1260 break;
1261 default:
1262 jj_la1[44] = jj_gen;
1263 if (jj_2_10(2)) {
1264 x = Function();
1265 } else {
1266 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1267 case ID:
1268 t = jj_consume_token(ID);
1269 x = new IdFn(t.image);
1270 break;
1271 default:
1272 jj_la1[45] = jj_gen;
1273 jj_consume_token(-1);
1274 throw new ParseException();
1275 }
1276 }
1277 }
1278 {if (true) return x;}
1279 throw new Error("Missing return statement in function");
1280 }
1281
1282 final private boolean jj_2_1(int xla) {
1283 jj_la = xla; jj_lastpos = jj_scanpos = token;
1284 boolean retval = !jj_3_1();
1285 jj_save(0, xla);
1286 return retval;
1287 }
1288
1289 final private boolean jj_2_2(int xla) {
1290 jj_la = xla; jj_lastpos = jj_scanpos = token;
1291 boolean retval = !jj_3_2();
1292 jj_save(1, xla);
1293 return retval;
1294 }
1295
1296 final private boolean jj_2_3(int xla) {
1297 jj_la = xla; jj_lastpos = jj_scanpos = token;
1298 boolean retval = !jj_3_3();
1299 jj_save(2, xla);
1300 return retval;
1301 }
1302
1303 final private boolean jj_2_4(int xla) {
1304 jj_la = xla; jj_lastpos = jj_scanpos = token;
1305 boolean retval = !jj_3_4();
1306 jj_save(3, xla);
1307 return retval;
1308 }
1309
1310 final private boolean jj_2_5(int xla) {
1311 jj_la = xla; jj_lastpos = jj_scanpos = token;
1312 boolean retval = !jj_3_5();
1313 jj_save(4, xla);
1314 return retval;
1315 }
1316
1317 final private boolean jj_2_6(int xla) {
1318 jj_la = xla; jj_lastpos = jj_scanpos = token;
1319 boolean retval = !jj_3_6();
1320 jj_save(5, xla);
1321 return retval;
1322 }
1323
1324 final private boolean jj_2_7(int xla) {
1325 jj_la = xla; jj_lastpos = jj_scanpos = token;
1326 boolean retval = !jj_3_7();
1327 jj_save(6, xla);
1328 return retval;
1329 }
1330
1331 final private boolean jj_2_8(int xla) {
1332 jj_la = xla; jj_lastpos = jj_scanpos = token;
1333 boolean retval = !jj_3_8();
1334 jj_save(7, xla);
1335 return retval;
1336 }
1337
1338 final private boolean jj_2_9(int xla) {
1339 jj_la = xla; jj_lastpos = jj_scanpos = token;
1340 boolean retval = !jj_3_9();
1341 jj_save(8, xla);
1342 return retval;
1343 }
1344
1345 final private boolean jj_2_10(int xla) {
1346 jj_la = xla; jj_lastpos = jj_scanpos = token;
1347 boolean retval = !jj_3_10();
1348 jj_save(9, xla);
1349 return retval;
1350 }
1351
1352 final private boolean jj_3R_23() {
1353 if (jj_scan_token(ID)) return true;
1354 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1355 if (jj_scan_token(LBRACKET)) return true;
1356 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1357 return false;
1358 }
1359
1360 final private boolean jj_3R_25() {
1361 if (jj_scan_token(NE)) return true;
1362 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1363 return false;
1364 }
1365
1366 final private boolean jj_3R_30() {
1367 if (jj_3R_36()) return true;
1368 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1369 return false;
1370 }
1371
1372 final private boolean jj_3R_51() {
1373 if (jj_scan_token(UNOT)) return true;
1374 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1375 return false;
1376 }
1377
1378 final private boolean jj_3_1() {
1379 if (jj_3R_23()) return true;
1380 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1381 return false;
1382 }
1383
1384 final private boolean jj_3R_24() {
1385 if (jj_scan_token(EQ)) return true;
1386 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1387 return false;
1388 }
1389
1390 final private boolean jj_3_6() {
1391 Token xsp;
1392 xsp = jj_scanpos;
1393 if (jj_3R_24()) {
1394 jj_scanpos = xsp;
1395 if (jj_3R_25()) {
1396 jj_scanpos = xsp;
1397 if (jj_3R_26()) {
1398 jj_scanpos = xsp;
1399 if (jj_3R_27()) {
1400 jj_scanpos = xsp;
1401 if (jj_3R_28()) {
1402 jj_scanpos = xsp;
1403 if (jj_3R_29()) return true;
1404 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1405 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1406 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1407 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1408 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1409 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1410 if (jj_3R_30()) return true;
1411 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1412 return false;
1413 }
1414
1415 final private boolean jj_3_5() {
1416 if (jj_scan_token(UAND)) return true;
1417 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1418 return false;
1419 }
1420
1421 final private boolean jj_3R_50() {
1422 if (jj_scan_token(LT)) return true;
1423 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1424 return false;
1425 }
1426
1427 final private boolean jj_3R_60() {
1428 if (jj_scan_token(ID)) return true;
1429 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1430 return false;
1431 }
1432
1433 final private boolean jj_3_10() {
1434 if (jj_3R_23()) return true;
1435 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1436 return false;
1437 }
1438
1439 final private boolean jj_3R_59() {
1440 if (jj_scan_token(LCURLY)) return true;
1441 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1442 return false;
1443 }
1444
1445 final private boolean jj_3R_58() {
1446 if (jj_scan_token(BOOLEAN)) return true;
1447 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1448 return false;
1449 }
1450
1451 final private boolean jj_3R_57() {
1452 if (jj_scan_token(LITERAL)) return true;
1453 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1454 return false;
1455 }
1456
1457 final private boolean jj_3R_49() {
1458 if (jj_scan_token(GT)) return true;
1459 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1460 return false;
1461 }
1462
1463 final private boolean jj_3R_56() {
1464 if (jj_scan_token(TIME)) return true;
1465 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1466 return false;
1467 }
1468
1469 final private boolean jj_3_4() {
1470 if (jj_scan_token(UOR)) return true;
1471 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1472 return false;
1473 }
1474
1475 final private boolean jj_3R_55() {
1476 if (jj_scan_token(DATE)) return true;
1477 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1478 return false;
1479 }
1480
1481 final private boolean jj_3R_54() {
1482 if (jj_scan_token(REAL)) return true;
1483 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1484 return false;
1485 }
1486
1487 final private boolean jj_3R_53() {
1488 if (jj_scan_token(INTEGER)) return true;
1489 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1490 return false;
1491 }
1492
1493 final private boolean jj_3R_52() {
1494 Token xsp;
1495 xsp = jj_scanpos;
1496 if (jj_3R_53()) {
1497 jj_scanpos = xsp;
1498 if (jj_3R_54()) {
1499 jj_scanpos = xsp;
1500 if (jj_3R_55()) {
1501 jj_scanpos = xsp;
1502 if (jj_3R_56()) {
1503 jj_scanpos = xsp;
1504 if (jj_3R_57()) {
1505 jj_scanpos = xsp;
1506 if (jj_3R_58()) {
1507 jj_scanpos = xsp;
1508 if (jj_3R_59()) {
1509 jj_scanpos = xsp;
1510 if (jj_3_10()) {
1511 jj_scanpos = xsp;
1512 if (jj_3R_60()) return true;
1513 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1514 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1515 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1516 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1517 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1518 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1519 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1520 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1521 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1522 return false;
1523 }
1524
1525 final private boolean jj_3R_48() {
1526 if (jj_scan_token(NE)) return true;
1527 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1528 return false;
1529 }
1530
1531 final private boolean jj_3_9() {
1532 if (jj_scan_token(ELSE)) return true;
1533 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1534 return false;
1535 }
1536
1537 final private boolean jj_3_3() {
1538 if (jj_scan_token(AND)) return true;
1539 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1540 return false;
1541 }
1542
1543 final private boolean jj_3R_43() {
1544 if (jj_scan_token(LBRACKET)) return true;
1545 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1546 return false;
1547 }
1548
1549 final private boolean jj_3R_47() {
1550 if (jj_scan_token(GE)) return true;
1551 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1552 return false;
1553 }
1554
1555 final private boolean jj_3R_35() {
1556 if (jj_scan_token(REMAINDER)) return true;
1557 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1558 return false;
1559 }
1560
1561 final private boolean jj_3R_45() {
1562 if (jj_scan_token(MINUS)) return true;
1563 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1564 return false;
1565 }
1566
1567 final private boolean jj_3R_29() {
1568 if (jj_scan_token(GE)) return true;
1569 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1570 return false;
1571 }
1572
1573 final private boolean jj_3R_42() {
1574 if (jj_scan_token(IF)) return true;
1575 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1576 return false;
1577 }
1578
1579 final private boolean jj_3_2() {
1580 if (jj_scan_token(OR)) return true;
1581 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1582 return false;
1583 }
1584
1585 final private boolean jj_3R_41() {
1586 if (jj_3R_52()) return true;
1587 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1588 return false;
1589 }
1590
1591 final private boolean jj_3R_46() {
1592 if (jj_scan_token(LE)) return true;
1593 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1594 return false;
1595 }
1596
1597 final private boolean jj_3R_34() {
1598 if (jj_scan_token(DIVIDE)) return true;
1599 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1600 return false;
1601 }
1602
1603 final private boolean jj_3R_40() {
1604 Token xsp;
1605 xsp = jj_scanpos;
1606 if (jj_3R_46()) {
1607 jj_scanpos = xsp;
1608 if (jj_3R_47()) {
1609 jj_scanpos = xsp;
1610 if (jj_3R_48()) {
1611 jj_scanpos = xsp;
1612 if (jj_3R_49()) {
1613 jj_scanpos = xsp;
1614 if (jj_3R_50()) {
1615 jj_scanpos = xsp;
1616 if (jj_3R_51()) return true;
1617 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1618 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1619 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1620 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1621 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1622 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1623 return false;
1624 }
1625
1626 final private boolean jj_3R_28() {
1627 if (jj_scan_token(LE)) return true;
1628 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1629 return false;
1630 }
1631
1632 final private boolean jj_3R_39() {
1633 if (jj_scan_token(NOT)) return true;
1634 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1635 return false;
1636 }
1637
1638 final private boolean jj_3R_44() {
1639 if (jj_scan_token(PLUS)) return true;
1640 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1641 return false;
1642 }
1643
1644 final private boolean jj_3R_38() {
1645 Token xsp;
1646 xsp = jj_scanpos;
1647 if (jj_3R_44()) {
1648 jj_scanpos = xsp;
1649 if (jj_3R_45()) return true;
1650 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1651 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1652 return false;
1653 }
1654
1655 final private boolean jj_3R_37() {
1656 Token xsp;
1657 xsp = jj_scanpos;
1658 if (jj_3R_38()) {
1659 jj_scanpos = xsp;
1660 if (jj_3R_39()) {
1661 jj_scanpos = xsp;
1662 if (jj_3R_40()) {
1663 jj_scanpos = xsp;
1664 if (jj_3R_41()) {
1665 jj_scanpos = xsp;
1666 if (jj_3R_42()) {
1667 jj_scanpos = xsp;
1668 if (jj_3R_43()) return true;
1669 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1670 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1671 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1672 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1673 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1674 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1675 return false;
1676 }
1677
1678 final private boolean jj_3R_33() {
1679 if (jj_scan_token(MULTIPLY)) return true;
1680 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1681 return false;
1682 }
1683
1684 final private boolean jj_3_8() {
1685 Token xsp;
1686 xsp = jj_scanpos;
1687 if (jj_3R_33()) {
1688 jj_scanpos = xsp;
1689 if (jj_3R_34()) {
1690 jj_scanpos = xsp;
1691 if (jj_3R_35()) return true;
1692 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1693 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1694 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1695 return false;
1696 }
1697
1698 final private boolean jj_3R_27() {
1699 if (jj_scan_token(GT)) return true;
1700 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1701 return false;
1702 }
1703
1704 final private boolean jj_3R_32() {
1705 if (jj_scan_token(MINUS)) return true;
1706 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1707 return false;
1708 }
1709
1710 final private boolean jj_3R_31() {
1711 if (jj_scan_token(PLUS)) return true;
1712 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1713 return false;
1714 }
1715
1716 final private boolean jj_3R_26() {
1717 if (jj_scan_token(LT)) return true;
1718 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1719 return false;
1720 }
1721
1722 final private boolean jj_3_7() {
1723 Token xsp;
1724 xsp = jj_scanpos;
1725 if (jj_3R_31()) {
1726 jj_scanpos = xsp;
1727 if (jj_3R_32()) return true;
1728 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1729 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1730 return false;
1731 }
1732
1733 final private boolean jj_3R_36() {
1734 if (jj_3R_37()) return true;
1735 if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
1736 return false;
1737 }
1738
1739 public RestrictionParserTokenManager token_source;
1740 ASCII_CharStream jj_input_stream;
1741 public Token token, jj_nt;
1742 private int jj_ntk;
1743 private Token jj_scanpos, jj_lastpos;
1744 private int jj_la;
1745 public boolean lookingAhead = false;
1746 private boolean jj_semLA;
1747 private int jj_gen;
1748 final private int[] jj_la1 = new int[46];
1749 final private int[] jj_la1_0 = {0x800000,0x400000,0x200f80,0x1200f80,0x0,0x0,0x0,0x800000,0x400000,0x200f80,0x1200f80,0x0,0x800000,0x400000,0x200f80,0x1200f80,0x0,0x800000,0x400000,0x3000,0x3000,0x1c000,0x1c000,0x3000,0x200f80,0x1203f80,0x800000,0x400000,0x3000,0x3000,0x1c000,0x1c000,0x3000,0x200f80,0x1203f80,0x4000000,0x10000000,0x25303f80,0xfc0,0x3000,0x1c000,0x3000,0x200f80,0x25303f80,0x4000000,0x0,};
1750 final private int[] jj_la1_1 = {0x0,0x0,0x0,0x41,0x40,0x1,0x3,0x0,0x0,0x0,0x11,0x11,0x0,0x0,0x0,0x21,0x21,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x5,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xd,0x1,0x0,0x7f,0x0,0x0,0x0,0x0,0x0,0x7f,0x7e,0x1,};
1751 final private JJCalls[] jj_2_rtns = new JJCalls[10];
1752 private boolean jj_rescan = false;
1753 private int jj_gc = 0;
1754
1755 public RestrictionParser(java.io.InputStream stream) {
1756 jj_input_stream = new ASCII_CharStream(stream, 1, 1);
1757 token_source = new RestrictionParserTokenManager(jj_input_stream);
1758 token = new Token();
1759 jj_ntk = -1;
1760 jj_gen = 0;
1761 for (int i = 0; i < 46; i++) jj_la1[i] = -1;
1762 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
1763 }
1764
1765 public void ReInit(java.io.InputStream stream) {
1766 jj_input_stream.ReInit(stream, 1, 1);
1767 token_source.ReInit(jj_input_stream);
1768 token = new Token();
1769 jj_ntk = -1;
1770 jj_gen = 0;
1771 for (int i = 0; i < 46; i++) jj_la1[i] = -1;
1772 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
1773 }
1774
1775 public RestrictionParser(RestrictionParserTokenManager tm) {
1776 token_source = tm;
1777 token = new Token();
1778 jj_ntk = -1;
1779 jj_gen = 0;
1780 for (int i = 0; i < 46; i++) jj_la1[i] = -1;
1781 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
1782 }
1783
1784 public void ReInit(RestrictionParserTokenManager tm) {
1785 token_source = tm;
1786 token = new Token();
1787 jj_ntk = -1;
1788 jj_gen = 0;
1789 for (int i = 0; i < 46; i++) jj_la1[i] = -1;
1790 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
1791 }
1792
1793 final private Token jj_consume_token(int kind) throws ParseException {
1794 Token oldToken;
1795 if ((oldToken = token).next != null) token = token.next;
1796 else token = token.next = token_source.getNextToken();
1797 jj_ntk = -1;
1798 if (token.kind == kind) {
1799 jj_gen++;
1800 if (++jj_gc > 100) {
1801 jj_gc = 0;
1802 for (int i = 0; i < jj_2_rtns.length; i++) {
1803 JJCalls c = jj_2_rtns[i];
1804 while (c != null) {
1805 if (c.gen < jj_gen) c.first = null;
1806 c = c.next;
1807 }
1808 }
1809 }
1810 return token;
1811 }
1812 token = oldToken;
1813 jj_kind = kind;
1814 throw generateParseException();
1815 }
1816
1817 final private boolean jj_scan_token(int kind) {
1818 if (jj_scanpos == jj_lastpos) {
1819 jj_la--;
1820 if (jj_scanpos.next == null) {
1821 jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
1822 } else {
1823 jj_lastpos = jj_scanpos = jj_scanpos.next;
1824 }
1825 } else {
1826 jj_scanpos = jj_scanpos.next;
1827 }
1828 if (jj_rescan) {
1829 int i = 0; Token tok = token;
1830 while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
1831 if (tok != null) jj_add_error_token(kind, i);
1832 }
1833 return (jj_scanpos.kind != kind);
1834 }
1835
1836 final public Token getNextToken() {
1837 if (token.next != null) token = token.next;
1838 else token = token.next = token_source.getNextToken();
1839 jj_ntk = -1;
1840 jj_gen++;
1841 return token;
1842 }
1843
1844 final public Token getToken(int index) {
1845 Token t = lookingAhead ? jj_scanpos : token;
1846 for (int i = 0; i < index; i++) {
1847 if (t.next != null) t = t.next;
1848 else t = t.next = token_source.getNextToken();
1849 }
1850 return t;
1851 }
1852
1853 final private int jj_ntk() {
1854 if ((jj_nt=token.next) == null)
1855 return (jj_ntk = (token.next=token_source.getNextToken()).kind);
1856 else
1857 return (jj_ntk = jj_nt.kind);
1858 }
1859
1860 private java.util.Vector jj_expentries = new java.util.Vector();
1861 private int[] jj_expentry;
1862 private int jj_kind = -1;
1863 private int[] jj_lasttokens = new int[100];
1864 private int jj_endpos;
1865
1866 private void jj_add_error_token(int kind, int pos) {
1867 if (pos >= 100) return;
1868 if (pos == jj_endpos + 1) {
1869 jj_lasttokens[jj_endpos++] = kind;
1870 } else if (jj_endpos != 0) {
1871 jj_expentry = new int[jj_endpos];
1872 for (int i = 0; i < jj_endpos; i++) {
1873 jj_expentry[i] = jj_lasttokens[i];
1874 }
1875 boolean exists = false;
1876 for (java.util.Enumeration enum = jj_expentries.elements(); enum.hasMoreElements();) {
1877 int[] oldentry = (int[])(enum.nextElement());
1878 if (oldentry.length == jj_expentry.length) {
1879 exists = true;
1880 for (int i = 0; i < jj_expentry.length; i++) {
1881 if (oldentry[i] != jj_expentry[i]) {
1882 exists = false;
1883 break;
1884 }
1885 }
1886 if (exists) break;
1887 }
1888 }
1889 if (!exists) jj_expentries.addElement(jj_expentry);
1890 if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
1891 }
1892 }
1893
1894 final public ParseException generateParseException() {
1895 jj_expentries.removeAllElements();
1896 boolean[] la1tokens = new boolean[43];
1897 for (int i = 0; i < 43; i++) {
1898 la1tokens[i] = false;
1899 }
1900 if (jj_kind >= 0) {
1901 la1tokens[jj_kind] = true;
1902 jj_kind = -1;
1903 }
1904 for (int i = 0; i < 46; i++) {
1905 if (jj_la1[i] == jj_gen) {
1906 for (int j = 0; j < 32; j++) {
1907 if ((jj_la1_0[i] & (1<<j)) != 0) {
1908 la1tokens[j] = true;
1909 }
1910 if ((jj_la1_1[i] & (1<<j)) != 0) {
1911 la1tokens[32+j] = true;
1912 }
1913 }
1914 }
1915 }
1916 for (int i = 0; i < 43; i++) {
1917 if (la1tokens[i]) {
1918 jj_expentry = new int[1];
1919 jj_expentry[0] = i;
1920 jj_expentries.addElement(jj_expentry);
1921 }
1922 }
1923 jj_endpos = 0;
1924 jj_rescan_token();
1925 jj_add_error_token(0, 0);
1926 int[][] exptokseq = new int[jj_expentries.size()][];
1927 for (int i = 0; i < jj_expentries.size(); i++) {
1928 exptokseq[i] = (int[])jj_expentries.elementAt(i);
1929 }
1930 return new ParseException(token, exptokseq, tokenImage);
1931 }
1932
1933 final public void enable_tracing() {
1934 }
1935
1936 final public void disable_tracing() {
1937 }
1938
1939 final private void jj_rescan_token() {
1940 jj_rescan = true;
1941 for (int i = 0; i < 10; i++) {
1942 JJCalls p = jj_2_rtns[i];
1943 do {
1944 if (p.gen > jj_gen) {
1945 jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
1946 switch (i) {
1947 case 0: jj_3_1(); break;
1948 case 1: jj_3_2(); break;
1949 case 2: jj_3_3(); break;
1950 case 3: jj_3_4(); break;
1951 case 4: jj_3_5(); break;
1952 case 5: jj_3_6(); break;
1953 case 6: jj_3_7(); break;
1954 case 7: jj_3_8(); break;
1955 case 8: jj_3_9(); break;
1956 case 9: jj_3_10(); break;
1957 }
1958 }
1959 p = p.next;
1960 } while (p != null);
1961 }
1962 jj_rescan = false;
1963 }
1964
1965 final private void jj_save(int index, int xla) {
1966 JJCalls p = jj_2_rtns[index];
1967 while (p.gen > jj_gen) {
1968 if (p.next == null) { p = p.next = new JJCalls(); break; }
1969 p = p.next;
1970 }
1971 p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
1972 }
1973
1974 static final class JJCalls {
1975 int gen;
1976 Token first;
1977 int arg;
1978 JJCalls next;
1979 }
1980
1981 }
1982
1983 interface RestrictionParserConstants {
1984
1985 int EOF = 0;
1986 int EQ = 6;
1987 int LE = 7;
1988 int GE = 8;
1989 int NE = 9;
1990 int GT = 10;
1991 int LT = 11;
1992 int PLUS = 12;
1993 int MINUS = 13;
1994 int MULTIPLY = 14;
1995 int DIVIDE = 15;
1996 int REMAINDER = 16;
1997 int POWER = 17;
1998 int AND = 18;
1999 int OR = 19;
2000 int NOT = 20;
2001 int UNOT = 21;
2002 int UAND = 22;
2003 int UOR = 23;
2004 int LBRACKET = 24;
2005 int RBRACKET = 25;
2006 int LCURLY = 26;
2007 int RCURLY = 27;
2008 int COMMA = 28;
2009 int IF = 29;
2010 int THEN = 30;
2011 int ELSE = 31;
2012 int ID = 32;
2013 int BOOLEAN = 33;
2014 int INTEGER = 34;
2015 int REAL = 35;
2016 int DATE = 36;
2017 int TIME = 37;
2018 int LITERAL = 38;
2019 int EXPONENT = 39;
2020 int LETTER = 40;
2021 int DIGIT = 41;
2022 int DECIMAL = 42;
2023
2024 int DEFAULT = 0;
2025
2026 String[] tokenImage = {
2027 "<EOF>",
2028 "\" \"",
2029 "\"//t\"",
2030 "\"//n\"",
2031 "\"//r\"",
2032 "\"//f\"",
2033 "\"==\"",
2034 "\"<=\"",
2035 "\">=\"",
2036 "\"!=\"",
2037 "\">\"",
2038 "\"<\"",
2039 "\"+\"",
2040 "\"-\"",
2041 "\"*\"",
2042 "\"/\"",
2043 "\"%\"",
2044 "\"^\"",
2045 "\"&&\"",
2046 "\"||\"",
2047 "\"!\"",
2048 "\"~\"",
2049 "\"&\"",
2050 "\"|\"",
2051 "\"(\"",
2052 "\")\"",
2053 "\"{\"",
2054 "\"}\"",
2055 "\",\"",
2056 "\"if\"",
2057 "\"then\"",
2058 "\"else\"",
2059 "<ID>",
2060 "<BOOLEAN>",
2061 "<INTEGER>",
2062 "<REAL>",
2063 "<DATE>",
2064 "<TIME>",
2065 "<LITERAL>",
2066 "<EXPONENT>",
2067 "<LETTER>",
2068 "<DIGIT>",
2069 "<DECIMAL>",
2070 };
2071
2072 }
2073
2074 class RestrictionParserTokenManager implements RestrictionParserConstants
2075 {
2076 private final int jjStopStringLiteralDfa_0(int pos, long active0)
2077 {
2078 switch (pos)
2079 {
2080 case 0:
2081 if ((active0 & 0x40000000L) != 0L)
2082 {
2083 jjmatchedKind = 32;
2084 return 4;
2085 }
2086 if ((active0 & 0xa0000000L) != 0L)
2087 {
2088 jjmatchedKind = 32;
2089 return 1;
2090 }
2091 return -1;
2092 case 1:
2093 if ((active0 & 0xc0000000L) != 0L)
2094 {
2095 jjmatchedKind = 32;
2096 jjmatchedPos = 1;
2097 return 1;
2098 }
2099 if ((active0 & 0x20000000L) != 0L)
2100 return 1;
2101 return -1;
2102 case 2:
2103 if ((active0 & 0xc0000000L) != 0L)
2104 {
2105 jjmatchedKind = 32;
2106 jjmatchedPos = 2;
2107 return 1;
2108 }
2109 return -1;
2110 default :
2111 return -1;
2112 }
2113 }
2114 private final int jjStartNfa_0(int pos, long active0)
2115 {
2116 return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
2117 }
2118 private final int jjStopAtPos(int pos, int kind)
2119 {
2120 jjmatchedKind = kind;
2121 jjmatchedPos = pos;
2122 return pos + 1;
2123 }
2124 private final int jjStartNfaWithStates_0(int pos, int kind, int state)
2125 {
2126 jjmatchedKind = kind;
2127 jjmatchedPos = pos;
2128 try { curChar = input_stream.readChar(); }
2129 catch(java.io.IOException e) { return pos + 1; }
2130 return jjMoveNfa_0(state, pos + 1);
2131 }
2132 private final int jjMoveStringLiteralDfa0_0()
2133 {
2134 switch(curChar)
2135 {
2136 case 33:
2137 jjmatchedKind = 20;
2138 return jjMoveStringLiteralDfa1_0(0x200L);
2139 case 37:
2140 return jjStopAtPos(0, 16);
2141 case 38:
2142 jjmatchedKind = 22;
2143 return jjMoveStringLiteralDfa1_0(0x40000L);
2144 case 40:
2145 return jjStopAtPos(0, 24);
2146 case 41:
2147 return jjStopAtPos(0, 25);
2148 case 42:
2149 return jjStopAtPos(0, 14);
2150 case 43:
2151 return jjStopAtPos(0, 12);
2152 case 44:
2153 return jjStopAtPos(0, 28);
2154 case 45:
2155 return jjStopAtPos(0, 13);
2156 case 47:
2157 return jjStopAtPos(0, 15);
2158 case 60:
2159 jjmatchedKind = 11;
2160 return jjMoveStringLiteralDfa1_0(0x80L);
2161 case 61:
2162 return jjMoveStringLiteralDfa1_0(0x40L);
2163 case 62:
2164 jjmatchedKind = 10;
2165 return jjMoveStringLiteralDfa1_0(0x100L);
2166 case 94:
2167 return jjStopAtPos(0, 17);
2168 case 101:
2169 return jjMoveStringLiteralDfa1_0(0x80000000L);
2170 case 105:
2171 return jjMoveStringLiteralDfa1_0(0x20000000L);
2172 case 116:
2173 return jjMoveStringLiteralDfa1_0(0x40000000L);
2174 case 123:
2175 return jjStopAtPos(0, 26);
2176 case 124:
2177 jjmatchedKind = 23;
2178 return jjMoveStringLiteralDfa1_0(0x80000L);
2179 case 125:
2180 return jjStopAtPos(0, 27);
2181 case 126:
2182 return jjStopAtPos(0, 21);
2183 default :
2184 return jjMoveNfa_0(0, 0);
2185 }
2186 }
2187 private final int jjMoveStringLiteralDfa1_0(long active0)
2188 {
2189 try { curChar = input_stream.readChar(); }
2190 catch(java.io.IOException e) {
2191 jjStopStringLiteralDfa_0(0, active0);
2192 return 1;
2193 }
2194 switch(curChar)
2195 {
2196 case 38:
2197 if ((active0 & 0x40000L) != 0L)
2198 return jjStopAtPos(1, 18);
2199 break;
2200 case 61:
2201 if ((active0 & 0x40L) != 0L)
2202 return jjStopAtPos(1, 6);
2203 else if ((active0 & 0x80L) != 0L)
2204 return jjStopAtPos(1, 7);
2205 else if ((active0 & 0x100L) != 0L)
2206 return jjStopAtPos(1, 8);
2207 else if ((active0 & 0x200L) != 0L)
2208 return jjStopAtPos(1, 9);
2209 break;
2210 case 102:
2211 if ((active0 & 0x20000000L) != 0L)
2212 return jjStartNfaWithStates_0(1, 29, 1);
2213 break;
2214 case 104:
2215 return jjMoveStringLiteralDfa2_0(active0, 0x40000000L);
2216 case 108:
2217 return jjMoveStringLiteralDfa2_0(active0, 0x80000000L);
2218 case 124:
2219 if ((active0 & 0x80000L) != 0L)
2220 return jjStopAtPos(1, 19);
2221 break;
2222 default :
2223 break;
2224 }
2225 return jjStartNfa_0(0, active0);
2226 }
2227 private final int jjMoveStringLiteralDfa2_0(long old0, long active0)
2228 {
2229 if (((active0 &= old0)) == 0L)
2230 return jjStartNfa_0(0, old0);
2231 try { curChar = input_stream.readChar(); }
2232 catch(java.io.IOException e) {
2233 jjStopStringLiteralDfa_0(1, active0);
2234 return 2;
2235 }
2236 switch(curChar)
2237 {
2238 case 101:
2239 return jjMoveStringLiteralDfa3_0(active0, 0x40000000L);
2240 case 115:
2241 return jjMoveStringLiteralDfa3_0(active0, 0x80000000L);
2242 default :
2243 break;
2244 }
2245 return jjStartNfa_0(1, active0);
2246 }
2247 private final int jjMoveStringLiteralDfa3_0(long old0, long active0)
2248 {
2249 if (((active0 &= old0)) == 0L)
2250 return jjStartNfa_0(1, old0);
2251 try { curChar = input_stream.readChar(); }
2252 catch(java.io.IOException e) {
2253 jjStopStringLiteralDfa_0(2, active0);
2254 return 3;
2255 }
2256 switch(curChar)
2257 {
2258 case 101:
2259 if ((active0 & 0x80000000L) != 0L)
2260 return jjStartNfaWithStates_0(3, 31, 1);
2261 break;
2262 case 110:
2263 if ((active0 & 0x40000000L) != 0L)
2264 return jjStartNfaWithStates_0(3, 30, 1);
2265 break;
2266 default :
2267 break;
2268 }
2269 return jjStartNfa_0(2, active0);
2270 }
2271 private final void jjCheckNAdd(int state)
2272 {
2273 if (jjrounds[state] != jjround)
2274 {
2275 jjstateSet[jjnewStateCnt++] = state;
2276 jjrounds[state] = jjround;
2277 }
2278 }
2279 private final void jjAddStates(int start, int end)
2280 {
2281 do {
2282 jjstateSet[jjnewStateCnt++] = jjnextStates[start];
2283 } while (start++ != end);
2284 }
2285 private final void jjCheckNAddTwoStates(int state1, int state2)
2286 {
2287 jjCheckNAdd(state1);
2288 jjCheckNAdd(state2);
2289 }
2290 private final void jjCheckNAddStates(int start, int end)
2291 {
2292 do {
2293 jjCheckNAdd(jjnextStates[start]);
2294 } while (start++ != end);
2295 }
2296 private final void jjCheckNAddStates(int start)
2297 {
2298 jjCheckNAdd(jjnextStates[start]);
2299 jjCheckNAdd(jjnextStates[start + 1]);
2300 }
2301 static final long[] jjbitVec0 = {
2302 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
2303 };
2304 private final int jjMoveNfa_0(int startState, int curPos)
2305 {
2306 int[] nextStates;
2307 int startsAt = 0;
2308 jjnewStateCnt = 70;
2309 int i = 1;
2310 jjstateSet[0] = startState;
2311 int j, kind = 0x7fffffff;
2312 for (;;)
2313 {
2314 if (++jjround == 0x7fffffff)
2315 ReInitRounds();
2316 if (curChar < 64)
2317 {
2318 long l = 1L << curChar;
2319 MatchLoop: do
2320 {
2321 switch(jjstateSet[--i])
2322 {
2323 case 0:
2324 if ((0x3ff000000000000L & l) != 0L)
2325 jjCheckNAddStates(0, 7);
2326 else if (curChar == 34)
2327 jjCheckNAddStates(8, 10);
2328 else if (curChar == 46)
2329 jjCheckNAdd(11);
2330 if ((0x3fe000000000000L & l) != 0L)
2331 {
2332 if (kind > 34)
2333 kind = 34;
2334 jjCheckNAddStates(11, 13);
2335 }
2336 else if (curChar == 48)
2337 {
2338 if (kind > 34)
2339 kind = 34;
2340 jjCheckNAddStates(14, 16);
2341 }
2342 if ((0x6000000000000L & l) != 0L)
2343 jjstateSet[jjnewStateCnt++] = 17;
2344 else if (curChar == 51)
2345 jjAddStates(17, 18);
2346 if (curChar == 50)
2347 jjstateSet[jjnewStateCnt++] = 37;
2348 else if (curChar == 49)
2349 jjCheckNAdd(29);
2350 break;
2351 case 4:
2352 case 1:
2353 if ((0x3ff001000000000L & l) == 0L)
2354 break;
2355 if (kind > 32)
2356 kind = 32;
2357 jjCheckNAdd(1);
2358 break;
2359 case 10:
2360 if (curChar == 46)
2361 jjCheckNAdd(11);
2362 break;
2363 case 11:
2364 if ((0x3ff000000000000L & l) == 0L)
2365 break;
2366 if (kind > 35)
2367 kind = 35;
2368 jjCheckNAddStates(19, 21);
2369 break;
2370 case 13:
2371 if ((0x280000000000L & l) != 0L)
2372 jjCheckNAdd(14);
2373 break;
2374 case 14:
2375 if ((0x3ff000000000000L & l) == 0L)
2376 break;
2377 if (kind > 35)
2378 kind = 35;
2379 jjCheckNAddTwoStates(14, 15);
2380 break;
2381 case 16:
2382 if ((0x6000000000000L & l) != 0L)
2383 jjstateSet[jjnewStateCnt++] = 17;
2384 break;
2385 case 17:
2386 if ((0x3ff000000000000L & l) != 0L)
2387 jjCheckNAdd(18);
2388 break;
2389 case 18:
2390 if ((0xa00000000000L & l) != 0L)
2391 jjCheckNAddStates(22, 24);
2392 break;
2393 case 19:
2394 if (curChar == 48)
2395 jjCheckNAdd(20);
2396 break;
2397 case 20:
2398 if ((0x3fe000000000000L & l) != 0L)
2399 jjCheckNAdd(21);
2400 break;
2401 case 21:
2402 if ((0xa00000000000L & l) != 0L)
2403 jjstateSet[jjnewStateCnt++] = 22;
2404 break;
2405 case 22:
2406 if ((0x3ff000000000000L & l) != 0L)
2407 jjstateSet[jjnewStateCnt++] = 23;
2408 break;
2409 case 23:
2410 if ((0x3ff000000000000L & l) != 0L && kind > 36)
2411 kind = 36;
2412 break;
2413 case 24:
2414 if (curChar == 49)
2415 jjAddStates(25, 27);
2416 break;
2417 case 25:
2418 if (curChar == 48)
2419 jjCheckNAdd(21);
2420 break;
2421 case 26:
2422 if (curChar == 49)
2423 jjCheckNAdd(21);
2424 break;
2425 case 27:
2426 if (curChar == 50)
2427 jjCheckNAdd(21);
2428 break;
2429 case 28:
2430 if (curChar == 49)
2431 jjCheckNAdd(29);
2432 break;
2433 case 29:
2434 if ((0x3ff000000000000L & l) != 0L)
2435 jjCheckNAdd(30);
2436 break;
2437 case 30:
2438 if (curChar == 58)
2439 jjstateSet[jjnewStateCnt++] = 31;
2440 break;
2441 case 31:
2442 if ((0x3f000000000000L & l) != 0L)
2443 jjstateSet[jjnewStateCnt++] = 32;
2444 break;
2445 case 32:
2446 if ((0x3ff000000000000L & l) == 0L)
2447 break;
2448 if (kind > 37)
2449 kind = 37;
2450 jjstateSet[jjnewStateCnt++] = 33;
2451 break;
2452 case 33:
2453 if (curChar == 58)
2454 jjstateSet[jjnewStateCnt++] = 34;
2455 break;
2456 case 34:
2457 if ((0x3f000000000000L & l) != 0L)
2458 jjstateSet[jjnewStateCnt++] = 35;
2459 break;
2460 case 35:
2461 if ((0x3ff000000000000L & l) != 0L && kind > 37)
2462 kind = 37;
2463 break;
2464 case 36:
2465 if (curChar == 50)
2466 jjstateSet[jjnewStateCnt++] = 37;
2467 break;
2468 case 37:
2469 if ((0xf000000000000L & l) != 0L)
2470 jjCheckNAdd(30);
2471 break;
2472 case 38:
2473 if (curChar == 34)
2474 jjCheckNAddStates(8, 10);
2475 break;
2476 case 39:
2477 if ((0xfffffffbffffdbffL & l) != 0L)
2478 jjCheckNAddStates(8, 10);
2479 break;
2480 case 41:
2481 if ((0x8400000000L & l) != 0L)
2482 jjCheckNAddStates(8, 10);
2483 break;
2484 case 42:
2485 if (curChar == 34 && kind > 38)
2486 kind = 38;
2487 break;
2488 case 43:
2489 if ((0xff000000000000L & l) != 0L)
2490 jjCheckNAddStates(28, 31);
2491 break;
2492 case 44:
2493 if ((0xff000000000000L & l) != 0L)
2494 jjCheckNAddStates(8, 10);
2495 break;
2496 case 45:
2497 if ((0xf000000000000L & l) != 0L)
2498 jjstateSet[jjnewStateCnt++] = 46;
2499 break;
2500 case 46:
2501 if ((0xff000000000000L & l) != 0L)
2502 jjCheckNAdd(44);
2503 break;
2504 case 47:
2505 if (curChar == 51)
2506 jjAddStates(17, 18);
2507 break;
2508 case 48:
2509 if (curChar == 48)
2510 jjCheckNAdd(18);
2511 break;
2512 case 49:
2513 if (curChar == 49)
2514 jjCheckNAdd(18);
2515 break;
2516 case 50:
2517 if (curChar != 48)
2518 break;
2519 if (kind > 34)
2520 kind = 34;
2521 jjCheckNAddStates(14, 16);
2522 break;
2523 case 52:
2524 if ((0x3fe000000000000L & l) != 0L)
2525 jjCheckNAdd(18);
2526 break;
2527 case 53:
2528 if ((0x3fe000000000000L & l) == 0L)
2529 break;
2530 if (kind > 34)
2531 kind = 34;
2532 jjCheckNAddStates(11, 13);
2533 break;
2534 case 54:
2535 if ((0x3ff000000000000L & l) == 0L)
2536 break;
2537 if (kind > 34)
2538 kind = 34;
2539 jjCheckNAddTwoStates(54, 51);
2540 break;
2541 case 55:
2542 if ((0x3ff000000000000L & l) != 0L)
2543 jjCheckNAddStates(0, 7);
2544 break;
2545 case 56:
2546 if ((0x3ff000000000000L & l) != 0L)
2547 jjCheckNAddTwoStates(56, 57);
2548 break;
2549 case 57:
2550 if (curChar != 46)
2551 break;
2552 if (kind > 35)
2553 kind = 35;
2554 jjCheckNAddStates(32, 34);
2555 break;
2556 case 58:
2557 if ((0x3ff000000000000L & l) == 0L)
2558 break;
2559 if (kind > 35)
2560 kind = 35;
2561 jjCheckNAddStates(32, 34);
2562 break;
2563 case 60:
2564 if ((0x280000000000L & l) != 0L)
2565 jjCheckNAdd(61);
2566 break;
2567 case 61:
2568 if ((0x3ff000000000000L & l) == 0L)
2569 break;
2570 if (kind > 35)
2571 kind = 35;
2572 jjCheckNAddTwoStates(61, 15);
2573 break;
2574 case 62:
2575 if ((0x3ff000000000000L & l) != 0L)
2576 jjCheckNAddTwoStates(62, 63);
2577 break;
2578 case 64:
2579 if ((0x280000000000L & l) != 0L)
2580 jjCheckNAdd(65);
2581 break;
2582 case 65:
2583 if ((0x3ff000000000000L & l) == 0L)
2584 break;
2585 if (kind > 35)
2586 kind = 35;
2587 jjCheckNAddTwoStates(65, 15);
2588 break;
2589 case 66:
2590 if ((0x3ff000000000000L & l) != 0L)
2591 jjCheckNAddStates(35, 37);
2592 break;
2593 case 68:
2594 if ((0x280000000000L & l) != 0L)
2595 jjCheckNAdd(69);
2596 break;
2597 case 69:
2598 if ((0x3ff000000000000L & l) != 0L)
2599 jjCheckNAddTwoStates(69, 15);
2600 break;
2601 default : break;
2602 }
2603 } while(i != startsAt);
2604 }
2605 else if (curChar < 128)
2606 {
2607 long l = 1L << (curChar & 077);
2608 MatchLoop: do
2609 {
2610 switch(jjstateSet[--i])
2611 {
2612 case 0:
2613 if ((0x7fffffe87fffffeL & l) != 0L)
2614 {
2615 if (kind > 32)
2616 kind = 32;
2617 jjCheckNAdd(1);
2618 }
2619 if (curChar == 102)
2620 jjstateSet[jjnewStateCnt++] = 8;
2621 else if (curChar == 116)
2622 jjstateSet[jjnewStateCnt++] = 4;
2623 break;
2624 case 4:
2625 if ((0x7fffffe87fffffeL & l) != 0L)
2626 {
2627 if (kind > 32)
2628 kind = 32;
2629 jjCheckNAdd(1);
2630 }
2631 if (curChar == 114)
2632 jjstateSet[jjnewStateCnt++] = 3;
2633 break;
2634 case 1:
2635 if ((0x7fffffe87fffffeL & l) == 0L)
2636 break;
2637 if (kind > 32)
2638 kind = 32;
2639 jjCheckNAdd(1);
2640 break;
2641 case 2:
2642 if (curChar == 101 && kind > 33)
2643 kind = 33;
2644 break;
2645 case 3:
2646 if (curChar == 117)
2647 jjCheckNAdd(2);
2648 break;
2649 case 5:
2650 if (curChar == 116)
2651 jjstateSet[jjnewStateCnt++] = 4;
2652 break;
2653 case 6:
2654 if (curChar == 115)
2655 jjCheckNAdd(2);
2656 break;
2657 case 7:
2658 if (curChar == 108)
2659 jjstateSet[jjnewStateCnt++] = 6;
2660 break;
2661 case 8:
2662 if (curChar == 97)
2663 jjstateSet[jjnewStateCnt++] = 7;
2664 break;
2665 case 9:
2666 if (curChar == 102)
2667 jjstateSet[jjnewStateCnt++] = 8;
2668 break;
2669 case 12:
2670 if ((0x2000000020L & l) != 0L)
2671 jjAddStates(38, 39);
2672 break;
2673 case 15:
2674 if ((0x5000000050L & l) != 0L && kind > 35)
2675 kind = 35;
2676 break;
2677 case 39:
2678 if ((0xffffffffefffffffL & l) != 0L)
2679 jjCheckNAddStates(8, 10);
2680 break;
2681 case 40:
2682 if (curChar == 92)
2683 jjAddStates(40, 42);
2684 break;
2685 case 41:
2686 if ((0x14404410000000L & l) != 0L)
2687 jjCheckNAddStates(8, 10);
2688 break;
2689 case 51:
2690 if ((0x100000001000L & l) != 0L && kind > 34)
2691 kind = 34;
2692 break;
2693 case 59:
2694 if ((0x2000000020L & l) != 0L)
2695 jjAddStates(43, 44);
2696 break;
2697 case 63:
2698 if ((0x2000000020L & l) != 0L)
2699 jjAddStates(45, 46);
2700 break;
2701 case 67:
2702 if ((0x2000000020L & l) != 0L)
2703 jjAddStates(47, 48);
2704 break;
2705 default : break;
2706 }
2707 } while(i != startsAt);
2708 }
2709 else
2710 {
2711 int i2 = (curChar & 0xff) >> 6;
2712 long l2 = 1L << (curChar & 077);
2713 MatchLoop: do
2714 {
2715 switch(jjstateSet[--i])
2716 {
2717 case 39:
2718 if ((jjbitVec0[i2] & l2) != 0L)
2719 jjAddStates(8, 10);
2720 break;
2721 default : break;
2722 }
2723 } while(i != startsAt);
2724 }
2725 if (kind != 0x7fffffff)
2726 {
2727 jjmatchedKind = kind;
2728 jjmatchedPos = curPos;
2729 kind = 0x7fffffff;
2730 }
2731 ++curPos;
2732 if ((i = jjnewStateCnt) == (startsAt = 70 - (jjnewStateCnt = startsAt)))
2733 return curPos;
2734 try { curChar = input_stream.readChar(); }
2735 catch(java.io.IOException e) { return curPos; }
2736 }
2737 }
2738 static final int[] jjnextStates = {
2739 56, 57, 62, 63, 66, 67, 15, 30, 39, 40, 42, 54, 51, 18, 51, 52,
2740 29, 48, 49, 11, 12, 15, 19, 20, 24, 25, 26, 27, 39, 40, 44, 42,
2741 58, 59, 15, 66, 67, 15, 13, 14, 41, 43, 45, 60, 61, 64, 65, 68,
2742 69,
2743 };
2744 public static final String[] jjstrLiteralImages = {
2745 "", null, null, null, null, null, "\75\75", "\74\75", "\76\75", "\41\75",
2746 "\76", "\74", "\53", "\55", "\52", "\57", "\45", "\136", "\46\46", "\174\174", "\41",
2747 "\176", "\46", "\174", "\50", "\51", "\173", "\175", "\54", "\151\146",
2748 "\164\150\145\156", "\145\154\163\145", null, null, null, null, null, null, null, null, null, null,
2749 null, };
2750 public static final String[] lexStateNames = {
2751 "DEFAULT",
2752 };
2753 static final long[] jjtoToken = {
2754 0x7fffffffc1L,
2755 };
2756 static final long[] jjtoSkip = {
2757 0x3eL,
2758 };
2759 private ASCII_CharStream input_stream;
2760 private final int[] jjrounds = new int[70];
2761 private final int[] jjstateSet = new int[140];
2762 protected char curChar;
2763 public RestrictionParserTokenManager(ASCII_CharStream stream)
2764 {
2765 if (ASCII_CharStream.staticFlag)
2766 throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
2767 input_stream = stream;
2768 }
2769 public RestrictionParserTokenManager(ASCII_CharStream stream, int lexState)
2770 {
2771 this(stream);
2772 SwitchTo(lexState);
2773 }
2774 public void ReInit(ASCII_CharStream stream)
2775 {
2776 jjmatchedPos = jjnewStateCnt = 0;
2777 curLexState = defaultLexState;
2778 input_stream = stream;
2779 ReInitRounds();
2780 }
2781 private final void ReInitRounds()
2782 {
2783 int i;
2784 jjround = 0x80000001;
2785 for (i = 70; i-- > 0;)
2786 jjrounds[i] = 0x80000000;
2787 }
2788 public void ReInit(ASCII_CharStream stream, int lexState)
2789 {
2790 ReInit(stream);
2791 SwitchTo(lexState);
2792 }
2793 public void SwitchTo(int lexState)
2794 {
2795 if (lexState >= 1 || lexState < 0)
2796 throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
2797 else
2798 curLexState = lexState;
2799 }
2800
2801 private final Token jjFillToken()
2802 {
2803 Token t = Token.newToken(jjmatchedKind);
2804 t.kind = jjmatchedKind;
2805 String im = jjstrLiteralImages[jjmatchedKind];
2806 t.image = (im == null) ? input_stream.GetImage() : im;
2807 t.beginLine = input_stream.getBeginLine();
2808 t.beginColumn = input_stream.getBeginColumn();
2809 t.endLine = input_stream.getEndLine();
2810 t.endColumn = input_stream.getEndColumn();
2811 return t;
2812 }
2813
2814 int curLexState = 0;
2815 int defaultLexState = 0;
2816 int jjnewStateCnt;
2817 int jjround;
2818 int jjmatchedPos;
2819 int jjmatchedKind;
2820
2821 public final Token getNextToken()
2822 {
2823 int kind;
2824 Token specialToken = null;
2825 Token matchedToken;
2826 int curPos = 0;
2827
2828
2829 try {
2830
2831 EOFLoop :
2832 for (;;)
2833 {
2834 try
2835 {
2836 curChar = input_stream.BeginToken();
2837 }
2838 catch(java.io.IOException e)
2839 {
2840 jjmatchedKind = 0;
2841 matchedToken = jjFillToken();
2842 return matchedToken;
2843 }
2844
2845 try {
2846 while (curChar <= 32 && (0x100003600L & (1L << curChar)) != 0L)
2847 curChar = input_stream.BeginToken();
2848 }
2849
2850 catch(java.io.IOException e1) {
2851 jjmatchedKind = 0;
2852 matchedToken = new Token();
2853 matchedToken.kind = 0;
2854 matchedToken.image = "<EOF>";
2855 matchedToken.specialToken = specialToken;
2856 matchedToken.next = null;
2857 return matchedToken;
2858 }
2859
2860 jjmatchedKind = 0x7fffffff;
2861 jjmatchedPos = 0;
2862 curPos = jjMoveStringLiteralDfa0_0();
2863 if (jjmatchedKind != 0x7fffffff)
2864 {
2865 if (jjmatchedPos + 1 < curPos)
2866 input_stream.backup(curPos - jjmatchedPos - 1);
2867 if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
2868 {
2869 matchedToken = jjFillToken();
2870 return matchedToken;
2871 }
2872 else
2873 {
2874 continue EOFLoop;
2875 }
2876 }
2877 int error_line = input_stream.getEndLine();
2878 int error_column = input_stream.getEndColumn();
2879 String error_after = null;
2880 boolean EOFSeen = false;
2881 try { input_stream.readChar(); input_stream.backup(1); }
2882 catch (java.io.IOException e1) {
2883 EOFSeen = true;
2884 error_after = curPos <= 1 ? "" : input_stream.GetImage();
2885 if (curChar == '\n' || curChar == '\r') {
2886 error_line++;
2887 error_column = 0;
2888 }
2889 else
2890 error_column++;
2891 }
2892 if (!EOFSeen) {
2893 input_stream.backup(1);
2894 error_after = curPos <= 1 ? "" : input_stream.GetImage();
2895 }
2896 throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
2897 }
2898
2899 }
2900 catch(Exception x) {
2901 jjmatchedKind = 0;
2902 matchedToken = new Token();
2903 matchedToken.kind = 0;
2904 matchedToken.image = "<EOF>";
2905 matchedToken.specialToken = specialToken;
2906 matchedToken.next = null;
2907 return matchedToken;
2908 }
2909
2910 }
2911
2912 }