|
1
2
5
6 package com.hp.hpl.jena.rdql.parser ;
7
8 public class RDQLParserimplements RDQLParserTreeConstants, RDQLParserConstants {
9 protected JJTRDQLParserState jjtree = new JJTRDQLParserState();public SimpleNode top()
10 {
11 return (SimpleNode)jjtree.rootNode() ;
12 }
13
14 final public void CompilationUnit() throws ParseException {
16 Query();
17 jj_consume_token(0);
18 }
19
20 final public void CommaOpt() throws ParseException {
22 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
23 case COMMA:
24 jj_consume_token(COMMA);
25 break;
26 default:
27 jj_la1[0] = jj_gen;
28 ;
29 }
30 }
31
32 final public void Query() throws ParseException {
34
35 Q_Query jjtn000 = new Q_Query(JJTQUERY);
36 boolean jjtc000 = true;
37 jjtree.openNodeScope(jjtn000);
38 try {
39 SelectClause();
40 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
41 case SOURCE:
42 case FROM:
43 SourceClause();
44 break;
45 default:
46 jj_la1[1] = jj_gen;
47 ;
48 }
49 TriplePatternClause();
50 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
51 case SUCHTHAT:
52 ConstraintClause();
53 break;
54 default:
55 jj_la1[2] = jj_gen;
56 ;
57 }
58 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
59 case PREFIXES:
60 PrefixesClause();
61 break;
62 default:
63 jj_la1[3] = jj_gen;
64 ;
65 }
66 } catch (Throwable  jjte000) {
67 if (jjtc000) {
68 jjtree.clearNodeScope(jjtn000);
69 jjtc000 = false;
70 } else {
71 jjtree.popNode();
72 }
73 if (jjte000 instanceof RuntimeException ) {
74 {if (true) throw (RuntimeException )jjte000;}
75 }
76 if (jjte000 instanceof ParseException) {
77 {if (true) throw (ParseException)jjte000;}
78 }
79 {if (true) throw (Error )jjte000;}
80 } finally {
81 if (jjtc000) {
82 jjtree.closeNodeScope(jjtn000, true);
83 }
84 }
85 }
86
87 final public void SelectClause() throws ParseException {
88
89 Q_SelectClause jjtn000 = new Q_SelectClause(JJTSELECTCLAUSE);
90 boolean jjtc000 = true;
91 jjtree.openNodeScope(jjtn000);
92 try {
93 if (jj_2_1(2)) {
94 jj_consume_token(SELECT);
95 Var();
96 label_1:
97 while (true) {
98 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
99 case COMMA:
100 case HOOK:
101 ;
102 break;
103 default:
104 jj_la1[4] = jj_gen;
105 break label_1;
106 }
107 CommaOpt();
108 Var();
109 }
110 } else {
111 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
112 case SELECT:
113 jj_consume_token(SELECT);
114 jj_consume_token(STAR);
115 break;
116 default:
117 jj_la1[5] = jj_gen;
118 jj_consume_token(-1);
119 throw new ParseException();
120 }
121 }
122 } catch (Throwable jjte000) {
123 if (jjtc000) {
124 jjtree.clearNodeScope(jjtn000);
125 jjtc000 = false;
126 } else {
127 jjtree.popNode();
128 }
129 if (jjte000 instanceof RuntimeException ) {
130 {if (true) throw (RuntimeException )jjte000;}
131 }
132 if (jjte000 instanceof ParseException) {
133 {if (true) throw (ParseException)jjte000;}
134 }
135 {if (true) throw (Error )jjte000;}
136 } finally {
137 if (jjtc000) {
138 jjtree.closeNodeScope(jjtn000, true);
139 }
140 }
141 }
142
143 final public void SourceClause() throws ParseException {
144
145 Q_SourceClause jjtn000 = new Q_SourceClause(JJTSOURCECLAUSE);
146 boolean jjtc000 = true;
147 jjtree.openNodeScope(jjtn000);
148 try {
149 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
150 case SOURCE:
151 jj_consume_token(SOURCE);
152 break;
153 case FROM:
154 jj_consume_token(FROM);
155 break;
156 default:
157 jj_la1[6] = jj_gen;
158 jj_consume_token(-1);
159 throw new ParseException();
160 }
161 SourceSelector();
162 label_2:
163 while (true) {
164 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
165 case COMMA:
166 case LT:
167 ;
168 break;
169 default:
170 jj_la1[7] = jj_gen;
171 break label_2;
172 }
173 CommaOpt();
174 SourceSelector();
175 }
176 } catch (Throwable jjte000) {
177 if (jjtc000) {
178 jjtree.clearNodeScope(jjtn000);
179 jjtc000 = false;
180 } else {
181 jjtree.popNode();
182 }
183 if (jjte000 instanceof RuntimeException ) {
184 {if (true) throw (RuntimeException )jjte000;}
185 }
186 if (jjte000 instanceof ParseException) {
187 {if (true) throw (ParseException)jjte000;}
188 }
189 {if (true) throw (Error )jjte000;}
190 } finally {
191 if (jjtc000) {
192 jjtree.closeNodeScope(jjtn000, true);
193 }
194 }
195 }
196
197 final public void SourceSelector() throws ParseException {
198
199 Q_SourceSelector jjtn000 = new Q_SourceSelector(JJTSOURCESELECTOR);
200 boolean jjtc000 = true;
201 jjtree.openNodeScope(jjtn000);
202 try {
203 URL();
204 } catch (Throwable jjte000) {
205 if (jjtc000) {
206 jjtree.clearNodeScope(jjtn000);
207 jjtc000 = false;
208 } else {
209 jjtree.popNode();
210 }
211 if (jjte000 instanceof RuntimeException ) {
212 {if (true) throw (RuntimeException )jjte000;}
213 }
214 if (jjte000 instanceof ParseException) {
215 {if (true) throw (ParseException)jjte000;}
216 }
217 {if (true) throw (Error )jjte000;}
218 } finally {
219 if (jjtc000) {
220 jjtree.closeNodeScope(jjtn000, true);
221 }
222 }
223 }
224
225 final public void TriplePatternClause() throws ParseException {
226
227 Q_TriplePatternClause jjtn000 = new Q_TriplePatternClause(JJTTRIPLEPATTERNCLAUSE);
228 boolean jjtc000 = true;
229 jjtree.openNodeScope(jjtn000);
230 try {
231 jj_consume_token(WHERE);
232 TriplePattern();
233 label_3:
234 while (true) {
235 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
236 case LPAREN:
237 case COMMA:
238 ;
239 break;
240 default:
241 jj_la1[8] = jj_gen;
242 break label_3;
243 }
244 CommaOpt();
245 TriplePattern();
246 }
247 } catch (Throwable jjte000) {
248 if (jjtc000) {
249 jjtree.clearNodeScope(jjtn000);
250 jjtc000 = false;
251 } else {
252 jjtree.popNode();
253 }
254 if (jjte000 instanceof RuntimeException ) {
255 {if (true) throw (RuntimeException )jjte000;}
256 }
257 if (jjte000 instanceof ParseException) {
258 {if (true) throw (ParseException)jjte000;}
259 }
260 {if (true) throw (Error )jjte000;}
261 } finally {
262 if (jjtc000) {
263 jjtree.closeNodeScope(jjtn000, true);
264 }
265 }
266 }
267
268 final public void ConstraintClause() throws ParseException {
269
270 Q_ConstraintClause jjtn000 = new Q_ConstraintClause(JJTCONSTRAINTCLAUSE);
271 boolean jjtc000 = true;
272 jjtree.openNodeScope(jjtn000);
273 try {
274 jj_consume_token(SUCHTHAT);
275 Expression();
276 label_4:
277 while (true) {
278 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
279 case SUCHTHAT:
280 case COMMA:
281 ;
282 break;
283 default:
284 jj_la1[9] = jj_gen;
285 break label_4;
286 }
287 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
288 case COMMA:
289 jj_consume_token(COMMA);
290 break;
291 case SUCHTHAT:
292 jj_consume_token(SUCHTHAT);
293 break;
294 default:
295 jj_la1[10] = jj_gen;
296 jj_consume_token(-1);
297 throw new ParseException();
298 }
299 Expression();
300 }
301 } catch (Throwable jjte000) {
302 if (jjtc000) {
303 jjtree.clearNodeScope(jjtn000);
304 jjtc000 = false;
305 } else {
306 jjtree.popNode();
307 }
308 if (jjte000 instanceof RuntimeException ) {
309 {if (true) throw (RuntimeException )jjte000;}
310 }
311 if (jjte000 instanceof ParseException) {
312 {if (true) throw (ParseException)jjte000;}
313 }
314 {if (true) throw (Error )jjte000;}
315 } finally {
316 if (jjtc000) {
317 jjtree.closeNodeScope(jjtn000, true);
318 }
319 }
320 }
321
322 final public void TriplePattern() throws ParseException {
323
324 Q_TriplePattern jjtn000 = new Q_TriplePattern(JJTTRIPLEPATTERN);
325 boolean jjtc000 = true;
326 jjtree.openNodeScope(jjtn000);
327 try {
328 jj_consume_token(LPAREN);
329 VarOrURI();
330 CommaOpt();
331 VarOrURI();
332 CommaOpt();
333 VarOrLiteral();
334 jj_consume_token(RPAREN);
335 } catch (Throwable jjte000) {
336 if (jjtc000) {
337 jjtree.clearNodeScope(jjtn000);
338 jjtc000 = false;
339 } else {
340 jjtree.popNode();
341 }
342 if (jjte000 instanceof RuntimeException ) {
343 {if (true) throw (RuntimeException )jjte000;}
344 }
345 if (jjte000 instanceof ParseException) {
346 {if (true) throw (ParseException)jjte000;}
347 }
348 {if (true) throw (Error )jjte000;}
349 } finally {
350 if (jjtc000) {
351 jjtree.closeNodeScope(jjtn000, true);
352 }
353 }
354 }
355
356 final public void VarOrURI() throws ParseException {
357 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
358 case HOOK:
359 Var();
360 break;
361 case SELECT:
362 case SOURCE:
363 case FROM:
364 case WHERE:
365 case SUCHTHAT:
366 case PREFIXES:
367 case FOR:
368 case STR_EQ:
369 case STR_NE:
370 case NCName:
371 case LT:
372 URI();
373 break;
374 default:
375 jj_la1[11] = jj_gen;
376 jj_consume_token(-1);
377 throw new ParseException();
378 }
379 }
380
381 final public void VarOrLiteral() throws ParseException {
382 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
383 case HOOK:
384 Var();
385 break;
386 case INTEGER_LITERAL:
387 case FLOATING_POINT_LITERAL:
388 case STRING_LITERAL1:
389 case STRING_LITERAL2:
390 case SELECT:
391 case SOURCE:
392 case FROM:
393 case WHERE:
394 case SUCHTHAT:
395 case PREFIXES:
396 case FOR:
397 case STR_EQ:
398 case STR_NE:
399 case BOOLEAN_LITERAL:
400 case NULL_LITERAL:
401 case NCName:
402 case LT:
403 Literal();
404 break;
405 default:
406 jj_la1[12] = jj_gen;
407 jj_consume_token(-1);
408 throw new ParseException();
409 }
410 }
411
412 final public void Var() throws ParseException {
413
414 Q_Var jjtn000 = new Q_Var(JJTVAR);
415 boolean jjtc000 = true;
416 jjtree.openNodeScope(jjtn000);
417 try {
418 jj_consume_token(HOOK);
419 Identifier();
420 } catch (Throwable jjte000) {
421 if (jjtc000) {
422 jjtree.clearNodeScope(jjtn000);
423 jjtc000 = false;
424 } else {
425 jjtree.popNode();
426 }
427 if (jjte000 instanceof RuntimeException ) {
428 {if (true) throw (RuntimeException )jjte000;}
429 }
430 if (jjte000 instanceof ParseException) {
431 {if (true) throw (ParseException)jjte000;}
432 }
433 {if (true) throw (Error )jjte000;}
434 } finally {
435 if (jjtc000) {
436 jjtree.closeNodeScope(jjtn000, true);
437 }
438 }
439 }
440
441 final public void PrefixesClause() throws ParseException {
442
443 Q_PrefixesClause jjtn000 = new Q_PrefixesClause(JJTPREFIXESCLAUSE);
444 boolean jjtc000 = true;
445 jjtree.openNodeScope(jjtn000);
446 try {
447 jj_consume_token(PREFIXES);
448 PrefixDecl();
449 label_5:
450 while (true) {
451 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
452 case SELECT:
453 case SOURCE:
454 case FROM:
455 case WHERE:
456 case SUCHTHAT:
457 case PREFIXES:
458 case FOR:
459 case STR_EQ:
460 case STR_NE:
461 case NCName:
462 case COMMA:
463 ;
464 break;
465 default:
466 jj_la1[13] = jj_gen;
467 break label_5;
468 }
469 CommaOpt();
470 PrefixDecl();
471 }
472 } catch (Throwable jjte000) {
473 if (jjtc000) {
474 jjtree.clearNodeScope(jjtn000);
475 jjtc000 = false;
476 } else {
477 jjtree.popNode();
478 }
479 if (jjte000 instanceof RuntimeException ) {
480 {if (true) throw (RuntimeException )jjte000;}
481 }
482 if (jjte000 instanceof ParseException) {
483 {if (true) throw (ParseException)jjte000;}
484 }
485 {if (true) throw (Error )jjte000;}
486 } finally {
487 if (jjtc000) {
488 jjtree.closeNodeScope(jjtn000, true);
489 }
490 }
491 }
492
493 final public void PrefixDecl() throws ParseException {
494
495 Q_PrefixDecl jjtn000 = new Q_PrefixDecl(JJTPREFIXDECL);
496 boolean jjtc000 = true;
497 jjtree.openNodeScope(jjtn000);
498 try {
499 Identifier();
500 jj_consume_token(FOR);
501 QuotedURI();
502 } catch (Throwable jjte000) {
503 if (jjtc000) {
504 jjtree.clearNodeScope(jjtn000);
505 jjtc000 = false;
506 } else {
507 jjtree.popNode();
508 }
509 if (jjte000 instanceof RuntimeException ) {
510 {if (true) throw (RuntimeException )jjte000;}
511 }
512 if (jjte000 instanceof ParseException) {
513 {if (true) throw (ParseException)jjte000;}
514 }
515 {if (true) throw (Error )jjte000;}
516 } finally {
517 if (jjtc000) {
518 jjtree.closeNodeScope(jjtn000, true);
519 }
520 }
521 }
522
523
524
526 final public void Expression() throws ParseException {
528 ConditionalOrExpression();
529 }
530
531 final public void ConditionalOrExpression() throws ParseException {
532 ConditionalXorExpression();
533 label_6:
534 while (true) {
535 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
536 case SC_OR:
537 ;
538 break;
539 default:
540 jj_la1[14] = jj_gen;
541 break label_6;
542 }
543 jj_consume_token(SC_OR);
544 Q_LogicalOr jjtn001 = new Q_LogicalOr(JJTLOGICALOR);
545 boolean jjtc001 = true;
546 jjtree.openNodeScope(jjtn001);
547 try {
548 ConditionalXorExpression();
549 } catch (Throwable jjte001) {
550 if (jjtc001) {
551 jjtree.clearNodeScope(jjtn001);
552 jjtc001 = false;
553 } else {
554 jjtree.popNode();
555 }
556 if (jjte001 instanceof RuntimeException ) {
557 {if (true) throw (RuntimeException )jjte001;}
558 }
559 if (jjte001 instanceof ParseException) {
560 {if (true) throw (ParseException)jjte001;}
561 }
562 {if (true) throw (Error )jjte001;}
563 } finally {
564 if (jjtc001) {
565 jjtree.closeNodeScope(jjtn001, 2);
566 }
567 }
568 }
569 }
570
571 final public void ConditionalXorExpression() throws ParseException {
572 ConditionalAndExpression();
573 }
574
575 final public void ConditionalAndExpression() throws ParseException {
576 ValueLogical();
577 label_7:
578 while (true) {
579 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
580 case SC_AND:
581 ;
582 break;
583 default:
584 jj_la1[15] = jj_gen;
585 break label_7;
586 }
587 jj_consume_token(SC_AND);
588 Q_LogicalAnd jjtn001 = new Q_LogicalAnd(JJTLOGICALAND);
589 boolean jjtc001 = true;
590 jjtree.openNodeScope(jjtn001);
591 try {
592 ValueLogical();
593 } catch (Throwable jjte001) {
594 if (jjtc001) {
595 jjtree.clearNodeScope(jjtn001);
596 jjtc001 = false;
597 } else {
598 jjtree.popNode();
599 }
600 if (jjte001 instanceof RuntimeException ) {
601 {if (true) throw (RuntimeException )jjte001;}
602 }
603 if (jjte001 instanceof ParseException) {
604 {if (true) throw (ParseException)jjte001;}
605 }
606 {if (true) throw (Error )jjte001;}
607 } finally {
608 if (jjtc001) {
609 jjtree.closeNodeScope(jjtn001, 2);
610 }
611 }
612 }
613 }
614
615
617
618
619 final public void ValueLogical() throws ParseException {
621 StringEqualityExpression();
622 }
623
624 final public void StringEqualityExpression() throws ParseException {
625 NumericalLogical();
626 label_8:
627 while (true) {
628 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
629 case STR_EQ:
630 case STR_NE:
631 case STR_LANGEQ:
632 case STR_MATCH:
633 case STR_NMATCH:
634 ;
635 break;
636 default:
637 jj_la1[16] = jj_gen;
638 break label_8;
639 }
640 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
641 case STR_EQ:
642 jj_consume_token(STR_EQ);
643 Q_StringEqual jjtn001 = new Q_StringEqual(JJTSTRINGEQUAL);
644 boolean jjtc001 = true;
645 jjtree.openNodeScope(jjtn001);
646 try {
647 NumericalLogical();
648 } catch (Throwable jjte001) {
649 if (jjtc001) {
650 jjtree.clearNodeScope(jjtn001);
651 jjtc001 = false;
652 } else {
653 jjtree.popNode();
654 }
655 if (jjte001 instanceof RuntimeException ) {
656 {if (true) throw (RuntimeException )jjte001;}
657 }
658 if (jjte001 instanceof ParseException) {
659 {if (true) throw (ParseException)jjte001;}
660 }
661 {if (true) throw (Error )jjte001;}
662 } finally {
663 if (jjtc001) {
664 jjtree.closeNodeScope(jjtn001, 2);
665 }
666 }
667 break;
668 case STR_NE:
669 jj_consume_token(STR_NE);
670 Q_StringNotEqual jjtn002 = new Q_StringNotEqual(JJTSTRINGNOTEQUAL);
671 boolean jjtc002 = true;
672 jjtree.openNodeScope(jjtn002);
673 try {
674 NumericalLogical();
675 } catch (Throwable jjte002) {
676 if (jjtc002) {
677 jjtree.clearNodeScope(jjtn002);
678 jjtc002 = false;
679 } else {
680 jjtree.popNode();
681 }
682 if (jjte002 instanceof RuntimeException ) {
683 {if (true) throw (RuntimeException )jjte002;}
684 }
685 if (jjte002 instanceof ParseException) {
686 {if (true) throw (ParseException)jjte002;}
687 }
688 {if (true) throw (Error )jjte002;}
689 } finally {
690 if (jjtc002) {
691 jjtree.closeNodeScope(jjtn002, 2);
692 }
693 }
694 break;
695 case STR_LANGEQ:
696 jj_consume_token(STR_LANGEQ);
697 Q_StringLangEqual jjtn003 = new Q_StringLangEqual(JJTSTRINGLANGEQUAL);
698 boolean jjtc003 = true;
699 jjtree.openNodeScope(jjtn003);
700 try {
701 TextLiteral2();
702 } catch (Throwable jjte003) {
703 if (jjtc003) {
704 jjtree.clearNodeScope(jjtn003);
705 jjtc003 = false;
706 } else {
707 jjtree.popNode();
708 }
709 if (jjte003 instanceof RuntimeException ) {
710 {if (true) throw (RuntimeException )jjte003;}
711 }
712 if (jjte003 instanceof ParseException) {
713 {if (true) throw (ParseException)jjte003;}
714 }
715 {if (true) throw (Error )jjte003;}
716 } finally {
717 if (jjtc003) {
718 jjtree.closeNodeScope(jjtn003, 2);
719 }
720 }
721 break;
722 case STR_MATCH:
723 jj_consume_token(STR_MATCH);
724 Q_StringMatch jjtn004 = new Q_StringMatch(JJTSTRINGMATCH);
725 boolean jjtc004 = true;
726 jjtree.openNodeScope(jjtn004);
727 try {
728 PatternLiteral();
729 } catch (Throwable jjte004) {
730 if (jjtc004) {
731 jjtree.clearNodeScope(jjtn004);
732 jjtc004 = false;
733 } else {
734 jjtree.popNode();
735 }
736 if (jjte004 instanceof RuntimeException ) {
737 {if (true) throw (RuntimeException )jjte004;}
738 }
739 if (jjte004 instanceof ParseException) {
740 {if (true) throw (ParseException)jjte004;}
741 }
742 {if (true) throw (Error )jjte004;}
743 } finally {
744 if (jjtc004) {
745 jjtree.closeNodeScope(jjtn004, 2);
746 }
747 }
748 break;
749 case STR_NMATCH:
750 jj_consume_token(STR_NMATCH);
751 Q_StringNoMatch jjtn005 = new Q_StringNoMatch(JJTSTRINGNOMATCH);
752 boolean jjtc005 = true;
753 jjtree.openNodeScope(jjtn005);
754 try {
755 PatternLiteral();
756 } catch (Throwable jjte005) {
757 if (jjtc005) {
758 jjtree.clearNodeScope(jjtn005);
759 jjtc005 = false;
760 } else {
761 jjtree.popNode();
762 }
763 if (jjte005 instanceof RuntimeException ) {
764 {if (true) throw (RuntimeException )jjte005;}
765 }
766 if (jjte005 instanceof ParseException) {
767 {if (true) throw (ParseException)jjte005;}
768 }
769 {if (true) throw (Error )jjte005;}
770 } finally {
771 if (jjtc005) {
772 jjtree.closeNodeScope(jjtn005, 2);
773 }
774 }
775 break;
776 default:
777 jj_la1[17] = jj_gen;
778 jj_consume_token(-1);
779 throw new ParseException();
780 }
781 }
782 }
783
784 final public void NumericalLogical() throws ParseException {
786 InclusiveOrExpression();
787 }
788
789 final public void InclusiveOrExpression() throws ParseException {
790 ExclusiveOrExpression();
791 label_9:
792 while (true) {
793 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
794 case BIT_OR:
795 ;
796 break;
797 default:
798 jj_la1[18] = jj_gen;
799 break label_9;
800 }
801 jj_consume_token(BIT_OR);
802 Q_BitOr jjtn001 = new Q_BitOr(JJTBITOR);
803 boolean jjtc001 = true;
804 jjtree.openNodeScope(jjtn001);
805 <
|
Java API By Example, From Geeks To Geeks.