|
1
2 package org.objectweb.speedo.query.parser;
3
4
5 public class SpeedoQLimplements SpeedoQLTreeConstants, SpeedoQLConstants {
6 protected JJTSpeedoQLState jjtree = new JJTSpeedoQLState();
7
8 public static void main(String  args[]) throws ParseException {
9 SpeedoQL parser;
10 if (args.length == 0) {
11 System.out.println("SpeedoQL Parser : Reading from standard input . . .");
12 parser = new SpeedoQL(System.in);
13 } else if (args.length == 1) {
14 System.out.println("SpeedoQL Parser : Reading from file " + args[0] + " . . .");
15 try {
16 parser = new SpeedoQL(new java.io.FileInputStream (args[0]));
17 } catch (java.io.FileNotFoundException e) {
18 System.out.println("SpeedoQL Parser : File " + args[0] + " not found.");
19 return;
20 }
21 } else {
22 System.out.println("SpeedoQL Parser : Usage is one of:");
23 System.out.println(" java org.objectweb.speedo.test.conform.query.SpeedoQL < inputfile");
24 System.out.println("OR");
25 System.out.println(" java org.objectweb.speedo.test.conform.query.SpeedoQL inputfile");
26 return;
27 }
28 try {
29 SimpleNode sn = parser.SpeedoQL();
30 sn.dump("");
31 System.out.println("SpeedoQL Parser : Java program parsed successfully.");
32 } catch (ParseException e) {
33 System.out.println("SpeedoQL Parser : Encountered errors during parse.");
34 e.printStackTrace();
35 }
36 }
37
38
41 final public SimpleNode SpeedoQL() throws ParseException {
42
43 ASTSpeedoQL jjtn000 = new ASTSpeedoQL(JJTSPEEDOQL);
44 boolean jjtc000 = true;
45 jjtree.openNodeScope(jjtn000);
46 try {
47 SpeedoPrimary();
48 jj_consume_token(0);
49 jjtree.closeNodeScope(jjtn000, true);
50 jjtc000 = false;
51 {
52 if (true) return jjtn000;
53 }
54 } catch (Throwable jjte000) {
55 if (jjtc000) {
56 jjtree.clearNodeScope(jjtn000);
57 jjtc000 = false;
58 } else {
59 jjtree.popNode();
60 }
61 if (jjte000 instanceof RuntimeException ) {
62 {
63 if (true) throw (RuntimeException ) jjte000;
64 }
65 }
66 if (jjte000 instanceof ParseException) {
67 {
68 if (true) throw (ParseException) jjte000;
69 }
70 }
71 {
72 if (true) throw (Error ) jjte000;
73 }
74 } finally {
75 if (jjtc000) {
76 jjtree.closeNodeScope(jjtn000, true);
77 }
78 }
79 throw new Error ("Missing return statement in function");
80 }
81
82 final public void SpeedoPrimary() throws ParseException {
83
84 ASTSpeedoPrimary jjtn000 = new ASTSpeedoPrimary(JJTSPEEDOPRIMARY);
85 boolean jjtc000 = true;
86 jjtree.openNodeScope(jjtn000);
87 try {
88 label_1:
89 while (true) {
90 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
91 case NULL:
92 case TRUE:
93 case FALSE:
94 case INTEGER_LITERAL:
95 case FLOATING_POINT_LITERAL:
96 case CHARACTER_LITERAL:
97 case STRING_LITERAL:
98 case IDENTIFIER:
99 case 45:
100 ;
101 break;
102 default:
103 jj_la1[0] = jj_gen;
104 break label_1;
105 }
106 Primary();
107 }
108 } catch (Throwable jjte000) {
109 if (jjtc000) {
110 jjtree.clearNodeScope(jjtn000);
111 jjtc000 = false;
112 } else {
113 jjtree.popNode();
114 }
115 if (jjte000 instanceof RuntimeException ) {
116 {
117 if (true) throw (RuntimeException ) jjte000;
118 }
119 }
120 if (jjte000 instanceof ParseException) {
121 {
122 if (true) throw (ParseException) jjte000;
123 }
124 }
125 {
126 if (true) throw (Error ) jjte000;
127 }
128 } finally {
129 if (jjtc000) {
130 jjtree.closeNodeScope(jjtn000, true);
131 }
132 }
133 }
134
135 final public void Primary() throws ParseException {
136
137 ASTPrimary jjtn000 = new ASTPrimary(JJTPRIMARY);
138 boolean jjtc000 = true;
139 jjtree.openNodeScope(jjtn000);
140 Token t;
141 try {
142 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
143 case 45:
144 jj_consume_token(45);
145 Expression();
146 jj_consume_token(46);
147 label_2:
148 while (true) {
149 if (jj_2_1(2)) {
150 ;
151 } else {
152 break label_2;
153 }
154 jj_consume_token(DOT);
155 t = jj_consume_token(IDENTIFIER);
156 jjtn000.value = jjtn000.value + "." + t.image;
157 label_3:
158 while (true) {
159 if (jj_2_2(2)) {
160 ;
161 } else {
162 break label_3;
163 }
164 jj_consume_token(DOT);
165 t = jj_consume_token(IDENTIFIER);
166 jjtn000.value = jjtn000.value +"." + t.image;
167 }
168 label_4:
169 while (true) {
170 if (jj_2_3(2)) {
171 ;
172 } else {
173 break label_4;
174 }
175 ArgumentList();
176 }
177 label_5:
178 while (true) {
179 if (jj_2_4(2)) {
180 ;
181 } else {
182 break label_5;
183 }
184 jj_consume_token(DOT);
185 t = jj_consume_token(IDENTIFIER);
186 jjtn000.value = jjtn000.value + "." + t.image;
187 }
188 }
189 break;
190 case IDENTIFIER:
191 QualifiedName();
192 label_6:
193 while (true) {
194 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
195 case 45:
196 ;
197 break;
198 default:
199 jj_la1[1] = jj_gen;
200 break label_6;
201 }
202 ArgumentList();
203 }
204 label_7:
205 while (true) {
206 if (jj_2_5(2)) {
207 ;
208 } else {
209 break label_7;
210 }
211 jj_consume_token(DOT);
212 t = jj_consume_token(IDENTIFIER);
213 jjtn000.value = jjtn000.value + "." + t.image;
214 label_8:
215 while (true) {
216 if (jj_2_6(2)) {
217 ;
218 } else {
219 break label_8;
220 }
221 jj_consume_token(DOT);
222 t = jj_consume_token(IDENTIFIER);
223 jjtn000.value = jjtn000.value + "." + t.image;
224 }
225 label_9:
226 while (true) {
227 if (jj_2_7(2)) {
228 ;
229 } else {
230 break label_9;
231 }
232 ArgumentList();
233 }
234 label_10:
235 while (true) {
236 if (jj_2_8(2)) {
237 ;
238 } else {
239 break label_10;
240 }
241 jj_consume_token(DOT);
242 t = jj_consume_token(IDENTIFIER);
243 jjtn000.value = jjtn000.value + "." + t.image;
244 }
245 }
246 break;
247 case NULL:
248 case TRUE:
249 case FALSE:
250 case INTEGER_LITERAL:
251 case FLOATING_POINT_LITERAL:
252 case CHARACTER_LITERAL:
253 case STRING_LITERAL:
254 Literal();
255 label_11:
256 while (true) {
257 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
258 case DOT:
259 ;
260 break;
261 default:
262 jj_la1[2] = jj_gen;
263 break label_11;
264 }
265 jj_consume_token(DOT);
266 t = jj_consume_token(IDENTIFIER);
267 jjtn000.value = jjtn000.value + "." + t.image;
268 label_12:
269 while (true) {
270 if (jj_2_9(2)) {
271 ;
272 } else {
273 break label_12;
274 }
275 jj_consume_token(DOT);
276 t = jj_consume_token(IDENTIFIER);
277 jjtn000.value = jjtn000.value + "." + t.image;
278 }
279 label_13:
280 while (true) {
281 if (jj_2_10(2)) {
282 ;
283 } else {
284 break label_13;
285 }
286 ArgumentList();
287 }
288 label_14:
289 while (true) {
290 if (jj_2_11(2)) {
291 ;
292 } else {
293 break label_14;
294 }
295 jj_consume_token(DOT);
296 t = jj_consume_token(IDENTIFIER);
297 jjtn000.value = jjtn000.value + "." + t.image;
298 }
299 }
300 break;
301 default:
302 jj_la1[3] = jj_gen;
303 jj_consume_token(-1);
304 throw new ParseException();
305 }
306 } catch (Throwable jjte000) {
307 if (jjtc000) {
308 jjtree.clearNodeScope(jjtn000);
309 jjtc000 = false;
310 } else {
311 jjtree.popNode();
312 }
313 if (jjte000 instanceof RuntimeException ) {
314 {
315 if (true) throw (RuntimeException ) jjte000;
316 }
317 }
318 if (jjte000 instanceof ParseException) {
319 {
320 if (true) throw (ParseException) jjte000;
321 }
322 }
323 {
324 if (true) throw (Error ) jjte000;
325 }
326 } finally {
327 if (jjtc000) {
328 jjtree.closeNodeScope(jjtn000, true);
329 }
330 }
331 }
332
333
334 final public void Expression() throws ParseException {
335 RelationalExpression();
336 }
337
338 final public void RelationalExpression() throws ParseException {
339
340 ASTRelationalExpression jjtn000 = new ASTRelationalExpression(JJTRELATIONALEXPRESSION);
341 boolean jjtc000 = true;
342 jjtree.openNodeScope(jjtn000);
343 Token t;
344 try {
345 AdditiveExpression();
346 label_15:
347 while (true) {
348 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
349 case LT:
350 case GT:
351 case LTE:
352 case GTE:
353 case EQ:
354 case NEQ:
355 case OR:
356 case AND:
357 case BITWISEOR:
358 case BITWISEXOR:
359 case BITWISEAND:
360 ;
361 break;
362 default:
363 jj_la1[4] = jj_gen;
364 break label_15;
365 }
366 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
367 case OR:
368 t = jj_consume_token(OR);
369 break;
370 case AND:
371 t = jj_consume_token(AND);
372 break;
373 case BITWISEOR:
374 t = jj_consume_token(BITWISEOR);
375 break;
376 case BITWISEXOR:
377 t = jj_consume_token(BITWISEXOR);
378 break;
379 case BITWISEAND:
380 t = jj_consume_token(BITWISEAND);
381 break;
382 case EQ:
383 t = jj_consume_token(EQ);
384 break;
385 case NEQ:
386 t = jj_consume_token(NEQ);
387 break;
388 case LT:
389 t = jj_consume_token(LT);
390 break;
391 case GT:
392 t = jj_consume_token(GT);
393 break;
394 case GTE:
395 t = jj_consume_token(GTE);
396 break;
397 case LTE:
398 t = jj_consume_token(LTE);
399 break;
400 default:
401 jj_la1[5] = jj_gen;
402 jj_consume_token(-1);
403 throw new ParseException();
404 }
405 jjtn000.ops.add(new Integer (t.kind));
406 AdditiveExpression();
407 }
408 } catch (Throwable jjte000) {
409 if (jjtc000) {
410 jjtree.clearNodeScope(jjtn000);
411 jjtc000 = false;
412 } else {
413 jjtree.popNode();
414 }
415 if (jjte000 instanceof RuntimeException ) {
416 {
417 if (true) throw (RuntimeException ) jjte000;
418 }
419 }
420 if (jjte000 instanceof ParseException) {
421 {
422 if (true) throw (ParseException) jjte000;
423 }
424 }
425 {
426 if (true) throw (Error ) jjte000;
427 }
428 } finally {
429 if (jjtc000) {
430 jjtree.closeNodeScope(jjtn000, true);
431 }
432 }
433 }
434
435 final public void AdditiveExpression() throws ParseException {
436
437 ASTAdditiveExpression jjtn000 = new ASTAdditiveExpression(JJTADDITIVEEXPRESSION);
438 boolean jjtc000 = true;
439 jjtree.openNodeScope(jjtn000);
440 Token t;
441 try {
442 UnaryExpression();
443 label_16:
444 while (true) {
445 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
446 case PLUS:
447 case MINUS:
448 case MULT:
449 case DIV:
450 ;
451 break;
452 default:
453 jj_la1[6] = jj_gen;
454 break label_16;
455 }
456 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
457 case PLUS:
458 t = jj_consume_token(PLUS);
459 break;
460 case MINUS:
461 t = jj_consume_token(MINUS);
462 break;
463 case MULT:
464 t = jj_consume_token(MULT);
465 break;
466 case DIV:
467 t = jj_consume_token(DIV);
468 break;
469 default:
470 jj_la1[7] = jj_gen;
471 jj_consume_token(-1);
472 throw new ParseException();
473 }
474 jjtn000.ops.add(new Integer (t.kind));
475 UnaryExpression();
476 }
477 } catch (Throwable jjte000) {
478 if (jjtc000) {
479 jjtree.clearNodeScope(jjtn000);
480 jjtc000 = false;
481 } else {
482 jjtree.popNode();
483 }
484 if (jjte000 instanceof RuntimeException ) {
485 {
486 if (true) throw (RuntimeException ) jjte000;
487 }
488 }
489 if (jjte000 instanceof ParseException) {
490 {
491 if (true) throw (ParseException) jjte000;
492 }
493 }
494 {
495 if (true) throw (Error ) jjte000;
496 }
497 } finally {
498 if (jjtc000) {
499 jjtree.closeNodeScope(jjtn000, true);
500 }
501 }
502 }
503
504 final public void UnaryExpression() throws ParseException {
505
506 ASTUnaryExpression jjtn000 = new ASTUnaryExpression(JJTUNARYEXPRESSION);
507 boolean jjtc000 = true;
508 jjtree.openNodeScope(jjtn000);
509 Token t;
510 try {
511 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
512 case PLUS:
513 case MINUS:
514 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
515 case PLUS:
516 t = jj_consume_token(PLUS);
517 break;
518 case MINUS:
519 t = jj_consume_token(MINUS);
520 break;
521 default:
522 jj_la1[8] = jj_gen;
523 jj_consume_token(-1);
524 throw new ParseException();
525 }
526 jjtn000.ops.add(new Integer (t.kind));
527 UnaryExpression();
528 break;
529 case BITWISECOMPL:
530 case NOT:
531 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
532 case BITWISECOMPL:
533 t = jj_consume_token(BITWISECOMPL);
534 break;
535 case NOT:
536 t = jj_consume_token(NOT);
537 break;
538 default:
539 jj_la1[9] = jj_gen;
540 jj_consume_token(-1);
541 throw new ParseException();
542 }
543 jjtn000.ops.add(new Integer (t.kind));
544 UnaryExpression();
545 break;
546 default:
547 jj_la1[10] = jj_gen;
548 if (jj_2_12(2147483647)) {
549 CastExpression();
550 } else if (jj_2_13(2147483647)) {
551 PostfixExpression();
552 } else {
553 jj_consume_token(-1);
554 throw new ParseException();
555 }
556 }
557 } catch (Throwable jjte000) {
558 if (jjtc000) {
559 jjtree.clearNodeScope(jjtn000);
560 jjtc000 = false;
561 } else {
562 jjtree.popNode();
563 }
564 if (jjte000 instanceof RuntimeException ) {
565 {
566 if (true) throw (RuntimeException ) jjte000;
567 }
568 }
569 if (jjte000 instanceof ParseException) {
570 {
571 if (true) throw (ParseException) jjte000;
572 }
573 }
574 {
575 if (true) throw (Error ) jjte000;
576 }
577 } finally {
578 if (jjtc000) {
579 jjtree.closeNodeScope(jjtn000, true);
580 }
581 }
582 }
583
584 final public void PostfixExpression() throws ParseException {
585 if (jj_2_14(2147483647)) {
586 Primary();
587 } else if (jj_2_15(2147483647)) {
588 QualifiedName();
589 } else {
590 jj_consume_token(-1);
591 throw new ParseException();
592 }
593 }
594
595 final public void CastExpression() throws ParseException {
596
597 ASTCastExpression jjtn000 = new ASTCastExpression(JJTCASTEXPRESSION);
598 boolean jjtc000 = true;
599 jjtree.openNodeScope(jjtn000);
600 try {
601 jj_consume_token(45);
602 Type();
603 jj_consume_token(46);
604 UnaryExpression();
605 } catch (Throwable jjte000) {
606 if (jjtc000) {
607 jjtree.clearNodeScope(jjtn000);
608 jjtc000 = false;
609 } else {
610 jjtree.popNode();
611 }
612 if (jjte000 instanceof RuntimeException ) {
613 {
614 if (true) throw (RuntimeException ) jjte000;
615 }
616 }
617 if (jjte000 instanceof ParseException) {
618 {
619 if (true) throw (ParseException) jjte000;
620 }
621 }
622 {
623 if (true) throw (Error ) jjte000;
624 }
625 } finally {
626 if (jjtc000) {
627 jjtree.closeNodeScope(jjtn000, true);
628 }
629 }
630 }
631
632 final public void ArgumentList() throws ParseException {
633
634 ASTArgumentList jjtn000 = new ASTArgumentList(JJTARGUMENTLIST);
635 boolean jjtc000 = true;
636 jjtree.openNodeScope(jjtn000);
637 try {
638 jj_consume_token(45);
639 label_17:
640 while (true) {
641 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
642 case NULL:
643 case TRUE:
644 case FALSE:
645 case PLUS:
646 case MINUS:
647 case BITWISECOMPL:
648 case NOT:
649 case INTEGER_LITERAL:
650 case FLOATING_POINT_LITERAL:
651 case CHARACTER_LITERAL:
652 &nb
|
Java API By Example, From Geeks To Geeks.