1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20 package net.sourceforge.pmd.lang.plsql.ast;
21
22 import java.io.*;
23 import net.sourceforge.pmd.lang.ast.Node;
24 import net.sourceforge.pmd.lang.ast.SimpleCharStream;
25 import net.sourceforge.pmd.lang.ast.TokenMgrError;
26
27 public class PLSQLParserimplements PLSQLParserTreeConstants, PLSQLParserConstants {
28 protected JJTPLSQLParserState jjtree = new JJTPLSQLParserState();
29
30
31
32
33 public static void main(String[] args)
34 throws ParseException {
35
36 PLSQLParser parser = new PLSQLParser(System.in);
37 PLSQLNode node = parser.Input();
38
39 String s;
40 s = "qwerty";
41
42 s = "\u005c"qwerty\u005c"";
43
44 s = "\u005c"qwerty\u005c".uiop";
45
46 s = "\u005c"qwerty\u005c".\u005c"uiop\u005c"";
47
48 }
49
50
51
52
53 public static String canonicalName(String name)
54 {
55 StringBuilder s = null ;
56
57
58 if (null == name) {
59 return name;
60 }
61 else if (-1 == name.indexOf('"') )
62 {
63 name = name.toUpperCase();
64 s = new StringBuilder(name.trim());
65 }
66 else
67 {
68 StringBuilder oldString = new StringBuilder( name.trim().length());
69 s = new StringBuilder(name.trim());
70 boolean quotedCharacter = false ;
71 for (int i=0; i<oldString.length(); i++) {
72 if (oldString.charAt(i) == '"')
73 {
74
75 oldString.deleteCharAt(i);
76 i--;
77
78
79 quotedCharacter = !quotedCharacter ;
80 }
81 else
82 {
83 s.append( quotedCharacter
84 ? s.charAt(i)
85 : Character.toUpperCase(s.charAt(i))
86 );
87 }
88 }
89 }
90 return s.toString();
91 }
92
93
94
95
96
97
98
99
100
101
102
103 final public ASTInput Input() throws ParseException {
104
105 ASTInput jjtn000 = new ASTInput(this, JJTINPUT);
106 boolean jjtc000 = true;
107 jjtree.openNodeScope(jjtn000);
108 try {
109 label_1:
110 while (true) {
111 switch (jj_nt.kind) {
112 case 2:
113 case 3:
114 case 21:
115 case ALTER:
116 case BEGIN:
117 case COLUMN:
118 case COMMENT:
119 case COMMIT:
120 case CONNECT:
121 case CREATE:
122 case DECLARE:
123 case DELETE:
124 case DROP:
125 case EXECUTE:
126 case EXIT:
127 case FUNCTION:
128 case GRANT:
129 case INSERT:
130 case LOCK:
131 case MERGE:
132 case PACKAGE:
133 case PROMPT:
134 case PROCEDURE:
135 case RENAME:
136 case REVOKE:
137 case ROLLBACK:
138 case SAVEPOINT:
139 case SELECT:
140 case SET:
141 case START:
142 case TRIGGER:
143 case TYPE:
144 case SHOW:
145 case SPOOL:
146 case UPDATE:
147 case WITH:
148 case ANALYZE:
149 case ASSOCIATE:
150 case AUDIT:
151 case DDL:
152 case DISASSOCIATE:
153 case NOAUDIT:
154 case TRUNCATE:
155 case ACCEPT:
156 case COPY:
157 case DEFINE:
158 case DISCONNECT:
159 case HOST:
160 case PRINT:
161 case QUIT:
162 case REMARK:
163 case UNDEFINE:
164 case VARIABLE:
165 case WHENEVER:
166 case IDENTIFIER:
167 ;
168 break;
169 default:
170 jj_la1[0] = jj_gen;
171 break label_1;
172 }
173 if (jj_2_1(7)) {
174 PackageSpecification();
175 } else if (jj_2_2(7)) {
176 PackageBody();
177 } else if (jj_2_3(6)) {
178 TypeSpecification();
179 } else if (jj_2_4(6)) {
180 Table();
181 } else if (jj_2_5(6)) {
182 View();
183 } else if (jj_2_6(6)) {
184 TriggerUnit();
185 } else if (jj_2_7(6)) {
186 AlterTrigger();
187 } else if (jj_2_8(6)) {
188 Synonym();
189 } else if (jj_2_9(6)) {
190 Directory();
191 } else if (jj_2_10(6)) {
192 DatabaseLink();
193 } else if (jj_2_11(6)) {
194 Global();
195 } else if (jj_2_12(6)) {
196 DDLCommand();
197 } else if (jj_2_13(2)) {
198 SqlPlusCommand();
199 } else {
200 switch (jj_nt.kind) {
201 case COMMIT:
202 case DELETE:
203 case INSERT:
204 case LOCK:
205 case MERGE:
206 case ROLLBACK:
207 case SAVEPOINT:
208 case SELECT:
209 case UPDATE:
210 case WITH:
211 switch (jj_nt.kind) {
212 case SELECT:
213 jj_consume_token(SELECT);
214 break;
215 case UPDATE:
216 jj_consume_token(UPDATE);
217 break;
218 case INSERT:
219 jj_consume_token(INSERT);
220 break;
221 case DELETE:
222 jj_consume_token(DELETE);
223 break;
224 case COMMIT:
225 jj_consume_token(COMMIT);
226 break;
227 case ROLLBACK:
228 jj_consume_token(ROLLBACK);
229 break;
230 case SAVEPOINT:
231 jj_consume_token(SAVEPOINT);
232 break;
233 case LOCK:
234 jj_consume_token(LOCK);
235 jj_consume_token(TABLE);
236 break;
237 case MERGE:
238 jj_consume_token(MERGE);
239 break;
240 case WITH:
241 jj_consume_token(WITH);
242 break;
243 default:
244 jj_la1[1] = jj_gen;
245 jj_consume_token(-1);
246 throw new ParseException();
247 }
248 SkipPastNextTokenOccurrence(SQLPLUS_TERMINATOR);
249 break;
250 default:
251 jj_la1[2] = jj_gen;
252 jj_consume_token(-1);
253 throw new ParseException();
254 }
255 }
256 label_2:
257 while (true) {
258 switch (jj_nt.kind) {
259 case 1:
260 ;
261 break;
262 default:
263 jj_la1[3] = jj_gen;
264 break label_2;
265 }
266 jj_consume_token(1);
267 }
268 }
269 jj_consume_token(0);
270 jjtree.closeNodeScope(jjtn000, true);
271 jjtc000 = false;
272 {if (true) return jjtn000 ;}
273 } catch (Throwable jjte000) {
274 if (jjtc000) {
275 jjtree.clearNodeScope(jjtn000);
276 jjtc000 = false;
277 } else {
278 jjtree.popNode();
279 }
280 if (jjte000 instanceof RuntimeException) {
281 {if (true) throw (RuntimeException)jjte000;}
282 }
283 if (jjte000 instanceof ParseException) {
284 {if (true) throw (ParseException)jjte000;}
285 }
286 {if (true) throw (Error)jjte000;}
287 } finally {
288 if (jjtc000) {
289 jjtree.closeNodeScope(jjtn000, true);
290 }
291 }
292 throw new Error("Missing return statement in function");
293 }
294
295 final public ASTDDLCommand DDLCommand() throws ParseException {
296
297 ASTDDLCommand jjtn000 = new ASTDDLCommand(this, JJTDDLCOMMAND);
298 boolean jjtc000 = true;
299 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
300 try {
301 simpleNode = DDLEvent();
302 SkipPastNextTokenOccurrence(SQLPLUS_TERMINATOR);
303 jjtree.closeNodeScope(jjtn000, true);
304 jjtc000 = false;
305 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
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 {if (true) throw (RuntimeException)jjte000;}
315 }
316 if (jjte000 instanceof ParseException) {
317 {if (true) throw (ParseException)jjte000;}
318 }
319 {if (true) throw (Error)jjte000;}
320 } finally {
321 if (jjtc000) {
322 jjtree.closeNodeScope(jjtn000, true);
323 }
324 }
325 throw new Error("Missing return statement in function");
326 }
327
328 final public ASTSqlPlusCommand SqlPlusCommand() throws ParseException {
329
330 ASTSqlPlusCommand jjtn000 = new ASTSqlPlusCommand(this, JJTSQLPLUSCOMMAND);
331 boolean jjtc000 = true;
332 jjtree.openNodeScope(jjtn000);StringBuilder sb = new StringBuilder() ;
333 try {
334 switch (jj_nt.kind) {
335 case 2:
336 jj_consume_token(2);
337 break;
338 case ACCEPT:
339 jj_consume_token(ACCEPT);
340 break;
341 case COLUMN:
342 jj_consume_token(COLUMN);
343 break;
344 case CONNECT:
345 jj_consume_token(CONNECT);
346 break;
347 case COPY:
348 jj_consume_token(COPY);
349 break;
350 case DEFINE:
351 jj_consume_token(DEFINE);
352 break;
353 case DISCONNECT:
354 jj_consume_token(DISCONNECT);
355 break;
356 case EXECUTE:
357 jj_consume_token(EXECUTE);
358 break;
359 case EXIT:
360 jj_consume_token(EXIT);
361 break;
362 case HOST:
363 jj_consume_token(HOST);
364 break;
365 case PRINT:
366 jj_consume_token(PRINT);
367 break;
368 case PROMPT:
369 jj_consume_token(PROMPT);
370 break;
371 case QUIT:
372 jj_consume_token(QUIT);
373 break;
374 case REMARK:
375 jj_consume_token(REMARK);
376 break;
377 case SET:
378 jj_consume_token(SET);
379 break;
380 case SHOW:
381 jj_consume_token(SHOW);
382 break;
383 case SPOOL:
384 jj_consume_token(SPOOL);
385 break;
386 case START:
387 jj_consume_token(START);
388 break;
389 case UNDEFINE:
390 jj_consume_token(UNDEFINE);
391 break;
392 case VARIABLE:
393 jj_consume_token(VARIABLE);
394 break;
395 case WHENEVER:
396 jj_consume_token(WHENEVER);
397 break;
398 case COMMENT:
399 jj_consume_token(COMMENT);
400 break;
401 case GRANT:
402 jj_consume_token(GRANT);
403 break;
404 case REVOKE:
405 jj_consume_token(REVOKE);
406 break;
407 case DROP:
408 jj_consume_token(DROP);
409 break;
410 case IDENTIFIER:
411 jj_consume_token(IDENTIFIER);
412 break;
413 case 3:
414 jj_consume_token(3);
415 jj_consume_token(ATTACH);
416 break;
417 default:
418 jj_la1[4] = jj_gen;
419 jj_consume_token(-1);
420 throw new ParseException();
421 }
422 sb.append(token.image) ; sb.append(" ...") ;
423 Skip2NextTokenOccurrence(EOL);
424 jjtree.closeNodeScope(jjtn000, true);
425 jjtc000 = false;
426 jjtn000.setImage(sb.toString()) ; {if (true) return jjtn000 ;}
427 } catch (Throwable jjte000) {
428 if (jjtc000) {
429 jjtree.clearNodeScope(jjtn000);
430 jjtc000 = false;
431 } else {
432 jjtree.popNode();
433 }
434 if (jjte000 instanceof RuntimeException) {
435 {if (true) throw (RuntimeException)jjte000;}
436 }
437 if (jjte000 instanceof ParseException) {
438 {if (true) throw (ParseException)jjte000;}
439 }
440 {if (true) throw (Error)jjte000;}
441 } finally {
442 if (jjtc000) {
443 jjtree.closeNodeScope(jjtn000, true);
444 }
445 }
446 throw new Error("Missing return statement in function");
447 }
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474 final public ASTGlobal Global() throws ParseException {
475
476 ASTGlobal jjtn000 = new ASTGlobal(this, JJTGLOBAL);
477 boolean jjtc000 = true;
478 jjtree.openNodeScope(jjtn000);
479 try {
480 if (jj_2_14(2147483647)) {
481 label_3:
482 while (true) {
483 switch (jj_nt.kind) {
484 case 21:
485 ;
486 break;
487 default:
488 jj_la1[5] = jj_gen;
489 break label_3;
490 }
491 Label();
492 }
493 Block();
494 jj_consume_token(4);
495 } else if (jj_2_15(4)) {
496 ProgramUnit();
497 } else {
498 jj_consume_token(-1);
499 throw new ParseException();
500 }
501 jjtree.closeNodeScope(jjtn000, true);
502 jjtc000 = false;
503 {if (true) return jjtn000 ;}
504 } catch (Throwable jjte000) {
505 if (jjtc000) {
506 jjtree.clearNodeScope(jjtn000);
507 jjtc000 = false;
508 } else {
509 jjtree.popNode();
510 }
511 if (jjte000 instanceof RuntimeException) {
512 {if (true) throw (RuntimeException)jjte000;}
513 }
514 if (jjte000 instanceof ParseException) {
515 {if (true) throw (ParseException)jjte000;}
516 }
517 {if (true) throw (Error)jjte000;}
518 } finally {
519 if (jjtc000) {
520 jjtree.closeNodeScope(jjtn000, true);
521 }
522 }
523 throw new Error("Missing return statement in function");
524 }
525
526 final public ASTBlock Block() throws ParseException {
527
528 ASTBlock jjtn000 = new ASTBlock(this, JJTBLOCK);
529 boolean jjtc000 = true;
530 jjtree.openNodeScope(jjtn000);
531 try {
532 switch (jj_nt.kind) {
533 case DECLARE:
534 jj_consume_token(DECLARE);
535 DeclarativeSection();
536 break;
537 default:
538 jj_la1[6] = jj_gen;
539 ;
540 }
541 jj_consume_token(BEGIN);
542 label_4:
543 while (true) {
544 switch (jj_nt.kind) {
545 case 5:
546 case 16:
547 case 17:
548 case 21:
549 case REPLACE:
550 case DEFINER:
551 case CURRENT_USER:
552 case LANGUAGE:
553 case INLINE:
554 case ADD:
555 case AGGREGATE:
556 case ARRAY:
557 case AT:
558 case ATTRIBUTE:
559 case AUTHID:
560 case BEGIN:
561 case BODY:
562 case BULK:
563 case BYTE:
564 case CASCADE:
565 case CASE:
566 case CLOSE:
567 case COALESCE:
568 case COLLECT:
569 case COLUMN:
570 case COMMENT:
571 case COMMIT:
572 case CONSTRUCTOR:
573 case CONTINUE:
574 case CONVERT:
575 case CURRENT:
576 case CURSOR:
577 case DATA:
578 case DATE:
579 case DAY:
580 case DECLARE:
581 case DELETE:
582 case DISABLE:
583 case EDITIONABLE:
584 case ELEMENT:
585 case ENABLE:
586 case ESCAPE:
587 case EXCEPT:
588 case EXCEPTIONS:
589 case EXECUTE:
590 case EXIT:
591 case EXTERNAL:
592 case EXTENDS:
593 case EXTRACT:
594 case FALSE:
595 case FETCH:
596 case FINAL:
597 case FOR:
598 case FORALL:
599 case FORCE:
600 case FUNCTION:
601 case GLOBAL:
602 case GOTO:
603 case HASH:
604 case HEAP:
605 case HOUR:
606 case IF:
607 case IMMEDIATE:
608 case INDICES:
609 case INDEXTYPE:
610 case INDICATOR:
611 case INSERT:
612 case INSTANTIABLE:
613 case INTERVAL:
614 case INVALIDATE:
615 case ISOLATION:
616 case JAVA:
617 case LEVEL:
618 case LIMIT:
619 case LOCK:
620 case LOOP:
621 case MAP:
622 case MAX:
623 case MEMBER:
624 case MERGE:
625 case MIN:
626 case MINUTE:
627 case MLSLABEL:
628 case MODIFY:
629 case MOD:
630 case MONTH:
631 case NATURAL:
632 case NEW:
633 case NEW_DOT:
634 case NO:
635 case NONEDITIONABLE:
636 case NOT:
637 case NULL:
638 case NULLIF:
639 case OBJECT:
640 case OID:
641 case OPAQUE:
642 case OPEN:
643 case OPERATOR:
644 case ORGANIZATION:
645 case OTHERS:
646 case OVERRIDING:
647 case PACKAGE:
648 case PARTITION:
649 case PIPE:
650 case PRAGMA:
651 case PRESERVE:
652 case PRIVATE:
653 case PROCEDURE:
654 case RAISE:
655 case RANGE:
656 case RAW:
657 case REAL:
658 case RECORD:
659 case REF:
660 case RELEASE:
661 case RELIES_ON:
662 case RENAME:
663 case RESULT:
664 case RETURN:
665 case RETURNING:
666 case REVERSE:
667 case ROLLBACK:
668 case ROW:
669 case ROWS:
670 case ROWID:
671 case ROWNUM:
672 case SAVE:
673 case SAVEPOINT:
674 case SECOND:
675 case SELECT:
676 case SELF:
677 case SET:
678 case SPACE:
679 case SQL:
680 case SQLCODE:
681 case SQLERRM:
682 case STATIC:
683 case SUBTYPE:
684 case SUBSTITUTABLE:
685 case SUCCESSFUL:
686 case SYSDATE:
687 case SYS_REFCURSOR:
688 case TEMPORARY:
689 case TIME:
690 case TIMESTAMP:
691 case TIMEZONE_REGION:
692 case TIMEZONE_ABBR:
693 case TIMEZONE_MINUTE:
694 case TIMEZONE_HOUR:
695 case TRANSACTION:
696 case TRUE:
697 case TYPE:
698 case UNDER:
699 case USING:
700 case WHILE:
701 case YES:
702 case SHOW:
703 case A:
704 case UPDATE:
705 case DOUBLE:
706 case DEC:
707 case PRECISION:
708 case INT:
709 case NUMERIC:
710 case NCHAR:
711 case NVARCHAR2:
712 case STRING:
713 case UROWID:
714 case VARRAY:
715 case VARYING:
716 case BFILE:
717 case BLOB:
718 case CLOB:
719 case NCLOB:
720 case YEAR:
721 case LOCAL:
722 case WITH:
723 case ZONE:
724 case CHARACTER:
725 case AFTER:
726 case BEFORE:
727 case OLD:
728 case PARENT:
729 case CC_IF:
730 case CC_ERROR:
731 case ANALYZE:
732 case ASSOCIATE:
733 case AUDIT:
734 case COMPOUND:
735 case DATABASE:
736 case CALL:
737 case DDL:
738 case DISASSOCIATE:
739 case EACH:
740 case FOLLOWS:
741 case LOGOFF:
742 case LOGON:
743 case NESTED:
744 case NOAUDIT:
745 case SCHEMA:
746 case SERVERERROR:
747 case SHUTDOWN:
748 case STARTUP:
749 case STATEMENT:
750 case STATISTICS:
751 case SUSPEND:
752 case TRUNCATE:
753 case WRAPPED:
754 case LIBRARY:
755 case NAME:
756 case STRUCT:
757 case CONTEXT:
758 case PARAMETERS:
759 case LENGTH:
760 case TDO:
761 case MAXLEN:
762 case CHARSETID:
763 case CHARSETFORM:
764 case ACCEPT:
765 case ACCESSIBLE:
766 case COPY:
767 case DEFINE:
768 case DISCONNECT:
769 case HOST:
770 case PRINT:
771 case QUIT:
772 case REMARK:
773 case UNDEFINE:
774 case VARIABLE:
775 case WHENEVER:
776 case ATTACH:
777 case CAST:
778 case TREAT:
779 case TRIM:
780 case LEFT:
781 case RIGHT:
782 case BOTH:
783 case EMPTY:
784 case MULTISET:
785 case SUBMULTISET:
786 case LEADING:
787 case TRAILING:
788 case CHAR_CS:
789 case NCHAR_CS:
790 case DBTIMEZONE:
791 case SESSIONTIMEZONE:
792 case AUTHENTICATED:
793 case LINK:
794 case SHARED:
795 case DIRECTORY:
796 case USER:
797 case IDENTIFIER:
798 case UNSIGNED_NUMERIC_LITERAL:
799 case CHARACTER_LITERAL:
800 case STRING_LITERAL:
801 case QUOTED_LITERAL:
802 ;
803 break;
804 default:
805 jj_la1[7] = jj_gen;
806 break label_4;
807 }
808 Statement();
809 }
810 switch (jj_nt.kind) {
811 case EXCEPTION:
812 ExceptionHandler();
813 break;
814 default:
815 jj_la1[8] = jj_gen;
816 ;
817 }
818 jj_consume_token(END);
819 switch (jj_nt.kind) {
820 case IDENTIFIER:
821 jj_consume_token(IDENTIFIER);
822 break;
823 default:
824 jj_la1[9] = jj_gen;
825 ;
826 }
827 jjtree.closeNodeScope(jjtn000, true);
828 jjtc000 = false;
829 {if (true) return jjtn000 ;}
830 } catch (Throwable jjte000) {
831 if (jjtc000) {
832 jjtree.clearNodeScope(jjtn000);
833 jjtc000 = false;
834 } else {
835 jjtree.popNode();
836 }
837 if (jjte000 instanceof RuntimeException) {
838 {if (true) throw (RuntimeException)jjte000;}
839 }
840 if (jjte000 instanceof ParseException) {
841 {if (true) throw (ParseException)jjte000;}
842 }
843 {if (true) throw (Error)jjte000;}
844 } finally {
845 if (jjtc000) {
846 jjtree.closeNodeScope(jjtn000, true);
847 }
848 }
849 throw new Error("Missing return statement in function");
850 }
851
852 final public ASTPackageSpecification PackageSpecification() throws ParseException {
853
854 ASTPackageSpecification jjtn000 = new ASTPackageSpecification(this, JJTPACKAGESPECIFICATION);
855 boolean jjtc000 = true;
856 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
857 try {
858 switch (jj_nt.kind) {
859 case CREATE:
860 jj_consume_token(CREATE);
861 switch (jj_nt.kind) {
862 case OR:
863 jj_consume_token(OR);
864 jj_consume_token(REPLACE);
865 break;
866 default:
867 jj_la1[10] = jj_gen;
868 ;
869 }
870 switch (jj_nt.kind) {
871 case EDITIONABLE:
872 case NONEDITIONABLE:
873 switch (jj_nt.kind) {
874 case EDITIONABLE:
875 jj_consume_token(EDITIONABLE);
876 break;
877 case NONEDITIONABLE:
878 jj_consume_token(NONEDITIONABLE);
879 break;
880 default:
881 jj_la1[11] = jj_gen;
882 jj_consume_token(-1);
883 throw new ParseException();
884 }
885 break;
886 default:
887 jj_la1[12] = jj_gen;
888 ;
889 }
890 break;
891 default:
892 jj_la1[13] = jj_gen;
893 ;
894 }
895 jj_consume_token(PACKAGE);
896 simpleNode = ObjectNameDeclaration();
897 label_5:
898 while (true) {
899 switch (jj_nt.kind) {
900 case AUTHID:
901 case ACCESSIBLE:
902 ;
903 break;
904 default:
905 jj_la1[14] = jj_gen;
906 break label_5;
907 }
908 switch (jj_nt.kind) {
909 case AUTHID:
910 jj_consume_token(AUTHID);
911 switch (jj_nt.kind) {
912 case CURRENT_USER:
913 jj_consume_token(CURRENT_USER);
914 break;
915 case DEFINER:
916 jj_consume_token(DEFINER);
917 break;
918 default:
919 jj_la1[15] = jj_gen;
920 jj_consume_token(-1);
921 throw new ParseException();
922 }
923 break;
924 case ACCESSIBLE:
925 AccessibleByClause();
926 break;
927 default:
928 jj_la1[16] = jj_gen;
929 jj_consume_token(-1);
930 throw new ParseException();
931 }
932 }
933 switch (jj_nt.kind) {
934 case WRAPPED:
935 WrappedObject();
936 break;
937 case AS:
938 case IS:
939 switch (jj_nt.kind) {
940 case IS:
941 jj_consume_token(IS);
942 break;
943 case AS:
944 jj_consume_token(AS);
945 break;
946 default:
947 jj_la1[17] = jj_gen;
948 jj_consume_token(-1);
949 throw new ParseException();
950 }
951 DeclarativeSection();
952 jj_consume_token(END);
953 switch (jj_nt.kind) {
954 case REPLACE:
955 case DEFINER:
956 case CURRENT_USER:
957 case SERIALLY_REUSABLE:
958 case RESTRICT_REFERENCES:
959 case EXCEPTION_INIT:
960 case AUTONOMOUS_TRANSACTION:
961 case LANGUAGE:
962 case INLINE:
963 case ADD:
964 case AGGREGATE:
965 case ALL:
966 case ALTER:
967 case AND:
968 case ANY:
969 case ARRAY:
970 case AS:
971 case ASC:
972 case AT:
973 case ATTRIBUTE:
974 case AUTHID:
975 case AVG:
976 case BETWEEN:
977 case BINARY_INTEGER:
978 case BODY:
979 case BOOLEAN:
980 case BULK:
981 case BY:
982 case BYTE:
983 case CASCADE:
984 case CASE:
985 case CHAR:
986 case CHAR_BASE:
987 case CHECK:
988 case CLOSE:
989 case CLUSTER:
990 case COALESCE:
991 case COLLECT:
992 case COLUMN:
993 case COMMENT:
994 case COMMIT:
995 case COMPRESS:
996 case CONNECT:
997 case CONSTANT:
998 case CONSTRUCTOR:
999 case CONTINUE:
1000 case CONVERT:
1001 case CREATE:
1002 case CURRENT:
1003 case CURRVAL:
1004 case CURSOR:
1005 case DATA:
1006 case DATE:
1007 case DAY:
1008 case DECLARE:
1009 case DECIMAL:
1010 case _DEFAULT:
1011 case DELETE:
1012 case DESC:
1013 case DISABLE:
1014 case DISTINCT:
1015 case DO:
1016 case DROP:
1017 case EDITIONABLE:
1018 case ELEMENT:
1019 case ELSE:
1020 case ELSIF:
1021 case ENABLE:
1022 case ESCAPE:
1023 case EXCEPT:
1024 case EXCEPTION:
1025 case EXCEPTIONS:
1026 case EXCLUSIVE:
1027 case EXECUTE:
1028 case EXISTS:
1029 case EXIT:
1030 case EXTERNAL:
1031 case EXTENDS:
1032 case EXTRACT:
1033 case FALSE:
1034 case FETCH:
1035 case FINAL:
1036 case FLOAT:
1037 case FOR:
1038 case FORALL:
1039 case FORCE:
1040 case FROM:
1041 case FUNCTION:
1042 case GLOBAL:
1043 case GOTO:
1044 case GROUP:
1045 case HASH:
1046 case HAVING:
1047 case HEAP:
1048 case HOUR:
1049 case IF:
1050 case IMMEDIATE:
1051 case IN:
1052 case INDEX:
1053 case INDICES:
1054 case INDEXTYPE:
1055 case INDICATOR:
1056 case INSERT:
1057 case INSTANTIABLE:
1058 case INTEGER:
1059 case INTERFACE:
1060 case INTERSECT:
1061 case INTERVAL:
1062 case INTO:
1063 case INVALIDATE:
1064 case IS:
1065 case ISOLATION:
1066 case JAVA:
1067 case LEVEL:
1068 case LIKE:
1069 case LIMIT:
1070 case LIMITED:
1071 case LOCK:
1072 case LONG:
1073 case LOOP:
1074 case MAP:
1075 case MAX:
1076 case MEMBER:
1077 case MERGE:
1078 case MIN:
1079 case MINUS:
1080 case MINUTE:
1081 case MLSLABEL:
1082 case MODIFY:
1083 case MOD:
1084 case MODE:
1085 case MONTH:
1086 case NATURAL:
1087 case NATURALN:
1088 case NEW:
1089 case NEXTVAL:
1090 case NO:
1091 case NOCOPY:
1092 case NONEDITIONABLE:
1093 case NOT:
1094 case NOWAIT:
1095 case NULL:
1096 case NULLIF:
1097 case NUMBER:
1098 case BFILE_BASE:
1099 case BLOB_BASE:
1100 case CLOB_BASE:
1101 case DATE_BASE:
1102 case NUMBER_BASE:
1103 case OBJECT:
1104 case OCIROWID:
1105 case OF:
1106 case OID:
1107 case ON:
1108 case OPAQUE:
1109 case OPEN:
1110 case OPERATOR:
1111 case OPTION:
1112 case OR:
1113 case ORDER:
1114 case ORGANIZATION:
1115 case OTHERS:
1116 case OUT:
1117 case OVERRIDING:
1118 case PACKAGE:
1119 case PARTITION:
1120 case PCTFREE:
1121 case PLS_INTEGER:
1122 case POSITIVE:
1123 case POSITIVEN:
1124 case PRESERVE:
1125 case PRIOR:
1126 case PROMPT:
1127 case PRIVATE:
1128 case PROCEDURE:
1129 case PUBLIC:
1130 case RAISE:
1131 case RANGE:
1132 case RAW:
1133 case REAL:
1134 case RECORD:
1135 case REF:
1136 case RELEASE:
1137 case RELIES_ON:
1138 case RENAME:
1139 case RESULT:
1140 case RETURN:
1141 case RETURNING:
1142 case REVERSE:
1143 case ROLLBACK:
1144 case ROW:
1145 case ROWS:
1146 case ROWID:
1147 case ROWNUM:
1148 case ROWTYPE:
1149 case SAVE:
1150 case SAVEPOINT:
1151 case SECOND:
1152 case SELECT:
1153 case SELF:
1154 case SEPARATE:
1155 case SET:
1156 case SHARE:
1157 case SMALLINT:
1158 case SPACE:
1159 case SQL:
1160 case SQLCODE:
1161 case SQLERRM:
1162 case START:
1163 case STATIC:
1164 case STDDEV:
1165 case SUBTYPE:
1166 case SUBSTITUTABLE:
1167 case SUCCESSFUL:
1168 case SUM:
1169 case SYNONYM:
1170 case SYSDATE:
1171 case SYS_REFCURSOR:
1172 case TABLE:
1173 case TEMPORARY:
1174 case THEN:
1175 case TIME:
1176 case TIMESTAMP:
1177 case TIMEZONE_REGION:
1178 case TIMEZONE_ABBR:
1179 case TIMEZONE_MINUTE:
1180 case TIMEZONE_HOUR:
1181 case TO:
1182 case TRANSACTION:
1183 case TRIGGER:
1184 case TRUE:
1185 case TYPE:
1186 case UI:
1187 case UNDER:
1188 case USING:
1189 case WHILE:
1190 case YES:
1191 case SHOW:
1192 case A:
1193 case UPDATE:
1194 case VARCHAR:
1195 case VARCHAR2:
1196 case DOUBLE:
1197 case DEC:
1198 case PRECISION:
1199 case INT:
1200 case NUMERIC:
1201 case SIGNTYPE:
1202 case NCHAR:
1203 case NVARCHAR2:
1204 case STRING:
1205 case UROWID:
1206 case VARRAY:
1207 case VARYING:
1208 case BFILE:
1209 case BLOB:
1210 case CLOB:
1211 case NCLOB:
1212 case YEAR:
1213 case LOCAL:
1214 case WITH:
1215 case ZONE:
1216 case CHARACTER:
1217 case AFTER:
1218 case BEFORE:
1219 case OLD:
1220 case PARENT:
1221 case ANALYZE:
1222 case ASSOCIATE:
1223 case AUDIT:
1224 case COMPOUND:
1225 case DATABASE:
1226 case CALL:
1227 case DDL:
1228 case DISASSOCIATE:
1229 case EACH:
1230 case FOLLOWS:
1231 case LOGOFF:
1232 case LOGON:
1233 case NESTED:
1234 case NOAUDIT:
1235 case SCHEMA:
1236 case SERVERERROR:
1237 case SHUTDOWN:
1238 case STARTUP:
1239 case STATEMENT:
1240 case STATISTICS:
1241 case SUSPEND:
1242 case TRUNCATE:
1243 case WRAPPED:
1244 case LIBRARY:
1245 case NAME:
1246 case STRUCT:
1247 case CONTEXT:
1248 case PARAMETERS:
1249 case LENGTH:
1250 case TDO:
1251 case MAXLEN:
1252 case CHARSETID:
1253 case CHARSETFORM:
1254 case ACCEPT:
1255 case ACCESSIBLE:
1256 case COPY:
1257 case DEFINE:
1258 case DISCONNECT:
1259 case HOST:
1260 case PRINT:
1261 case QUIT:
1262 case REMARK:
1263 case UNDEFINE:
1264 case VARIABLE:
1265 case WHENEVER:
1266 case ATTACH:
1267 case CAST:
1268 case TREAT:
1269 case TRIM:
1270 case LEFT:
1271 case RIGHT:
1272 case BOTH:
1273 case EMPTY:
1274 case MULTISET:
1275 case SUBMULTISET:
1276 case LEADING:
1277 case TRAILING:
1278 case CHAR_CS:
1279 case NCHAR_CS:
1280 case DBTIMEZONE:
1281 case SESSIONTIMEZONE:
1282 case AUTHENTICATED:
1283 case LINK:
1284 case SHARED:
1285 case DIRECTORY:
1286 case USER:
1287 case IDENTIFIER:
1288 case QUOTED_LITERAL:
1289 case SQLDATA_CLASS:
1290 case CUSTOMDATUM_CLASS:
1291 case ORADATA_CLASS:
1292 case JAVA_INTERFACE_CLASS:
1293 ID();
1294 break;
1295 default:
1296 jj_la1[18] = jj_gen;
1297 ;
1298 }
1299 jj_consume_token(4);
1300 break;
1301 default:
1302 jj_la1[19] = jj_gen;
1303 jj_consume_token(-1);
1304 throw new ParseException();
1305 }
1306 jjtree.closeNodeScope(jjtn000, true);
1307 jjtc000 = false;
1308 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
1309 } catch (Throwable jjte000) {
1310 if (jjtc000) {
1311 jjtree.clearNodeScope(jjtn000);
1312 jjtc000 = false;
1313 } else {
1314 jjtree.popNode();
1315 }
1316 if (jjte000 instanceof RuntimeException) {
1317 {if (true) throw (RuntimeException)jjte000;}
1318 }
1319 if (jjte000 instanceof ParseException) {
1320 {if (true) throw (ParseException)jjte000;}
1321 }
1322 {if (true) throw (Error)jjte000;}
1323 } finally {
1324 if (jjtc000) {
1325 jjtree.closeNodeScope(jjtn000, true);
1326 }
1327 }
1328 throw new Error("Missing return statement in function");
1329 }
1330
1331 final public ASTPackageBody PackageBody() throws ParseException {
1332
1333 ASTPackageBody jjtn000 = new ASTPackageBody(this, JJTPACKAGEBODY);
1334 boolean jjtc000 = true;
1335 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
1336 try {
1337 switch (jj_nt.kind) {
1338 case CREATE:
1339 jj_consume_token(CREATE);
1340 switch (jj_nt.kind) {
1341 case OR:
1342 jj_consume_token(OR);
1343 jj_consume_token(REPLACE);
1344 break;
1345 default:
1346 jj_la1[20] = jj_gen;
1347 ;
1348 }
1349 switch (jj_nt.kind) {
1350 case EDITIONABLE:
1351 case NONEDITIONABLE:
1352 switch (jj_nt.kind) {
1353 case EDITIONABLE:
1354 jj_consume_token(EDITIONABLE);
1355 break;
1356 case NONEDITIONABLE:
1357 jj_consume_token(NONEDITIONABLE);
1358 break;
1359 default:
1360 jj_la1[21] = jj_gen;
1361 jj_consume_token(-1);
1362 throw new ParseException();
1363 }
1364 break;
1365 default:
1366 jj_la1[22] = jj_gen;
1367 ;
1368 }
1369 break;
1370 default:
1371 jj_la1[23] = jj_gen;
1372 ;
1373 }
1374 switch (jj_nt.kind) {
1375 case PACKAGE:
1376 jj_consume_token(PACKAGE);
1377 break;
1378 case TYPE:
1379 jj_consume_token(TYPE);
1380 break;
1381 default:
1382 jj_la1[24] = jj_gen;
1383 jj_consume_token(-1);
1384 throw new ParseException();
1385 }
1386 jj_consume_token(BODY);
1387 simpleNode = ObjectNameDeclaration();
1388 switch (jj_nt.kind) {
1389 case WRAPPED:
1390 WrappedObject();
1391 break;
1392 case AS:
1393 case IS:
1394 switch (jj_nt.kind) {
1395 case IS:
1396 jj_consume_token(IS);
1397 break;
1398 case AS:
1399 jj_consume_token(AS);
1400 break;
1401 default:
1402 jj_la1[25] = jj_gen;
1403 jj_consume_token(-1);
1404 throw new ParseException();
1405 }
1406 DeclarativeSection();
1407 switch (jj_nt.kind) {
1408 case BEGIN:
1409 jj_consume_token(BEGIN);
1410 label_6:
1411 while (true) {
1412 switch (jj_nt.kind) {
1413 case 5:
1414 case 16:
1415 case 17:
1416 case 21:
1417 case REPLACE:
1418 case DEFINER:
1419 case CURRENT_USER:
1420 case LANGUAGE:
1421 case INLINE:
1422 case ADD:
1423 case AGGREGATE:
1424 case ARRAY:
1425 case AT:
1426 case ATTRIBUTE:
1427 case AUTHID:
1428 case BEGIN:
1429 case BODY:
1430 case BULK:
1431 case BYTE:
1432 case CASCADE:
1433 case CASE:
1434 case CLOSE:
1435 case COALESCE:
1436 case COLLECT:
1437 case COLUMN:
1438 case COMMENT:
1439 case COMMIT:
1440 case CONSTRUCTOR:
1441 case CONTINUE:
1442 case CONVERT:
1443 case CURRENT:
1444 case CURSOR:
1445 case DATA:
1446 case DATE:
1447 case DAY:
1448 case DECLARE:
1449 case DELETE:
1450 case DISABLE:
1451 case EDITIONABLE:
1452 case ELEMENT:
1453 case ENABLE:
1454 case ESCAPE:
1455 case EXCEPT:
1456 case EXCEPTIONS:
1457 case EXECUTE:
1458 case EXIT:
1459 case EXTERNAL:
1460 case EXTENDS:
1461 case EXTRACT:
1462 case FALSE:
1463 case FETCH:
1464 case FINAL:
1465 case FOR:
1466 case FORALL:
1467 case FORCE:
1468 case FUNCTION:
1469 case GLOBAL:
1470 case GOTO:
1471 case HASH:
1472 case HEAP:
1473 case HOUR:
1474 case IF:
1475 case IMMEDIATE:
1476 case INDICES:
1477 case INDEXTYPE:
1478 case INDICATOR:
1479 case INSERT:
1480 case INSTANTIABLE:
1481 case INTERVAL:
1482 case INVALIDATE:
1483 case ISOLATION:
1484 case JAVA:
1485 case LEVEL:
1486 case LIMIT:
1487 case LOCK:
1488 case LOOP:
1489 case MAP:
1490 case MAX:
1491 case MEMBER:
1492 case MERGE:
1493 case MIN:
1494 case MINUTE:
1495 case MLSLABEL:
1496 case MODIFY:
1497 case MOD:
1498 case MONTH:
1499 case NATURAL:
1500 case NEW:
1501 case NEW_DOT:
1502 case NO:
1503 case NONEDITIONABLE:
1504 case NOT:
1505 case NULL:
1506 case NULLIF:
1507 case OBJECT:
1508 case OID:
1509 case OPAQUE:
1510 case OPEN:
1511 case OPERATOR:
1512 case ORGANIZATION:
1513 case OTHERS:
1514 case OVERRIDING:
1515 case PACKAGE:
1516 case PARTITION:
1517 case PIPE:
1518 case PRAGMA:
1519 case PRESERVE:
1520 case PRIVATE:
1521 case PROCEDURE:
1522 case RAISE:
1523 case RANGE:
1524 case RAW:
1525 case REAL:
1526 case RECORD:
1527 case REF:
1528 case RELEASE:
1529 case RELIES_ON:
1530 case RENAME:
1531 case RESULT:
1532 case RETURN:
1533 case RETURNING:
1534 case REVERSE:
1535 case ROLLBACK:
1536 case ROW:
1537 case ROWS:
1538 case ROWID:
1539 case ROWNUM:
1540 case SAVE:
1541 case SAVEPOINT:
1542 case SECOND:
1543 case SELECT:
1544 case SELF:
1545 case SET:
1546 case SPACE:
1547 case SQL:
1548 case SQLCODE:
1549 case SQLERRM:
1550 case STATIC:
1551 case SUBTYPE:
1552 case SUBSTITUTABLE:
1553 case SUCCESSFUL:
1554 case SYSDATE:
1555 case SYS_REFCURSOR:
1556 case TEMPORARY:
1557 case TIME:
1558 case TIMESTAMP:
1559 case TIMEZONE_REGION:
1560 case TIMEZONE_ABBR:
1561 case TIMEZONE_MINUTE:
1562 case TIMEZONE_HOUR:
1563 case TRANSACTION:
1564 case TRUE:
1565 case TYPE:
1566 case UNDER:
1567 case USING:
1568 case WHILE:
1569 case YES:
1570 case SHOW:
1571 case A:
1572 case UPDATE:
1573 case DOUBLE:
1574 case DEC:
1575 case PRECISION:
1576 case INT:
1577 case NUMERIC:
1578 case NCHAR:
1579 case NVARCHAR2:
1580 case STRING:
1581 case UROWID:
1582 case VARRAY:
1583 case VARYING:
1584 case BFILE:
1585 case BLOB:
1586 case CLOB:
1587 case NCLOB:
1588 case YEAR:
1589 case LOCAL:
1590 case WITH:
1591 case ZONE:
1592 case CHARACTER:
1593 case AFTER:
1594 case BEFORE:
1595 case OLD:
1596 case PARENT:
1597 case CC_IF:
1598 case CC_ERROR:
1599 case ANALYZE:
1600 case ASSOCIATE:
1601 case AUDIT:
1602 case COMPOUND:
1603 case DATABASE:
1604 case CALL:
1605 case DDL:
1606 case DISASSOCIATE:
1607 case EACH:
1608 case FOLLOWS:
1609 case LOGOFF:
1610 case LOGON:
1611 case NESTED:
1612 case NOAUDIT:
1613 case SCHEMA:
1614 case SERVERERROR:
1615 case SHUTDOWN:
1616 case STARTUP:
1617 case STATEMENT:
1618 case STATISTICS:
1619 case SUSPEND:
1620 case TRUNCATE:
1621 case WRAPPED:
1622 case LIBRARY:
1623 case NAME:
1624 case STRUCT:
1625 case CONTEXT:
1626 case PARAMETERS:
1627 case LENGTH:
1628 case TDO:
1629 case MAXLEN:
1630 case CHARSETID:
1631 case CHARSETFORM:
1632 case ACCEPT:
1633 case ACCESSIBLE:
1634 case COPY:
1635 case DEFINE:
1636 case DISCONNECT:
1637 case HOST:
1638 case PRINT:
1639 case QUIT:
1640 case REMARK:
1641 case UNDEFINE:
1642 case VARIABLE:
1643 case WHENEVER:
1644 case ATTACH:
1645 case CAST:
1646 case TREAT:
1647 case TRIM:
1648 case LEFT:
1649 case RIGHT:
1650 case BOTH:
1651 case EMPTY:
1652 case MULTISET:
1653 case SUBMULTISET:
1654 case LEADING:
1655 case TRAILING:
1656 case CHAR_CS:
1657 case NCHAR_CS:
1658 case DBTIMEZONE:
1659 case SESSIONTIMEZONE:
1660 case AUTHENTICATED:
1661 case LINK:
1662 case SHARED:
1663 case DIRECTORY:
1664 case USER:
1665 case IDENTIFIER:
1666 case UNSIGNED_NUMERIC_LITERAL:
1667 case CHARACTER_LITERAL:
1668 case STRING_LITERAL:
1669 case QUOTED_LITERAL:
1670 ;
1671 break;
1672 default:
1673 jj_la1[26] = jj_gen;
1674 break label_6;
1675 }
1676 Statement();
1677 }
1678 switch (jj_nt.kind) {
1679 case EXCEPTION:
1680 ExceptionHandler();
1681 break;
1682 default:
1683 jj_la1[27] = jj_gen;
1684 ;
1685 }
1686 break;
1687 default:
1688 jj_la1[28] = jj_gen;
1689 ;
1690 }
1691 jj_consume_token(END);
1692 switch (jj_nt.kind) {
1693 case REPLACE:
1694 case DEFINER:
1695 case CURRENT_USER:
1696 case SERIALLY_REUSABLE:
1697 case RESTRICT_REFERENCES:
1698 case EXCEPTION_INIT:
1699 case AUTONOMOUS_TRANSACTION:
1700 case LANGUAGE:
1701 case INLINE:
1702 case ADD:
1703 case AGGREGATE:
1704 case ALL:
1705 case ALTER:
1706 case AND:
1707 case ANY:
1708 case ARRAY:
1709 case AS:
1710 case ASC:
1711 case AT:
1712 case ATTRIBUTE:
1713 case AUTHID:
1714 case AVG:
1715 case BETWEEN:
1716 case BINARY_INTEGER:
1717 case BODY:
1718 case BOOLEAN:
1719 case BULK:
1720 case BY:
1721 case BYTE:
1722 case CASCADE:
1723 case CASE:
1724 case CHAR:
1725 case CHAR_BASE:
1726 case CHECK:
1727 case CLOSE:
1728 case CLUSTER:
1729 case COALESCE:
1730 case COLLECT:
1731 case COLUMN:
1732 case COMMENT:
1733 case COMMIT:
1734 case COMPRESS:
1735 case CONNECT:
1736 case CONSTANT:
1737 case CONSTRUCTOR:
1738 case CONTINUE:
1739 case CONVERT:
1740 case CREATE:
1741 case CURRENT:
1742 case CURRVAL:
1743 case CURSOR:
1744 case DATA:
1745 case DATE:
1746 case DAY:
1747 case DECLARE:
1748 case DECIMAL:
1749 case _DEFAULT:
1750 case DELETE:
1751 case DESC:
1752 case DISABLE:
1753 case DISTINCT:
1754 case DO:
1755 case DROP:
1756 case EDITIONABLE:
1757 case ELEMENT:
1758 case ELSE:
1759 case ELSIF:
1760 case ENABLE:
1761 case ESCAPE:
1762 case EXCEPT:
1763 case EXCEPTION:
1764 case EXCEPTIONS:
1765 case EXCLUSIVE:
1766 case EXECUTE:
1767 case EXISTS:
1768 case EXIT:
1769 case EXTERNAL:
1770 case EXTENDS:
1771 case EXTRACT:
1772 case FALSE:
1773 case FETCH:
1774 case FINAL:
1775 case FLOAT:
1776 case FOR:
1777 case FORALL:
1778 case FORCE:
1779 case FROM:
1780 case FUNCTION:
1781 case GLOBAL:
1782 case GOTO:
1783 case GROUP:
1784 case HASH:
1785 case HAVING:
1786 case HEAP:
1787 case HOUR:
1788 case IF:
1789 case IMMEDIATE:
1790 case IN:
1791 case INDEX:
1792 case INDICES:
1793 case INDEXTYPE:
1794 case INDICATOR:
1795 case INSERT:
1796 case INSTANTIABLE:
1797 case INTEGER:
1798 case INTERFACE:
1799 case INTERSECT:
1800 case INTERVAL:
1801 case INTO:
1802 case INVALIDATE:
1803 case IS:
1804 case ISOLATION:
1805 case JAVA:
1806 case LEVEL:
1807 case LIKE:
1808 case LIMIT:
1809 case LIMITED:
1810 case LOCK:
1811 case LONG:
1812 case LOOP:
1813 case MAP:
1814 case MAX:
1815 case MEMBER:
1816 case MERGE:
1817 case MIN:
1818 case MINUS:
1819 case MINUTE:
1820 case MLSLABEL:
1821 case MODIFY:
1822 case MOD:
1823 case MODE:
1824 case MONTH:
1825 case NATURAL:
1826 case NATURALN:
1827 case NEW:
1828 case NEXTVAL:
1829 case NO:
1830 case NOCOPY:
1831 case NONEDITIONABLE:
1832 case NOT:
1833 case NOWAIT:
1834 case NULL:
1835 case NULLIF:
1836 case NUMBER:
1837 case BFILE_BASE:
1838 case BLOB_BASE:
1839 case CLOB_BASE:
1840 case DATE_BASE:
1841 case NUMBER_BASE:
1842 case OBJECT:
1843 case OCIROWID:
1844 case OF:
1845 case OID:
1846 case ON:
1847 case OPAQUE:
1848 case OPEN:
1849 case OPERATOR:
1850 case OPTION:
1851 case OR:
1852 case ORDER:
1853 case ORGANIZATION:
1854 case OTHERS:
1855 case OUT:
1856 case OVERRIDING:
1857 case PACKAGE:
1858 case PARTITION:
1859 case PCTFREE:
1860 case PLS_INTEGER:
1861 case POSITIVE:
1862 case POSITIVEN:
1863 case PRESERVE:
1864 case PRIOR:
1865 case PROMPT:
1866 case PRIVATE:
1867 case PROCEDURE:
1868 case PUBLIC:
1869 case RAISE:
1870 case RANGE:
1871 case RAW:
1872 case REAL:
1873 case RECORD:
1874 case REF:
1875 case RELEASE:
1876 case RELIES_ON:
1877 case RENAME:
1878 case RESULT:
1879 case RETURN:
1880 case RETURNING:
1881 case REVERSE:
1882 case ROLLBACK:
1883 case ROW:
1884 case ROWS:
1885 case ROWID:
1886 case ROWNUM:
1887 case ROWTYPE:
1888 case SAVE:
1889 case SAVEPOINT:
1890 case SECOND:
1891 case SELECT:
1892 case SELF:
1893 case SEPARATE:
1894 case SET:
1895 case SHARE:
1896 case SMALLINT:
1897 case SPACE:
1898 case SQL:
1899 case SQLCODE:
1900 case SQLERRM:
1901 case START:
1902 case STATIC:
1903 case STDDEV:
1904 case SUBTYPE:
1905 case SUBSTITUTABLE:
1906 case SUCCESSFUL:
1907 case SUM:
1908 case SYNONYM:
1909 case SYSDATE:
1910 case SYS_REFCURSOR:
1911 case TABLE:
1912 case TEMPORARY:
1913 case THEN:
1914 case TIME:
1915 case TIMESTAMP:
1916 case TIMEZONE_REGION:
1917 case TIMEZONE_ABBR:
1918 case TIMEZONE_MINUTE:
1919 case TIMEZONE_HOUR:
1920 case TO:
1921 case TRANSACTION:
1922 case TRIGGER:
1923 case TRUE:
1924 case TYPE:
1925 case UI:
1926 case UNDER:
1927 case USING:
1928 case WHILE:
1929 case YES:
1930 case SHOW:
1931 case A:
1932 case UPDATE:
1933 case VARCHAR:
1934 case VARCHAR2:
1935 case DOUBLE:
1936 case DEC:
1937 case PRECISION:
1938 case INT:
1939 case NUMERIC:
1940 case SIGNTYPE:
1941 case NCHAR:
1942 case NVARCHAR2:
1943 case STRING:
1944 case UROWID:
1945 case VARRAY:
1946 case VARYING:
1947 case BFILE:
1948 case BLOB:
1949 case CLOB:
1950 case NCLOB:
1951 case YEAR:
1952 case LOCAL:
1953 case WITH:
1954 case ZONE:
1955 case CHARACTER:
1956 case AFTER:
1957 case BEFORE:
1958 case OLD:
1959 case PARENT:
1960 case ANALYZE:
1961 case ASSOCIATE:
1962 case AUDIT:
1963 case COMPOUND:
1964 case DATABASE:
1965 case CALL:
1966 case DDL:
1967 case DISASSOCIATE:
1968 case EACH:
1969 case FOLLOWS:
1970 case LOGOFF:
1971 case LOGON:
1972 case NESTED:
1973 case NOAUDIT:
1974 case SCHEMA:
1975 case SERVERERROR:
1976 case SHUTDOWN:
1977 case STARTUP:
1978 case STATEMENT:
1979 case STATISTICS:
1980 case SUSPEND:
1981 case TRUNCATE:
1982 case WRAPPED:
1983 case LIBRARY:
1984 case NAME:
1985 case STRUCT:
1986 case CONTEXT:
1987 case PARAMETERS:
1988 case LENGTH:
1989 case TDO:
1990 case MAXLEN:
1991 case CHARSETID:
1992 case CHARSETFORM:
1993 case ACCEPT:
1994 case ACCESSIBLE:
1995 case COPY:
1996 case DEFINE:
1997 case DISCONNECT:
1998 case HOST:
1999 case PRINT:
2000 case QUIT:
2001 case REMARK:
2002 case UNDEFINE:
2003 case VARIABLE:
2004 case WHENEVER:
2005 case ATTACH:
2006 case CAST:
2007 case TREAT:
2008 case TRIM:
2009 case LEFT:
2010 case RIGHT:
2011 case BOTH:
2012 case EMPTY:
2013 case MULTISET:
2014 case SUBMULTISET:
2015 case LEADING:
2016 case TRAILING:
2017 case CHAR_CS:
2018 case NCHAR_CS:
2019 case DBTIMEZONE:
2020 case SESSIONTIMEZONE:
2021 case AUTHENTICATED:
2022 case LINK:
2023 case SHARED:
2024 case DIRECTORY:
2025 case USER:
2026 case IDENTIFIER:
2027 case QUOTED_LITERAL:
2028 case SQLDATA_CLASS:
2029 case CUSTOMDATUM_CLASS:
2030 case ORADATA_CLASS:
2031 case JAVA_INTERFACE_CLASS:
2032 ID();
2033 break;
2034 default:
2035 jj_la1[29] = jj_gen;
2036 ;
2037 }
2038 jj_consume_token(4);
2039 break;
2040 default:
2041 jj_la1[30] = jj_gen;
2042 jj_consume_token(-1);
2043 throw new ParseException();
2044 }
2045 jjtree.closeNodeScope(jjtn000, true);
2046 jjtc000 = false;
2047 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
2048 } catch (Throwable jjte000) {
2049 if (jjtc000) {
2050 jjtree.clearNodeScope(jjtn000);
2051 jjtc000 = false;
2052 } else {
2053 jjtree.popNode();
2054 }
2055 if (jjte000 instanceof RuntimeException) {
2056 {if (true) throw (RuntimeException)jjte000;}
2057 }
2058 if (jjte000 instanceof ParseException) {
2059 {if (true) throw (ParseException)jjte000;}
2060 }
2061 {if (true) throw (Error)jjte000;}
2062 } finally {
2063 if (jjtc000) {
2064 jjtree.closeNodeScope(jjtn000, true);
2065 }
2066 }
2067 throw new Error("Missing return statement in function");
2068 }
2069
2070 final public ASTDeclarativeUnit DeclarativeUnit() throws ParseException {
2071
2072 ASTDeclarativeUnit jjtn000 = new ASTDeclarativeUnit(this, JJTDECLARATIVEUNIT);
2073 boolean jjtc000 = true;
2074 jjtree.openNodeScope(jjtn000);
2075 try {
2076 switch (jj_nt.kind) {
2077 case PRAGMA:
2078 Pragma();
2079 break;
2080 default:
2081 jj_la1[31] = jj_gen;
2082 if (jj_2_16(2)) {
2083 ExceptionDeclaration();
2084 } else if (jj_2_17(2147483647)) {
2085 SubTypeDefinition();
2086 } else if (jj_2_18(2147483647)) {
2087 ProgramUnit();
2088 } else if (jj_2_19(4)) {
2089 VariableOrConstantDeclaration();
2090 } else if (jj_2_20(2)) {
2091 CursorSpecification();
2092 } else {
2093 switch (jj_nt.kind) {
2094 case CURSOR:
2095 CursorBody();
2096 break;
2097 case IDENTIFIER:
2098 CollectionDeclaration();
2099 break;
2100 case CONSTRUCTOR:
2101 case CREATE:
2102 case FINAL:
2103 case FUNCTION:
2104 case INSTANTIABLE:
2105 case MAP:
2106 case MEMBER:
2107 case NOT:
2108 case ORDER:
2109 case OVERRIDING:
2110 case PROCEDURE:
2111 case STATIC:
2112 MethodDeclaration();
2113 break;
2114 case CC_IF:
2115 CompilationDeclarationFragment();
2116 break;
2117 default:
2118 jj_la1[32] = jj_gen;
2119 jj_consume_token(-1);
2120 throw new ParseException();
2121 }
2122 }
2123 }
2124 jjtree.closeNodeScope(jjtn000, true);
2125 jjtc000 = false;
2126 {if (true) return jjtn000 ;}
2127 } catch (Throwable jjte000) {
2128 if (jjtc000) {
2129 jjtree.clearNodeScope(jjtn000);
2130 jjtc000 = false;
2131 } else {
2132 jjtree.popNode();
2133 }
2134 if (jjte000 instanceof RuntimeException) {
2135 {if (true) throw (RuntimeException)jjte000;}
2136 }
2137 if (jjte000 instanceof ParseException) {
2138 {if (true) throw (ParseException)jjte000;}
2139 }
2140 {if (true) throw (Error)jjte000;}
2141 } finally {
2142 if (jjtc000) {
2143 jjtree.closeNodeScope(jjtn000, true);
2144 }
2145 }
2146 throw new Error("Missing return statement in function");
2147 }
2148
2149 final public ASTDeclarativeSection DeclarativeSection() throws ParseException {
2150
2151 ASTDeclarativeSection jjtn000 = new ASTDeclarativeSection(this, JJTDECLARATIVESECTION);
2152 boolean jjtc000 = true;
2153 jjtree.openNodeScope(jjtn000);
2154 try {
2155 label_7:
2156 while (true) {
2157 switch (jj_nt.kind) {
2158 case REPLACE:
2159 case DEFINER:
2160 case CURRENT_USER:
2161 case SERIALLY_REUSABLE:
2162 case RESTRICT_REFERENCES:
2163 case EXCEPTION_INIT:
2164 case AUTONOMOUS_TRANSACTION:
2165 case LANGUAGE:
2166 case INLINE:
2167 case ADD:
2168 case AGGREGATE:
2169 case ALL:
2170 case ALTER:
2171 case AND:
2172 case ANY:
2173 case ARRAY:
2174 case AS:
2175 case ASC:
2176 case AT:
2177 case ATTRIBUTE:
2178 case AUTHID:
2179 case AVG:
2180 case BETWEEN:
2181 case BINARY_INTEGER:
2182 case BODY:
2183 case BOOLEAN:
2184 case BULK:
2185 case BY:
2186 case BYTE:
2187 case CASCADE:
2188 case CASE:
2189 case CHAR:
2190 case CHAR_BASE:
2191 case CHECK:
2192 case CLOSE:
2193 case CLUSTER:
2194 case COALESCE:
2195 case COLLECT:
2196 case COLUMN:
2197 case COMMENT:
2198 case COMMIT:
2199 case COMPRESS:
2200 case CONNECT:
2201 case CONSTANT:
2202 case CONSTRUCTOR:
2203 case CONTINUE:
2204 case CONVERT:
2205 case CREATE:
2206 case CURRENT:
2207 case CURRVAL:
2208 case CURSOR:
2209 case DATA:
2210 case DATE:
2211 case DAY:
2212 case DECLARE:
2213 case DECIMAL:
2214 case _DEFAULT:
2215 case DELETE:
2216 case DESC:
2217 case DISABLE:
2218 case DISTINCT:
2219 case DO:
2220 case DROP:
2221 case EDITIONABLE:
2222 case ELEMENT:
2223 case ELSE:
2224 case ELSIF:
2225 case ENABLE:
2226 case ESCAPE:
2227 case EXCEPT:
2228 case EXCEPTION:
2229 case EXCEPTIONS:
2230 case EXCLUSIVE:
2231 case EXECUTE:
2232 case EXISTS:
2233 case EXIT:
2234 case EXTERNAL:
2235 case EXTENDS:
2236 case EXTRACT:
2237 case FALSE:
2238 case FETCH:
2239 case FINAL:
2240 case FLOAT:
2241 case FOR:
2242 case FORALL:
2243 case FORCE:
2244 case FROM:
2245 case FUNCTION:
2246 case GLOBAL:
2247 case GOTO:
2248 case GROUP:
2249 case HASH:
2250 case HAVING:
2251 case HEAP:
2252 case HOUR:
2253 case IF:
2254 case IMMEDIATE:
2255 case IN:
2256 case INDEX:
2257 case INDICES:
2258 case INDEXTYPE:
2259 case INDICATOR:
2260 case INSERT:
2261 case INSTANTIABLE:
2262 case INTEGER:
2263 case INTERFACE:
2264 case INTERSECT:
2265 case INTERVAL:
2266 case INTO:
2267 case INVALIDATE:
2268 case IS:
2269 case ISOLATION:
2270 case JAVA:
2271 case LEVEL:
2272 case LIKE:
2273 case LIMIT:
2274 case LIMITED:
2275 case LOCK:
2276 case LONG:
2277 case LOOP:
2278 case MAP:
2279 case MAX:
2280 case MEMBER:
2281 case MERGE:
2282 case MIN:
2283 case MINUS:
2284 case MINUTE:
2285 case MLSLABEL:
2286 case MODIFY:
2287 case MOD:
2288 case MODE:
2289 case MONTH:
2290 case NATURAL:
2291 case NATURALN:
2292 case NEW:
2293 case NEXTVAL:
2294 case NO:
2295 case NOCOPY:
2296 case NONEDITIONABLE:
2297 case NOT:
2298 case NOWAIT:
2299 case NULL:
2300 case NULLIF:
2301 case NUMBER:
2302 case BFILE_BASE:
2303 case BLOB_BASE:
2304 case CLOB_BASE:
2305 case DATE_BASE:
2306 case NUMBER_BASE:
2307 case OBJECT:
2308 case OCIROWID:
2309 case OF:
2310 case OID:
2311 case ON:
2312 case OPAQUE:
2313 case OPEN:
2314 case OPERATOR:
2315 case OPTION:
2316 case OR:
2317 case ORDER:
2318 case ORGANIZATION:
2319 case OTHERS:
2320 case OUT:
2321 case OVERRIDING:
2322 case PACKAGE:
2323 case PARTITION:
2324 case PCTFREE:
2325 case PLS_INTEGER:
2326 case POSITIVE:
2327 case POSITIVEN:
2328 case PRAGMA:
2329 case PRESERVE:
2330 case PRIOR:
2331 case PROMPT:
2332 case PRIVATE:
2333 case PROCEDURE:
2334 case PUBLIC:
2335 case RAISE:
2336 case RANGE:
2337 case RAW:
2338 case REAL:
2339 case RECORD:
2340 case REF:
2341 case RELEASE:
2342 case RELIES_ON:
2343 case RENAME:
2344 case RESULT:
2345 case RETURN:
2346 case RETURNING:
2347 case REVERSE:
2348 case ROLLBACK:
2349 case ROW:
2350 case ROWS:
2351 case ROWID:
2352 case ROWNUM:
2353 case ROWTYPE:
2354 case SAVE:
2355 case SAVEPOINT:
2356 case SECOND:
2357 case SELECT:
2358 case SELF:
2359 case SEPARATE:
2360 case SET:
2361 case SHARE:
2362 case SMALLINT:
2363 case SPACE:
2364 case SQL:
2365 case SQLCODE:
2366 case SQLERRM:
2367 case START:
2368 case STATIC:
2369 case STDDEV:
2370 case SUBTYPE:
2371 case SUBSTITUTABLE:
2372 case SUCCESSFUL:
2373 case SUM:
2374 case SYNONYM:
2375 case SYSDATE:
2376 case SYS_REFCURSOR:
2377 case TABLE:
2378 case TEMPORARY:
2379 case THEN:
2380 case TIME:
2381 case TIMESTAMP:
2382 case TIMEZONE_REGION:
2383 case TIMEZONE_ABBR:
2384 case TIMEZONE_MINUTE:
2385 case TIMEZONE_HOUR:
2386 case TO:
2387 case TRANSACTION:
2388 case TRIGGER:
2389 case TRUE:
2390 case TYPE:
2391 case UI:
2392 case UNDER:
2393 case USING:
2394 case WHILE:
2395 case YES:
2396 case SHOW:
2397 case A:
2398 case UPDATE:
2399 case VARCHAR:
2400 case VARCHAR2:
2401 case DOUBLE:
2402 case DEC:
2403 case PRECISION:
2404 case INT:
2405 case NUMERIC:
2406 case SIGNTYPE:
2407 case NCHAR:
2408 case NVARCHAR2:
2409 case STRING:
2410 case UROWID:
2411 case VARRAY:
2412 case VARYING:
2413 case BFILE:
2414 case BLOB:
2415 case CLOB:
2416 case NCLOB:
2417 case YEAR:
2418 case LOCAL:
2419 case WITH:
2420 case ZONE:
2421 case CHARACTER:
2422 case AFTER:
2423 case BEFORE:
2424 case OLD:
2425 case PARENT:
2426 case CC_IF:
2427 case ANALYZE:
2428 case ASSOCIATE:
2429 case AUDIT:
2430 case COMPOUND:
2431 case DATABASE:
2432 case CALL:
2433 case DDL:
2434 case DISASSOCIATE:
2435 case EACH:
2436 case FOLLOWS:
2437 case LOGOFF:
2438 case LOGON:
2439 case NESTED:
2440 case NOAUDIT:
2441 case SCHEMA:
2442 case SERVERERROR:
2443 case SHUTDOWN:
2444 case STARTUP:
2445 case STATEMENT:
2446 case STATISTICS:
2447 case SUSPEND:
2448 case TRUNCATE:
2449 case WRAPPED:
2450 case LIBRARY:
2451 case NAME:
2452 case STRUCT:
2453 case CONTEXT:
2454 case PARAMETERS:
2455 case LENGTH:
2456 case TDO:
2457 case MAXLEN:
2458 case CHARSETID:
2459 case CHARSETFORM:
2460 case ACCEPT:
2461 case ACCESSIBLE:
2462 case COPY:
2463 case DEFINE:
2464 case DISCONNECT:
2465 case HOST:
2466 case PRINT:
2467 case QUIT:
2468 case REMARK:
2469 case UNDEFINE:
2470 case VARIABLE:
2471 case WHENEVER:
2472 case ATTACH:
2473 case CAST:
2474 case TREAT:
2475 case TRIM:
2476 case LEFT:
2477 case RIGHT:
2478 case BOTH:
2479 case EMPTY:
2480 case MULTISET:
2481 case SUBMULTISET:
2482 case LEADING:
2483 case TRAILING:
2484 case CHAR_CS:
2485 case NCHAR_CS:
2486 case DBTIMEZONE:
2487 case SESSIONTIMEZONE:
2488 case AUTHENTICATED:
2489 case LINK:
2490 case SHARED:
2491 case DIRECTORY:
2492 case USER:
2493 case IDENTIFIER:
2494 case QUOTED_LITERAL:
2495 case SQLDATA_CLASS:
2496 case CUSTOMDATUM_CLASS:
2497 case ORADATA_CLASS:
2498 case JAVA_INTERFACE_CLASS:
2499 ;
2500 break;
2501 default:
2502 jj_la1[33] = jj_gen;
2503 break label_7;
2504 }
2505 DeclarativeUnit();
2506 }
2507 jjtree.closeNodeScope(jjtn000, true);
2508 jjtc000 = false;
2509 {if (true) return jjtn000 ;}
2510 } catch (Throwable jjte000) {
2511 if (jjtc000) {
2512 jjtree.clearNodeScope(jjtn000);
2513 jjtc000 = false;
2514 } else {
2515 jjtree.popNode();
2516 }
2517 if (jjte000 instanceof RuntimeException) {
2518 {if (true) throw (RuntimeException)jjte000;}
2519 }
2520 if (jjte000 instanceof ParseException) {
2521 {if (true) throw (ParseException)jjte000;}
2522 }
2523 {if (true) throw (Error)jjte000;}
2524 } finally {
2525 if (jjtc000) {
2526 jjtree.closeNodeScope(jjtn000, true);
2527 }
2528 }
2529 throw new Error("Missing return statement in function");
2530 }
2531
2532 final public ASTCompilationDeclarationFragment CompilationDeclarationFragment() throws ParseException {
2533
2534 ASTCompilationDeclarationFragment jjtn000 = new ASTCompilationDeclarationFragment(this, JJTCOMPILATIONDECLARATIONFRAGMENT);
2535 boolean jjtc000 = true;
2536 jjtree.openNodeScope(jjtn000);
2537 try {
2538 jj_consume_token(CC_IF);
2539 ConditionalOrExpression();
2540 jj_consume_token(CC_THEN);
2541 label_8:
2542 while (true) {
2543 switch (jj_nt.kind) {
2544 case REPLACE:
2545 case DEFINER:
2546 case CURRENT_USER:
2547 case SERIALLY_REUSABLE:
2548 case RESTRICT_REFERENCES:
2549 case EXCEPTION_INIT:
2550 case AUTONOMOUS_TRANSACTION:
2551 case LANGUAGE:
2552 case INLINE:
2553 case ADD:
2554 case AGGREGATE:
2555 case ALL:
2556 case ALTER:
2557 case AND:
2558 case ANY:
2559 case ARRAY:
2560 case AS:
2561 case ASC:
2562 case AT:
2563 case ATTRIBUTE:
2564 case AUTHID:
2565 case AVG:
2566 case BETWEEN:
2567 case BINARY_INTEGER:
2568 case BODY:
2569 case BOOLEAN:
2570 case BULK:
2571 case BY:
2572 case BYTE:
2573 case CASCADE:
2574 case CASE:
2575 case CHAR:
2576 case CHAR_BASE:
2577 case CHECK:
2578 case CLOSE:
2579 case CLUSTER:
2580 case COALESCE:
2581 case COLLECT:
2582 case COLUMN:
2583 case COMMENT:
2584 case COMMIT:
2585 case COMPRESS:
2586 case CONNECT:
2587 case CONSTANT:
2588 case CONSTRUCTOR:
2589 case CONTINUE:
2590 case CONVERT:
2591 case CREATE:
2592 case CURRENT:
2593 case CURRVAL:
2594 case CURSOR:
2595 case DATA:
2596 case DATE:
2597 case DAY:
2598 case DECLARE:
2599 case DECIMAL:
2600 case _DEFAULT:
2601 case DELETE:
2602 case DESC:
2603 case DISABLE:
2604 case DISTINCT:
2605 case DO:
2606 case DROP:
2607 case EDITIONABLE:
2608 case ELEMENT:
2609 case ELSE:
2610 case ELSIF:
2611 case ENABLE:
2612 case ESCAPE:
2613 case EXCEPT:
2614 case EXCEPTION:
2615 case EXCEPTIONS:
2616 case EXCLUSIVE:
2617 case EXECUTE:
2618 case EXISTS:
2619 case EXIT:
2620 case EXTERNAL:
2621 case EXTENDS:
2622 case EXTRACT:
2623 case FALSE:
2624 case FETCH:
2625 case FINAL:
2626 case FLOAT:
2627 case FOR:
2628 case FORALL:
2629 case FORCE:
2630 case FROM:
2631 case FUNCTION:
2632 case GLOBAL:
2633 case GOTO:
2634 case GROUP:
2635 case HASH:
2636 case HAVING:
2637 case HEAP:
2638 case HOUR:
2639 case IF:
2640 case IMMEDIATE:
2641 case IN:
2642 case INDEX:
2643 case INDICES:
2644 case INDEXTYPE:
2645 case INDICATOR:
2646 case INSERT:
2647 case INSTANTIABLE:
2648 case INTEGER:
2649 case INTERFACE:
2650 case INTERSECT:
2651 case INTERVAL:
2652 case INTO:
2653 case INVALIDATE:
2654 case IS:
2655 case ISOLATION:
2656 case JAVA:
2657 case LEVEL:
2658 case LIKE:
2659 case LIMIT:
2660 case LIMITED:
2661 case LOCK:
2662 case LONG:
2663 case LOOP:
2664 case MAP:
2665 case MAX:
2666 case MEMBER:
2667 case MERGE:
2668 case MIN:
2669 case MINUS:
2670 case MINUTE:
2671 case MLSLABEL:
2672 case MODIFY:
2673 case MOD:
2674 case MODE:
2675 case MONTH:
2676 case NATURAL:
2677 case NATURALN:
2678 case NEW:
2679 case NEXTVAL:
2680 case NO:
2681 case NOCOPY:
2682 case NONEDITIONABLE:
2683 case NOT:
2684 case NOWAIT:
2685 case NULL:
2686 case NULLIF:
2687 case NUMBER:
2688 case BFILE_BASE:
2689 case BLOB_BASE:
2690 case CLOB_BASE:
2691 case DATE_BASE:
2692 case NUMBER_BASE:
2693 case OBJECT:
2694 case OCIROWID:
2695 case OF:
2696 case OID:
2697 case ON:
2698 case OPAQUE:
2699 case OPEN:
2700 case OPERATOR:
2701 case OPTION:
2702 case OR:
2703 case ORDER:
2704 case ORGANIZATION:
2705 case OTHERS:
2706 case OUT:
2707 case OVERRIDING:
2708 case PACKAGE:
2709 case PARTITION:
2710 case PCTFREE:
2711 case PLS_INTEGER:
2712 case POSITIVE:
2713 case POSITIVEN:
2714 case PRAGMA:
2715 case PRESERVE:
2716 case PRIOR:
2717 case PROMPT:
2718 case PRIVATE:
2719 case PROCEDURE:
2720 case PUBLIC:
2721 case RAISE:
2722 case RANGE:
2723 case RAW:
2724 case REAL:
2725 case RECORD:
2726 case REF:
2727 case RELEASE:
2728 case RELIES_ON:
2729 case RENAME:
2730 case RESULT:
2731 case RETURN:
2732 case RETURNING:
2733 case REVERSE:
2734 case ROLLBACK:
2735 case ROW:
2736 case ROWS:
2737 case ROWID:
2738 case ROWNUM:
2739 case ROWTYPE:
2740 case SAVE:
2741 case SAVEPOINT:
2742 case SECOND:
2743 case SELECT:
2744 case SELF:
2745 case SEPARATE:
2746 case SET:
2747 case SHARE:
2748 case SMALLINT:
2749 case SPACE:
2750 case SQL:
2751 case SQLCODE:
2752 case SQLERRM:
2753 case START:
2754 case STATIC:
2755 case STDDEV:
2756 case SUBTYPE:
2757 case SUBSTITUTABLE:
2758 case SUCCESSFUL:
2759 case SUM:
2760 case SYNONYM:
2761 case SYSDATE:
2762 case SYS_REFCURSOR:
2763 case TABLE:
2764 case TEMPORARY:
2765 case THEN:
2766 case TIME:
2767 case TIMESTAMP:
2768 case TIMEZONE_REGION:
2769 case TIMEZONE_ABBR:
2770 case TIMEZONE_MINUTE:
2771 case TIMEZONE_HOUR:
2772 case TO:
2773 case TRANSACTION:
2774 case TRIGGER:
2775 case TRUE:
2776 case TYPE:
2777 case UI:
2778 case UNDER:
2779 case USING:
2780 case WHILE:
2781 case YES:
2782 case SHOW:
2783 case A:
2784 case UPDATE:
2785 case VARCHAR:
2786 case VARCHAR2:
2787 case DOUBLE:
2788 case DEC:
2789 case PRECISION:
2790 case INT:
2791 case NUMERIC:
2792 case SIGNTYPE:
2793 case NCHAR:
2794 case NVARCHAR2:
2795 case STRING:
2796 case UROWID:
2797 case VARRAY:
2798 case VARYING:
2799 case BFILE:
2800 case BLOB:
2801 case CLOB:
2802 case NCLOB:
2803 case YEAR:
2804 case LOCAL:
2805 case WITH:
2806 case ZONE:
2807 case CHARACTER:
2808 case AFTER:
2809 case BEFORE:
2810 case OLD:
2811 case PARENT:
2812 case CC_IF:
2813 case CC_ERROR:
2814 case ANALYZE:
2815 case ASSOCIATE:
2816 case AUDIT:
2817 case COMPOUND:
2818 case DATABASE:
2819 case CALL:
2820 case DDL:
2821 case DISASSOCIATE:
2822 case EACH:
2823 case FOLLOWS:
2824 case LOGOFF:
2825 case LOGON:
2826 case NESTED:
2827 case NOAUDIT:
2828 case SCHEMA:
2829 case SERVERERROR:
2830 case SHUTDOWN:
2831 case STARTUP:
2832 case STATEMENT:
2833 case STATISTICS:
2834 case SUSPEND:
2835 case TRUNCATE:
2836 case WRAPPED:
2837 case LIBRARY:
2838 case NAME:
2839 case STRUCT:
2840 case CONTEXT:
2841 case PARAMETERS:
2842 case LENGTH:
2843 case TDO:
2844 case MAXLEN:
2845 case CHARSETID:
2846 case CHARSETFORM:
2847 case ACCEPT:
2848 case ACCESSIBLE:
2849 case COPY:
2850 case DEFINE:
2851 case DISCONNECT:
2852 case HOST:
2853 case PRINT:
2854 case QUIT:
2855 case REMARK:
2856 case UNDEFINE:
2857 case VARIABLE:
2858 case WHENEVER:
2859 case ATTACH:
2860 case CAST:
2861 case TREAT:
2862 case TRIM:
2863 case LEFT:
2864 case RIGHT:
2865 case BOTH:
2866 case EMPTY:
2867 case MULTISET:
2868 case SUBMULTISET:
2869 case LEADING:
2870 case TRAILING:
2871 case CHAR_CS:
2872 case NCHAR_CS:
2873 case DBTIMEZONE:
2874 case SESSIONTIMEZONE:
2875 case AUTHENTICATED:
2876 case LINK:
2877 case SHARED:
2878 case DIRECTORY:
2879 case USER:
2880 case IDENTIFIER:
2881 case QUOTED_LITERAL:
2882 case SQLDATA_CLASS:
2883 case CUSTOMDATUM_CLASS:
2884 case ORADATA_CLASS:
2885 case JAVA_INTERFACE_CLASS:
2886 ;
2887 break;
2888 default:
2889 jj_la1[34] = jj_gen;
2890 break label_8;
2891 }
2892 switch (jj_nt.kind) {
2893 case REPLACE:
2894 case DEFINER:
2895 case CURRENT_USER:
2896 case SERIALLY_REUSABLE:
2897 case RESTRICT_REFERENCES:
2898 case EXCEPTION_INIT:
2899 case AUTONOMOUS_TRANSACTION:
2900 case LANGUAGE:
2901 case INLINE:
2902 case ADD:
2903 case AGGREGATE:
2904 case ALL:
2905 case ALTER:
2906 case AND:
2907 case ANY:
2908 case ARRAY:
2909 case AS:
2910 case ASC:
2911 case AT:
2912 case ATTRIBUTE:
2913 case AUTHID:
2914 case AVG:
2915 case BETWEEN:
2916 case BINARY_INTEGER:
2917 case BODY:
2918 case BOOLEAN:
2919 case BULK:
2920 case BY:
2921 case BYTE:
2922 case CASCADE:
2923 case CASE:
2924 case CHAR:
2925 case CHAR_BASE:
2926 case CHECK:
2927 case CLOSE:
2928 case CLUSTER:
2929 case COALESCE:
2930 case COLLECT:
2931 case COLUMN:
2932 case COMMENT:
2933 case COMMIT:
2934 case COMPRESS:
2935 case CONNECT:
2936 case CONSTANT:
2937 case CONSTRUCTOR:
2938 case CONTINUE:
2939 case CONVERT:
2940 case CREATE:
2941 case CURRENT:
2942 case CURRVAL:
2943 case CURSOR:
2944 case DATA:
2945 case DATE:
2946 case DAY:
2947 case DECLARE:
2948 case DECIMAL:
2949 case _DEFAULT:
2950 case DELETE:
2951 case DESC:
2952 case DISABLE:
2953 case DISTINCT:
2954 case DO:
2955 case DROP:
2956 case EDITIONABLE:
2957 case ELEMENT:
2958 case ELSE:
2959 case ELSIF:
2960 case ENABLE:
2961 case ESCAPE:
2962 case EXCEPT:
2963 case EXCEPTION:
2964 case EXCEPTIONS:
2965 case EXCLUSIVE:
2966 case EXECUTE:
2967 case EXISTS:
2968 case EXIT:
2969 case EXTERNAL:
2970 case EXTENDS:
2971 case EXTRACT:
2972 case FALSE:
2973 case FETCH:
2974 case FINAL:
2975 case FLOAT:
2976 case FOR:
2977 case FORALL:
2978 case FORCE:
2979 case FROM:
2980 case FUNCTION:
2981 case GLOBAL:
2982 case GOTO:
2983 case GROUP:
2984 case HASH:
2985 case HAVING:
2986 case HEAP:
2987 case HOUR:
2988 case IF:
2989 case IMMEDIATE:
2990 case IN:
2991 case INDEX:
2992 case INDICES:
2993 case INDEXTYPE:
2994 case INDICATOR:
2995 case INSERT:
2996 case INSTANTIABLE:
2997 case INTEGER:
2998 case INTERFACE:
2999 case INTERSECT:
3000 case INTERVAL:
3001 case INTO:
3002 case INVALIDATE:
3003 case IS:
3004 case ISOLATION:
3005 case JAVA:
3006 case LEVEL:
3007 case LIKE:
3008 case LIMIT:
3009 case LIMITED:
3010 case LOCK:
3011 case LONG:
3012 case LOOP:
3013 case MAP:
3014 case MAX:
3015 case MEMBER:
3016 case MERGE:
3017 case MIN:
3018 case MINUS:
3019 case MINUTE:
3020 case MLSLABEL:
3021 case MODIFY:
3022 case MOD:
3023 case MODE:
3024 case MONTH:
3025 case NATURAL:
3026 case NATURALN:
3027 case NEW:
3028 case NEXTVAL:
3029 case NO:
3030 case NOCOPY:
3031 case NONEDITIONABLE:
3032 case NOT:
3033 case NOWAIT:
3034 case NULL:
3035 case NULLIF:
3036 case NUMBER:
3037 case BFILE_BASE:
3038 case BLOB_BASE:
3039 case CLOB_BASE:
3040 case DATE_BASE:
3041 case NUMBER_BASE:
3042 case OBJECT:
3043 case OCIROWID:
3044 case OF:
3045 case OID:
3046 case ON:
3047 case OPAQUE:
3048 case OPEN:
3049 case OPERATOR:
3050 case OPTION:
3051 case OR:
3052 case ORDER:
3053 case ORGANIZATION:
3054 case OTHERS:
3055 case OUT:
3056 case OVERRIDING:
3057 case PACKAGE:
3058 case PARTITION:
3059 case PCTFREE:
3060 case PLS_INTEGER:
3061 case POSITIVE:
3062 case POSITIVEN:
3063 case PRAGMA:
3064 case PRESERVE:
3065 case PRIOR:
3066 case PROMPT:
3067 case PRIVATE:
3068 case PROCEDURE:
3069 case PUBLIC:
3070 case RAISE:
3071 case RANGE:
3072 case RAW:
3073 case REAL:
3074 case RECORD:
3075 case REF:
3076 case RELEASE:
3077 case RELIES_ON:
3078 case RENAME:
3079 case RESULT:
3080 case RETURN:
3081 case RETURNING:
3082 case REVERSE:
3083 case ROLLBACK:
3084 case ROW:
3085 case ROWS:
3086 case ROWID:
3087 case ROWNUM:
3088 case ROWTYPE:
3089 case SAVE:
3090 case SAVEPOINT:
3091 case SECOND:
3092 case SELECT:
3093 case SELF:
3094 case SEPARATE:
3095 case SET:
3096 case SHARE:
3097 case SMALLINT:
3098 case SPACE:
3099 case SQL:
3100 case SQLCODE:
3101 case SQLERRM:
3102 case START:
3103 case STATIC:
3104 case STDDEV:
3105 case SUBTYPE:
3106 case SUBSTITUTABLE:
3107 case SUCCESSFUL:
3108 case SUM:
3109 case SYNONYM:
3110 case SYSDATE:
3111 case SYS_REFCURSOR:
3112 case TABLE:
3113 case TEMPORARY:
3114 case THEN:
3115 case TIME:
3116 case TIMESTAMP:
3117 case TIMEZONE_REGION:
3118 case TIMEZONE_ABBR:
3119 case TIMEZONE_MINUTE:
3120 case TIMEZONE_HOUR:
3121 case TO:
3122 case TRANSACTION:
3123 case TRIGGER:
3124 case TRUE:
3125 case TYPE:
3126 case UI:
3127 case UNDER:
3128 case USING:
3129 case WHILE:
3130 case YES:
3131 case SHOW:
3132 case A:
3133 case UPDATE:
3134 case VARCHAR:
3135 case VARCHAR2:
3136 case DOUBLE:
3137 case DEC:
3138 case PRECISION:
3139 case INT:
3140 case NUMERIC:
3141 case SIGNTYPE:
3142 case NCHAR:
3143 case NVARCHAR2:
3144 case STRING:
3145 case UROWID:
3146 case VARRAY:
3147 case VARYING:
3148 case BFILE:
3149 case BLOB:
3150 case CLOB:
3151 case NCLOB:
3152 case YEAR:
3153 case LOCAL:
3154 case WITH:
3155 case ZONE:
3156 case CHARACTER:
3157 case AFTER:
3158 case BEFORE:
3159 case OLD:
3160 case PARENT:
3161 case CC_IF:
3162 case ANALYZE:
3163 case ASSOCIATE:
3164 case AUDIT:
3165 case COMPOUND:
3166 case DATABASE:
3167 case CALL:
3168 case DDL:
3169 case DISASSOCIATE:
3170 case EACH:
3171 case FOLLOWS:
3172 case LOGOFF:
3173 case LOGON:
3174 case NESTED:
3175 case NOAUDIT:
3176 case SCHEMA:
3177 case SERVERERROR:
3178 case SHUTDOWN:
3179 case STARTUP:
3180 case STATEMENT:
3181 case STATISTICS:
3182 case SUSPEND:
3183 case TRUNCATE:
3184 case WRAPPED:
3185 case LIBRARY:
3186 case NAME:
3187 case STRUCT:
3188 case CONTEXT:
3189 case PARAMETERS:
3190 case LENGTH:
3191 case TDO:
3192 case MAXLEN:
3193 case CHARSETID:
3194 case CHARSETFORM:
3195 case ACCEPT:
3196 case ACCESSIBLE:
3197 case COPY:
3198 case DEFINE:
3199 case DISCONNECT:
3200 case HOST:
3201 case PRINT:
3202 case QUIT:
3203 case REMARK:
3204 case UNDEFINE:
3205 case VARIABLE:
3206 case WHENEVER:
3207 case ATTACH:
3208 case CAST:
3209 case TREAT:
3210 case TRIM:
3211 case LEFT:
3212 case RIGHT:
3213 case BOTH:
3214 case EMPTY:
3215 case MULTISET:
3216 case SUBMULTISET:
3217 case LEADING:
3218 case TRAILING:
3219 case CHAR_CS:
3220 case NCHAR_CS:
3221 case DBTIMEZONE:
3222 case SESSIONTIMEZONE:
3223 case AUTHENTICATED:
3224 case LINK:
3225 case SHARED:
3226 case DIRECTORY:
3227 case USER:
3228 case IDENTIFIER:
3229 case QUOTED_LITERAL:
3230 case SQLDATA_CLASS:
3231 case CUSTOMDATUM_CLASS:
3232 case ORADATA_CLASS:
3233 case JAVA_INTERFACE_CLASS:
3234 DeclarativeUnit();
3235 break;
3236 case CC_ERROR:
3237 jj_consume_token(CC_ERROR);
3238 Expression();
3239 jj_consume_token(CC_END);
3240 break;
3241 default:
3242 jj_la1[35] = jj_gen;
3243 jj_consume_token(-1);
3244 throw new ParseException();
3245 }
3246 }
3247 label_9:
3248 while (true) {
3249 switch (jj_nt.kind) {
3250 case CC_ELSIF:
3251 ;
3252 break;
3253 default:
3254 jj_la1[36] = jj_gen;
3255 break label_9;
3256 }
3257 jj_consume_token(CC_ELSIF);
3258 ConditionalOrExpression();
3259 jj_consume_token(CC_THEN);
3260 label_10:
3261 while (true) {
3262 switch (jj_nt.kind) {
3263 case REPLACE:
3264 case DEFINER:
3265 case CURRENT_USER:
3266 case SERIALLY_REUSABLE:
3267 case RESTRICT_REFERENCES:
3268 case EXCEPTION_INIT:
3269 case AUTONOMOUS_TRANSACTION:
3270 case LANGUAGE:
3271 case INLINE:
3272 case ADD:
3273 case AGGREGATE:
3274 case ALL:
3275 case ALTER:
3276 case AND:
3277 case ANY:
3278 case ARRAY:
3279 case AS:
3280 case ASC:
3281 case AT:
3282 case ATTRIBUTE:
3283 case AUTHID:
3284 case AVG:
3285 case BETWEEN:
3286 case BINARY_INTEGER:
3287 case BODY:
3288 case BOOLEAN:
3289 case BULK:
3290 case BY:
3291 case BYTE:
3292 case CASCADE:
3293 case CASE:
3294 case CHAR:
3295 case CHAR_BASE:
3296 case CHECK:
3297 case CLOSE:
3298 case CLUSTER:
3299 case COALESCE:
3300 case COLLECT:
3301 case COLUMN:
3302 case COMMENT:
3303 case COMMIT:
3304 case COMPRESS:
3305 case CONNECT:
3306 case CONSTANT:
3307 case CONSTRUCTOR:
3308 case CONTINUE:
3309 case CONVERT:
3310 case CREATE:
3311 case CURRENT:
3312 case CURRVAL:
3313 case CURSOR:
3314 case DATA:
3315 case DATE:
3316 case DAY:
3317 case DECLARE:
3318 case DECIMAL:
3319 case _DEFAULT:
3320 case DELETE:
3321 case DESC:
3322 case DISABLE:
3323 case DISTINCT:
3324 case DO:
3325 case DROP:
3326 case EDITIONABLE:
3327 case ELEMENT:
3328 case ELSE:
3329 case ELSIF:
3330 case ENABLE:
3331 case ESCAPE:
3332 case EXCEPT:
3333 case EXCEPTION:
3334 case EXCEPTIONS:
3335 case EXCLUSIVE:
3336 case EXECUTE:
3337 case EXISTS:
3338 case EXIT:
3339 case EXTERNAL:
3340 case EXTENDS:
3341 case EXTRACT:
3342 case FALSE:
3343 case FETCH:
3344 case FINAL:
3345 case FLOAT:
3346 case FOR:
3347 case FORALL:
3348 case FORCE:
3349 case FROM:
3350 case FUNCTION:
3351 case GLOBAL:
3352 case GOTO:
3353 case GROUP:
3354 case HASH:
3355 case HAVING:
3356 case HEAP:
3357 case HOUR:
3358 case IF:
3359 case IMMEDIATE:
3360 case IN:
3361 case INDEX:
3362 case INDICES:
3363 case INDEXTYPE:
3364 case INDICATOR:
3365 case INSERT:
3366 case INSTANTIABLE:
3367 case INTEGER:
3368 case INTERFACE:
3369 case INTERSECT:
3370 case INTERVAL:
3371 case INTO:
3372 case INVALIDATE:
3373 case IS:
3374 case ISOLATION:
3375 case JAVA:
3376 case LEVEL:
3377 case LIKE:
3378 case LIMIT:
3379 case LIMITED:
3380 case LOCK:
3381 case LONG:
3382 case LOOP:
3383 case MAP:
3384 case MAX:
3385 case MEMBER:
3386 case MERGE:
3387 case MIN:
3388 case MINUS:
3389 case MINUTE:
3390 case MLSLABEL:
3391 case MODIFY:
3392 case MOD:
3393 case MODE:
3394 case MONTH:
3395 case NATURAL:
3396 case NATURALN:
3397 case NEW:
3398 case NEXTVAL:
3399 case NO:
3400 case NOCOPY:
3401 case NONEDITIONABLE:
3402 case NOT:
3403 case NOWAIT:
3404 case NULL:
3405 case NULLIF:
3406 case NUMBER:
3407 case BFILE_BASE:
3408 case BLOB_BASE:
3409 case CLOB_BASE:
3410 case DATE_BASE:
3411 case NUMBER_BASE:
3412 case OBJECT:
3413 case OCIROWID:
3414 case OF:
3415 case OID:
3416 case ON:
3417 case OPAQUE:
3418 case OPEN:
3419 case OPERATOR:
3420 case OPTION:
3421 case OR:
3422 case ORDER:
3423 case ORGANIZATION:
3424 case OTHERS:
3425 case OUT:
3426 case OVERRIDING:
3427 case PACKAGE:
3428 case PARTITION:
3429 case PCTFREE:
3430 case PLS_INTEGER:
3431 case POSITIVE:
3432 case POSITIVEN:
3433 case PRAGMA:
3434 case PRESERVE:
3435 case PRIOR:
3436 case PROMPT:
3437 case PRIVATE:
3438 case PROCEDURE:
3439 case PUBLIC:
3440 case RAISE:
3441 case RANGE:
3442 case RAW:
3443 case REAL:
3444 case RECORD:
3445 case REF:
3446 case RELEASE:
3447 case RELIES_ON:
3448 case RENAME:
3449 case RESULT:
3450 case RETURN:
3451 case RETURNING:
3452 case REVERSE:
3453 case ROLLBACK:
3454 case ROW:
3455 case ROWS:
3456 case ROWID:
3457 case ROWNUM:
3458 case ROWTYPE:
3459 case SAVE:
3460 case SAVEPOINT:
3461 case SECOND:
3462 case SELECT:
3463 case SELF:
3464 case SEPARATE:
3465 case SET:
3466 case SHARE:
3467 case SMALLINT:
3468 case SPACE:
3469 case SQL:
3470 case SQLCODE:
3471 case SQLERRM:
3472 case START:
3473 case STATIC:
3474 case STDDEV:
3475 case SUBTYPE:
3476 case SUBSTITUTABLE:
3477 case SUCCESSFUL:
3478 case SUM:
3479 case SYNONYM:
3480 case SYSDATE:
3481 case SYS_REFCURSOR:
3482 case TABLE:
3483 case TEMPORARY:
3484 case THEN:
3485 case TIME:
3486 case TIMESTAMP:
3487 case TIMEZONE_REGION:
3488 case TIMEZONE_ABBR:
3489 case TIMEZONE_MINUTE:
3490 case TIMEZONE_HOUR:
3491 case TO:
3492 case TRANSACTION:
3493 case TRIGGER:
3494 case TRUE:
3495 case TYPE:
3496 case UI:
3497 case UNDER:
3498 case USING:
3499 case WHILE:
3500 case YES:
3501 case SHOW:
3502 case A:
3503 case UPDATE:
3504 case VARCHAR:
3505 case VARCHAR2:
3506 case DOUBLE:
3507 case DEC:
3508 case PRECISION:
3509 case INT:
3510 case NUMERIC:
3511 case SIGNTYPE:
3512 case NCHAR:
3513 case NVARCHAR2:
3514 case STRING:
3515 case UROWID:
3516 case VARRAY:
3517 case VARYING:
3518 case BFILE:
3519 case BLOB:
3520 case CLOB:
3521 case NCLOB:
3522 case YEAR:
3523 case LOCAL:
3524 case WITH:
3525 case ZONE:
3526 case CHARACTER:
3527 case AFTER:
3528 case BEFORE:
3529 case OLD:
3530 case PARENT:
3531 case CC_IF:
3532 case CC_ERROR:
3533 case ANALYZE:
3534 case ASSOCIATE:
3535 case AUDIT:
3536 case COMPOUND:
3537 case DATABASE:
3538 case CALL:
3539 case DDL:
3540 case DISASSOCIATE:
3541 case EACH:
3542 case FOLLOWS:
3543 case LOGOFF:
3544 case LOGON:
3545 case NESTED:
3546 case NOAUDIT:
3547 case SCHEMA:
3548 case SERVERERROR:
3549 case SHUTDOWN:
3550 case STARTUP:
3551 case STATEMENT:
3552 case STATISTICS:
3553 case SUSPEND:
3554 case TRUNCATE:
3555 case WRAPPED:
3556 case LIBRARY:
3557 case NAME:
3558 case STRUCT:
3559 case CONTEXT:
3560 case PARAMETERS:
3561 case LENGTH:
3562 case TDO:
3563 case MAXLEN:
3564 case CHARSETID:
3565 case CHARSETFORM:
3566 case ACCEPT:
3567 case ACCESSIBLE:
3568 case COPY:
3569 case DEFINE:
3570 case DISCONNECT:
3571 case HOST:
3572 case PRINT:
3573 case QUIT:
3574 case REMARK:
3575 case UNDEFINE:
3576 case VARIABLE:
3577 case WHENEVER:
3578 case ATTACH:
3579 case CAST:
3580 case TREAT:
3581 case TRIM:
3582 case LEFT:
3583 case RIGHT:
3584 case BOTH:
3585 case EMPTY:
3586 case MULTISET:
3587 case SUBMULTISET:
3588 case LEADING:
3589 case TRAILING:
3590 case CHAR_CS:
3591 case NCHAR_CS:
3592 case DBTIMEZONE:
3593 case SESSIONTIMEZONE:
3594 case AUTHENTICATED:
3595 case LINK:
3596 case SHARED:
3597 case DIRECTORY:
3598 case USER:
3599 case IDENTIFIER:
3600 case QUOTED_LITERAL:
3601 case SQLDATA_CLASS:
3602 case CUSTOMDATUM_CLASS:
3603 case ORADATA_CLASS:
3604 case JAVA_INTERFACE_CLASS:
3605 ;
3606 break;
3607 default:
3608 jj_la1[37] = jj_gen;
3609 break label_10;
3610 }
3611 switch (jj_nt.kind) {
3612 case REPLACE:
3613 case DEFINER:
3614 case CURRENT_USER:
3615 case SERIALLY_REUSABLE:
3616 case RESTRICT_REFERENCES:
3617 case EXCEPTION_INIT:
3618 case AUTONOMOUS_TRANSACTION:
3619 case LANGUAGE:
3620 case INLINE:
3621 case ADD:
3622 case AGGREGATE:
3623 case ALL:
3624 case ALTER:
3625 case AND:
3626 case ANY:
3627 case ARRAY:
3628 case AS:
3629 case ASC:
3630 case AT:
3631 case ATTRIBUTE:
3632 case AUTHID:
3633 case AVG:
3634 case BETWEEN:
3635 case BINARY_INTEGER:
3636 case BODY:
3637 case BOOLEAN:
3638 case BULK:
3639 case BY:
3640 case BYTE:
3641 case CASCADE:
3642 case CASE:
3643 case CHAR:
3644 case CHAR_BASE:
3645 case CHECK:
3646 case CLOSE:
3647 case CLUSTER:
3648 case COALESCE:
3649 case COLLECT:
3650 case COLUMN:
3651 case COMMENT:
3652 case COMMIT:
3653 case COMPRESS:
3654 case CONNECT:
3655 case CONSTANT:
3656 case CONSTRUCTOR:
3657 case CONTINUE:
3658 case CONVERT:
3659 case CREATE:
3660 case CURRENT:
3661 case CURRVAL:
3662 case CURSOR:
3663 case DATA:
3664 case DATE:
3665 case DAY:
3666 case DECLARE:
3667 case DECIMAL:
3668 case _DEFAULT:
3669 case DELETE:
3670 case DESC:
3671 case DISABLE:
3672 case DISTINCT:
3673 case DO:
3674 case DROP:
3675 case EDITIONABLE:
3676 case ELEMENT:
3677 case ELSE:
3678 case ELSIF:
3679 case ENABLE:
3680 case ESCAPE:
3681 case EXCEPT:
3682 case EXCEPTION:
3683 case EXCEPTIONS:
3684 case EXCLUSIVE:
3685 case EXECUTE:
3686 case EXISTS:
3687 case EXIT:
3688 case EXTERNAL:
3689 case EXTENDS:
3690 case EXTRACT:
3691 case FALSE:
3692 case FETCH:
3693 case FINAL:
3694 case FLOAT:
3695 case FOR:
3696 case FORALL:
3697 case FORCE:
3698 case FROM:
3699 case FUNCTION:
3700 case GLOBAL:
3701 case GOTO:
3702 case GROUP:
3703 case HASH:
3704 case HAVING:
3705 case HEAP:
3706 case HOUR:
3707 case IF:
3708 case IMMEDIATE:
3709 case IN:
3710 case INDEX:
3711 case INDICES:
3712 case INDEXTYPE:
3713 case INDICATOR:
3714 case INSERT:
3715 case INSTANTIABLE:
3716 case INTEGER:
3717 case INTERFACE:
3718 case INTERSECT:
3719 case INTERVAL:
3720 case INTO:
3721 case INVALIDATE:
3722 case IS:
3723 case ISOLATION:
3724 case JAVA:
3725 case LEVEL:
3726 case LIKE:
3727 case LIMIT:
3728 case LIMITED:
3729 case LOCK:
3730 case LONG:
3731 case LOOP:
3732 case MAP:
3733 case MAX:
3734 case MEMBER:
3735 case MERGE:
3736 case MIN:
3737 case MINUS:
3738 case MINUTE:
3739 case MLSLABEL:
3740 case MODIFY:
3741 case MOD:
3742 case MODE:
3743 case MONTH:
3744 case NATURAL:
3745 case NATURALN:
3746 case NEW:
3747 case NEXTVAL:
3748 case NO:
3749 case NOCOPY:
3750 case NONEDITIONABLE:
3751 case NOT:
3752 case NOWAIT:
3753 case NULL:
3754 case NULLIF:
3755 case NUMBER:
3756 case BFILE_BASE:
3757 case BLOB_BASE:
3758 case CLOB_BASE:
3759 case DATE_BASE:
3760 case NUMBER_BASE:
3761 case OBJECT:
3762 case OCIROWID:
3763 case OF:
3764 case OID:
3765 case ON:
3766 case OPAQUE:
3767 case OPEN:
3768 case OPERATOR:
3769 case OPTION:
3770 case OR:
3771 case ORDER:
3772 case ORGANIZATION:
3773 case OTHERS:
3774 case OUT:
3775 case OVERRIDING:
3776 case PACKAGE:
3777 case PARTITION:
3778 case PCTFREE:
3779 case PLS_INTEGER:
3780 case POSITIVE:
3781 case POSITIVEN:
3782 case PRAGMA:
3783 case PRESERVE:
3784 case PRIOR:
3785 case PROMPT:
3786 case PRIVATE:
3787 case PROCEDURE:
3788 case PUBLIC:
3789 case RAISE:
3790 case RANGE:
3791 case RAW:
3792 case REAL:
3793 case RECORD:
3794 case REF:
3795 case RELEASE:
3796 case RELIES_ON:
3797 case RENAME:
3798 case RESULT:
3799 case RETURN:
3800 case RETURNING:
3801 case REVERSE:
3802 case ROLLBACK:
3803 case ROW:
3804 case ROWS:
3805 case ROWID:
3806 case ROWNUM:
3807 case ROWTYPE:
3808 case SAVE:
3809 case SAVEPOINT:
3810 case SECOND:
3811 case SELECT:
3812 case SELF:
3813 case SEPARATE:
3814 case SET:
3815 case SHARE:
3816 case SMALLINT:
3817 case SPACE:
3818 case SQL:
3819 case SQLCODE:
3820 case SQLERRM:
3821 case START:
3822 case STATIC:
3823 case STDDEV:
3824 case SUBTYPE:
3825 case SUBSTITUTABLE:
3826 case SUCCESSFUL:
3827 case SUM:
3828 case SYNONYM:
3829 case SYSDATE:
3830 case SYS_REFCURSOR:
3831 case TABLE:
3832 case TEMPORARY:
3833 case THEN:
3834 case TIME:
3835 case TIMESTAMP:
3836 case TIMEZONE_REGION:
3837 case TIMEZONE_ABBR:
3838 case TIMEZONE_MINUTE:
3839 case TIMEZONE_HOUR:
3840 case TO:
3841 case TRANSACTION:
3842 case TRIGGER:
3843 case TRUE:
3844 case TYPE:
3845 case UI:
3846 case UNDER:
3847 case USING:
3848 case WHILE:
3849 case YES:
3850 case SHOW:
3851 case A:
3852 case UPDATE:
3853 case VARCHAR:
3854 case VARCHAR2:
3855 case DOUBLE:
3856 case DEC:
3857 case PRECISION:
3858 case INT:
3859 case NUMERIC:
3860 case SIGNTYPE:
3861 case NCHAR:
3862 case NVARCHAR2:
3863 case STRING:
3864 case UROWID:
3865 case VARRAY:
3866 case VARYING:
3867 case BFILE:
3868 case BLOB:
3869 case CLOB:
3870 case NCLOB:
3871 case YEAR:
3872 case LOCAL:
3873 case WITH:
3874 case ZONE:
3875 case CHARACTER:
3876 case AFTER:
3877 case BEFORE:
3878 case OLD:
3879 case PARENT:
3880 case CC_IF:
3881 case ANALYZE:
3882 case ASSOCIATE:
3883 case AUDIT:
3884 case COMPOUND:
3885 case DATABASE:
3886 case CALL:
3887 case DDL:
3888 case DISASSOCIATE:
3889 case EACH:
3890 case FOLLOWS:
3891 case LOGOFF:
3892 case LOGON:
3893 case NESTED:
3894 case NOAUDIT:
3895 case SCHEMA:
3896 case SERVERERROR:
3897 case SHUTDOWN:
3898 case STARTUP:
3899 case STATEMENT:
3900 case STATISTICS:
3901 case SUSPEND:
3902 case TRUNCATE:
3903 case WRAPPED:
3904 case LIBRARY:
3905 case NAME:
3906 case STRUCT:
3907 case CONTEXT:
3908 case PARAMETERS:
3909 case LENGTH:
3910 case TDO:
3911 case MAXLEN:
3912 case CHARSETID:
3913 case CHARSETFORM:
3914 case ACCEPT:
3915 case ACCESSIBLE:
3916 case COPY:
3917 case DEFINE:
3918 case DISCONNECT:
3919 case HOST:
3920 case PRINT:
3921 case QUIT:
3922 case REMARK:
3923 case UNDEFINE:
3924 case VARIABLE:
3925 case WHENEVER:
3926 case ATTACH:
3927 case CAST:
3928 case TREAT:
3929 case TRIM:
3930 case LEFT:
3931 case RIGHT:
3932 case BOTH:
3933 case EMPTY:
3934 case MULTISET:
3935 case SUBMULTISET:
3936 case LEADING:
3937 case TRAILING:
3938 case CHAR_CS:
3939 case NCHAR_CS:
3940 case DBTIMEZONE:
3941 case SESSIONTIMEZONE:
3942 case AUTHENTICATED:
3943 case LINK:
3944 case SHARED:
3945 case DIRECTORY:
3946 case USER:
3947 case IDENTIFIER:
3948 case QUOTED_LITERAL:
3949 case SQLDATA_CLASS:
3950 case CUSTOMDATUM_CLASS:
3951 case ORADATA_CLASS:
3952 case JAVA_INTERFACE_CLASS:
3953 DeclarativeUnit();
3954 break;
3955 case CC_ERROR:
3956 jj_consume_token(CC_ERROR);
3957 Expression();
3958 jj_consume_token(CC_END);
3959 break;
3960 default:
3961 jj_la1[38] = jj_gen;
3962 jj_consume_token(-1);
3963 throw new ParseException();
3964 }
3965 }
3966 }
3967 label_11:
3968 while (true) {
3969 switch (jj_nt.kind) {
3970 case CC_ELSE:
3971 ;
3972 break;
3973 default:
3974 jj_la1[39] = jj_gen;
3975 break label_11;
3976 }
3977 jj_consume_token(CC_ELSE);
3978 label_12:
3979 while (true) {
3980 switch (jj_nt.kind) {
3981 case REPLACE:
3982 case DEFINER:
3983 case CURRENT_USER:
3984 case SERIALLY_REUSABLE:
3985 case RESTRICT_REFERENCES:
3986 case EXCEPTION_INIT:
3987 case AUTONOMOUS_TRANSACTION:
3988 case LANGUAGE:
3989 case INLINE:
3990 case ADD:
3991 case AGGREGATE:
3992 case ALL:
3993 case ALTER:
3994 case AND:
3995 case ANY:
3996 case ARRAY:
3997 case AS:
3998 case ASC:
3999 case AT:
4000 case ATTRIBUTE:
4001 case AUTHID:
4002 case AVG:
4003 case BETWEEN:
4004 case BINARY_INTEGER:
4005 case BODY:
4006 case BOOLEAN:
4007 case BULK:
4008 case BY:
4009 case BYTE:
4010 case CASCADE:
4011 case CASE:
4012 case CHAR:
4013 case CHAR_BASE:
4014 case CHECK:
4015 case CLOSE:
4016 case CLUSTER:
4017 case COALESCE:
4018 case COLLECT:
4019 case COLUMN:
4020 case COMMENT:
4021 case COMMIT:
4022 case COMPRESS:
4023 case CONNECT:
4024 case CONSTANT:
4025 case CONSTRUCTOR:
4026 case CONTINUE:
4027 case CONVERT:
4028 case CREATE:
4029 case CURRENT:
4030 case CURRVAL:
4031 case CURSOR:
4032 case DATA:
4033 case DATE:
4034 case DAY:
4035 case DECLARE:
4036 case DECIMAL:
4037 case _DEFAULT:
4038 case DELETE:
4039 case DESC:
4040 case DISABLE:
4041 case DISTINCT:
4042 case DO:
4043 case DROP:
4044 case EDITIONABLE:
4045 case ELEMENT:
4046 case ELSE:
4047 case ELSIF:
4048 case ENABLE:
4049 case ESCAPE:
4050 case EXCEPT:
4051 case EXCEPTION:
4052 case EXCEPTIONS:
4053 case EXCLUSIVE:
4054 case EXECUTE:
4055 case EXISTS:
4056 case EXIT:
4057 case EXTERNAL:
4058 case EXTENDS:
4059 case EXTRACT:
4060 case FALSE:
4061 case FETCH:
4062 case FINAL:
4063 case FLOAT:
4064 case FOR:
4065 case FORALL:
4066 case FORCE:
4067 case FROM:
4068 case FUNCTION:
4069 case GLOBAL:
4070 case GOTO:
4071 case GROUP:
4072 case HASH:
4073 case HAVING:
4074 case HEAP:
4075 case HOUR:
4076 case IF:
4077 case IMMEDIATE:
4078 case IN:
4079 case INDEX:
4080 case INDICES:
4081 case INDEXTYPE:
4082 case INDICATOR:
4083 case INSERT:
4084 case INSTANTIABLE:
4085 case INTEGER:
4086 case INTERFACE:
4087 case INTERSECT:
4088 case INTERVAL:
4089 case INTO:
4090 case INVALIDATE:
4091 case IS:
4092 case ISOLATION:
4093 case JAVA:
4094 case LEVEL:
4095 case LIKE:
4096 case LIMIT:
4097 case LIMITED:
4098 case LOCK:
4099 case LONG:
4100 case LOOP:
4101 case MAP:
4102 case MAX:
4103 case MEMBER:
4104 case MERGE:
4105 case MIN:
4106 case MINUS:
4107 case MINUTE:
4108 case MLSLABEL:
4109 case MODIFY:
4110 case MOD:
4111 case MODE:
4112 case MONTH:
4113 case NATURAL:
4114 case NATURALN:
4115 case NEW:
4116 case NEXTVAL:
4117 case NO:
4118 case NOCOPY:
4119 case NONEDITIONABLE:
4120 case NOT:
4121 case NOWAIT:
4122 case NULL:
4123 case NULLIF:
4124 case NUMBER:
4125 case BFILE_BASE:
4126 case BLOB_BASE:
4127 case CLOB_BASE:
4128 case DATE_BASE:
4129 case NUMBER_BASE:
4130 case OBJECT:
4131 case OCIROWID:
4132 case OF:
4133 case OID:
4134 case ON:
4135 case OPAQUE:
4136 case OPEN:
4137 case OPERATOR:
4138 case OPTION:
4139 case OR:
4140 case ORDER:
4141 case ORGANIZATION:
4142 case OTHERS:
4143 case OUT:
4144 case OVERRIDING:
4145 case PACKAGE:
4146 case PARTITION:
4147 case PCTFREE:
4148 case PLS_INTEGER:
4149 case POSITIVE:
4150 case POSITIVEN:
4151 case PRAGMA:
4152 case PRESERVE:
4153 case PRIOR:
4154 case PROMPT:
4155 case PRIVATE:
4156 case PROCEDURE:
4157 case PUBLIC:
4158 case RAISE:
4159 case RANGE:
4160 case RAW:
4161 case REAL:
4162 case RECORD:
4163 case REF:
4164 case RELEASE:
4165 case RELIES_ON:
4166 case RENAME:
4167 case RESULT:
4168 case RETURN:
4169 case RETURNING:
4170 case REVERSE:
4171 case ROLLBACK:
4172 case ROW:
4173 case ROWS:
4174 case ROWID:
4175 case ROWNUM:
4176 case ROWTYPE:
4177 case SAVE:
4178 case SAVEPOINT:
4179 case SECOND:
4180 case SELECT:
4181 case SELF:
4182 case SEPARATE:
4183 case SET:
4184 case SHARE:
4185 case SMALLINT:
4186 case SPACE:
4187 case SQL:
4188 case SQLCODE:
4189 case SQLERRM:
4190 case START:
4191 case STATIC:
4192 case STDDEV:
4193 case SUBTYPE:
4194 case SUBSTITUTABLE:
4195 case SUCCESSFUL:
4196 case SUM:
4197 case SYNONYM:
4198 case SYSDATE:
4199 case SYS_REFCURSOR:
4200 case TABLE:
4201 case TEMPORARY:
4202 case THEN:
4203 case TIME:
4204 case TIMESTAMP:
4205 case TIMEZONE_REGION:
4206 case TIMEZONE_ABBR:
4207 case TIMEZONE_MINUTE:
4208 case TIMEZONE_HOUR:
4209 case TO:
4210 case TRANSACTION:
4211 case TRIGGER:
4212 case TRUE:
4213 case TYPE:
4214 case UI:
4215 case UNDER:
4216 case USING:
4217 case WHILE:
4218 case YES:
4219 case SHOW:
4220 case A:
4221 case UPDATE:
4222 case VARCHAR:
4223 case VARCHAR2:
4224 case DOUBLE:
4225 case DEC:
4226 case PRECISION:
4227 case INT:
4228 case NUMERIC:
4229 case SIGNTYPE:
4230 case NCHAR:
4231 case NVARCHAR2:
4232 case STRING:
4233 case UROWID:
4234 case VARRAY:
4235 case VARYING:
4236 case BFILE:
4237 case BLOB:
4238 case CLOB:
4239 case NCLOB:
4240 case YEAR:
4241 case LOCAL:
4242 case WITH:
4243 case ZONE:
4244 case CHARACTER:
4245 case AFTER:
4246 case BEFORE:
4247 case OLD:
4248 case PARENT:
4249 case CC_IF:
4250 case CC_ERROR:
4251 case ANALYZE:
4252 case ASSOCIATE:
4253 case AUDIT:
4254 case COMPOUND:
4255 case DATABASE:
4256 case CALL:
4257 case DDL:
4258 case DISASSOCIATE:
4259 case EACH:
4260 case FOLLOWS:
4261 case LOGOFF:
4262 case LOGON:
4263 case NESTED:
4264 case NOAUDIT:
4265 case SCHEMA:
4266 case SERVERERROR:
4267 case SHUTDOWN:
4268 case STARTUP:
4269 case STATEMENT:
4270 case STATISTICS:
4271 case SUSPEND:
4272 case TRUNCATE:
4273 case WRAPPED:
4274 case LIBRARY:
4275 case NAME:
4276 case STRUCT:
4277 case CONTEXT:
4278 case PARAMETERS:
4279 case LENGTH:
4280 case TDO:
4281 case MAXLEN:
4282 case CHARSETID:
4283 case CHARSETFORM:
4284 case ACCEPT:
4285 case ACCESSIBLE:
4286 case COPY:
4287 case DEFINE:
4288 case DISCONNECT:
4289 case HOST:
4290 case PRINT:
4291 case QUIT:
4292 case REMARK:
4293 case UNDEFINE:
4294 case VARIABLE:
4295 case WHENEVER:
4296 case ATTACH:
4297 case CAST:
4298 case TREAT:
4299 case TRIM:
4300 case LEFT:
4301 case RIGHT:
4302 case BOTH:
4303 case EMPTY:
4304 case MULTISET:
4305 case SUBMULTISET:
4306 case LEADING:
4307 case TRAILING:
4308 case CHAR_CS:
4309 case NCHAR_CS:
4310 case DBTIMEZONE:
4311 case SESSIONTIMEZONE:
4312 case AUTHENTICATED:
4313 case LINK:
4314 case SHARED:
4315 case DIRECTORY:
4316 case USER:
4317 case IDENTIFIER:
4318 case QUOTED_LITERAL:
4319 case SQLDATA_CLASS:
4320 case CUSTOMDATUM_CLASS:
4321 case ORADATA_CLASS:
4322 case JAVA_INTERFACE_CLASS:
4323 ;
4324 break;
4325 default:
4326 jj_la1[40] = jj_gen;
4327 break label_12;
4328 }
4329 switch (jj_nt.kind) {
4330 case REPLACE:
4331 case DEFINER:
4332 case CURRENT_USER:
4333 case SERIALLY_REUSABLE:
4334 case RESTRICT_REFERENCES:
4335 case EXCEPTION_INIT:
4336 case AUTONOMOUS_TRANSACTION:
4337 case LANGUAGE:
4338 case INLINE:
4339 case ADD:
4340 case AGGREGATE:
4341 case ALL:
4342 case ALTER:
4343 case AND:
4344 case ANY:
4345 case ARRAY:
4346 case AS:
4347 case ASC:
4348 case AT:
4349 case ATTRIBUTE:
4350 case AUTHID:
4351 case AVG:
4352 case BETWEEN:
4353 case BINARY_INTEGER:
4354 case BODY:
4355 case BOOLEAN:
4356 case BULK:
4357 case BY:
4358 case BYTE:
4359 case CASCADE:
4360 case CASE:
4361 case CHAR:
4362 case CHAR_BASE:
4363 case CHECK:
4364 case CLOSE:
4365 case CLUSTER:
4366 case COALESCE:
4367 case COLLECT:
4368 case COLUMN:
4369 case COMMENT:
4370 case COMMIT:
4371 case COMPRESS:
4372 case CONNECT:
4373 case CONSTANT:
4374 case CONSTRUCTOR:
4375 case CONTINUE:
4376 case CONVERT:
4377 case CREATE:
4378 case CURRENT:
4379 case CURRVAL:
4380 case CURSOR:
4381 case DATA:
4382 case DATE:
4383 case DAY:
4384 case DECLARE:
4385 case DECIMAL:
4386 case _DEFAULT:
4387 case DELETE:
4388 case DESC:
4389 case DISABLE:
4390 case DISTINCT:
4391 case DO:
4392 case DROP:
4393 case EDITIONABLE:
4394 case ELEMENT:
4395 case ELSE:
4396 case ELSIF:
4397 case ENABLE:
4398 case ESCAPE:
4399 case EXCEPT:
4400 case EXCEPTION:
4401 case EXCEPTIONS:
4402 case EXCLUSIVE:
4403 case EXECUTE:
4404 case EXISTS:
4405 case EXIT:
4406 case EXTERNAL:
4407 case EXTENDS:
4408 case EXTRACT:
4409 case FALSE:
4410 case FETCH:
4411 case FINAL:
4412 case FLOAT:
4413 case FOR:
4414 case FORALL:
4415 case FORCE:
4416 case FROM:
4417 case FUNCTION:
4418 case GLOBAL:
4419 case GOTO:
4420 case GROUP:
4421 case HASH:
4422 case HAVING:
4423 case HEAP:
4424 case HOUR:
4425 case IF:
4426 case IMMEDIATE:
4427 case IN:
4428 case INDEX:
4429 case INDICES:
4430 case INDEXTYPE:
4431 case INDICATOR:
4432 case INSERT:
4433 case INSTANTIABLE:
4434 case INTEGER:
4435 case INTERFACE:
4436 case INTERSECT:
4437 case INTERVAL:
4438 case INTO:
4439 case INVALIDATE:
4440 case IS:
4441 case ISOLATION:
4442 case JAVA:
4443 case LEVEL:
4444 case LIKE:
4445 case LIMIT:
4446 case LIMITED:
4447 case LOCK:
4448 case LONG:
4449 case LOOP:
4450 case MAP:
4451 case MAX:
4452 case MEMBER:
4453 case MERGE:
4454 case MIN:
4455 case MINUS:
4456 case MINUTE:
4457 case MLSLABEL:
4458 case MODIFY:
4459 case MOD:
4460 case MODE:
4461 case MONTH:
4462 case NATURAL:
4463 case NATURALN:
4464 case NEW:
4465 case NEXTVAL:
4466 case NO:
4467 case NOCOPY:
4468 case NONEDITIONABLE:
4469 case NOT:
4470 case NOWAIT:
4471 case NULL:
4472 case NULLIF:
4473 case NUMBER:
4474 case BFILE_BASE:
4475 case BLOB_BASE:
4476 case CLOB_BASE:
4477 case DATE_BASE:
4478 case NUMBER_BASE:
4479 case OBJECT:
4480 case OCIROWID:
4481 case OF:
4482 case OID:
4483 case ON:
4484 case OPAQUE:
4485 case OPEN:
4486 case OPERATOR:
4487 case OPTION:
4488 case OR:
4489 case ORDER:
4490 case ORGANIZATION:
4491 case OTHERS:
4492 case OUT:
4493 case OVERRIDING:
4494 case PACKAGE:
4495 case PARTITION:
4496 case PCTFREE:
4497 case PLS_INTEGER:
4498 case POSITIVE:
4499 case POSITIVEN:
4500 case PRAGMA:
4501 case PRESERVE:
4502 case PRIOR:
4503 case PROMPT:
4504 case PRIVATE:
4505 case PROCEDURE:
4506 case PUBLIC:
4507 case RAISE:
4508 case RANGE:
4509 case RAW:
4510 case REAL:
4511 case RECORD:
4512 case REF:
4513 case RELEASE:
4514 case RELIES_ON:
4515 case RENAME:
4516 case RESULT:
4517 case RETURN:
4518 case RETURNING:
4519 case REVERSE:
4520 case ROLLBACK:
4521 case ROW:
4522 case ROWS:
4523 case ROWID:
4524 case ROWNUM:
4525 case ROWTYPE:
4526 case SAVE:
4527 case SAVEPOINT:
4528 case SECOND:
4529 case SELECT:
4530 case SELF:
4531 case SEPARATE:
4532 case SET:
4533 case SHARE:
4534 case SMALLINT:
4535 case SPACE:
4536 case SQL:
4537 case SQLCODE:
4538 case SQLERRM:
4539 case START:
4540 case STATIC:
4541 case STDDEV:
4542 case SUBTYPE:
4543 case SUBSTITUTABLE:
4544 case SUCCESSFUL:
4545 case SUM:
4546 case SYNONYM:
4547 case SYSDATE:
4548 case SYS_REFCURSOR:
4549 case TABLE:
4550 case TEMPORARY:
4551 case THEN:
4552 case TIME:
4553 case TIMESTAMP:
4554 case TIMEZONE_REGION:
4555 case TIMEZONE_ABBR:
4556 case TIMEZONE_MINUTE:
4557 case TIMEZONE_HOUR:
4558 case TO:
4559 case TRANSACTION:
4560 case TRIGGER:
4561 case TRUE:
4562 case TYPE:
4563 case UI:
4564 case UNDER:
4565 case USING:
4566 case WHILE:
4567 case YES:
4568 case SHOW:
4569 case A:
4570 case UPDATE:
4571 case VARCHAR:
4572 case VARCHAR2:
4573 case DOUBLE:
4574 case DEC:
4575 case PRECISION:
4576 case INT:
4577 case NUMERIC:
4578 case SIGNTYPE:
4579 case NCHAR:
4580 case NVARCHAR2:
4581 case STRING:
4582 case UROWID:
4583 case VARRAY:
4584 case VARYING:
4585 case BFILE:
4586 case BLOB:
4587 case CLOB:
4588 case NCLOB:
4589 case YEAR:
4590 case LOCAL:
4591 case WITH:
4592 case ZONE:
4593 case CHARACTER:
4594 case AFTER:
4595 case BEFORE:
4596 case OLD:
4597 case PARENT:
4598 case CC_IF:
4599 case ANALYZE:
4600 case ASSOCIATE:
4601 case AUDIT:
4602 case COMPOUND:
4603 case DATABASE:
4604 case CALL:
4605 case DDL:
4606 case DISASSOCIATE:
4607 case EACH:
4608 case FOLLOWS:
4609 case LOGOFF:
4610 case LOGON:
4611 case NESTED:
4612 case NOAUDIT:
4613 case SCHEMA:
4614 case SERVERERROR:
4615 case SHUTDOWN:
4616 case STARTUP:
4617 case STATEMENT:
4618 case STATISTICS:
4619 case SUSPEND:
4620 case TRUNCATE:
4621 case WRAPPED:
4622 case LIBRARY:
4623 case NAME:
4624 case STRUCT:
4625 case CONTEXT:
4626 case PARAMETERS:
4627 case LENGTH:
4628 case TDO:
4629 case MAXLEN:
4630 case CHARSETID:
4631 case CHARSETFORM:
4632 case ACCEPT:
4633 case ACCESSIBLE:
4634 case COPY:
4635 case DEFINE:
4636 case DISCONNECT:
4637 case HOST:
4638 case PRINT:
4639 case QUIT:
4640 case REMARK:
4641 case UNDEFINE:
4642 case VARIABLE:
4643 case WHENEVER:
4644 case ATTACH:
4645 case CAST:
4646 case TREAT:
4647 case TRIM:
4648 case LEFT:
4649 case RIGHT:
4650 case BOTH:
4651 case EMPTY:
4652 case MULTISET:
4653 case SUBMULTISET:
4654 case LEADING:
4655 case TRAILING:
4656 case CHAR_CS:
4657 case NCHAR_CS:
4658 case DBTIMEZONE:
4659 case SESSIONTIMEZONE:
4660 case AUTHENTICATED:
4661 case LINK:
4662 case SHARED:
4663 case DIRECTORY:
4664 case USER:
4665 case IDENTIFIER:
4666 case QUOTED_LITERAL:
4667 case SQLDATA_CLASS:
4668 case CUSTOMDATUM_CLASS:
4669 case ORADATA_CLASS:
4670 case JAVA_INTERFACE_CLASS:
4671 DeclarativeUnit();
4672 break;
4673 case CC_ERROR:
4674 jj_consume_token(CC_ERROR);
4675 Expression();
4676 jj_consume_token(CC_END);
4677 break;
4678 default:
4679 jj_la1[41] = jj_gen;
4680 jj_consume_token(-1);
4681 throw new ParseException();
4682 }
4683 }
4684 }
4685 jj_consume_token(CC_END);
4686 jjtree.closeNodeScope(jjtn000, true);
4687 jjtc000 = false;
4688 {if (true) return jjtn000 ;}
4689 } catch (Throwable jjte000) {
4690 if (jjtc000) {
4691 jjtree.clearNodeScope(jjtn000);
4692 jjtc000 = false;
4693 } else {
4694 jjtree.popNode();
4695 }
4696 if (jjte000 instanceof RuntimeException) {
4697 {if (true) throw (RuntimeException)jjte000;}
4698 }
4699 if (jjte000 instanceof ParseException) {
4700 {if (true) throw (ParseException)jjte000;}
4701 }
4702 {if (true) throw (Error)jjte000;}
4703 } finally {
4704 if (jjtc000) {
4705 jjtree.closeNodeScope(jjtn000, true);
4706 }
4707 }
4708 throw new Error("Missing return statement in function");
4709 }
4710
4711
4712
4713
4714
4715
4716
4717 final public ASTProgramUnit ProgramUnit() throws ParseException {
4718
4719 ASTProgramUnit jjtn000 = new ASTProgramUnit(this, JJTPROGRAMUNIT);
4720 boolean jjtc000 = true;
4721 jjtree.openNodeScope(jjtn000);
4722 try {
4723 switch (jj_nt.kind) {
4724 case CREATE:
4725 jj_consume_token(CREATE);
4726 switch (jj_nt.kind) {
4727 case OR:
4728 jj_consume_token(OR);
4729 jj_consume_token(REPLACE);
4730 break;
4731 default:
4732 jj_la1[42] = jj_gen;
4733 ;
4734 }
4735 switch (jj_nt.kind) {
4736 case EDITIONABLE:
4737 case NONEDITIONABLE:
4738 switch (jj_nt.kind) {
4739 case EDITIONABLE:
4740 jj_consume_token(EDITIONABLE);
4741 break;
4742 case NONEDITIONABLE:
4743 jj_consume_token(NONEDITIONABLE);
4744 break;
4745 default:
4746 jj_la1[43] = jj_gen;
4747 jj_consume_token(-1);
4748 throw new ParseException();
4749 }
4750 break;
4751 default:
4752 jj_la1[44] = jj_gen;
4753 ;
4754 }
4755 break;
4756 default:
4757 jj_la1[45] = jj_gen;
4758 ;
4759 }
4760 MethodDeclarator();
4761 switch (jj_nt.kind) {
4762 case WRAPPED:
4763 WrappedObject();
4764 break;
4765 case 4:
4766 case AGGREGATE:
4767 case AS:
4768 case AUTHID:
4769 case DETERMINISTIC:
4770 case IS:
4771 case PARALLEL_ENABLE:
4772 case PIPELINED:
4773 case RESULT_CACHE:
4774 case ACCESSIBLE:
4775 label_13:
4776 while (true) {
4777 switch (jj_nt.kind) {
4778 case AUTHID:
4779 case DETERMINISTIC:
4780 case PARALLEL_ENABLE:
4781 case PIPELINED:
4782 case RESULT_CACHE:
4783 case ACCESSIBLE:
4784 ;
4785 break;
4786 default:
4787 jj_la1[46] = jj_gen;
4788 break label_13;
4789 }
4790 switch (jj_nt.kind) {
4791 case AUTHID:
4792 jj_consume_token(AUTHID);
4793 switch (jj_nt.kind) {
4794 case CURRENT_USER:
4795 jj_consume_token(CURRENT_USER);
4796 break;
4797 case DEFINER:
4798 jj_consume_token(DEFINER);
4799 break;
4800 default:
4801 jj_la1[47] = jj_gen;
4802 jj_consume_token(-1);
4803 throw new ParseException();
4804 }
4805 break;
4806 case DETERMINISTIC:
4807 jj_consume_token(DETERMINISTIC);
4808 break;
4809 case ACCESSIBLE:
4810 AccessibleByClause();
4811 break;
4812 case PARALLEL_ENABLE:
4813 jj_consume_token(PARALLEL_ENABLE);
4814 switch (jj_nt.kind) {
4815 case 5:
4816 ParallelClause();
4817 break;
4818 default:
4819 jj_la1[48] = jj_gen;
4820 ;
4821 }
4822 switch (jj_nt.kind) {
4823 case USING:
4824 jj_consume_token(USING);
4825 ID();
4826 switch (jj_nt.kind) {
4827 case 3:
4828 jj_consume_token(3);
4829 ID();
4830 break;
4831 default:
4832 jj_la1[49] = jj_gen;
4833 ;
4834 }
4835 break;
4836 default:
4837 jj_la1[50] = jj_gen;
4838 ;
4839 }
4840 break;
4841 case PIPELINED:
4842 jj_consume_token(PIPELINED);
4843 switch (jj_nt.kind) {
4844 case CLUSTER:
4845 case ORDER:
4846 case USING:
4847 switch (jj_nt.kind) {
4848 case USING:
4849 jj_consume_token(USING);
4850 ID();
4851 switch (jj_nt.kind) {
4852 case 3:
4853 jj_consume_token(3);
4854 ID();
4855 break;
4856 default:
4857 jj_la1[51] = jj_gen;
4858 ;
4859 }
4860 break;
4861 case CLUSTER:
4862 case ORDER:
4863 switch (jj_nt.kind) {
4864 case ORDER:
4865 jj_consume_token(ORDER);
4866 break;
4867 case CLUSTER:
4868 jj_consume_token(CLUSTER);
4869 break;
4870 default:
4871 jj_la1[52] = jj_gen;
4872 jj_consume_token(-1);
4873 throw new ParseException();
4874 }
4875 switch (jj_nt.kind) {
4876 case REPLACE:
4877 case DEFINER:
4878 case CURRENT_USER:
4879 case SERIALLY_REUSABLE:
4880 case RESTRICT_REFERENCES:
4881 case EXCEPTION_INIT:
4882 case AUTONOMOUS_TRANSACTION:
4883 case LANGUAGE:
4884 case INLINE:
4885 case ADD:
4886 case AGGREGATE:
4887 case ALL:
4888 case ALTER:
4889 case AND:
4890 case ANY:
4891 case ARRAY:
4892 case AS:
4893 case ASC:
4894 case AT:
4895 case ATTRIBUTE:
4896 case AUTHID:
4897 case AVG:
4898 case BETWEEN:
4899 case BINARY_INTEGER:
4900 case BODY:
4901 case BOOLEAN:
4902 case BULK:
4903 case BY:
4904 case BYTE:
4905 case CASCADE:
4906 case CASE:
4907 case CHAR:
4908 case CHAR_BASE:
4909 case CHECK:
4910 case CLOSE:
4911 case CLUSTER:
4912 case COALESCE:
4913 case COLLECT:
4914 case COLUMN:
4915 case COMMENT:
4916 case COMMIT:
4917 case COMPRESS:
4918 case CONNECT:
4919 case CONSTANT:
4920 case CONSTRUCTOR:
4921 case CONTINUE:
4922 case CONVERT:
4923 case CREATE:
4924 case CURRENT:
4925 case CURRVAL:
4926 case CURSOR:
4927 case DATA:
4928 case DATE:
4929 case DAY:
4930 case DECLARE:
4931 case DECIMAL:
4932 case _DEFAULT:
4933 case DELETE:
4934 case DESC:
4935 case DISABLE:
4936 case DISTINCT:
4937 case DO:
4938 case DROP:
4939 case EDITIONABLE:
4940 case ELEMENT:
4941 case ELSE:
4942 case ELSIF:
4943 case ENABLE:
4944 case ESCAPE:
4945 case EXCEPT:
4946 case EXCEPTION:
4947 case EXCEPTIONS:
4948 case EXCLUSIVE:
4949 case EXECUTE:
4950 case EXISTS:
4951 case EXIT:
4952 case EXTERNAL:
4953 case EXTENDS:
4954 case EXTRACT:
4955 case FALSE:
4956 case FETCH:
4957 case FINAL:
4958 case FLOAT:
4959 case FOR:
4960 case FORALL:
4961 case FORCE:
4962 case FROM:
4963 case FUNCTION:
4964 case GLOBAL:
4965 case GOTO:
4966 case GROUP:
4967 case HASH:
4968 case HAVING:
4969 case HEAP:
4970 case HOUR:
4971 case IF:
4972 case IMMEDIATE:
4973 case IN:
4974 case INDEX:
4975 case INDICES:
4976 case INDEXTYPE:
4977 case INDICATOR:
4978 case INSERT:
4979 case INSTANTIABLE:
4980 case INTEGER:
4981 case INTERFACE:
4982 case INTERSECT:
4983 case INTERVAL:
4984 case INTO:
4985 case INVALIDATE:
4986 case IS:
4987 case ISOLATION:
4988 case JAVA:
4989 case LEVEL:
4990 case LIKE:
4991 case LIMIT:
4992 case LIMITED:
4993 case LOCK:
4994 case LONG:
4995 case LOOP:
4996 case MAP:
4997 case MAX:
4998 case MEMBER:
4999 case MERGE:
5000 case MIN:
5001 case MINUS:
5002 case MINUTE:
5003 case MLSLABEL:
5004 case MODIFY:
5005 case MOD:
5006 case MODE:
5007 case MONTH:
5008 case NATURAL:
5009 case NATURALN:
5010 case NEW:
5011 case NEXTVAL:
5012 case NO:
5013 case NOCOPY:
5014 case NONEDITIONABLE:
5015 case NOT:
5016 case NOWAIT:
5017 case NULL:
5018 case NULLIF:
5019 case NUMBER:
5020 case BFILE_BASE:
5021 case BLOB_BASE:
5022 case CLOB_BASE:
5023 case DATE_BASE:
5024 case NUMBER_BASE:
5025 case OBJECT:
5026 case OCIROWID:
5027 case OF:
5028 case OID:
5029 case ON:
5030 case OPAQUE:
5031 case OPEN:
5032 case OPERATOR:
5033 case OPTION:
5034 case OR:
5035 case ORDER:
5036 case ORGANIZATION:
5037 case OTHERS:
5038 case OUT:
5039 case OVERRIDING:
5040 case PACKAGE:
5041 case PARTITION:
5042 case PCTFREE:
5043 case PLS_INTEGER:
5044 case POSITIVE:
5045 case POSITIVEN:
5046 case PRESERVE:
5047 case PRIOR:
5048 case PROMPT:
5049 case PRIVATE:
5050 case PROCEDURE:
5051 case PUBLIC:
5052 case RAISE:
5053 case RANGE:
5054 case RAW:
5055 case REAL:
5056 case RECORD:
5057 case REF:
5058 case RELEASE:
5059 case RELIES_ON:
5060 case RENAME:
5061 case RESULT:
5062 case RETURN:
5063 case RETURNING:
5064 case REVERSE:
5065 case ROLLBACK:
5066 case ROW:
5067 case ROWS:
5068 case ROWID:
5069 case ROWNUM:
5070 case ROWTYPE:
5071 case SAVE:
5072 case SAVEPOINT:
5073 case SECOND:
5074 case SELECT:
5075 case SELF:
5076 case SEPARATE:
5077 case SET:
5078 case SHARE:
5079 case SMALLINT:
5080 case SPACE:
5081 case SQL:
5082 case SQLCODE:
5083 case SQLERRM:
5084 case START:
5085 case STATIC:
5086 case STDDEV:
5087 case SUBTYPE:
5088 case SUBSTITUTABLE:
5089 case SUCCESSFUL:
5090 case SUM:
5091 case SYNONYM:
5092 case SYSDATE:
5093 case SYS_REFCURSOR:
5094 case TABLE:
5095 case TEMPORARY:
5096 case THEN:
5097 case TIME:
5098 case TIMESTAMP:
5099 case TIMEZONE_REGION:
5100 case TIMEZONE_ABBR:
5101 case TIMEZONE_MINUTE:
5102 case TIMEZONE_HOUR:
5103 case TO:
5104 case TRANSACTION:
5105 case TRIGGER:
5106 case TRUE:
5107 case TYPE:
5108 case UI:
5109 case UNDER:
5110 case USING:
5111 case WHILE:
5112 case YES:
5113 case SHOW:
5114 case A:
5115 case UPDATE:
5116 case VARCHAR:
5117 case VARCHAR2:
5118 case DOUBLE:
5119 case DEC:
5120 case PRECISION:
5121 case INT:
5122 case NUMERIC:
5123 case SIGNTYPE:
5124 case NCHAR:
5125 case NVARCHAR2:
5126 case STRING:
5127 case UROWID:
5128 case VARRAY:
5129 case VARYING:
5130 case BFILE:
5131 case BLOB:
5132 case CLOB:
5133 case NCLOB:
5134 case YEAR:
5135 case LOCAL:
5136 case WITH:
5137 case ZONE:
5138 case CHARACTER:
5139 case AFTER:
5140 case BEFORE:
5141 case OLD:
5142 case PARENT:
5143 case ANALYZE:
5144 case ASSOCIATE:
5145 case AUDIT:
5146 case COMPOUND:
5147 case DATABASE:
5148 case CALL:
5149 case DDL:
5150 case DISASSOCIATE:
5151 case EACH:
5152 case FOLLOWS:
5153 case LOGOFF:
5154 case LOGON:
5155 case NESTED:
5156 case NOAUDIT:
5157 case SCHEMA:
5158 case SERVERERROR:
5159 case SHUTDOWN:
5160 case STARTUP:
5161 case STATEMENT:
5162 case STATISTICS:
5163 case SUSPEND:
5164 case TRUNCATE:
5165 case WRAPPED:
5166 case LIBRARY:
5167 case NAME:
5168 case STRUCT:
5169 case CONTEXT:
5170 case PARAMETERS:
5171 case LENGTH:
5172 case TDO:
5173 case MAXLEN:
5174 case CHARSETID:
5175 case CHARSETFORM:
5176 case ACCEPT:
5177 case ACCESSIBLE:
5178 case COPY:
5179 case DEFINE:
5180 case DISCONNECT:
5181 case HOST:
5182 case PRINT:
5183 case QUIT:
5184 case REMARK:
5185 case UNDEFINE:
5186 case VARIABLE:
5187 case WHENEVER:
5188 case ATTACH:
5189 case CAST:
5190 case TREAT:
5191 case TRIM:
5192 case LEFT:
5193 case RIGHT:
5194 case BOTH:
5195 case EMPTY:
5196 case MULTISET:
5197 case SUBMULTISET:
5198 case LEADING:
5199 case TRAILING:
5200 case CHAR_CS:
5201 case NCHAR_CS:
5202 case DBTIMEZONE:
5203 case SESSIONTIMEZONE:
5204 case AUTHENTICATED:
5205 case LINK:
5206 case SHARED:
5207 case DIRECTORY:
5208 case USER:
5209 case IDENTIFIER:
5210 case QUOTED_LITERAL:
5211 case SQLDATA_CLASS:
5212 case CUSTOMDATUM_CLASS:
5213 case ORADATA_CLASS:
5214 case JAVA_INTERFACE_CLASS:
5215 ID();
5216 break;
5217 default:
5218 jj_la1[53] = jj_gen;
5219 ;
5220 }
5221 jj_consume_token(BY);
5222 jj_consume_token(5);
5223 ID();
5224 label_14:
5225 while (true) {
5226 switch (jj_nt.kind) {
5227 case 6:
5228 ;
5229 break;
5230 default:
5231 jj_la1[54] = jj_gen;
5232 break label_14;
5233 }
5234 jj_consume_token(6);
5235 ID();
5236 }
5237 jj_consume_token(7);
5238 break;
5239 default:
5240 jj_la1[55] = jj_gen;
5241 jj_consume_token(-1);
5242 throw new ParseException();
5243 }
5244 break;
5245 default:
5246 jj_la1[56] = jj_gen;
5247 ;
5248 }
5249 break;
5250 case RESULT_CACHE:
5251 jj_consume_token(RESULT_CACHE);
5252 switch (jj_nt.kind) {
5253 case RELIES_ON:
5254 jj_consume_token(RELIES_ON);
5255 jj_consume_token(5);
5256 ID();
5257 switch (jj_nt.kind) {
5258 case 3:
5259 jj_consume_token(3);
5260 ID();
5261 break;
5262 default:
5263 jj_la1[57] = jj_gen;
5264 ;
5265 }
5266 label_15:
5267 while (true) {
5268 switch (jj_nt.kind) {
5269 case 6:
5270 ;
5271 break;
5272 default:
5273 jj_la1[58] = jj_gen;
5274 break label_15;
5275 }
5276 jj_consume_token(6);
5277 ID();
5278 switch (jj_nt.kind) {
5279 case 3:
5280 jj_consume_token(3);
5281 ID();
5282 break;
5283 default:
5284 jj_la1[59] = jj_gen;
5285 ;
5286 }
5287 }
5288 jj_consume_token(7);
5289 break;
5290 default:
5291 jj_la1[60] = jj_gen;
5292 ;
5293 }
5294 break;
5295 default:
5296 jj_la1[61] = jj_gen;
5297 jj_consume_token(-1);
5298 throw new ParseException();
5299 }
5300 }
5301 switch (jj_nt.kind) {
5302 case AGGREGATE:
5303 jj_consume_token(AGGREGATE);
5304 jj_consume_token(USING);
5305 ID();
5306 break;
5307 default:
5308 jj_la1[62] = jj_gen;
5309 ;
5310 }
5311 switch (jj_nt.kind) {
5312 case AS:
5313 case IS:
5314 switch (jj_nt.kind) {
5315 case IS:
5316 jj_consume_token(IS);
5317 break;
5318 case AS:
5319 jj_consume_token(AS);
5320 break;
5321 default:
5322 jj_la1[63] = jj_gen;
5323 jj_consume_token(-1);
5324 throw new ParseException();
5325 }
5326 if (jj_2_21(2)) {
5327 CallSpecTail();
5328 } else {
5329 switch (jj_nt.kind) {
5330 case REPLACE:
5331 case DEFINER:
5332 case CURRENT_USER:
5333 case SERIALLY_REUSABLE:
5334 case RESTRICT_REFERENCES:
5335 case EXCEPTION_INIT:
5336 case AUTONOMOUS_TRANSACTION:
5337 case LANGUAGE:
5338 case INLINE:
5339 case ADD:
5340 case AGGREGATE:
5341 case ALL:
5342 case ALTER:
5343 case AND:
5344 case ANY:
5345 case ARRAY:
5346 case AS:
5347 case ASC:
5348 case AT:
5349 case ATTRIBUTE:
5350 case AUTHID:
5351 case AVG:
5352 case BEGIN:
5353 case BETWEEN:
5354 case BINARY_INTEGER:
5355 case BODY:
5356 case BOOLEAN:
5357 case BULK:
5358 case BY:
5359 case BYTE:
5360 case CASCADE:
5361 case CASE:
5362 case CHAR:
5363 case CHAR_BASE:
5364 case CHECK:
5365 case CLOSE:
5366 case CLUSTER:
5367 case COALESCE:
5368 case COLLECT:
5369 case COLUMN:
5370 case COMMENT:
5371 case COMMIT:
5372 case COMPRESS:
5373 case CONNECT:
5374 case CONSTANT:
5375 case CONSTRUCTOR:
5376 case CONTINUE:
5377 case CONVERT:
5378 case CREATE:
5379 case CURRENT:
5380 case CURRVAL:
5381 case CURSOR:
5382 case DATA:
5383 case DATE:
5384 case DAY:
5385 case DECLARE:
5386 case DECIMAL:
5387 case _DEFAULT:
5388 case DELETE:
5389 case DESC:
5390 case DISABLE:
5391 case DISTINCT:
5392 case DO:
5393 case DROP:
5394 case EDITIONABLE:
5395 case ELEMENT:
5396 case ELSE:
5397 case ELSIF:
5398 case ENABLE:
5399 case ESCAPE:
5400 case EXCEPT:
5401 case EXCEPTION:
5402 case EXCEPTIONS:
5403 case EXCLUSIVE:
5404 case EXECUTE:
5405 case EXISTS:
5406 case EXIT:
5407 case EXTERNAL:
5408 case EXTENDS:
5409 case EXTRACT:
5410 case FALSE:
5411 case FETCH:
5412 case FINAL:
5413 case FLOAT:
5414 case FOR:
5415 case FORALL:
5416 case FORCE:
5417 case FROM:
5418 case FUNCTION:
5419 case GLOBAL:
5420 case GOTO:
5421 case GROUP:
5422 case HASH:
5423 case HAVING:
5424 case HEAP:
5425 case HOUR:
5426 case IF:
5427 case IMMEDIATE:
5428 case IN:
5429 case INDEX:
5430 case INDICES:
5431 case INDEXTYPE:
5432 case INDICATOR:
5433 case INSERT:
5434 case INSTANTIABLE:
5435 case INTEGER:
5436 case INTERFACE:
5437 case INTERSECT:
5438 case INTERVAL:
5439 case INTO:
5440 case INVALIDATE:
5441 case IS:
5442 case ISOLATION:
5443 case JAVA:
5444 case LEVEL:
5445 case LIKE:
5446 case LIMIT:
5447 case LIMITED:
5448 case LOCK:
5449 case LONG:
5450 case LOOP:
5451 case MAP:
5452 case MAX:
5453 case MEMBER:
5454 case MERGE:
5455 case MIN:
5456 case MINUS:
5457 case MINUTE:
5458 case MLSLABEL:
5459 case MODIFY:
5460 case MOD:
5461 case MODE:
5462 case MONTH:
5463 case NATURAL:
5464 case NATURALN:
5465 case NEW:
5466 case NEXTVAL:
5467 case NO:
5468 case NOCOPY:
5469 case NONEDITIONABLE:
5470 case NOT:
5471 case NOWAIT:
5472 case NULL:
5473 case NULLIF:
5474 case NUMBER:
5475 case BFILE_BASE:
5476 case BLOB_BASE:
5477 case CLOB_BASE:
5478 case DATE_BASE:
5479 case NUMBER_BASE:
5480 case OBJECT:
5481 case OCIROWID:
5482 case OF:
5483 case OID:
5484 case ON:
5485 case OPAQUE:
5486 case OPEN:
5487 case OPERATOR:
5488 case OPTION:
5489 case OR:
5490 case ORDER:
5491 case ORGANIZATION:
5492 case OTHERS:
5493 case OUT:
5494 case OVERRIDING:
5495 case PACKAGE:
5496 case PARTITION:
5497 case PCTFREE:
5498 case PLS_INTEGER:
5499 case POSITIVE:
5500 case POSITIVEN:
5501 case PRAGMA:
5502 case PRESERVE:
5503 case PRIOR:
5504 case PROMPT:
5505 case PRIVATE:
5506 case PROCEDURE:
5507 case PUBLIC:
5508 case RAISE:
5509 case RANGE:
5510 case RAW:
5511 case REAL:
5512 case RECORD:
5513 case REF:
5514 case RELEASE:
5515 case RELIES_ON:
5516 case RENAME:
5517 case RESULT:
5518 case RETURN:
5519 case RETURNING:
5520 case REVERSE:
5521 case ROLLBACK:
5522 case ROW:
5523 case ROWS:
5524 case ROWID:
5525 case ROWNUM:
5526 case ROWTYPE:
5527 case SAVE:
5528 case SAVEPOINT:
5529 case SECOND:
5530 case SELECT:
5531 case SELF:
5532 case SEPARATE:
5533 case SET:
5534 case SHARE:
5535 case SMALLINT:
5536 case SPACE:
5537 case SQL:
5538 case SQLCODE:
5539 case SQLERRM:
5540 case START:
5541 case STATIC:
5542 case STDDEV:
5543 case SUBTYPE:
5544 case SUBSTITUTABLE:
5545 case SUCCESSFUL:
5546 case SUM:
5547 case SYNONYM:
5548 case SYSDATE:
5549 case SYS_REFCURSOR:
5550 case TABLE:
5551 case TEMPORARY:
5552 case THEN:
5553 case TIME:
5554 case TIMESTAMP:
5555 case TIMEZONE_REGION:
5556 case TIMEZONE_ABBR:
5557 case TIMEZONE_MINUTE:
5558 case TIMEZONE_HOUR:
5559 case TO:
5560 case TRANSACTION:
5561 case TRIGGER:
5562 case TRUE:
5563 case TYPE:
5564 case UI:
5565 case UNDER:
5566 case USING:
5567 case WHILE:
5568 case YES:
5569 case SHOW:
5570 case A:
5571 case UPDATE:
5572 case VARCHAR:
5573 case VARCHAR2:
5574 case DOUBLE:
5575 case DEC:
5576 case PRECISION:
5577 case INT:
5578 case NUMERIC:
5579 case SIGNTYPE:
5580 case NCHAR:
5581 case NVARCHAR2:
5582 case STRING:
5583 case UROWID:
5584 case VARRAY:
5585 case VARYING:
5586 case BFILE:
5587 case BLOB:
5588 case CLOB:
5589 case NCLOB:
5590 case YEAR:
5591 case LOCAL:
5592 case WITH:
5593 case ZONE:
5594 case CHARACTER:
5595 case AFTER:
5596 case BEFORE:
5597 case OLD:
5598 case PARENT:
5599 case CC_IF:
5600 case ANALYZE:
5601 case ASSOCIATE:
5602 case AUDIT:
5603 case COMPOUND:
5604 case DATABASE:
5605 case CALL:
5606 case DDL:
5607 case DISASSOCIATE:
5608 case EACH:
5609 case FOLLOWS:
5610 case LOGOFF:
5611 case LOGON:
5612 case NESTED:
5613 case NOAUDIT:
5614 case SCHEMA:
5615 case SERVERERROR:
5616 case SHUTDOWN:
5617 case STARTUP:
5618 case STATEMENT:
5619 case STATISTICS:
5620 case SUSPEND:
5621 case TRUNCATE:
5622 case WRAPPED:
5623 case LIBRARY:
5624 case NAME:
5625 case STRUCT:
5626 case CONTEXT:
5627 case PARAMETERS:
5628 case LENGTH:
5629 case TDO:
5630 case MAXLEN:
5631 case CHARSETID:
5632 case CHARSETFORM:
5633 case ACCEPT:
5634 case ACCESSIBLE:
5635 case COPY:
5636 case DEFINE:
5637 case DISCONNECT:
5638 case HOST:
5639 case PRINT:
5640 case QUIT:
5641 case REMARK:
5642 case UNDEFINE:
5643 case VARIABLE:
5644 case WHENEVER:
5645 case ATTACH:
5646 case CAST:
5647 case TREAT:
5648 case TRIM:
5649 case LEFT:
5650 case RIGHT:
5651 case BOTH:
5652 case EMPTY:
5653 case MULTISET:
5654 case SUBMULTISET:
5655 case LEADING:
5656 case TRAILING:
5657 case CHAR_CS:
5658 case NCHAR_CS:
5659 case DBTIMEZONE:
5660 case SESSIONTIMEZONE:
5661 case AUTHENTICATED:
5662 case LINK:
5663 case SHARED:
5664 case DIRECTORY:
5665 case USER:
5666 case IDENTIFIER:
5667 case QUOTED_LITERAL:
5668 case SQLDATA_CLASS:
5669 case CUSTOMDATUM_CLASS:
5670 case ORADATA_CLASS:
5671 case JAVA_INTERFACE_CLASS:
5672 DeclarativeSection();
5673 jj_consume_token(BEGIN);
5674 label_16:
5675 while (true) {
5676 switch (jj_nt.kind) {
5677 case 5:
5678 case 16:
5679 case 17:
5680 case 21:
5681 case REPLACE:
5682 case DEFINER:
5683 case CURRENT_USER:
5684 case LANGUAGE:
5685 case INLINE:
5686 case ADD:
5687 case AGGREGATE:
5688 case ARRAY:
5689 case AT:
5690 case ATTRIBUTE:
5691 case AUTHID:
5692 case BEGIN:
5693 case BODY:
5694 case BULK:
5695 case BYTE:
5696 case CASCADE:
5697 case CASE:
5698 case CLOSE:
5699 case COALESCE:
5700 case COLLECT:
5701 case COLUMN:
5702 case COMMENT:
5703 case COMMIT:
5704 case CONSTRUCTOR:
5705 case CONTINUE:
5706 case CONVERT:
5707 case CURRENT:
5708 case CURSOR:
5709 case DATA:
5710 case DATE:
5711 case DAY:
5712 case DECLARE:
5713 case DELETE:
5714 case DISABLE:
5715 case EDITIONABLE:
5716 case ELEMENT:
5717 case ENABLE:
5718 case ESCAPE:
5719 case EXCEPT:
5720 case EXCEPTIONS:
5721 case EXECUTE:
5722 case EXIT:
5723 case EXTERNAL:
5724 case EXTENDS:
5725 case EXTRACT:
5726 case FALSE:
5727 case FETCH:
5728 case FINAL:
5729 case FOR:
5730 case FORALL:
5731 case FORCE:
5732 case FUNCTION:
5733 case GLOBAL:
5734 case GOTO:
5735 case HASH:
5736 case HEAP:
5737 case HOUR:
5738 case IF:
5739 case IMMEDIATE:
5740 case INDICES:
5741 case INDEXTYPE:
5742 case INDICATOR:
5743 case INSERT:
5744 case INSTANTIABLE:
5745 case INTERVAL:
5746 case INVALIDATE:
5747 case ISOLATION:
5748 case JAVA:
5749 case LEVEL:
5750 case LIMIT:
5751 case LOCK:
5752 case LOOP:
5753 case MAP:
5754 case MAX:
5755 case MEMBER:
5756 case MERGE:
5757 case MIN:
5758 case MINUTE:
5759 case MLSLABEL:
5760 case MODIFY:
5761 case MOD:
5762 case MONTH:
5763 case NATURAL:
5764 case NEW:
5765 case NEW_DOT:
5766 case NO:
5767 case NONEDITIONABLE:
5768 case NOT:
5769 case NULL:
5770 case NULLIF:
5771 case OBJECT:
5772 case OID:
5773 case OPAQUE:
5774 case OPEN:
5775 case OPERATOR:
5776 case ORGANIZATION:
5777 case OTHERS:
5778 case OVERRIDING:
5779 case PACKAGE:
5780 case PARTITION:
5781 case PIPE:
5782 case PRAGMA:
5783 case PRESERVE:
5784 case PRIVATE:
5785 case PROCEDURE:
5786 case RAISE:
5787 case RANGE:
5788 case RAW:
5789 case REAL:
5790 case RECORD:
5791 case REF:
5792 case RELEASE:
5793 case RELIES_ON:
5794 case RENAME:
5795 case RESULT:
5796 case RETURN:
5797 case RETURNING:
5798 case REVERSE:
5799 case ROLLBACK:
5800 case ROW:
5801 case ROWS:
5802 case ROWID:
5803 case ROWNUM:
5804 case SAVE:
5805 case SAVEPOINT:
5806 case SECOND:
5807 case SELECT:
5808 case SELF:
5809 case SET:
5810 case SPACE:
5811 case SQL:
5812 case SQLCODE:
5813 case SQLERRM:
5814 case STATIC:
5815 case SUBTYPE:
5816 case SUBSTITUTABLE:
5817 case SUCCESSFUL:
5818 case SYSDATE:
5819 case SYS_REFCURSOR:
5820 case TEMPORARY:
5821 case TIME:
5822 case TIMESTAMP:
5823 case TIMEZONE_REGION:
5824 case TIMEZONE_ABBR:
5825 case TIMEZONE_MINUTE:
5826 case TIMEZONE_HOUR:
5827 case TRANSACTION:
5828 case TRUE:
5829 case TYPE:
5830 case UNDER:
5831 case USING:
5832 case WHILE:
5833 case YES:
5834 case SHOW:
5835 case A:
5836 case UPDATE:
5837 case DOUBLE:
5838 case DEC:
5839 case PRECISION:
5840 case INT:
5841 case NUMERIC:
5842 case NCHAR:
5843 case NVARCHAR2:
5844 case STRING:
5845 case UROWID:
5846 case VARRAY:
5847 case VARYING:
5848 case BFILE:
5849 case BLOB:
5850 case CLOB:
5851 case NCLOB:
5852 case YEAR:
5853 case LOCAL:
5854 case WITH:
5855 case ZONE:
5856 case CHARACTER:
5857 case AFTER:
5858 case BEFORE:
5859 case OLD:
5860 case PARENT:
5861 case CC_IF:
5862 case CC_ERROR:
5863 case ANALYZE:
5864 case ASSOCIATE:
5865 case AUDIT:
5866 case COMPOUND:
5867 case DATABASE:
5868 case CALL:
5869 case DDL:
5870 case DISASSOCIATE:
5871 case EACH:
5872 case FOLLOWS:
5873 case LOGOFF:
5874 case LOGON:
5875 case NESTED:
5876 case NOAUDIT:
5877 case SCHEMA:
5878 case SERVERERROR:
5879 case SHUTDOWN:
5880 case STARTUP:
5881 case STATEMENT:
5882 case STATISTICS:
5883 case SUSPEND:
5884 case TRUNCATE:
5885 case WRAPPED:
5886 case LIBRARY:
5887 case NAME:
5888 case STRUCT:
5889 case CONTEXT:
5890 case PARAMETERS:
5891 case LENGTH:
5892 case TDO:
5893 case MAXLEN:
5894 case CHARSETID:
5895 case CHARSETFORM:
5896 case ACCEPT:
5897 case ACCESSIBLE:
5898 case COPY:
5899 case DEFINE:
5900 case DISCONNECT:
5901 case HOST:
5902 case PRINT:
5903 case QUIT:
5904 case REMARK:
5905 case UNDEFINE:
5906 case VARIABLE:
5907 case WHENEVER:
5908 case ATTACH:
5909 case CAST:
5910 case TREAT:
5911 case TRIM:
5912 case LEFT:
5913 case RIGHT:
5914 case BOTH:
5915 case EMPTY:
5916 case MULTISET:
5917 case SUBMULTISET:
5918 case LEADING:
5919 case TRAILING:
5920 case CHAR_CS:
5921 case NCHAR_CS:
5922 case DBTIMEZONE:
5923 case SESSIONTIMEZONE:
5924 case AUTHENTICATED:
5925 case LINK:
5926 case SHARED:
5927 case DIRECTORY:
5928 case USER:
5929 case IDENTIFIER:
5930 case UNSIGNED_NUMERIC_LITERAL:
5931 case CHARACTER_LITERAL:
5932 case STRING_LITERAL:
5933 case QUOTED_LITERAL:
5934 ;
5935 break;
5936 default:
5937 jj_la1[64] = jj_gen;
5938 break label_16;
5939 }
5940 Statement();
5941 }
5942 switch (jj_nt.kind) {
5943 case EXCEPTION:
5944 ExceptionHandler();
5945 break;
5946 default:
5947 jj_la1[65] = jj_gen;
5948 ;
5949 }
5950 jj_consume_token(END);
5951 switch (jj_nt.kind) {
5952 case REPLACE:
5953 case DEFINER:
5954 case CURRENT_USER:
5955 case SERIALLY_REUSABLE:
5956 case RESTRICT_REFERENCES:
5957 case EXCEPTION_INIT:
5958 case AUTONOMOUS_TRANSACTION:
5959 case LANGUAGE:
5960 case INLINE:
5961 case ADD:
5962 case AGGREGATE:
5963 case ALL:
5964 case ALTER:
5965 case AND:
5966 case ANY:
5967 case ARRAY:
5968 case AS:
5969 case ASC:
5970 case AT:
5971 case ATTRIBUTE:
5972 case AUTHID:
5973 case AVG:
5974 case BETWEEN:
5975 case BINARY_INTEGER:
5976 case BODY:
5977 case BOOLEAN:
5978 case BULK:
5979 case BY:
5980 case BYTE:
5981 case CASCADE:
5982 case CASE:
5983 case CHAR:
5984 case CHAR_BASE:
5985 case CHECK:
5986 case CLOSE:
5987 case CLUSTER:
5988 case COALESCE:
5989 case COLLECT:
5990 case COLUMN:
5991 case COMMENT:
5992 case COMMIT:
5993 case COMPRESS:
5994 case CONNECT:
5995 case CONSTANT:
5996 case CONSTRUCTOR:
5997 case CONTINUE:
5998 case CONVERT:
5999 case CREATE:
6000 case CURRENT:
6001 case CURRVAL:
6002 case CURSOR:
6003 case DATA:
6004 case DATE:
6005 case DAY:
6006 case DECLARE:
6007 case DECIMAL:
6008 case _DEFAULT:
6009 case DELETE:
6010 case DESC:
6011 case DISABLE:
6012 case DISTINCT:
6013 case DO:
6014 case DROP:
6015 case EDITIONABLE:
6016 case ELEMENT:
6017 case ELSE:
6018 case ELSIF:
6019 case ENABLE:
6020 case ESCAPE:
6021 case EXCEPT:
6022 case EXCEPTION:
6023 case EXCEPTIONS:
6024 case EXCLUSIVE:
6025 case EXECUTE:
6026 case EXISTS:
6027 case EXIT:
6028 case EXTERNAL:
6029 case EXTENDS:
6030 case EXTRACT:
6031 case FALSE:
6032 case FETCH:
6033 case FINAL:
6034 case FLOAT:
6035 case FOR:
6036 case FORALL:
6037 case FORCE:
6038 case FROM:
6039 case FUNCTION:
6040 case GLOBAL:
6041 case GOTO:
6042 case GROUP:
6043 case HASH:
6044 case HAVING:
6045 case HEAP:
6046 case HOUR:
6047 case IF:
6048 case IMMEDIATE:
6049 case IN:
6050 case INDEX:
6051 case INDICES:
6052 case INDEXTYPE:
6053 case INDICATOR:
6054 case INSERT:
6055 case INSTANTIABLE:
6056 case INTEGER:
6057 case INTERFACE:
6058 case INTERSECT:
6059 case INTERVAL:
6060 case INTO:
6061 case INVALIDATE:
6062 case IS:
6063 case ISOLATION:
6064 case JAVA:
6065 case LEVEL:
6066 case LIKE:
6067 case LIMIT:
6068 case LIMITED:
6069 case LOCK:
6070 case LONG:
6071 case LOOP:
6072 case MAP:
6073 case MAX:
6074 case MEMBER:
6075 case MERGE:
6076 case MIN:
6077 case MINUS:
6078 case MINUTE:
6079 case MLSLABEL:
6080 case MODIFY:
6081 case MOD:
6082 case MODE:
6083 case MONTH:
6084 case NATURAL:
6085 case NATURALN:
6086 case NEW:
6087 case NEXTVAL:
6088 case NO:
6089 case NOCOPY:
6090 case NONEDITIONABLE:
6091 case NOT:
6092 case NOWAIT:
6093 case NULL:
6094 case NULLIF:
6095 case NUMBER:
6096 case BFILE_BASE:
6097 case BLOB_BASE:
6098 case CLOB_BASE:
6099 case DATE_BASE:
6100 case NUMBER_BASE:
6101 case OBJECT:
6102 case OCIROWID:
6103 case OF:
6104 case OID:
6105 case ON:
6106 case OPAQUE:
6107 case OPEN:
6108 case OPERATOR:
6109 case OPTION:
6110 case OR:
6111 case ORDER:
6112 case ORGANIZATION:
6113 case OTHERS:
6114 case OUT:
6115 case OVERRIDING:
6116 case PACKAGE:
6117 case PARTITION:
6118 case PCTFREE:
6119 case PLS_INTEGER:
6120 case POSITIVE:
6121 case POSITIVEN:
6122 case PRESERVE:
6123 case PRIOR:
6124 case PROMPT:
6125 case PRIVATE:
6126 case PROCEDURE:
6127 case PUBLIC:
6128 case RAISE:
6129 case RANGE:
6130 case RAW:
6131 case REAL:
6132 case RECORD:
6133 case REF:
6134 case RELEASE:
6135 case RELIES_ON:
6136 case RENAME:
6137 case RESULT:
6138 case RETURN:
6139 case RETURNING:
6140 case REVERSE:
6141 case ROLLBACK:
6142 case ROW:
6143 case ROWS:
6144 case ROWID:
6145 case ROWNUM:
6146 case ROWTYPE:
6147 case SAVE:
6148 case SAVEPOINT:
6149 case SECOND:
6150 case SELECT:
6151 case SELF:
6152 case SEPARATE:
6153 case SET:
6154 case SHARE:
6155 case SMALLINT:
6156 case SPACE:
6157 case SQL:
6158 case SQLCODE:
6159 case SQLERRM:
6160 case START:
6161 case STATIC:
6162 case STDDEV:
6163 case SUBTYPE:
6164 case SUBSTITUTABLE:
6165 case SUCCESSFUL:
6166 case SUM:
6167 case SYNONYM:
6168 case SYSDATE:
6169 case SYS_REFCURSOR:
6170 case TABLE:
6171 case TEMPORARY:
6172 case THEN:
6173 case TIME:
6174 case TIMESTAMP:
6175 case TIMEZONE_REGION:
6176 case TIMEZONE_ABBR:
6177 case TIMEZONE_MINUTE:
6178 case TIMEZONE_HOUR:
6179 case TO:
6180 case TRANSACTION:
6181 case TRIGGER:
6182 case TRUE:
6183 case TYPE:
6184 case UI:
6185 case UNDER:
6186 case USING:
6187 case WHILE:
6188 case YES:
6189 case SHOW:
6190 case A:
6191 case UPDATE:
6192 case VARCHAR:
6193 case VARCHAR2:
6194 case DOUBLE:
6195 case DEC:
6196 case PRECISION:
6197 case INT:
6198 case NUMERIC:
6199 case SIGNTYPE:
6200 case NCHAR:
6201 case NVARCHAR2:
6202 case STRING:
6203 case UROWID:
6204 case VARRAY:
6205 case VARYING:
6206 case BFILE:
6207 case BLOB:
6208 case CLOB:
6209 case NCLOB:
6210 case YEAR:
6211 case LOCAL:
6212 case WITH:
6213 case ZONE:
6214 case CHARACTER:
6215 case AFTER:
6216 case BEFORE:
6217 case OLD:
6218 case PARENT:
6219 case ANALYZE:
6220 case ASSOCIATE:
6221 case AUDIT:
6222 case COMPOUND:
6223 case DATABASE:
6224 case CALL:
6225 case DDL:
6226 case DISASSOCIATE:
6227 case EACH:
6228 case FOLLOWS:
6229 case LOGOFF:
6230 case LOGON:
6231 case NESTED:
6232 case NOAUDIT:
6233 case SCHEMA:
6234 case SERVERERROR:
6235 case SHUTDOWN:
6236 case STARTUP:
6237 case STATEMENT:
6238 case STATISTICS:
6239 case SUSPEND:
6240 case TRUNCATE:
6241 case WRAPPED:
6242 case LIBRARY:
6243 case NAME:
6244 case STRUCT:
6245 case CONTEXT:
6246 case PARAMETERS:
6247 case LENGTH:
6248 case TDO:
6249 case MAXLEN:
6250 case CHARSETID:
6251 case CHARSETFORM:
6252 case ACCEPT:
6253 case ACCESSIBLE:
6254 case COPY:
6255 case DEFINE:
6256 case DISCONNECT:
6257 case HOST:
6258 case PRINT:
6259 case QUIT:
6260 case REMARK:
6261 case UNDEFINE:
6262 case VARIABLE:
6263 case WHENEVER:
6264 case ATTACH:
6265 case CAST:
6266 case TREAT:
6267 case TRIM:
6268 case LEFT:
6269 case RIGHT:
6270 case BOTH:
6271 case EMPTY:
6272 case MULTISET:
6273 case SUBMULTISET:
6274 case LEADING:
6275 case TRAILING:
6276 case CHAR_CS:
6277 case NCHAR_CS:
6278 case DBTIMEZONE:
6279 case SESSIONTIMEZONE:
6280 case AUTHENTICATED:
6281 case LINK:
6282 case SHARED:
6283 case DIRECTORY:
6284 case USER:
6285 case IDENTIFIER:
6286 case QUOTED_LITERAL:
6287 case SQLDATA_CLASS:
6288 case CUSTOMDATUM_CLASS:
6289 case ORADATA_CLASS:
6290 case JAVA_INTERFACE_CLASS:
6291 ID();
6292 break;
6293 default:
6294 jj_la1[66] = jj_gen;
6295 ;
6296 }
6297 break;
6298 default:
6299 jj_la1[67] = jj_gen;
6300 jj_consume_token(-1);
6301 throw new ParseException();
6302 }
6303 }
6304 break;
6305 default:
6306 jj_la1[68] = jj_gen;
6307 ;
6308 }
6309 jj_consume_token(4);
6310 break;
6311 default:
6312 jj_la1[69] = jj_gen;
6313 jj_consume_token(-1);
6314 throw new ParseException();
6315 }
6316 jjtree.closeNodeScope(jjtn000, true);
6317 jjtc000 = false;
6318 {if (true) return jjtn000 ;}
6319 } catch (Throwable jjte000) {
6320 if (jjtc000) {
6321 jjtree.clearNodeScope(jjtn000);
6322 jjtc000 = false;
6323 } else {
6324 jjtree.popNode();
6325 }
6326 if (jjte000 instanceof RuntimeException) {
6327 {if (true) throw (RuntimeException)jjte000;}
6328 }
6329 if (jjte000 instanceof ParseException) {
6330 {if (true) throw (ParseException)jjte000;}
6331 }
6332 {if (true) throw (Error)jjte000;}
6333 } finally {
6334 if (jjtc000) {
6335 jjtree.closeNodeScope(jjtn000, true);
6336 }
6337 }
6338 throw new Error("Missing return statement in function");
6339 }
6340
6341 final public ASTObjectNameDeclaration ObjectNameDeclaration() throws ParseException {
6342
6343 ASTObjectNameDeclaration jjtn000 = new ASTObjectNameDeclaration(this, JJTOBJECTNAMEDECLARATION);
6344 boolean jjtc000 = true;
6345 jjtree.openNodeScope(jjtn000);PLSQLNode schemaName = null, objectName = null ;
6346 try {
6347 if (jj_2_22(2)) {
6348 schemaName = ID();
6349 jj_consume_token(3);
6350 } else {
6351 ;
6352 }
6353 objectName = ID();
6354 jjtn000.setImage( (null == schemaName) ? objectName.getImage() : (schemaName.getImage() + "." + objectName.getImage() ) ) ;
6355 jjtree.closeNodeScope(jjtn000, true);
6356 jjtc000 = false;
6357 {if (true) return jjtn000 ;}
6358 } catch (Throwable jjte000) {
6359 if (jjtc000) {
6360 jjtree.clearNodeScope(jjtn000);
6361 jjtc000 = false;
6362 } else {
6363 jjtree.popNode();
6364 }
6365 if (jjte000 instanceof RuntimeException) {
6366 {if (true) throw (RuntimeException)jjte000;}
6367 }
6368 if (jjte000 instanceof ParseException) {
6369 {if (true) throw (ParseException)jjte000;}
6370 }
6371 {if (true) throw (Error)jjte000;}
6372 } finally {
6373 if (jjtc000) {
6374 jjtree.closeNodeScope(jjtn000, true);
6375 }
6376 }
6377 throw new Error("Missing return statement in function");
6378 }
6379
6380 final public ASTFormalParameter FormalParameter() throws ParseException {
6381
6382 ASTFormalParameter jjtn000 = new ASTFormalParameter(this, JJTFORMALPARAMETER);
6383 boolean jjtc000 = true;
6384 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
6385 try {
6386 simpleNode = ID();
6387 if (jj_2_25(2)) {
6388 if (jj_2_24(2)) {
6389 switch (jj_nt.kind) {
6390 case OUT:
6391 jj_consume_token(OUT);
6392 break;
6393 case IN:
6394 jj_consume_token(IN);
6395 jj_consume_token(OUT);
6396 break;
6397 default:
6398 jj_la1[70] = jj_gen;
6399 jj_consume_token(-1);
6400 throw new ParseException();
6401 }
6402 if (jj_2_23(2)) {
6403 jj_consume_token(NOCOPY);
6404 } else {
6405 ;
6406 }
6407 } else {
6408 switch (jj_nt.kind) {
6409 case IN:
6410 jj_consume_token(IN);
6411 break;
6412 default:
6413 jj_la1[71] = jj_gen;
6414 jj_consume_token(-1);
6415 throw new ParseException();
6416 }
6417 }
6418 } else {
6419 ;
6420 }
6421 switch (jj_nt.kind) {
6422 case 8:
6423 jj_consume_token(8);
6424 break;
6425 case REPLACE:
6426 case DEFINER:
6427 case CURRENT_USER:
6428 case LANGUAGE:
6429 case INLINE:
6430 case ADD:
6431 case AGGREGATE:
6432 case ARRAY:
6433 case AT:
6434 case ATTRIBUTE:
6435 case AUTHID:
6436 case BINARY_INTEGER:
6437 case BODY:
6438 case BOOLEAN:
6439 case BULK:
6440 case BYTE:
6441 case CASCADE:
6442 case CHAR:
6443 case CHAR_BASE:
6444 case CLOSE:
6445 case COALESCE:
6446 case COLLECT:
6447 case COLUMN:
6448 case COMMENT:
6449 case COMMIT:
6450 case CONSTRUCTOR:
6451 case CONTINUE:
6452 case CONVERT:
6453 case CURRENT:
6454 case CURSOR:
6455 case DATA:
6456 case DATE:
6457 case DAY:
6458 case DECIMAL:
6459 case DISABLE:
6460 case EDITIONABLE:
6461 case ELEMENT:
6462 case ENABLE:
6463 case ESCAPE:
6464 case EXCEPT:
6465 case EXCEPTIONS:
6466 case EXIT:
6467 case EXTERNAL:
6468 case EXTENDS:
6469 case EXTRACT:
6470 case FALSE:
6471 case FINAL:
6472 case FLOAT:
6473 case FORCE:
6474 case FUNCTION:
6475 case GLOBAL:
6476 case HASH:
6477 case HEAP:
6478 case HOUR:
6479 case IMMEDIATE:
6480 case INDICES:
6481 case INDEXTYPE:
6482 case INDICATOR:
6483 case INSTANTIABLE:
6484 case INTEGER:
6485 case INTERVAL:
6486 case INVALIDATE:
6487 case ISOLATION:
6488 case JAVA:
6489 case LEVEL:
6490 case LIMIT:
6491 case LONG:
6492 case LOOP:
6493 case MAP:
6494 case MAX:
6495 case MEMBER:
6496 case MERGE:
6497 case MIN:
6498 case MINUTE:
6499 case MLSLABEL:
6500 case MODIFY:
6501 case MOD:
6502 case MONTH:
6503 case NATURAL:
6504 case NATURALN:
6505 case NEW:
6506 case NO:
6507 case NONEDITIONABLE:
6508 case NULLIF:
6509 case NUMBER:
6510 case BFILE_BASE:
6511 case BLOB_BASE:
6512 case CLOB_BASE:
6513 case DATE_BASE:
6514 case NUMBER_BASE:
6515 case OBJECT:
6516 case OID:
6517 case OPAQUE:
6518 case OPEN:
6519 case OPERATOR:
6520 case ORGANIZATION:
6521 case OTHERS:
6522 case OVERRIDING:
6523 case PACKAGE:
6524 case PARTITION:
6525 case PLS_INTEGER:
6526 case POSITIVE:
6527 case POSITIVEN:
6528 case PRESERVE:
6529 case PRIVATE:
6530 case PROCEDURE:
6531 case RANGE:
6532 case RAW:
6533 case REAL:
6534 case RECORD:
6535 case REF:
6536 case RELEASE:
6537 case RELIES_ON:
6538 case RENAME:
6539 case RESULT:
6540 case RETURN:
6541 case RETURNING:
6542 case REVERSE:
6543 case ROLLBACK:
6544 case ROW:
6545 case ROWS:
6546 case ROWID:
6547 case ROWNUM:
6548 case SAVE:
6549 case SAVEPOINT:
6550 case SECOND:
6551 case SELF:
6552 case SET:
6553 case SMALLINT:
6554 case SPACE:
6555 case SQL:
6556 case SQLCODE:
6557 case SQLERRM:
6558 case STATIC:
6559 case SUBTYPE:
6560 case SUBSTITUTABLE:
6561 case SUCCESSFUL:
6562 case SYSDATE:
6563 case SYS_REFCURSOR:
6564 case TEMPORARY:
6565 case TIME:
6566 case TIMESTAMP:
6567 case TIMEZONE_REGION:
6568 case TIMEZONE_ABBR:
6569 case TIMEZONE_MINUTE:
6570 case TIMEZONE_HOUR:
6571 case TRANSACTION:
6572 case TRUE:
6573 case TYPE:
6574 case UNDER:
6575 case USING:
6576 case YES:
6577 case SHOW:
6578 case A:
6579 case VARCHAR:
6580 case VARCHAR2:
6581 case DOUBLE:
6582 case DEC:
6583 case PRECISION:
6584 case INT:
6585 case NUMERIC:
6586 case SIGNTYPE:
6587 case NCHAR:
6588 case NVARCHAR2:
6589 case STRING:
6590 case UROWID:
6591 case VARRAY:
6592 case VARYING:
6593 case BFILE:
6594 case BLOB:
6595 case CLOB:
6596 case NCLOB:
6597 case YEAR:
6598 case LOCAL:
6599 case ZONE:
6600 case CHARACTER:
6601 case AFTER:
6602 case BEFORE:
6603 case OLD:
6604 case PARENT:
6605 case CC_IF:
6606 case ANALYZE:
6607 case ASSOCIATE:
6608 case AUDIT:
6609 case COMPOUND:
6610 case DATABASE:
6611 case CALL:
6612 case DDL:
6613 case DISASSOCIATE:
6614 case EACH:
6615 case FOLLOWS:
6616 case LOGOFF:
6617 case LOGON:
6618 case NESTED:
6619 case NOAUDIT:
6620 case SCHEMA:
6621 case SERVERERROR:
6622 case SHUTDOWN:
6623 case STARTUP:
6624 case STATEMENT:
6625 case STATISTICS:
6626 case SUSPEND:
6627 case TRUNCATE:
6628 case WRAPPED:
6629 case LIBRARY:
6630 case NAME:
6631 case STRUCT:
6632 case CONTEXT:
6633 case PARAMETERS:
6634 case LENGTH:
6635 case TDO:
6636 case MAXLEN:
6637 case CHARSETID:
6638 case CHARSETFORM:
6639 case ACCEPT:
6640 case ACCESSIBLE:
6641 case COPY:
6642 case DEFINE:
6643 case DISCONNECT:
6644 case HOST:
6645 case PRINT:
6646 case QUIT:
6647 case REMARK:
6648 case UNDEFINE:
6649 case VARIABLE:
6650 case WHENEVER:
6651 case ATTACH:
6652 case CAST:
6653 case TREAT:
6654 case TRIM:
6655 case LEFT:
6656 case RIGHT:
6657 case BOTH:
6658 case EMPTY:
6659 case MULTISET:
6660 case SUBMULTISET:
6661 case LEADING:
6662 case TRAILING:
6663 case CHAR_CS:
6664 case NCHAR_CS:
6665 case DBTIMEZONE:
6666 case SESSIONTIMEZONE:
6667 case AUTHENTICATED:
6668 case LINK:
6669 case SHARED:
6670 case DIRECTORY:
6671 case USER:
6672 case IDENTIFIER:
6673 case QUOTED_LITERAL:
6674 Datatype();
6675 break;
6676 default:
6677 jj_la1[72] = jj_gen;
6678 jj_consume_token(-1);
6679 throw new ParseException();
6680 }
6681 switch (jj_nt.kind) {
6682 case 9:
6683 case _DEFAULT:
6684 switch (jj_nt.kind) {
6685 case 9:
6686 jj_consume_token(9);
6687 jj_consume_token(10);
6688 break;
6689 case _DEFAULT:
6690 jj_consume_token(_DEFAULT);
6691 break;
6692 default:
6693 jj_la1[73] = jj_gen;
6694 jj_consume_token(-1);
6695 throw new ParseException();
6696 }
6697 Expression();
6698 break;
6699 default:
6700 jj_la1[74] = jj_gen;
6701 ;
6702 }
6703 jjtree.closeNodeScope(jjtn000, true);
6704 jjtc000 = false;
6705 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
6706 } catch (Throwable jjte000) {
6707 if (jjtc000) {
6708 jjtree.clearNodeScope(jjtn000);
6709 jjtc000 = false;
6710 } else {
6711 jjtree.popNode();
6712 }
6713 if (jjte000 instanceof RuntimeException) {
6714 {if (true) throw (RuntimeException)jjte000;}
6715 }
6716 if (jjte000 instanceof ParseException) {
6717 {if (true) throw (ParseException)jjte000;}
6718 }
6719 {if (true) throw (Error)jjte000;}
6720 } finally {
6721 if (jjtc000) {
6722 jjtree.closeNodeScope(jjtn000, true);
6723 }
6724 }
6725 throw new Error("Missing return statement in function");
6726 }
6727
6728 final public ASTMethodDeclaration MethodDeclaration() throws ParseException {
6729
6730 ASTMethodDeclaration jjtn000 = new ASTMethodDeclaration(this, JJTMETHODDECLARATION);
6731 boolean jjtc000 = true;
6732 jjtree.openNodeScope(jjtn000);
6733 try {
6734 switch (jj_nt.kind) {
6735 case CREATE:
6736 case FUNCTION:
6737 case PROCEDURE:
6738 ProgramUnit();
6739 break;
6740 case CONSTRUCTOR:
6741 case FINAL:
6742 case INSTANTIABLE:
6743 case MAP:
6744 case MEMBER:
6745 case NOT:
6746 case ORDER:
6747 case OVERRIDING:
6748 case STATIC:
6749 TypeMethod();
6750 break;
6751 default:
6752 jj_la1[75] = jj_gen;
6753 jj_consume_token(-1);
6754 throw new ParseException();
6755 }
6756 jjtree.closeNodeScope(jjtn000, true);
6757 jjtc000 = false;
6758 {if (true) return jjtn000 ;}
6759 } catch (Throwable jjte000) {
6760 if (jjtc000) {
6761 jjtree.clearNodeScope(jjtn000);
6762 jjtc000 = false;
6763 } else {
6764 jjtree.popNode();
6765 }
6766 if (jjte000 instanceof RuntimeException) {
6767 {if (true) throw (RuntimeException)jjte000;}
6768 }
6769 if (jjte000 instanceof ParseException) {
6770 {if (true) throw (ParseException)jjte000;}
6771 }
6772 {if (true) throw (Error)jjte000;}
6773 } finally {
6774 if (jjtc000) {
6775 jjtree.closeNodeScope(jjtn000, true);
6776 }
6777 }
6778 throw new Error("Missing return statement in function");
6779 }
6780
6781 final public ASTMethodDeclarator MethodDeclarator() throws ParseException {
6782
6783 ASTMethodDeclarator jjtn000 = new ASTMethodDeclarator(this, JJTMETHODDECLARATOR);
6784 boolean jjtc000 = true;
6785 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
6786 try {
6787 switch (jj_nt.kind) {
6788 case FUNCTION:
6789 jj_consume_token(FUNCTION);
6790 simpleNode = ObjectNameDeclaration();
6791 switch (jj_nt.kind) {
6792 case 5:
6793 FormalParameters();
6794 break;
6795 default:
6796 jj_la1[76] = jj_gen;
6797 ;
6798 }
6799 Token nextToken;
6800 nextToken = getToken(1);
6801 if (!nextToken.image.equalsIgnoreCase("WRAPPED")
6802 &&
6803 !nextToken.image.equalsIgnoreCase("RETURN")
6804 )
6805 {
6806 {if (true) throw new ParseException("FUNCTION must RETURN a value or must be WRAPPED : found \u005c""
6807 + nextToken.image
6808 + "\u005c" at line "+nextToken.beginLine
6809 + ", column "+nextToken.beginColumn
6810 );}
6811 }
6812 switch (jj_nt.kind) {
6813 case RETURN:
6814 jj_consume_token(RETURN);
6815 Datatype();
6816 break;
6817 default:
6818 jj_la1[77] = jj_gen;
6819 ;
6820 }
6821 break;
6822 case PROCEDURE:
6823 jj_consume_token(PROCEDURE);
6824 simpleNode = ObjectNameDeclaration();
6825 switch (jj_nt.kind) {
6826 case 5:
6827 FormalParameters();
6828 break;
6829 default:
6830 jj_la1[78] = jj_gen;
6831 ;
6832 }
6833 break;
6834 default:
6835 jj_la1[79] = jj_gen;
6836 jj_consume_token(-1);
6837 throw new ParseException();
6838 }
6839 jjtree.closeNodeScope(jjtn000, true);
6840 jjtc000 = false;
6841 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
6842 } catch (Throwable jjte000) {
6843 if (jjtc000) {
6844 jjtree.clearNodeScope(jjtn000);
6845 jjtc000 = false;
6846 } else {
6847 jjtree.popNode();
6848 }
6849 if (jjte000 instanceof RuntimeException) {
6850 {if (true) throw (RuntimeException)jjte000;}
6851 }
6852 if (jjte000 instanceof ParseException) {
6853 {if (true) throw (ParseException)jjte000;}
6854 }
6855 {if (true) throw (Error)jjte000;}
6856 } finally {
6857 if (jjtc000) {
6858 jjtree.closeNodeScope(jjtn000, true);
6859 }
6860 }
6861 throw new Error("Missing return statement in function");
6862 }
6863
6864 final public ASTFormalParameters FormalParameters() throws ParseException {
6865
6866 ASTFormalParameters jjtn000 = new ASTFormalParameters(this, JJTFORMALPARAMETERS);
6867 boolean jjtc000 = true;
6868 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
6869 StringBuilder sb = new StringBuilder();
6870 try {
6871 jj_consume_token(5);
6872 sb.append("(");
6873 switch (jj_nt.kind) {
6874 case REPLACE:
6875 case DEFINER:
6876 case CURRENT_USER:
6877 case SERIALLY_REUSABLE:
6878 case RESTRICT_REFERENCES:
6879 case EXCEPTION_INIT:
6880 case AUTONOMOUS_TRANSACTION:
6881 case LANGUAGE:
6882 case INLINE:
6883 case ADD:
6884 case AGGREGATE:
6885 case ALL:
6886 case ALTER:
6887 case AND:
6888 case ANY:
6889 case ARRAY:
6890 case AS:
6891 case ASC:
6892 case AT:
6893 case ATTRIBUTE:
6894 case AUTHID:
6895 case AVG:
6896 case BETWEEN:
6897 case BINARY_INTEGER:
6898 case BODY:
6899 case BOOLEAN:
6900 case BULK:
6901 case BY:
6902 case BYTE:
6903 case CASCADE:
6904 case CASE:
6905 case CHAR:
6906 case CHAR_BASE:
6907 case CHECK:
6908 case CLOSE:
6909 case CLUSTER:
6910 case COALESCE:
6911 case COLLECT:
6912 case COLUMN:
6913 case COMMENT:
6914 case COMMIT:
6915 case COMPRESS:
6916 case CONNECT:
6917 case CONSTANT:
6918 case CONSTRUCTOR:
6919 case CONTINUE:
6920 case CONVERT:
6921 case CREATE:
6922 case CURRENT:
6923 case CURRVAL:
6924 case CURSOR:
6925 case DATA:
6926 case DATE:
6927 case DAY:
6928 case DECLARE:
6929 case DECIMAL:
6930 case _DEFAULT:
6931 case DELETE:
6932 case DESC:
6933 case DISABLE:
6934 case DISTINCT:
6935 case DO:
6936 case DROP:
6937 case EDITIONABLE:
6938 case ELEMENT:
6939 case ELSE:
6940 case ELSIF:
6941 case ENABLE:
6942 case ESCAPE:
6943 case EXCEPT:
6944 case EXCEPTION:
6945 case EXCEPTIONS:
6946 case EXCLUSIVE:
6947 case EXECUTE:
6948 case EXISTS:
6949 case EXIT:
6950 case EXTERNAL:
6951 case EXTENDS:
6952 case EXTRACT:
6953 case FALSE:
6954 case FETCH:
6955 case FINAL:
6956 case FLOAT:
6957 case FOR:
6958 case FORALL:
6959 case FORCE:
6960 case FROM:
6961 case FUNCTION:
6962 case GLOBAL:
6963 case GOTO:
6964 case GROUP:
6965 case HASH:
6966 case HAVING:
6967 case HEAP:
6968 case HOUR:
6969 case IF:
6970 case IMMEDIATE:
6971 case IN:
6972 case INDEX:
6973 case INDICES:
6974 case INDEXTYPE:
6975 case INDICATOR:
6976 case INSERT:
6977 case INSTANTIABLE:
6978 case INTEGER:
6979 case INTERFACE:
6980 case INTERSECT:
6981 case INTERVAL:
6982 case INTO:
6983 case INVALIDATE:
6984 case IS:
6985 case ISOLATION:
6986 case JAVA:
6987 case LEVEL:
6988 case LIKE:
6989 case LIMIT:
6990 case LIMITED:
6991 case LOCK:
6992 case LONG:
6993 case LOOP:
6994 case MAP:
6995 case MAX:
6996 case MEMBER:
6997 case MERGE:
6998 case MIN:
6999 case MINUS:
7000 case MINUTE:
7001 case MLSLABEL:
7002 case MODIFY:
7003 case MOD:
7004 case MODE:
7005 case MONTH:
7006 case NATURAL:
7007 case NATURALN:
7008 case NEW:
7009 case NEXTVAL:
7010 case NO:
7011 case NOCOPY:
7012 case NONEDITIONABLE:
7013 case NOT:
7014 case NOWAIT:
7015 case NULL:
7016 case NULLIF:
7017 case NUMBER:
7018 case BFILE_BASE:
7019 case BLOB_BASE:
7020 case CLOB_BASE:
7021 case DATE_BASE:
7022 case NUMBER_BASE:
7023 case OBJECT:
7024 case OCIROWID:
7025 case OF:
7026 case OID:
7027 case ON:
7028 case OPAQUE:
7029 case OPEN:
7030 case OPERATOR:
7031 case OPTION:
7032 case OR:
7033 case ORDER:
7034 case ORGANIZATION:
7035 case OTHERS:
7036 case OUT:
7037 case OVERRIDING:
7038 case PACKAGE:
7039 case PARTITION:
7040 case PCTFREE:
7041 case PLS_INTEGER:
7042 case POSITIVE:
7043 case POSITIVEN:
7044 case PRESERVE:
7045 case PRIOR:
7046 case PROMPT:
7047 case PRIVATE:
7048 case PROCEDURE:
7049 case PUBLIC:
7050 case RAISE:
7051 case RANGE:
7052 case RAW:
7053 case REAL:
7054 case RECORD:
7055 case REF:
7056 case RELEASE:
7057 case RELIES_ON:
7058 case RENAME:
7059 case RESULT:
7060 case RETURN:
7061 case RETURNING:
7062 case REVERSE:
7063 case ROLLBACK:
7064 case ROW:
7065 case ROWS:
7066 case ROWID:
7067 case ROWNUM:
7068 case ROWTYPE:
7069 case SAVE:
7070 case SAVEPOINT:
7071 case SECOND:
7072 case SELECT:
7073 case SELF:
7074 case SEPARATE:
7075 case SET:
7076 case SHARE:
7077 case SMALLINT:
7078 case SPACE:
7079 case SQL:
7080 case SQLCODE:
7081 case SQLERRM:
7082 case START:
7083 case STATIC:
7084 case STDDEV:
7085 case SUBTYPE:
7086 case SUBSTITUTABLE:
7087 case SUCCESSFUL:
7088 case SUM:
7089 case SYNONYM:
7090 case SYSDATE:
7091 case SYS_REFCURSOR:
7092 case TABLE:
7093 case TEMPORARY:
7094 case THEN:
7095 case TIME:
7096 case TIMESTAMP:
7097 case TIMEZONE_REGION:
7098 case TIMEZONE_ABBR:
7099 case TIMEZONE_MINUTE:
7100 case TIMEZONE_HOUR:
7101 case TO:
7102 case TRANSACTION:
7103 case TRIGGER:
7104 case TRUE:
7105 case TYPE:
7106 case UI:
7107 case UNDER:
7108 case USING:
7109 case WHILE:
7110 case YES:
7111 case SHOW:
7112 case A:
7113 case UPDATE:
7114 case VARCHAR:
7115 case VARCHAR2:
7116 case DOUBLE:
7117 case DEC:
7118 case PRECISION:
7119 case INT:
7120 case NUMERIC:
7121 case SIGNTYPE:
7122 case NCHAR:
7123 case NVARCHAR2:
7124 case STRING:
7125 case UROWID:
7126 case VARRAY:
7127 case VARYING:
7128 case BFILE:
7129 case BLOB:
7130 case CLOB:
7131 case NCLOB:
7132 case YEAR:
7133 case LOCAL:
7134 case WITH:
7135 case ZONE:
7136 case CHARACTER:
7137 case AFTER:
7138 case BEFORE:
7139 case OLD:
7140 case PARENT:
7141 case ANALYZE:
7142 case ASSOCIATE:
7143 case AUDIT:
7144 case COMPOUND:
7145 case DATABASE:
7146 case CALL:
7147 case DDL:
7148 case DISASSOCIATE:
7149 case EACH:
7150 case FOLLOWS:
7151 case LOGOFF:
7152 case LOGON:
7153 case NESTED:
7154 case NOAUDIT:
7155 case SCHEMA:
7156 case SERVERERROR:
7157 case SHUTDOWN:
7158 case STARTUP:
7159 case STATEMENT:
7160 case STATISTICS:
7161 case SUSPEND:
7162 case TRUNCATE:
7163 case WRAPPED:
7164 case LIBRARY:
7165 case NAME:
7166 case STRUCT:
7167 case CONTEXT:
7168 case PARAMETERS:
7169 case LENGTH:
7170 case TDO:
7171 case MAXLEN:
7172 case CHARSETID:
7173 case CHARSETFORM:
7174 case ACCEPT:
7175 case ACCESSIBLE:
7176 case COPY:
7177 case DEFINE:
7178 case DISCONNECT:
7179 case HOST:
7180 case PRINT:
7181 case QUIT:
7182 case REMARK:
7183 case UNDEFINE:
7184 case VARIABLE:
7185 case WHENEVER:
7186 case ATTACH:
7187 case CAST:
7188 case TREAT:
7189 case TRIM:
7190 case LEFT:
7191 case RIGHT:
7192 case BOTH:
7193 case EMPTY:
7194 case MULTISET:
7195 case SUBMULTISET:
7196 case LEADING:
7197 case TRAILING:
7198 case CHAR_CS:
7199 case NCHAR_CS:
7200 case DBTIMEZONE:
7201 case SESSIONTIMEZONE:
7202 case AUTHENTICATED:
7203 case LINK:
7204 case SHARED:
7205 case DIRECTORY:
7206 case USER:
7207 case IDENTIFIER:
7208 case QUOTED_LITERAL:
7209 case SQLDATA_CLASS:
7210 case CUSTOMDATUM_CLASS:
7211 case ORADATA_CLASS:
7212 case JAVA_INTERFACE_CLASS:
7213 simpleNode = FormalParameter();
7214 sb.append(simpleNode.getImage());
7215 label_17:
7216 while (true) {
7217 switch (jj_nt.kind) {
7218 case 6:
7219 ;
7220 break;
7221 default:
7222 jj_la1[80] = jj_gen;
7223 break label_17;
7224 }
7225 jj_consume_token(6);
7226 simpleNode = FormalParameter();
7227 sb.append(","+simpleNode.getImage());
7228 }
7229 break;
7230 default:
7231 jj_la1[81] = jj_gen;
7232 ;
7233 }
7234 jj_consume_token(7);
7235 sb.append(")");
7236 jjtree.closeNodeScope(jjtn000, true);
7237 jjtc000 = false;
7238 jjtn000.setImage(sb.toString()) ; {if (true) return jjtn000 ;}
7239 } catch (Throwable jjte000) {
7240 if (jjtc000) {
7241 jjtree.clearNodeScope(jjtn000);
7242 jjtc000 = false;
7243 } else {
7244 jjtree.popNode();
7245 }
7246 if (jjte000 instanceof RuntimeException) {
7247 {if (true) throw (RuntimeException)jjte000;}
7248 }
7249 if (jjte000 instanceof ParseException) {
7250 {if (true) throw (ParseException)jjte000;}
7251 }
7252 {if (true) throw (Error)jjte000;}
7253 } finally {
7254 if (jjtc000) {
7255 jjtree.closeNodeScope(jjtn000, true);
7256 }
7257 }
7258 throw new Error("Missing return statement in function");
7259 }
7260
7261 final public ASTVariableOrConstantDeclarator VariableOrConstantDeclarator() throws ParseException {
7262
7263 ASTVariableOrConstantDeclarator jjtn000 = new ASTVariableOrConstantDeclarator(this, JJTVARIABLEORCONSTANTDECLARATOR);
7264 boolean jjtc000 = true;
7265 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
7266 StringBuilder sb = new StringBuilder();
7267 try {
7268 simpleNode = VariableOrConstantDeclaratorId();
7269 sb.append(simpleNode.getImage());
7270 if (jj_2_26(2)) {
7271 jj_consume_token(CONSTANT);
7272 sb.append(" " + token.image);
7273 } else {
7274 ;
7275 }
7276 simpleNode = Datatype();
7277 sb.append(" " + simpleNode.getImage());
7278 switch (jj_nt.kind) {
7279 case NOT:
7280 case NULL:
7281 switch (jj_nt.kind) {
7282 case NOT:
7283 jj_consume_token(NOT);
7284 sb.append(" " + token.image);
7285 break;
7286 default:
7287 jj_la1[82] = jj_gen;
7288 ;
7289 }
7290 jj_consume_token(NULL);
7291 sb.append(" " + token.image);
7292 break;
7293 default:
7294 jj_la1[83] = jj_gen;
7295 ;
7296 }
7297 switch (jj_nt.kind) {
7298 case 9:
7299 case _DEFAULT:
7300 switch (jj_nt.kind) {
7301 case 9:
7302 jj_consume_token(9);
7303 jj_consume_token(10);
7304 sb.append(" :=");
7305 break;
7306 case _DEFAULT:
7307 jj_consume_token(_DEFAULT);
7308 sb.append(" " + token.image);
7309 break;
7310 default:
7311 jj_la1[84] = jj_gen;
7312 jj_consume_token(-1);
7313 throw new ParseException();
7314 }
7315 simpleNode = VariableOrConstantInitializer();
7316 sb.append(" " + simpleNode.getImage());
7317 break;
7318 default:
7319 jj_la1[85] = jj_gen;
7320 ;
7321 }
7322 jjtree.closeNodeScope(jjtn000, true);
7323 jjtc000 = false;
7324 jjtn000.setImage(sb.toString()) ; {if (true) return jjtn000 ;}
7325 } catch (Throwable jjte000) {
7326 if (jjtc000) {
7327 jjtree.clearNodeScope(jjtn000);
7328 jjtc000 = false;
7329 } else {
7330 jjtree.popNode();
7331 }
7332 if (jjte000 instanceof RuntimeException) {
7333 {if (true) throw (RuntimeException)jjte000;}
7334 }
7335 if (jjte000 instanceof ParseException) {
7336 {if (true) throw (ParseException)jjte000;}
7337 }
7338 {if (true) throw (Error)jjte000;}
7339 } finally {
7340 if (jjtc000) {
7341 jjtree.closeNodeScope(jjtn000, true);
7342 }
7343 }
7344 throw new Error("Missing return statement in function");
7345 }
7346
7347 final public ASTVariableOrConstantDeclaratorId VariableOrConstantDeclaratorId() throws ParseException {
7348
7349 ASTVariableOrConstantDeclaratorId jjtn000 = new ASTVariableOrConstantDeclaratorId(this, JJTVARIABLEORCONSTANTDECLARATORID);
7350 boolean jjtc000 = true;
7351 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
7352 try {
7353 simpleNode = ID();
7354 jjtree.closeNodeScope(jjtn000, true);
7355 jjtc000 = false;
7356 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
7357 } catch (Throwable jjte000) {
7358 if (jjtc000) {
7359 jjtree.clearNodeScope(jjtn000);
7360 jjtc000 = false;
7361 } else {
7362 jjtree.popNode();
7363 }
7364 if (jjte000 instanceof RuntimeException) {
7365 {if (true) throw (RuntimeException)jjte000;}
7366 }
7367 if (jjte000 instanceof ParseException) {
7368 {if (true) throw (ParseException)jjte000;}
7369 }
7370 {if (true) throw (Error)jjte000;}
7371 } finally {
7372 if (jjtc000) {
7373 jjtree.closeNodeScope(jjtn000, true);
7374 }
7375 }
7376 throw new Error("Missing return statement in function");
7377 }
7378
7379 final public ASTVariableOrConstantInitializer VariableOrConstantInitializer() throws ParseException {
7380
7381 ASTVariableOrConstantInitializer jjtn000 = new ASTVariableOrConstantInitializer(this, JJTVARIABLEORCONSTANTINITIALIZER);
7382 boolean jjtc000 = true;
7383 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
7384 try {
7385 simpleNode = Expression();
7386 jjtree.closeNodeScope(jjtn000, true);
7387 jjtc000 = false;
7388 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
7389 } catch (Throwable jjte000) {
7390 if (jjtc000) {
7391 jjtree.clearNodeScope(jjtn000);
7392 jjtc000 = false;
7393 } else {
7394 jjtree.popNode();
7395 }
7396 if (jjte000 instanceof RuntimeException) {
7397 {if (true) throw (RuntimeException)jjte000;}
7398 }
7399 if (jjte000 instanceof ParseException) {
7400 {if (true) throw (ParseException)jjte000;}
7401 }
7402 {if (true) throw (Error)jjte000;}
7403 } finally {
7404 if (jjtc000) {
7405 jjtree.closeNodeScope(jjtn000, true);
7406 }
7407 }
7408 throw new Error("Missing return statement in function");
7409 }
7410
7411 final public ASTDatatype Datatype() throws ParseException {
7412
7413 ASTDatatype jjtn000 = new ASTDatatype(this, JJTDATATYPE);
7414 boolean jjtc000 = true;
7415 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
7416 StringBuilder sb = new StringBuilder();
7417 try {
7418 switch (jj_nt.kind) {
7419 case CC_IF:
7420
7421 simpleNode = CompilationDataType();
7422 sb.append(simpleNode.getImage());
7423 break;
7424 default:
7425 jj_la1[89] = jj_gen;
7426 if (jj_2_28(2)) {
7427 simpleNode = ScalarDataTypeName();
7428 sb.append(simpleNode.getImage());
7429 } else {
7430 switch (jj_nt.kind) {
7431 case REPLACE:
7432 case DEFINER:
7433 case CURRENT_USER:
7434 case LANGUAGE:
7435 case INLINE:
7436 case ADD:
7437 case AGGREGATE:
7438 case ARRAY:
7439 case AT:
7440 case ATTRIBUTE:
7441 case AUTHID:
7442 case BODY:
7443 case BULK:
7444 case BYTE:
7445 case CASCADE:
7446 case CLOSE:
7447 case COALESCE:
7448 case COLLECT:
7449 case COLUMN:
7450 case COMMENT:
7451 case COMMIT:
7452 case CONSTRUCTOR:
7453 case CONTINUE:
7454 case CONVERT:
7455 case CURRENT:
7456 case CURSOR:
7457 case DATA:
7458 case DAY:
7459 case DISABLE:
7460 case EDITIONABLE:
7461 case ELEMENT:
7462 case ENABLE:
7463 case ESCAPE:
7464 case EXCEPT:
7465 case EXCEPTIONS:
7466 case EXIT:
7467 case EXTERNAL:
7468 case EXTENDS:
7469 case EXTRACT:
7470 case FALSE:
7471 case FINAL:
7472 case FORCE:
7473 case FUNCTION:
7474 case GLOBAL:
7475 case HASH:
7476 case HEAP:
7477 case HOUR:
7478 case IMMEDIATE:
7479 case INDICES:
7480 case INDEXTYPE:
7481 case INDICATOR:
7482 case INSTANTIABLE:
7483 case INTERVAL:
7484 case INVALIDATE:
7485 case ISOLATION:
7486 case JAVA:
7487 case LEVEL:
7488 case LIMIT:
7489 case LOOP:
7490 case MAP:
7491 case MAX:
7492 case MEMBER:
7493 case MERGE:
7494 case MIN:
7495 case MINUTE:
7496 case MLSLABEL:
7497 case MODIFY:
7498 case MOD:
7499 case MONTH:
7500 case NATURAL:
7501 case NEW:
7502 case NO:
7503 case NONEDITIONABLE:
7504 case NULLIF:
7505 case OBJECT:
7506 case OID:
7507 case OPAQUE:
7508 case OPEN:
7509 case OPERATOR:
7510 case ORGANIZATION:
7511 case OTHERS:
7512 case OVERRIDING:
7513 case PACKAGE:
7514 case PARTITION:
7515 case PRESERVE:
7516 case PRIVATE:
7517 case PROCEDURE:
7518 case RANGE:
7519 case RAW:
7520 case REAL:
7521 case RECORD:
7522 case REF:
7523 case RELEASE:
7524 case RELIES_ON:
7525 case RENAME:
7526 case RESULT:
7527 case RETURN:
7528 case RETURNING:
7529 case REVERSE:
7530 case ROLLBACK:
7531 case ROW:
7532 case ROWS:
7533 case ROWID:
7534 case ROWNUM:
7535 case SAVE:
7536 case SAVEPOINT:
7537 case SECOND:
7538 case SELF:
7539 case SET:
7540 case SPACE:
7541 case SQL:
7542 case SQLCODE:
7543 case SQLERRM:
7544 case STATIC:
7545 case SUBTYPE:
7546 case SUBSTITUTABLE:
7547 case SUCCESSFUL:
7548 case SYSDATE:
7549 case SYS_REFCURSOR:
7550 case TEMPORARY:
7551 case TIME:
7552 case TIMESTAMP:
7553 case TIMEZONE_REGION:
7554 case TIMEZONE_ABBR:
7555 case TIMEZONE_MINUTE:
7556 case TIMEZONE_HOUR:
7557 case TRANSACTION:
7558 case TRUE:
7559 case TYPE:
7560 case UNDER:
7561 case USING:
7562 case YES:
7563 case SHOW:
7564 case A:
7565 case DOUBLE:
7566 case DEC:
7567 case PRECISION:
7568 case INT:
7569 case NUMERIC:
7570 case NCHAR:
7571 case NVARCHAR2:
7572 case STRING:
7573 case UROWID:
7574 case VARRAY:
7575 case VARYING:
7576 case BFILE:
7577 case BLOB:
7578 case CLOB:
7579 case NCLOB:
7580 case YEAR:
7581 case LOCAL:
7582 case ZONE:
7583 case CHARACTER:
7584 case AFTER:
7585 case BEFORE:
7586 case OLD:
7587 case PARENT:
7588 case ANALYZE:
7589 case ASSOCIATE:
7590 case AUDIT:
7591 case COMPOUND:
7592 case DATABASE:
7593 case CALL:
7594 case DDL:
7595 case DISASSOCIATE:
7596 case EACH:
7597 case FOLLOWS:
7598 case LOGOFF:
7599 case LOGON:
7600 case NESTED:
7601 case NOAUDIT:
7602 case SCHEMA:
7603 case SERVERERROR:
7604 case SHUTDOWN:
7605 case STARTUP:
7606 case STATEMENT:
7607 case STATISTICS:
7608 case SUSPEND:
7609 case TRUNCATE:
7610 case WRAPPED:
7611 case LIBRARY:
7612 case NAME:
7613 case STRUCT:
7614 case CONTEXT:
7615 case PARAMETERS:
7616 case LENGTH:
7617 case TDO:
7618 case MAXLEN:
7619 case CHARSETID:
7620 case CHARSETFORM:
7621 case ACCEPT:
7622 case ACCESSIBLE:
7623 case COPY:
7624 case DEFINE:
7625 case DISCONNECT:
7626 case HOST:
7627 case PRINT:
7628 case QUIT:
7629 case REMARK:
7630 case UNDEFINE:
7631 case VARIABLE:
7632 case WHENEVER:
7633 case ATTACH:
7634 case CAST:
7635 case TREAT:
7636 case TRIM:
7637 case LEFT:
7638 case RIGHT:
7639 case BOTH:
7640 case EMPTY:
7641 case MULTISET:
7642 case SUBMULTISET:
7643 case LEADING:
7644 case TRAILING:
7645 case CHAR_CS:
7646 case NCHAR_CS:
7647 case DBTIMEZONE:
7648 case SESSIONTIMEZONE:
7649 case AUTHENTICATED:
7650 case LINK:
7651 case SHARED:
7652 case DIRECTORY:
7653 case USER:
7654 case IDENTIFIER:
7655 case QUOTED_LITERAL:
7656 if (jj_2_27(2)) {
7657 jj_consume_token(REF);
7658 sb.append(token.image);
7659 } else {
7660 ;
7661 }
7662 simpleNode = QualifiedName();
7663 sb.append(simpleNode.getImage());
7664 switch (jj_nt.kind) {
7665 case 2:
7666 jj_consume_token(2);
7667 simpleNode = QualifiedName();
7668 sb.append("@"+simpleNode.getImage());
7669 break;
7670 default:
7671 jj_la1[86] = jj_gen;
7672 ;
7673 }
7674 switch (jj_nt.kind) {
7675 case 11:
7676 jj_consume_token(11);
7677 switch (jj_nt.kind) {
7678 case TYPE:
7679 jj_consume_token(TYPE);
7680 break;
7681 case ROWTYPE:
7682 jj_consume_token(ROWTYPE);
7683 break;
7684 default:
7685 jj_la1[87] = jj_gen;
7686 jj_consume_token(-1);
7687 throw new ParseException();
7688 }
7689 sb.append("%"+token.image);
7690 break;
7691 default:
7692 jj_la1[88] = jj_gen;
7693 ;
7694 }
7695 break;
7696 default:
7697 jj_la1[90] = jj_gen;
7698 jj_consume_token(-1);
7699 throw new ParseException();
7700 }
7701 }
7702 }
7703 jjtree.closeNodeScope(jjtn000, true);
7704 jjtc000 = false;
7705 jjtn000.setImage(sb.toString()) ; {if (true) return jjtn000;}
7706 } catch (Throwable jjte000) {
7707 if (jjtc000) {
7708 jjtree.clearNodeScope(jjtn000);
7709 jjtc000 = false;
7710 } else {
7711 jjtree.popNode();
7712 }
7713 if (jjte000 instanceof RuntimeException) {
7714 {if (true) throw (RuntimeException)jjte000;}
7715 }
7716 if (jjte000 instanceof ParseException) {
7717 {if (true) throw (ParseException)jjte000;}
7718 }
7719 {if (true) throw (Error)jjte000;}
7720 } finally {
7721 if (jjtc000) {
7722 jjtree.closeNodeScope(jjtn000, true);
7723 }
7724 }
7725 throw new Error("Missing return statement in function");
7726 }
7727
7728 final public ASTCompilationDataType CompilationDataType() throws ParseException {
7729
7730 ASTCompilationDataType jjtn000 = new ASTCompilationDataType(this, JJTCOMPILATIONDATATYPE);
7731 boolean jjtc000 = true;
7732 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
7733 StringBuilder sb = new StringBuilder() ;
7734 try {
7735 jj_consume_token(CC_IF);
7736 sb.append(" "); sb.append(token.image) ;
7737 simpleNode = ConditionalOrExpression();
7738 sb.append(" "); sb.append(simpleNode.getImage());
7739 jj_consume_token(CC_THEN);
7740 sb.append(" "); sb.append(token.image);
7741 simpleNode = Datatype();
7742 sb.append(" "); sb.append(simpleNode.getImage());
7743 label_18:
7744 while (true) {
7745 switch (jj_nt.kind) {
7746 case CC_ELSIF:
7747 ;
7748 break;
7749 default:
7750 jj_la1[91] = jj_gen;
7751 break label_18;
7752 }
7753 jj_consume_token(CC_ELSIF);
7754 sb.append(" "); sb.append(token.image);
7755 simpleNode = ConditionalOrExpression();
7756 sb.append(" "); sb.append(simpleNode.getImage());
7757 jj_consume_token(CC_THEN);
7758 sb.append(" "); sb.append(token.image);
7759 simpleNode = Datatype();
7760 sb.append(" "); sb.append(simpleNode.getImage());
7761 }
7762 label_19:
7763 while (true) {
7764 switch (jj_nt.kind) {
7765 case CC_ELSE:
7766 ;
7767 break;
7768 default:
7769 jj_la1[92] = jj_gen;
7770 break label_19;
7771 }
7772 jj_consume_token(CC_ELSE);
7773 sb.append(" "); sb.append(token.image);
7774 simpleNode = Datatype();
7775 sb.append(" "); sb.append(simpleNode.getImage());
7776 }
7777 jj_consume_token(CC_END);
7778 sb.append(" "); sb.append(token.image);
7779 jjtree.closeNodeScope(jjtn000, true);
7780 jjtc000 = false;
7781 jjtn000.setImage(sb.toString()) ; {if (true) return jjtn000;}
7782 } catch (Throwable jjte000) {
7783 if (jjtc000) {
7784 jjtree.clearNodeScope(jjtn000);
7785 jjtc000 = false;
7786 } else {
7787 jjtree.popNode();
7788 }
7789 if (jjte000 instanceof RuntimeException) {
7790 {if (true) throw (RuntimeException)jjte000;}
7791 }
7792 if (jjte000 instanceof ParseException) {
7793 {if (true) throw (ParseException)jjte000;}
7794 }
7795 {if (true) throw (Error)jjte000;}
7796 } finally {
7797 if (jjtc000) {
7798 jjtree.closeNodeScope(jjtn000, true);
7799 }
7800 }
7801 throw new Error("Missing return statement in function");
7802 }
7803
7804 final public ASTCollectionTypeName CollectionTypeName() throws ParseException {
7805
7806 ASTCollectionTypeName jjtn000 = new ASTCollectionTypeName(this, JJTCOLLECTIONTYPENAME);
7807 boolean jjtc000 = true;
7808 jjtree.openNodeScope(jjtn000);PLSQLNode size=null, precision=null;
7809 StringBuilder sb = new StringBuilder();
7810 try {
7811 switch (jj_nt.kind) {
7812 case TABLE:
7813 jj_consume_token(TABLE);
7814 break;
7815 case VARRAY:
7816 jj_consume_token(VARRAY);
7817 break;
7818 case VARYING:
7819 jj_consume_token(VARYING);
7820 jj_consume_token(ARRAY);
7821 sb.append( "VARYING ARRAY") ;
7822 break;
7823 default:
7824 jj_la1[93] = jj_gen;
7825 jj_consume_token(-1);
7826 throw new ParseException();
7827 }
7828 if (sb.length() == 0) {
7829 sb.append(token.toString());
7830 }
7831 if (jj_2_29(2)) {
7832 jj_consume_token(5);
7833 size = NumericLiteral();
7834 sb.append( "(" + size);
7835 switch (jj_nt.kind) {
7836 case 6:
7837 jj_consume_token(6);
7838 precision = NumericLiteral();
7839 sb.append( "," + precision);
7840 break;
7841 default:
7842 jj_la1[94] = jj_gen;
7843 ;
7844 }
7845 switch (jj_nt.kind) {
7846 case CHAR:
7847 jj_consume_token(CHAR);
7848 sb.append( " CHAR") ;
7849 break;
7850 default:
7851 jj_la1[95] = jj_gen;
7852 ;
7853 }
7854 switch (jj_nt.kind) {
7855 case BYTE:
7856 jj_consume_token(BYTE);
7857 sb.append( " BYTE") ;
7858 break;
7859 default:
7860 jj_la1[96] = jj_gen;
7861 ;
7862 }
7863 jj_consume_token(7);
7864 sb.append( ")");
7865 } else {
7866 ;
7867 }
7868 jjtree.closeNodeScope(jjtn000, true);
7869 jjtc000 = false;
7870 jjtn000.setImage(sb.toString()) ; {if (true) return jjtn000;}
7871 } catch (Throwable jjte000) {
7872 if (jjtc000) {
7873 jjtree.clearNodeScope(jjtn000);
7874 jjtc000 = false;
7875 } else {
7876 jjtree.popNode();
7877 }
7878 if (jjte000 instanceof RuntimeException) {
7879 {if (true) throw (RuntimeException)jjte000;}
7880 }
7881 if (jjte000 instanceof ParseException) {
7882 {if (true) throw (ParseException)jjte000;}
7883 }
7884 {if (true) throw (Error)jjte000;}
7885 } finally {
7886 if (jjtc000) {
7887 jjtree.closeNodeScope(jjtn000, true);
7888 }
7889 }
7890 throw new Error("Missing return statement in function");
7891 }
7892
7893 final public ASTScalarDataTypeName ScalarDataTypeName() throws ParseException {
7894
7895 ASTScalarDataTypeName jjtn000 = new ASTScalarDataTypeName(this, JJTSCALARDATATYPENAME);
7896 boolean jjtc000 = true;
7897 jjtree.openNodeScope(jjtn000);PLSQLNode size=null, precision=null ;
7898 StringBuilder name = new StringBuilder();
7899 PLSQLNode characterSet = null;
7900 try {
7901 switch (jj_nt.kind) {
7902 case BFILE_BASE:
7903 jj_consume_token(BFILE_BASE);
7904 break;
7905 case BLOB_BASE:
7906 jj_consume_token(BLOB_BASE);
7907 break;
7908 case CHAR_BASE:
7909 jj_consume_token(CHAR_BASE);
7910 break;
7911 case CLOB_BASE:
7912 jj_consume_token(CLOB_BASE);
7913 break;
7914 case DATE_BASE:
7915 jj_consume_token(DATE_BASE);
7916 break;
7917 case NUMBER_BASE:
7918 jj_consume_token(NUMBER_BASE);
7919 break;
7920 case BINARY_INTEGER:
7921 jj_consume_token(BINARY_INTEGER);
7922 break;
7923 case DEC:
7924 jj_consume_token(DEC);
7925 break;
7926 case DECIMAL:
7927 jj_consume_token(DECIMAL);
7928 break;
7929 case DOUBLE:
7930 jj_consume_token(DOUBLE);
7931 jj_consume_token(PRECISION);
7932 name.append("DOUBLE PRECISION");
7933 break;
7934 case FLOAT:
7935 jj_consume_token(FLOAT);
7936 break;
7937 case INT:
7938 jj_consume_token(INT);
7939 break;
7940 case INTEGER:
7941 jj_consume_token(INTEGER);
7942 break;
7943 case NATURAL:
7944 jj_consume_token(NATURAL);
7945 break;
7946 case NATURALN:
7947 jj_consume_token(NATURALN);
7948 break;
7949 case NUMBER:
7950 jj_consume_token(NUMBER);
7951 break;
7952 case NUMERIC:
7953 jj_consume_token(NUMERIC);
7954 break;
7955 case PLS_INTEGER:
7956 jj_consume_token(PLS_INTEGER);
7957 break;
7958 case POSITIVE:
7959 jj_consume_token(POSITIVE);
7960 break;
7961 case POSITIVEN:
7962 jj_consume_token(POSITIVEN);
7963 break;
7964 case REAL:
7965 jj_consume_token(REAL);
7966 break;
7967 case SIGNTYPE:
7968 jj_consume_token(SIGNTYPE);
7969 break;
7970 case SMALLINT:
7971 jj_consume_token(SMALLINT);
7972 break;
7973 case CHAR:
7974 case LONG:
7975 case RAW:
7976 case ROWID:
7977 case VARCHAR:
7978 case VARCHAR2:
7979 case NCHAR:
7980 case NVARCHAR2:
7981 case STRING:
7982 case UROWID:
7983 case CLOB:
7984 case NCLOB:
7985 case CHARACTER:
7986 switch (jj_nt.kind) {
7987 case CHAR:
7988 jj_consume_token(CHAR);
7989 break;
7990 case CHARACTER:
7991 jj_consume_token(CHARACTER);
7992 break;
7993 default:
7994 jj_la1[97] = jj_gen;
7995 if (jj_2_30(2)) {
7996 jj_consume_token(LONG);
7997 jj_consume_token(RAW);
7998 name.append("LONG RAW");
7999 } else {
8000 switch (jj_nt.kind) {
8001 case LONG:
8002 jj_consume_token(LONG);
8003 break;
8004 case NCHAR:
8005 jj_consume_token(NCHAR);
8006 break;
8007 case NVARCHAR2:
8008 jj_consume_token(NVARCHAR2);
8009 break;
8010 case RAW:
8011 jj_consume_token(RAW);
8012 break;
8013 case ROWID:
8014 jj_consume_token(ROWID);
8015 break;
8016 case STRING:
8017 jj_consume_token(STRING);
8018 break;
8019 case UROWID:
8020 jj_consume_token(UROWID);
8021 break;
8022 case VARCHAR:
8023 jj_consume_token(VARCHAR);
8024 break;
8025 case VARCHAR2:
8026 jj_consume_token(VARCHAR2);
8027 break;
8028 case CLOB:
8029 jj_consume_token(CLOB);
8030 break;
8031 case NCLOB:
8032 jj_consume_token(NCLOB);
8033 break;
8034 default:
8035 jj_la1[98] = jj_gen;
8036 jj_consume_token(-1);
8037 throw new ParseException();
8038 }
8039 }
8040 }
8041 break;
8042 case BOOLEAN:
8043 jj_consume_token(BOOLEAN);
8044 break;
8045 case BFILE:
8046 jj_consume_token(BFILE);
8047 break;
8048 case BLOB:
8049 jj_consume_token(BLOB);
8050 break;
8051 case SYS_REFCURSOR:
8052 jj_consume_token(SYS_REFCURSOR);
8053 break;
8054 case REF:
8055 jj_consume_token(REF);
8056 jj_consume_token(CURSOR);
8057 name.append("REF CURSOR");
8058 break;
8059 case DATE:
8060 jj_consume_token(DATE);
8061 break;
8062 default:
8063 jj_la1[99] = jj_gen;
8064 if (jj_2_31(2)) {
8065 jj_consume_token(INTERVAL);
8066 jj_consume_token(YEAR);
8067 name.append("INTERVAL YEAR");
8068 } else if (jj_2_32(2)) {
8069 jj_consume_token(INTERVAL);
8070 jj_consume_token(DAY);
8071 name.append("INTERVAL DAY");
8072 } else {
8073 switch (jj_nt.kind) {
8074 case TIME:
8075 jj_consume_token(TIME);
8076 break;
8077 case TIMESTAMP:
8078 jj_consume_token(TIMESTAMP);
8079 break;
8080 case SELF:
8081 jj_consume_token(SELF);
8082 jj_consume_token(AS);
8083 jj_consume_token(RESULT);
8084 name.append("SELF AS RESULT");
8085 break;
8086 default:
8087 jj_la1[100] = jj_gen;
8088 jj_consume_token(-1);
8089 throw new ParseException();
8090 }
8091 }
8092 }
8093 if (name.length() == 0 ) {
8094 name.append(token.toString());
8095 }
8096 if (jj_2_33(2)) {
8097 jj_consume_token(5);
8098 size = NumericLiteral();
8099 name.append("("); name.append(size.getImage()) ;
8100 switch (jj_nt.kind) {
8101 case 6:
8102 jj_consume_token(6);
8103 precision = UnaryExpression(true);
8104 name.append(",") ; name.append(precision.getImage()) ;
8105 break;
8106 default:
8107 jj_la1[101] = jj_gen;
8108 ;
8109 }
8110 switch (jj_nt.kind) {
8111 case CHAR:
8112 jj_consume_token(CHAR);
8113 name.append(" CHAR") ;
8114 break;
8115 default:
8116 jj_la1[102] = jj_gen;
8117 ;
8118 }
8119 switch (jj_nt.kind) {
8120 case BYTE:
8121 jj_consume_token(BYTE);
8122 name.append(" BYTE") ;
8123 break;
8124 default:
8125 jj_la1[103] = jj_gen;
8126 ;
8127 }
8128 jj_consume_token(7);
8129 name.append( ")") ;
8130 } else {
8131 ;
8132 }
8133 switch (jj_nt.kind) {
8134 case TO:
8135 case WITH:
8136 case CHARACTER:
8137 switch (jj_nt.kind) {
8138 case CHARACTER:
8139 jj_consume_token(CHARACTER);
8140 jj_consume_token(SET);
8141 characterSet = Name();
8142 name.append( " CHARACTER SET ") ; name.append(characterSet.getImage()) ;
8143 break;
8144 default:
8145 jj_la1[104] = jj_gen;
8146 if (jj_2_35(4)) {
8147 jj_consume_token(WITH);
8148 jj_consume_token(LOCAL);
8149 jj_consume_token(TIME);
8150 jj_consume_token(ZONE);
8151 name.append(" WITH LOCAL TIME ZONE");
8152 } else if (jj_2_36(3)) {
8153 jj_consume_token(WITH);
8154 jj_consume_token(TIME);
8155 jj_consume_token(ZONE);
8156 name.append( " WITH TIME ZONE");
8157 } else if (jj_2_37(2)) {
8158 jj_consume_token(TO);
8159 jj_consume_token(MONTH);
8160 name.append( " TO MONTH");
8161 } else if (jj_2_38(2)) {
8162 jj_consume_token(TO);
8163 jj_consume_token(SECOND);
8164 name.append( " TO SECOND");
8165 if (jj_2_34(2)) {
8166 jj_consume_token(5);
8167 precision = NumericLiteral();
8168 name.append( "(" + precision) ;
8169 jj_consume_token(7);
8170 name.append( ")");
8171 } else {
8172 ;
8173 }
8174 } else {
8175 jj_consume_token(-1);
8176 throw new ParseException();
8177 }
8178 }
8179 break;
8180 default:
8181 jj_la1[105] = jj_gen;
8182 ;
8183 }
8184 jjtree.closeNodeScope(jjtn000, true);
8185 jjtc000 = false;
8186 jjtn000.setImage(name.toString()) ; {if (true) return jjtn000;}
8187 } catch (Throwable jjte000) {
8188 if (jjtc000) {
8189 jjtree.clearNodeScope(jjtn000);
8190 jjtc000 = false;
8191 } else {
8192 jjtree.popNode();
8193 }
8194 if (jjte000 instanceof RuntimeException) {
8195 {if (true) throw (RuntimeException)jjte000;}
8196 }
8197 if (jjte000 instanceof ParseException) {
8198 {if (true) throw (ParseException)jjte000;}
8199 }
8200 {if (true) throw (Error)jjte000;}
8201 } finally {
8202 if (jjtc000) {
8203 jjtree.closeNodeScope(jjtn000, true);
8204 }
8205 }
8206 throw new Error("Missing return statement in function");
8207 }
8208
8209 final public ASTDateTimeLiteral DateTimeLiteral() throws ParseException {
8210
8211 ASTDateTimeLiteral jjtn000 = new ASTDateTimeLiteral(this, JJTDATETIMELITERAL);
8212 boolean jjtc000 = true;
8213 jjtree.openNodeScope(jjtn000);Token t = null ;
8214 PLSQLNode simpleNode = null ;
8215 StringBuilder sb = new StringBuilder() ;
8216 try {
8217 switch (jj_nt.kind) {
8218 case INTERVAL:
8219 jj_consume_token(INTERVAL);
8220 break;
8221 case TIMESTAMP:
8222 jj_consume_token(TIMESTAMP);
8223 break;
8224 case DATE:
8225 jj_consume_token(DATE);
8226 break;
8227 default:
8228 jj_la1[106] = jj_gen;
8229 jj_consume_token(-1);
8230 throw new ParseException();
8231 }
8232 sb.append(token.image);
8233 switch (jj_nt.kind) {
8234 case CHARACTER_LITERAL:
8235 jj_consume_token(CHARACTER_LITERAL);
8236 sb.append(" "); sb.append(token.image);
8237 break;
8238 case STRING_LITERAL:
8239 simpleNode = StringLiteral();
8240 sb.append(" "); sb.append(simpleNode.getImage());
8241 break;
8242 default:
8243 jj_la1[107] = jj_gen;
8244 jj_consume_token(-1);
8245 throw new ParseException();
8246 }
8247 switch (jj_nt.kind) {
8248 case DAY:
8249 case HOUR:
8250 case MINUTE:
8251 case MONTH:
8252 case SECOND:
8253 case YEAR:
8254 switch (jj_nt.kind) {
8255 case YEAR:
8256 jj_consume_token(YEAR);
8257 break;
8258 case MONTH:
8259 jj_consume_token(MONTH);
8260 break;
8261 case DAY:
8262 jj_consume_token(DAY);
8263 break;
8264 case HOUR:
8265 jj_consume_token(HOUR);
8266 break;
8267 case MINUTE:
8268 jj_consume_token(MINUTE);
8269 break;
8270 case SECOND:
8271 jj_consume_token(SECOND);
8272 break;
8273 default:
8274 jj_la1[108] = jj_gen;
8275 jj_consume_token(-1);
8276 throw new ParseException();
8277 }
8278 break;
8279 default:
8280 jj_la1[109] = jj_gen;
8281 ;
8282 }
8283 if (null != t)
8284 {
8285 sb.append(" "); sb.append(token.image);
8286 t = null;
8287 }
8288 if (jj_2_39(2)) {
8289 jj_consume_token(5);
8290 simpleNode = NumericLiteral();
8291 sb.append("("); sb.append(simpleNode.getImage());
8292 jj_consume_token(7);
8293 sb.append("}");
8294 } else {
8295 ;
8296 }
8297 switch (jj_nt.kind) {
8298 case TO:
8299 case WITH:
8300 switch (jj_nt.kind) {
8301 case WITH:
8302 jj_consume_token(WITH);
8303 sb.append(" "); sb.append(token.toString()) ;
8304 switch (jj_nt.kind) {
8305 case LOCAL:
8306 jj_consume_token(LOCAL);
8307 sb.append(" "); sb.append(token.toString()) ;
8308 break;
8309 default:
8310 jj_la1[110] = jj_gen;
8311 ;
8312 }
8313 jj_consume_token(TIME);
8314 jj_consume_token(ZONE);
8315 sb.append(" "); sb.append("TIME ZONE") ;
8316 break;
8317 case TO:
8318 jj_consume_token(TO);
8319 sb.append(" "); sb.append(token.toString()) ;
8320 switch (jj_nt.kind) {
8321 case YEAR:
8322 jj_consume_token(YEAR);
8323 break;
8324 case MONTH:
8325 jj_consume_token(MONTH);
8326 break;
8327 case DAY:
8328 jj_consume_token(DAY);
8329 break;
8330 case HOUR:
8331 jj_consume_token(HOUR);
8332 break;
8333 case MINUTE:
8334 jj_consume_token(MINUTE);
8335 break;
8336 case SECOND:
8337 jj_consume_token(SECOND);
8338 break;
8339 default:
8340 jj_la1[111] = jj_gen;
8341 jj_consume_token(-1);
8342 throw new ParseException();
8343 }
8344 sb.append(token.image);
8345 if (jj_2_40(2)) {
8346 jj_consume_token(5);
8347 simpleNode = NumericLiteral();
8348 sb.append("("); sb.append(simpleNode.getImage());
8349 jj_consume_token(7);
8350 sb.append("}");
8351 } else {
8352 ;
8353 }
8354 break;
8355 default:
8356 jj_la1[112] = jj_gen;
8357 jj_consume_token(-1);
8358 throw new ParseException();
8359 }
8360 break;
8361 default:
8362 jj_la1[113] = jj_gen;
8363 ;
8364 }
8365 jjtree.closeNodeScope(jjtn000, true);
8366 jjtc000 = false;
8367 jjtn000.setImage(sb.toString()) ; {if (true) return jjtn000 ;}
8368 } catch (Throwable jjte000) {
8369 if (jjtc000) {
8370 jjtree.clearNodeScope(jjtn000);
8371 jjtc000 = false;
8372 } else {
8373 jjtree.popNode();
8374 }
8375 if (jjte000 instanceof RuntimeException) {
8376 {if (true) throw (RuntimeException)jjte000;}
8377 }
8378 if (jjte000 instanceof ParseException) {
8379 {if (true) throw (ParseException)jjte000;}
8380 }
8381 {if (true) throw (Error)jjte000;}
8382 } finally {
8383 if (jjtc000) {
8384 jjtree.closeNodeScope(jjtn000, true);
8385 }
8386 }
8387 throw new Error("Missing return statement in function");
8388 }
8389
8390 final public ASTExceptionHandler ExceptionHandler() throws ParseException {
8391
8392 ASTExceptionHandler jjtn000 = new ASTExceptionHandler(this, JJTEXCEPTIONHANDLER);
8393 boolean jjtc000 = true;
8394 jjtree.openNodeScope(jjtn000);
8395 try {
8396 jj_consume_token(EXCEPTION);
8397 label_20:
8398 while (true) {
8399 if (jj_2_41(2)) {
8400 ;
8401 } else {
8402 break label_20;
8403 }
8404 jj_consume_token(WHEN);
8405 QualifiedName();
8406 label_21:
8407 while (true) {
8408 switch (jj_nt.kind) {
8409 case OR:
8410 ;
8411 break;
8412 default:
8413 jj_la1[114] = jj_gen;
8414 break label_21;
8415 }
8416 jj_consume_token(OR);
8417 QualifiedName();
8418 }
8419 jj_consume_token(THEN);
8420 label_22:
8421 while (true) {
8422 Statement();
8423 switch (jj_nt.kind) {
8424 case 5:
8425 case 16:
8426 case 17:
8427 case 21:
8428 case REPLACE:
8429 case DEFINER:
8430 case CURRENT_USER:
8431 case LANGUAGE:
8432 case INLINE:
8433 case ADD:
8434 case AGGREGATE:
8435 case ARRAY:
8436 case AT:
8437 case ATTRIBUTE:
8438 case AUTHID:
8439 case BEGIN:
8440 case BODY:
8441 case BULK:
8442 case BYTE:
8443 case CASCADE:
8444 case CASE:
8445 case CLOSE:
8446 case COALESCE:
8447 case COLLECT:
8448 case COLUMN:
8449 case COMMENT:
8450 case COMMIT:
8451 case CONSTRUCTOR:
8452 case CONTINUE:
8453 case CONVERT:
8454 case CURRENT:
8455 case CURSOR:
8456 case DATA:
8457 case DATE:
8458 case DAY:
8459 case DECLARE:
8460 case DELETE:
8461 case DISABLE:
8462 case EDITIONABLE:
8463 case ELEMENT:
8464 case ENABLE:
8465 case ESCAPE:
8466 case EXCEPT:
8467 case EXCEPTIONS:
8468 case EXECUTE:
8469 case EXIT:
8470 case EXTERNAL:
8471 case EXTENDS:
8472 case EXTRACT:
8473 case FALSE:
8474 case FETCH:
8475 case FINAL:
8476 case FOR:
8477 case FORALL:
8478 case FORCE:
8479 case FUNCTION:
8480 case GLOBAL:
8481 case GOTO:
8482 case HASH:
8483 case HEAP:
8484 case HOUR:
8485 case IF:
8486 case IMMEDIATE:
8487 case INDICES:
8488 case INDEXTYPE:
8489 case INDICATOR:
8490 case INSERT:
8491 case INSTANTIABLE:
8492 case INTERVAL:
8493 case INVALIDATE:
8494 case ISOLATION:
8495 case JAVA:
8496 case LEVEL:
8497 case LIMIT:
8498 case LOCK:
8499 case LOOP:
8500 case MAP:
8501 case MAX:
8502 case MEMBER:
8503 case MERGE:
8504 case MIN:
8505 case MINUTE:
8506 case MLSLABEL:
8507 case MODIFY:
8508 case MOD:
8509 case MONTH:
8510 case NATURAL:
8511 case NEW:
8512 case NEW_DOT:
8513 case NO:
8514 case NONEDITIONABLE:
8515 case NOT:
8516 case NULL:
8517 case NULLIF:
8518 case OBJECT:
8519 case OID:
8520 case OPAQUE:
8521 case OPEN:
8522 case OPERATOR:
8523 case ORGANIZATION:
8524 case OTHERS:
8525 case OVERRIDING:
8526 case PACKAGE:
8527 case PARTITION:
8528 case PIPE:
8529 case PRAGMA:
8530 case PRESERVE:
8531 case PRIVATE:
8532 case PROCEDURE:
8533 case RAISE:
8534 case RANGE:
8535 case RAW:
8536 case REAL:
8537 case RECORD:
8538 case REF:
8539 case RELEASE:
8540 case RELIES_ON:
8541 case RENAME:
8542 case RESULT:
8543 case RETURN:
8544 case RETURNING:
8545 case REVERSE:
8546 case ROLLBACK:
8547 case ROW:
8548 case ROWS:
8549 case ROWID:
8550 case ROWNUM:
8551 case SAVE:
8552 case SAVEPOINT:
8553 case SECOND:
8554 case SELECT:
8555 case SELF:
8556 case SET:
8557 case SPACE:
8558 case SQL:
8559 case SQLCODE:
8560 case SQLERRM:
8561 case STATIC:
8562 case SUBTYPE:
8563 case SUBSTITUTABLE:
8564 case SUCCESSFUL:
8565 case SYSDATE:
8566 case SYS_REFCURSOR:
8567 case TEMPORARY:
8568 case TIME:
8569 case TIMESTAMP:
8570 case TIMEZONE_REGION:
8571 case TIMEZONE_ABBR:
8572 case TIMEZONE_MINUTE:
8573 case TIMEZONE_HOUR:
8574 case TRANSACTION:
8575 case TRUE:
8576 case TYPE:
8577 case UNDER:
8578 case USING:
8579 case WHILE:
8580 case YES:
8581 case SHOW:
8582 case A:
8583 case UPDATE:
8584 case DOUBLE:
8585 case DEC:
8586 case PRECISION:
8587 case INT:
8588 case NUMERIC:
8589 case NCHAR:
8590 case NVARCHAR2:
8591 case STRING:
8592 case UROWID:
8593 case VARRAY:
8594 case VARYING:
8595 case BFILE:
8596 case BLOB:
8597 case CLOB:
8598 case NCLOB:
8599 case YEAR:
8600 case LOCAL:
8601 case WITH:
8602 case ZONE:
8603 case CHARACTER:
8604 case AFTER:
8605 case BEFORE:
8606 case OLD:
8607 case PARENT:
8608 case CC_IF:
8609 case CC_ERROR:
8610 case ANALYZE:
8611 case ASSOCIATE:
8612 case AUDIT:
8613 case COMPOUND:
8614 case DATABASE:
8615 case CALL:
8616 case DDL:
8617 case DISASSOCIATE:
8618 case EACH:
8619 case FOLLOWS:
8620 case LOGOFF:
8621 case LOGON:
8622 case NESTED:
8623 case NOAUDIT:
8624 case SCHEMA:
8625 case SERVERERROR:
8626 case SHUTDOWN:
8627 case STARTUP:
8628 case STATEMENT:
8629 case STATISTICS:
8630 case SUSPEND:
8631 case TRUNCATE:
8632 case WRAPPED:
8633 case LIBRARY:
8634 case NAME:
8635 case STRUCT:
8636 case CONTEXT:
8637 case PARAMETERS:
8638 case LENGTH:
8639 case TDO:
8640 case MAXLEN:
8641 case CHARSETID:
8642 case CHARSETFORM:
8643 case ACCEPT:
8644 case ACCESSIBLE:
8645 case COPY:
8646 case DEFINE:
8647 case DISCONNECT:
8648 case HOST:
8649 case PRINT:
8650 case QUIT:
8651 case REMARK:
8652 case UNDEFINE:
8653 case VARIABLE:
8654 case WHENEVER:
8655 case ATTACH:
8656 case CAST:
8657 case TREAT:
8658 case TRIM:
8659 case LEFT:
8660 case RIGHT:
8661 case BOTH:
8662 case EMPTY:
8663 case MULTISET:
8664 case SUBMULTISET:
8665 case LEADING:
8666 case TRAILING:
8667 case CHAR_CS:
8668 case NCHAR_CS:
8669 case DBTIMEZONE:
8670 case SESSIONTIMEZONE:
8671 case AUTHENTICATED:
8672 case LINK:
8673 case SHARED:
8674 case DIRECTORY:
8675 case USER:
8676 case IDENTIFIER:
8677 case UNSIGNED_NUMERIC_LITERAL:
8678 case CHARACTER_LITERAL:
8679 case STRING_LITERAL:
8680 case QUOTED_LITERAL:
8681 ;
8682 break;
8683 default:
8684 jj_la1[115] = jj_gen;
8685 break label_22;
8686 }
8687 }
8688 }
8689 switch (jj_nt.kind) {
8690 case WHEN:
8691 jj_consume_token(WHEN);
8692 jj_consume_token(OTHERS);
8693 jj_consume_token(THEN);
8694 label_23:
8695 while (true) {
8696 Statement();
8697 switch (jj_nt.kind) {
8698 case 5:
8699 case 16:
8700 case 17:
8701 case 21:
8702 case REPLACE:
8703 case DEFINER:
8704 case CURRENT_USER:
8705 case LANGUAGE:
8706 case INLINE:
8707 case ADD:
8708 case AGGREGATE:
8709 case ARRAY:
8710 case AT:
8711 case ATTRIBUTE:
8712 case AUTHID:
8713 case BEGIN:
8714 case BODY:
8715 case BULK:
8716 case BYTE:
8717 case CASCADE:
8718 case CASE:
8719 case CLOSE:
8720 case COALESCE:
8721 case COLLECT:
8722 case COLUMN:
8723 case COMMENT:
8724 case COMMIT:
8725 case CONSTRUCTOR:
8726 case CONTINUE:
8727 case CONVERT:
8728 case CURRENT:
8729 case CURSOR:
8730 case DATA:
8731 case DATE:
8732 case DAY:
8733 case DECLARE:
8734 case DELETE:
8735 case DISABLE:
8736 case EDITIONABLE:
8737 case ELEMENT:
8738 case ENABLE:
8739 case ESCAPE:
8740 case EXCEPT:
8741 case EXCEPTIONS:
8742 case EXECUTE:
8743 case EXIT:
8744 case EXTERNAL:
8745 case EXTENDS:
8746 case EXTRACT:
8747 case FALSE:
8748 case FETCH:
8749 case FINAL:
8750 case FOR:
8751 case FORALL:
8752 case FORCE:
8753 case FUNCTION:
8754 case GLOBAL:
8755 case GOTO:
8756 case HASH:
8757 case HEAP:
8758 case HOUR:
8759 case IF:
8760 case IMMEDIATE:
8761 case INDICES:
8762 case INDEXTYPE:
8763 case INDICATOR:
8764 case INSERT:
8765 case INSTANTIABLE:
8766 case INTERVAL:
8767 case INVALIDATE:
8768 case ISOLATION:
8769 case JAVA:
8770 case LEVEL:
8771 case LIMIT:
8772 case LOCK:
8773 case LOOP:
8774 case MAP:
8775 case MAX:
8776 case MEMBER:
8777 case MERGE:
8778 case MIN:
8779 case MINUTE:
8780 case MLSLABEL:
8781 case MODIFY:
8782 case MOD:
8783 case MONTH:
8784 case NATURAL:
8785 case NEW:
8786 case NEW_DOT:
8787 case NO:
8788 case NONEDITIONABLE:
8789 case NOT:
8790 case NULL:
8791 case NULLIF:
8792 case OBJECT:
8793 case OID:
8794 case OPAQUE:
8795 case OPEN:
8796 case OPERATOR:
8797 case ORGANIZATION:
8798 case OTHERS:
8799 case OVERRIDING:
8800 case PACKAGE:
8801 case PARTITION:
8802 case PIPE:
8803 case PRAGMA:
8804 case PRESERVE:
8805 case PRIVATE:
8806 case PROCEDURE:
8807 case RAISE:
8808 case RANGE:
8809 case RAW:
8810 case REAL:
8811 case RECORD:
8812 case REF:
8813 case RELEASE:
8814 case RELIES_ON:
8815 case RENAME:
8816 case RESULT:
8817 case RETURN:
8818 case RETURNING:
8819 case REVERSE:
8820 case ROLLBACK:
8821 case ROW:
8822 case ROWS:
8823 case ROWID:
8824 case ROWNUM:
8825 case SAVE:
8826 case SAVEPOINT:
8827 case SECOND:
8828 case SELECT:
8829 case SELF:
8830 case SET:
8831 case SPACE:
8832 case SQL:
8833 case SQLCODE:
8834 case SQLERRM:
8835 case STATIC:
8836 case SUBTYPE:
8837 case SUBSTITUTABLE:
8838 case SUCCESSFUL:
8839 case SYSDATE:
8840 case SYS_REFCURSOR:
8841 case TEMPORARY:
8842 case TIME:
8843 case TIMESTAMP:
8844 case TIMEZONE_REGION:
8845 case TIMEZONE_ABBR:
8846 case TIMEZONE_MINUTE:
8847 case TIMEZONE_HOUR:
8848 case TRANSACTION:
8849 case TRUE:
8850 case TYPE:
8851 case UNDER:
8852 case USING:
8853 case WHILE:
8854 case YES:
8855 case SHOW:
8856 case A:
8857 case UPDATE:
8858 case DOUBLE:
8859 case DEC:
8860 case PRECISION:
8861 case INT:
8862 case NUMERIC:
8863 case NCHAR:
8864 case NVARCHAR2:
8865 case STRING:
8866 case UROWID:
8867 case VARRAY:
8868 case VARYING:
8869 case BFILE:
8870 case BLOB:
8871 case CLOB:
8872 case NCLOB:
8873 case YEAR:
8874 case LOCAL:
8875 case WITH:
8876 case ZONE:
8877 case CHARACTER:
8878 case AFTER:
8879 case BEFORE:
8880 case OLD:
8881 case PARENT:
8882 case CC_IF:
8883 case CC_ERROR:
8884 case ANALYZE:
8885 case ASSOCIATE:
8886 case AUDIT:
8887 case COMPOUND:
8888 case DATABASE:
8889 case CALL:
8890 case DDL:
8891 case DISASSOCIATE:
8892 case EACH:
8893 case FOLLOWS:
8894 case LOGOFF:
8895 case LOGON:
8896 case NESTED:
8897 case NOAUDIT:
8898 case SCHEMA:
8899 case SERVERERROR:
8900 case SHUTDOWN:
8901 case STARTUP:
8902 case STATEMENT:
8903 case STATISTICS:
8904 case SUSPEND:
8905 case TRUNCATE:
8906 case WRAPPED:
8907 case LIBRARY:
8908 case NAME:
8909 case STRUCT:
8910 case CONTEXT:
8911 case PARAMETERS:
8912 case LENGTH:
8913 case TDO:
8914 case MAXLEN:
8915 case CHARSETID:
8916 case CHARSETFORM:
8917 case ACCEPT:
8918 case ACCESSIBLE:
8919 case COPY:
8920 case DEFINE:
8921 case DISCONNECT:
8922 case HOST:
8923 case PRINT:
8924 case QUIT:
8925 case REMARK:
8926 case UNDEFINE:
8927 case VARIABLE:
8928 case WHENEVER:
8929 case ATTACH:
8930 case CAST:
8931 case TREAT:
8932 case TRIM:
8933 case LEFT:
8934 case RIGHT:
8935 case BOTH:
8936 case EMPTY:
8937 case MULTISET:
8938 case SUBMULTISET:
8939 case LEADING:
8940 case TRAILING:
8941 case CHAR_CS:
8942 case NCHAR_CS:
8943 case DBTIMEZONE:
8944 case SESSIONTIMEZONE:
8945 case AUTHENTICATED:
8946 case LINK:
8947 case SHARED:
8948 case DIRECTORY:
8949 case USER:
8950 case IDENTIFIER:
8951 case UNSIGNED_NUMERIC_LITERAL:
8952 case CHARACTER_LITERAL:
8953 case STRING_LITERAL:
8954 case QUOTED_LITERAL:
8955 ;
8956 break;
8957 default:
8958 jj_la1[116] = jj_gen;
8959 break label_23;
8960 }
8961 }
8962 break;
8963 default:
8964 jj_la1[117] = jj_gen;
8965 ;
8966 }
8967 jjtree.closeNodeScope(jjtn000, true);
8968 jjtc000 = false;
8969 {if (true) return jjtn000 ;}
8970 } catch (Throwable jjte000) {
8971 if (jjtc000) {
8972 jjtree.clearNodeScope(jjtn000);
8973 jjtc000 = false;
8974 } else {
8975 jjtree.popNode();
8976 }
8977 if (jjte000 instanceof RuntimeException) {
8978 {if (true) throw (RuntimeException)jjte000;}
8979 }
8980 if (jjte000 instanceof ParseException) {
8981 {if (true) throw (ParseException)jjte000;}
8982 }
8983 {if (true) throw (Error)jjte000;}
8984 } finally {
8985 if (jjtc000) {
8986 jjtree.closeNodeScope(jjtn000, true);
8987 }
8988 }
8989 throw new Error("Missing return statement in function");
8990 }
8991
8992 final public void Skip2NextTerminator(String initiator,String terminator) throws ParseException {
8993
8994 ASTSkip2NextTerminator jjtn000 = new ASTSkip2NextTerminator(this, JJTSKIP2NEXTTERMINATOR);
8995 boolean jjtc000 = true;
8996 jjtree.openNodeScope(jjtn000);Token t = getToken(1);
8997 int count = (initiator == null) ? 0 : 1;
8998 if(t.image.equals(initiator)) count++;
8999 while (count > 0 || !t.image.equals(terminator))
9000 {
9001 t = getNextToken();
9002 t = getToken(1);
9003 if(t.image.equals(initiator)) count++;
9004 if(t.image.equals(terminator)) count--;
9005 }
9006 try {
9007 jjtree.closeNodeScope(jjtn000, true);
9008 jjtc000 = false;
9009 {if (true) return;}
9010 } finally {
9011 if (jjtc000) {
9012 jjtree.closeNodeScope(jjtn000, true);
9013 }
9014 }
9015 }
9016
9017
9018
9019
9020 final public void Skip2NextOccurrence(String target) throws ParseException {
9021
9022 ASTSkip2NextOccurrence jjtn000 = new ASTSkip2NextOccurrence(this, JJTSKIP2NEXTOCCURRENCE);
9023 boolean jjtc000 = true;
9024 jjtree.openNodeScope(jjtn000);Token nextToken = getToken(1);
9025 while (!nextToken.image.equals(target)
9026 && (null == nextToken.specialToken || !nextToken.specialToken.image.equals(target) )
9027 && nextToken.kind!=EOF
9028 )
9029 {
9030 nextToken = getNextToken();
9031 nextToken = getToken(1);
9032 }
9033 try {
9034 jjtree.closeNodeScope(jjtn000, true);
9035 jjtc000 = false;
9036 {if (true) return;}
9037 } finally {
9038 if (jjtc000) {
9039 jjtree.closeNodeScope(jjtn000, true);
9040 }
9041 }
9042 }
9043
9044
9045
9046
9047 final public void SkipPastNextOccurrence(String target) throws ParseException {
9048
9049 ASTSkipPastNextOccurrence jjtn000 = new ASTSkipPastNextOccurrence(this, JJTSKIPPASTNEXTOCCURRENCE);
9050 boolean jjtc000 = true;
9051 jjtree.openNodeScope(jjtn000);Token t = null;
9052 Skip2NextOccurrence(target) ;
9053 t = getNextToken();
9054 try {
9055 jjtree.closeNodeScope(jjtn000, true);
9056 jjtc000 = false;
9057 {if (true) return;}
9058 } finally {
9059 if (jjtc000) {
9060 jjtree.closeNodeScope(jjtn000, true);
9061 }
9062 }
9063 }
9064
9065
9066
9067
9068 final public void Skip2NextTokenOccurrence(int target) throws ParseException {
9069
9070 ASTSkip2NextTokenOccurrence jjtn000 = new ASTSkip2NextTokenOccurrence(this, JJTSKIP2NEXTTOKENOCCURRENCE);
9071 boolean jjtc000 = true;
9072 jjtree.openNodeScope(jjtn000);Token nextToken = getToken(1);
9073 Token specToken = null ;
9074 while (nextToken.kind!=target
9075 && (null == nextToken.specialToken || nextToken.specialToken.kind!=target )
9076 && nextToken.kind!=EOF
9077 )
9078 {
9079
9080
9081
9082
9083
9084
9085
9086
9087
9088
9089
9090
9091
9092
9093 specToken = nextToken.specialToken;
9094 if (null!= specToken)
9095 {
9096
9097 while (specToken != null && specToken.kind != target)
9098 {
9099 specToken = specToken.specialToken;
9100 }
9101
9102
9103 if (null != specToken && specToken.kind == target)
9104 {
9105 break;
9106 }
9107 }
9108
9109 nextToken = getNextToken();
9110 nextToken = getToken(1);
9111 }
9112 try {
9113 jjtree.closeNodeScope(jjtn000, true);
9114 jjtc000 = false;
9115 {if (true) return;}
9116 } finally {
9117 if (jjtc000) {
9118 jjtree.closeNodeScope(jjtn000, true);
9119 }
9120 }
9121 }
9122
9123
9124
9125
9126 final public void SkipPastNextTokenOccurrence(int target) throws ParseException {
9127
9128 ASTSkipPastNextTokenOccurrence jjtn000 = new ASTSkipPastNextTokenOccurrence(this, JJTSKIPPASTNEXTTOKENOCCURRENCE);
9129 boolean jjtc000 = true;
9130 jjtree.openNodeScope(jjtn000);Token t = null;
9131 Skip2NextTokenOccurrence(target) ;
9132 t = getNextToken();
9133 try {
9134 jjtree.closeNodeScope(jjtn000, true);
9135 jjtc000 = false;
9136 {if (true) return;}
9137 } finally {
9138 if (jjtc000) {
9139 jjtree.closeNodeScope(jjtn000, true);
9140 }
9141 }
9142 }
9143
9144
9145
9146
9147 final public ASTRead2NextOccurrence Read2NextOccurrence(String target) throws ParseException {
9148
9149 ASTRead2NextOccurrence jjtn000 = new ASTRead2NextOccurrence(this, JJTREAD2NEXTOCCURRENCE);
9150 boolean jjtc000 = true;
9151 jjtree.openNodeScope(jjtn000);StringBuilder sb = new StringBuilder();
9152 Token nextToken = getToken(1);
9153 while (!nextToken.image.equals(target)
9154 && nextToken.kind!=EOF
9155 )
9156 {
9157 nextToken = getNextToken();
9158 sb.append(nextToken.image);
9159 nextToken = getToken(1);
9160 }
9161 try {
9162 jjtree.closeNodeScope(jjtn000, true);
9163 jjtc000 = false;
9164 jjtn000.setImage(sb.toString()) ; jjtn000.value = sb.toString(); {if (true) return jjtn000 ;}
9165 } finally {
9166 if (jjtc000) {
9167 jjtree.closeNodeScope(jjtn000, true);
9168 }
9169 }
9170 throw new Error("Missing return statement in function");
9171 }
9172
9173
9174
9175
9176 final public ASTReadPastNextOccurrence ReadPastNextOccurrence(String target) throws ParseException {
9177
9178 ASTReadPastNextOccurrence jjtn000 = new ASTReadPastNextOccurrence(this, JJTREADPASTNEXTOCCURRENCE);
9179 boolean jjtc000 = true;
9180 jjtree.openNodeScope(jjtn000);StringBuilder sb = new StringBuilder();
9181 Token t = null;
9182 sb.append(Read2NextOccurrence(target)) ;
9183 t = getNextToken();
9184 sb.append(t.image);
9185 try {
9186 jjtree.closeNodeScope(jjtn000, true);
9187 jjtc000 = false;
9188 jjtn000.setImage(sb.toString()) ; jjtn000.value = sb.toString(); {if (true) return jjtn000 ;}
9189 } finally {
9190 if (jjtc000) {
9191 jjtree.closeNodeScope(jjtn000, true);
9192 }
9193 }
9194 throw new Error("Missing return statement in function");
9195 }
9196
9197
9198
9199
9200 final public ASTSqlStatement SqlStatement(String initiator, String terminator) throws ParseException {
9201
9202 ASTSqlStatement jjtn000 = new ASTSqlStatement(this, JJTSQLSTATEMENT);
9203 boolean jjtc000 = true;
9204 jjtree.openNodeScope(jjtn000);
9205 try {
9206 switch (jj_nt.kind) {
9207 case SELECT:
9208 jj_consume_token(SELECT);
9209 break;
9210 case UPDATE:
9211 jj_consume_token(UPDATE);
9212 break;
9213 case INSERT:
9214 jj_consume_token(INSERT);
9215 break;
9216 case DELETE:
9217 jj_consume_token(DELETE);
9218 break;
9219 case COMMIT:
9220 jj_consume_token(COMMIT);
9221 break;
9222 case ROLLBACK:
9223 jj_consume_token(ROLLBACK);
9224 break;
9225 case SAVEPOINT:
9226 jj_consume_token(SAVEPOINT);
9227 break;
9228 case EXECUTE:
9229 jj_consume_token(EXECUTE);
9230 break;
9231 case SET:
9232 jj_consume_token(SET);
9233 jj_consume_token(TRANSACTION);
9234 break;
9235 case LOCK:
9236 jj_consume_token(LOCK);
9237 jj_consume_token(TABLE);
9238 break;
9239 case MERGE:
9240 jj_consume_token(MERGE);
9241 break;
9242 case WITH:
9243 jj_consume_token(WITH);
9244 break;
9245 default:
9246 jj_la1[118] = jj_gen;
9247 jj_consume_token(-1);
9248 throw new ParseException();
9249 }
9250 Skip2NextTerminator(initiator,terminator);
9251 jjtree.closeNodeScope(jjtn000, true);
9252 jjtc000 = false;
9253 {if (true) return jjtn000 ;}
9254 } catch (Throwable jjte000) {
9255 if (jjtc000) {
9256 jjtree.clearNodeScope(jjtn000);
9257 jjtc000 = false;
9258 } else {
9259 jjtree.popNode();
9260 }
9261 if (jjte000 instanceof RuntimeException) {
9262 {if (true) throw (RuntimeException)jjte000;}
9263 }
9264 if (jjte000 instanceof ParseException) {
9265 {if (true) throw (ParseException)jjte000;}
9266 }
9267 {if (true) throw (Error)jjte000;}
9268 } finally {
9269 if (jjtc000) {
9270 jjtree.closeNodeScope(jjtn000, true);
9271 }
9272 }
9273 throw new Error("Missing return statement in function");
9274 }
9275
9276
9277
9278
9279
9280
9281
9282
9283
9284
9285
9286
9287
9288
9289
9290
9291
9292
9293
9294
9295
9296
9297
9298
9299
9300
9301
9302
9303
9304
9305
9306
9307
9308
9309
9310
9311
9312 final public void WrappedObject() throws ParseException {
9313
9314 ASTWrappedObject jjtn000 = new ASTWrappedObject(this, JJTWRAPPEDOBJECT);
9315 boolean jjtc000 = true;
9316 jjtree.openNodeScope(jjtn000);
9317 try {
9318 jj_consume_token(WRAPPED);
9319 jjtree.closeNodeScope(jjtn000, true);
9320 jjtc000 = false;
9321 Token nextToken;
9322
9323 nextToken = getToken(1);
9324 while (
9325 null != nextToken && nextToken.kind!=EOF
9326 )
9327 {
9328 nextToken = getNextToken();
9329
9330
9331 nextToken = getToken(1);
9332 }
9333 {if (true) return;}
9334 } finally {
9335 if (jjtc000) {
9336 jjtree.closeNodeScope(jjtn000, true);
9337 }
9338 }
9339 }
9340
9341
9342
9343
9344
9345
9346
9347
9348 final public ASTUnlabelledStatement UnlabelledStatement() throws ParseException {
9349
9350 ASTUnlabelledStatement jjtn000 = new ASTUnlabelledStatement(this, JJTUNLABELLEDSTATEMENT);
9351 boolean jjtc000 = true;
9352 jjtree.openNodeScope(jjtn000);
9353 try {
9354 if (jj_2_42(2147483647)) {
9355 SqlStatement(null,";");
9356 switch (jj_nt.kind) {
9357 case 4:
9358 jj_consume_token(4);
9359 break;
9360 default:
9361 jj_la1[119] = jj_gen;
9362 ;
9363 }
9364 } else if (jj_2_43(3)) {
9365 ContinueStatement();
9366 jj_consume_token(4);
9367 } else {
9368 switch (jj_nt.kind) {
9369 case CASE:
9370 CaseStatement();
9371 jj_consume_token(4);
9372 break;
9373 case IF:
9374 IfStatement();
9375 jj_consume_token(4);
9376 break;
9377 case FOR:
9378 ForStatement();
9379 jj_consume_token(4);
9380 break;
9381 case FORALL:
9382 ForAllStatement();
9383 jj_consume_token(4);
9384 break;
9385 case LOOP:
9386 LoopStatement();
9387 jj_consume_token(4);
9388 break;
9389 case WHILE:
9390 WhileStatement();
9391 jj_consume_token(4);
9392 break;
9393 case GOTO:
9394 GotoStatement();
9395 jj_consume_token(4);
9396 break;
9397 case RETURN:
9398 ReturnStatement();
9399 jj_consume_token(4);
9400 break;
9401 case EXIT:
9402 ExitStatement();
9403 jj_consume_token(4);
9404 break;
9405 case RAISE:
9406 RaiseStatement();
9407 jj_consume_token(4);
9408 break;
9409 case CLOSE:
9410 CloseStatement();
9411 jj_consume_token(4);
9412 break;
9413 case OPEN:
9414 OpenStatement();
9415 jj_consume_token(4);
9416 break;
9417 case FETCH:
9418 FetchStatement();
9419 jj_consume_token(4);
9420 break;
9421 case BEGIN:
9422 case DECLARE:
9423 Block();
9424 jj_consume_token(4);
9425 break;
9426 case EXECUTE:
9427 EmbeddedSqlStatement();
9428 jj_consume_token(4);
9429 break;
9430 case PIPE:
9431 PipelineStatement();
9432 jj_consume_token(4);
9433 break;
9434 case CC_IF:
9435 case CC_ERROR:
9436 ConditionalCompilationStatement();
9437 break;
9438 case PRAGMA:
9439 InlinePragma();
9440 jj_consume_token(4);
9441 break;
9442 case 5:
9443 case 16:
9444 case 17:
9445 case REPLACE:
9446 case DEFINER:
9447 case CURRENT_USER:
9448 case LANGUAGE:
9449 case INLINE:
9450 case ADD:
9451 case AGGREGATE:
9452 case ARRAY:
9453 case AT:
9454 case ATTRIBUTE:
9455 case AUTHID:
9456 case BODY:
9457 case BULK:
9458 case BYTE:
9459 case CASCADE:
9460 case COALESCE:
9461 case COLLECT:
9462 case COLUMN:
9463 case COMMENT:
9464 case COMMIT:
9465 case CONSTRUCTOR:
9466 case CONTINUE:
9467 case CONVERT:
9468 case CURRENT:
9469 case CURSOR:
9470 case DATA:
9471 case DATE:
9472 case DAY:
9473 case DISABLE:
9474 case EDITIONABLE:
9475 case ELEMENT:
9476 case ENABLE:
9477 case ESCAPE:
9478 case EXCEPT:
9479 case EXCEPTIONS:
9480 case EXTERNAL:
9481 case EXTENDS:
9482 case EXTRACT:
9483 case FALSE:
9484 case FINAL:
9485 case FORCE:
9486 case FUNCTION:
9487 case GLOBAL:
9488 case HASH:
9489 case HEAP:
9490 case HOUR:
9491 case IMMEDIATE:
9492 case INDICES:
9493 case INDEXTYPE:
9494 case INDICATOR:
9495 case INSTANTIABLE:
9496 case INTERVAL:
9497 case INVALIDATE:
9498 case ISOLATION:
9499 case JAVA:
9500 case LEVEL:
9501 case LIMIT:
9502 case MAP:
9503 case MAX:
9504 case MEMBER:
9505 case MERGE:
9506 case MIN:
9507 case MINUTE:
9508 case MLSLABEL:
9509 case MODIFY:
9510 case MOD:
9511 case MONTH:
9512 case NATURAL:
9513 case NEW:
9514 case NEW_DOT:
9515 case NO:
9516 case NONEDITIONABLE:
9517 case NOT:
9518 case NULL:
9519 case NULLIF:
9520 case OBJECT:
9521 case OID:
9522 case OPAQUE:
9523 case OPERATOR:
9524 case ORGANIZATION:
9525 case OTHERS:
9526 case OVERRIDING:
9527 case PACKAGE:
9528 case PARTITION:
9529 case PRESERVE:
9530 case PRIVATE:
9531 case PROCEDURE:
9532 case RANGE:
9533 case RAW:
9534 case REAL:
9535 case RECORD:
9536 case REF:
9537 case RELEASE:
9538 case RELIES_ON:
9539 case RENAME:
9540 case RESULT:
9541 case RETURNING:
9542 case REVERSE:
9543 case ROLLBACK:
9544 case ROW:
9545 case ROWS:
9546 case ROWID:
9547 case ROWNUM:
9548 case SAVE:
9549 case SAVEPOINT:
9550 case SECOND:
9551 case SELECT:
9552 case SELF:
9553 case SET:
9554 case SPACE:
9555 case SQL:
9556 case SQLCODE:
9557 case SQLERRM:
9558 case STATIC:
9559 case SUBTYPE:
9560 case SUBSTITUTABLE:
9561 case SUCCESSFUL:
9562 case SYSDATE:
9563 case SYS_REFCURSOR:
9564 case TEMPORARY:
9565 case TIME:
9566 case TIMESTAMP:
9567 case TIMEZONE_REGION:
9568 case TIMEZONE_ABBR:
9569 case TIMEZONE_MINUTE:
9570 case TIMEZONE_HOUR:
9571 case TRANSACTION:
9572 case TRUE:
9573 case TYPE:
9574 case UNDER:
9575 case USING:
9576 case YES:
9577 case SHOW:
9578 case A:
9579 case DOUBLE:
9580 case DEC:
9581 case PRECISION:
9582 case INT:
9583 case NUMERIC:
9584 case NCHAR:
9585 case NVARCHAR2:
9586 case STRING:
9587 case UROWID:
9588 case VARRAY:
9589 case VARYING:
9590 case BFILE:
9591 case BLOB:
9592 case CLOB:
9593 case NCLOB:
9594 case YEAR:
9595 case LOCAL:
9596 case WITH:
9597 case ZONE:
9598 case CHARACTER:
9599 case AFTER:
9600 case BEFORE:
9601 case OLD:
9602 case PARENT:
9603 case ANALYZE:
9604 case ASSOCIATE:
9605 case AUDIT:
9606 case COMPOUND:
9607 case DATABASE:
9608 case CALL:
9609 case DDL:
9610 case DISASSOCIATE:
9611 case EACH:
9612 case FOLLOWS:
9613 case LOGOFF:
9614 case LOGON:
9615 case NESTED:
9616 case NOAUDIT:
9617 case SCHEMA:
9618 case SERVERERROR:
9619 case SHUTDOWN:
9620 case STARTUP:
9621 case STATEMENT:
9622 case STATISTICS:
9623 case SUSPEND:
9624 case TRUNCATE:
9625 case WRAPPED:
9626 case LIBRARY:
9627 case NAME:
9628 case STRUCT:
9629 case CONTEXT:
9630 case PARAMETERS:
9631 case LENGTH:
9632 case TDO:
9633 case MAXLEN:
9634 case CHARSETID:
9635 case CHARSETFORM:
9636 case ACCEPT:
9637 case ACCESSIBLE:
9638 case COPY:
9639 case DEFINE:
9640 case DISCONNECT:
9641 case HOST:
9642 case PRINT:
9643 case QUIT:
9644 case REMARK:
9645 case UNDEFINE:
9646 case VARIABLE:
9647 case WHENEVER:
9648 case ATTACH:
9649 case CAST:
9650 case TREAT:
9651 case TRIM:
9652 case LEFT:
9653 case RIGHT:
9654 case BOTH:
9655 case EMPTY:
9656 case MULTISET:
9657 case SUBMULTISET:
9658 case LEADING:
9659 case TRAILING:
9660 case CHAR_CS:
9661 case NCHAR_CS:
9662 case DBTIMEZONE:
9663 case SESSIONTIMEZONE:
9664 case AUTHENTICATED:
9665 case LINK:
9666 case SHARED:
9667 case DIRECTORY:
9668 case USER:
9669 case IDENTIFIER:
9670 case UNSIGNED_NUMERIC_LITERAL:
9671 case CHARACTER_LITERAL:
9672 case STRING_LITERAL:
9673 case QUOTED_LITERAL:
9674 Expression();
9675 jj_consume_token(4);
9676 break;
9677 default:
9678 jj_la1[120] = jj_gen;
9679 jj_consume_token(-1);
9680 throw new ParseException();
9681 }
9682 }
9683 jjtree.closeNodeScope(jjtn000, true);
9684 jjtc000 = false;
9685 {if (true) return jjtn000 ;}
9686 } catch (Throwable jjte000) {
9687 if (jjtc000) {
9688 jjtree.clearNodeScope(jjtn000);
9689 jjtc000 = false;
9690 } else {
9691 jjtree.popNode();
9692 }
9693 if (jjte000 instanceof RuntimeException) {
9694 {if (true) throw (RuntimeException)jjte000;}
9695 }
9696 if (jjte000 instanceof ParseException) {
9697 {if (true) throw (ParseException)jjte000;}
9698 }
9699 {if (true) throw (Error)jjte000;}
9700 } finally {
9701 if (jjtc000) {
9702 jjtree.closeNodeScope(jjtn000, true);
9703 }
9704 }
9705 throw new Error("Missing return statement in function");
9706 }
9707
9708 final public ASTStatement Statement() throws ParseException {
9709
9710 ASTStatement jjtn000 = new ASTStatement(this, JJTSTATEMENT);
9711 boolean jjtc000 = true;
9712 jjtree.openNodeScope(jjtn000);
9713 try {
9714 switch (jj_nt.kind) {
9715 case 21:
9716 LabelledStatement();
9717 break;
9718 case 5:
9719 case 16:
9720 case 17:
9721 case REPLACE:
9722 case DEFINER:
9723 case CURRENT_USER:
9724 case LANGUAGE:
9725 case INLINE:
9726 case ADD:
9727 case AGGREGATE:
9728 case ARRAY:
9729 case AT:
9730 case ATTRIBUTE:
9731 case AUTHID:
9732 case BEGIN:
9733 case BODY:
9734 case BULK:
9735 case BYTE:
9736 case CASCADE:
9737 case CASE:
9738 case CLOSE:
9739 case COALESCE:
9740 case COLLECT:
9741 case COLUMN:
9742 case COMMENT:
9743 case COMMIT:
9744 case CONSTRUCTOR:
9745 case CONTINUE:
9746 case CONVERT:
9747 case CURRENT:
9748 case CURSOR:
9749 case DATA:
9750 case DATE:
9751 case DAY:
9752 case DECLARE:
9753 case DELETE:
9754 case DISABLE:
9755 case EDITIONABLE:
9756 case ELEMENT:
9757 case ENABLE:
9758 case ESCAPE:
9759 case EXCEPT:
9760 case EXCEPTIONS:
9761 case EXECUTE:
9762 case EXIT:
9763 case EXTERNAL:
9764 case EXTENDS:
9765 case EXTRACT:
9766 case FALSE:
9767 case FETCH:
9768 case FINAL:
9769 case FOR:
9770 case FORALL:
9771 case FORCE:
9772 case FUNCTION:
9773 case GLOBAL:
9774 case GOTO:
9775 case HASH:
9776 case HEAP:
9777 case HOUR:
9778 case IF:
9779 case IMMEDIATE:
9780 case INDICES:
9781 case INDEXTYPE:
9782 case INDICATOR:
9783 case INSERT:
9784 case INSTANTIABLE:
9785 case INTERVAL:
9786 case INVALIDATE:
9787 case ISOLATION:
9788 case JAVA:
9789 case LEVEL:
9790 case LIMIT:
9791 case LOCK:
9792 case LOOP:
9793 case MAP:
9794 case MAX:
9795 case MEMBER:
9796 case MERGE:
9797 case MIN:
9798 case MINUTE:
9799 case MLSLABEL:
9800 case MODIFY:
9801 case MOD:
9802 case MONTH:
9803 case NATURAL:
9804 case NEW:
9805 case NEW_DOT:
9806 case NO:
9807 case NONEDITIONABLE:
9808 case NOT:
9809 case NULL:
9810 case NULLIF:
9811 case OBJECT:
9812 case OID:
9813 case OPAQUE:
9814 case OPEN:
9815 case OPERATOR:
9816 case ORGANIZATION:
9817 case OTHERS:
9818 case OVERRIDING:
9819 case PACKAGE:
9820 case PARTITION:
9821 case PIPE:
9822 case PRAGMA:
9823 case PRESERVE:
9824 case PRIVATE:
9825 case PROCEDURE:
9826 case RAISE:
9827 case RANGE:
9828 case RAW:
9829 case REAL:
9830 case RECORD:
9831 case REF:
9832 case RELEASE:
9833 case RELIES_ON:
9834 case RENAME:
9835 case RESULT:
9836 case RETURN:
9837 case RETURNING:
9838 case REVERSE:
9839 case ROLLBACK:
9840 case ROW:
9841 case ROWS:
9842 case ROWID:
9843 case ROWNUM:
9844 case SAVE:
9845 case SAVEPOINT:
9846 case SECOND:
9847 case SELECT:
9848 case SELF:
9849 case SET:
9850 case SPACE:
9851 case SQL:
9852 case SQLCODE:
9853 case SQLERRM:
9854 case STATIC:
9855 case SUBTYPE:
9856 case SUBSTITUTABLE:
9857 case SUCCESSFUL:
9858 case SYSDATE:
9859 case SYS_REFCURSOR:
9860 case TEMPORARY:
9861 case TIME:
9862 case TIMESTAMP:
9863 case TIMEZONE_REGION:
9864 case TIMEZONE_ABBR:
9865 case TIMEZONE_MINUTE:
9866 case TIMEZONE_HOUR:
9867 case TRANSACTION:
9868 case TRUE:
9869 case TYPE:
9870 case UNDER:
9871 case USING:
9872 case WHILE:
9873 case YES:
9874 case SHOW:
9875 case A:
9876 case UPDATE:
9877 case DOUBLE:
9878 case DEC:
9879 case PRECISION:
9880 case INT:
9881 case NUMERIC:
9882 case NCHAR:
9883 case NVARCHAR2:
9884 case STRING:
9885 case UROWID:
9886 case VARRAY:
9887 case VARYING:
9888 case BFILE:
9889 case BLOB:
9890 case CLOB:
9891 case NCLOB:
9892 case YEAR:
9893 case LOCAL:
9894 case WITH:
9895 case ZONE:
9896 case CHARACTER:
9897 case AFTER:
9898 case BEFORE:
9899 case OLD:
9900 case PARENT:
9901 case CC_IF:
9902 case CC_ERROR:
9903 case ANALYZE:
9904 case ASSOCIATE:
9905 case AUDIT:
9906 case COMPOUND:
9907 case DATABASE:
9908 case CALL:
9909 case DDL:
9910 case DISASSOCIATE:
9911 case EACH:
9912 case FOLLOWS:
9913 case LOGOFF:
9914 case LOGON:
9915 case NESTED:
9916 case NOAUDIT:
9917 case SCHEMA:
9918 case SERVERERROR:
9919 case SHUTDOWN:
9920 case STARTUP:
9921 case STATEMENT:
9922 case STATISTICS:
9923 case SUSPEND:
9924 case TRUNCATE:
9925 case WRAPPED:
9926 case LIBRARY:
9927 case NAME:
9928 case STRUCT:
9929 case CONTEXT:
9930 case PARAMETERS:
9931 case LENGTH:
9932 case TDO:
9933 case MAXLEN:
9934 case CHARSETID:
9935 case CHARSETFORM:
9936 case ACCEPT:
9937 case ACCESSIBLE:
9938 case COPY:
9939 case DEFINE:
9940 case DISCONNECT:
9941 case HOST:
9942 case PRINT:
9943 case QUIT:
9944 case REMARK:
9945 case UNDEFINE:
9946 case VARIABLE:
9947 case WHENEVER:
9948 case ATTACH:
9949 case CAST:
9950 case TREAT:
9951 case TRIM:
9952 case LEFT:
9953 case RIGHT:
9954 case BOTH:
9955 case EMPTY:
9956 case MULTISET:
9957 case SUBMULTISET:
9958 case LEADING:
9959 case TRAILING:
9960 case CHAR_CS:
9961 case NCHAR_CS:
9962 case DBTIMEZONE:
9963 case SESSIONTIMEZONE:
9964 case AUTHENTICATED:
9965 case LINK:
9966 case SHARED:
9967 case DIRECTORY:
9968 case USER:
9969 case IDENTIFIER:
9970 case UNSIGNED_NUMERIC_LITERAL:
9971 case CHARACTER_LITERAL:
9972 case STRING_LITERAL:
9973 case QUOTED_LITERAL:
9974 UnlabelledStatement();
9975 break;
9976 default:
9977 jj_la1[121] = jj_gen;
9978 jj_consume_token(-1);
9979 throw new ParseException();
9980 }
9981 jjtree.closeNodeScope(jjtn000, true);
9982 jjtc000 = false;
9983 {if (true) return jjtn000 ;}
9984 } catch (Throwable jjte000) {
9985 if (jjtc000) {
9986 jjtree.clearNodeScope(jjtn000);
9987 jjtc000 = false;
9988 } else {
9989 jjtree.popNode();
9990 }
9991 if (jjte000 instanceof RuntimeException) {
9992 {if (true) throw (RuntimeException)jjte000;}
9993 }
9994 if (jjte000 instanceof ParseException) {
9995 {if (true) throw (ParseException)jjte000;}
9996 }
9997 {if (true) throw (Error)jjte000;}
9998 } finally {
9999 if (jjtc000) {
10000 jjtree.closeNodeScope(jjtn000, true);
10001 }
10002 }
10003 throw new Error("Missing return statement in function");
10004 }
10005
10006
10007
10008
10009
10010 final public ASTLabelledStatement LabelledStatement() throws ParseException {
10011
10012 ASTLabelledStatement jjtn000 = new ASTLabelledStatement(this, JJTLABELLEDSTATEMENT);
10013 boolean jjtc000 = true;
10014 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
10015 try {
10016 label_24:
10017 while (true) {
10018 simpleNode = Label();
10019 switch (jj_nt.kind) {
10020 case 21:
10021 ;
10022 break;
10023 default:
10024 jj_la1[122] = jj_gen;
10025 break label_24;
10026 }
10027 }
10028 UnlabelledStatement();
10029 jjtree.closeNodeScope(jjtn000, true);
10030 jjtc000 = false;
10031 jjtn000.setImage( simpleNode.getImage() ) ;
10032 {if (true) return jjtn000 ;}
10033 } catch (Throwable jjte000) {
10034 if (jjtc000) {
10035 jjtree.clearNodeScope(jjtn000);
10036 jjtc000 = false;
10037 } else {
10038 jjtree.popNode();
10039 }
10040 if (jjte000 instanceof RuntimeException) {
10041 {if (true) throw (RuntimeException)jjte000;}
10042 }
10043 if (jjte000 instanceof ParseException) {
10044 {if (true) throw (ParseException)jjte000;}
10045 }
10046 {if (true) throw (Error)jjte000;}
10047 } finally {
10048 if (jjtc000) {
10049 jjtree.closeNodeScope(jjtn000, true);
10050 }
10051 }
10052 throw new Error("Missing return statement in function");
10053 }
10054
10055 final public ASTCaseStatement CaseStatement() throws ParseException {
10056
10057 ASTCaseStatement jjtn000 = new ASTCaseStatement(this, JJTCASESTATEMENT);
10058 boolean jjtc000 = true;
10059 jjtree.openNodeScope(jjtn000);
10060 try {
10061 jj_consume_token(CASE);
10062 switch (jj_nt.kind) {
10063 case 5:
10064 case 16:
10065 case 17:
10066 case REPLACE:
10067 case DEFINER:
10068 case CURRENT_USER:
10069 case LANGUAGE:
10070 case INLINE:
10071 case ADD:
10072 case AGGREGATE:
10073 case ARRAY:
10074 case AT:
10075 case ATTRIBUTE:
10076 case AUTHID:
10077 case BODY:
10078 case BULK:
10079 case BYTE:
10080 case CASCADE:
10081 case CASE:
10082 case CLOSE:
10083 case COALESCE:
10084 case COLLECT:
10085 case COLUMN:
10086 case COMMENT:
10087 case COMMIT:
10088 case CONSTRUCTOR:
10089 case CONTINUE:
10090 case CONVERT:
10091 case CURRENT:
10092 case CURSOR:
10093 case DATA:
10094 case DATE:
10095 case DAY:
10096 case DISABLE:
10097 case EDITIONABLE:
10098 case ELEMENT:
10099 case ENABLE:
10100 case ESCAPE:
10101 case EXCEPT:
10102 case EXCEPTIONS:
10103 case EXIT:
10104 case EXTERNAL:
10105 case EXTENDS:
10106 case EXTRACT:
10107 case FALSE:
10108 case FINAL:
10109 case FORCE:
10110 case FUNCTION:
10111 case GLOBAL:
10112 case HASH:
10113 case HEAP:
10114 case HOUR:
10115 case IMMEDIATE:
10116 case INDICES:
10117 case INDEXTYPE:
10118 case INDICATOR:
10119 case INSTANTIABLE:
10120 case INTERVAL:
10121 case INVALIDATE:
10122 case ISOLATION:
10123 case JAVA:
10124 case LEVEL:
10125 case LIMIT:
10126 case LOOP:
10127 case MAP:
10128 case MAX:
10129 case MEMBER:
10130 case MERGE:
10131 case MIN:
10132 case MINUTE:
10133 case MLSLABEL:
10134 case MODIFY:
10135 case MOD:
10136 case MONTH:
10137 case NATURAL:
10138 case NEW:
10139 case NEW_DOT:
10140 case NO:
10141 case NONEDITIONABLE:
10142 case NOT:
10143 case NULL:
10144 case NULLIF:
10145 case OBJECT:
10146 case OID:
10147 case OPAQUE:
10148 case OPEN:
10149 case OPERATOR:
10150 case ORGANIZATION:
10151 case OTHERS:
10152 case OVERRIDING:
10153 case PACKAGE:
10154 case PARTITION:
10155 case PRESERVE:
10156 case PRIVATE:
10157 case PROCEDURE:
10158 case RANGE:
10159 case RAW:
10160 case REAL:
10161 case RECORD:
10162 case REF:
10163 case RELEASE:
10164 case RELIES_ON:
10165 case RENAME:
10166 case RESULT:
10167 case RETURN:
10168 case RETURNING:
10169 case REVERSE:
10170 case ROLLBACK:
10171 case ROW:
10172 case ROWS:
10173 case ROWID:
10174 case ROWNUM:
10175 case SAVE:
10176 case SAVEPOINT:
10177 case SECOND:
10178 case SELECT:
10179 case SELF:
10180 case SET:
10181 case SPACE:
10182 case SQL:
10183 case SQLCODE:
10184 case SQLERRM:
10185 case STATIC:
10186 case SUBTYPE:
10187 case SUBSTITUTABLE:
10188 case SUCCESSFUL:
10189 case SYSDATE:
10190 case SYS_REFCURSOR:
10191 case TEMPORARY:
10192 case TIME:
10193 case TIMESTAMP:
10194 case TIMEZONE_REGION:
10195 case TIMEZONE_ABBR:
10196 case TIMEZONE_MINUTE:
10197 case TIMEZONE_HOUR:
10198 case TRANSACTION:
10199 case TRUE:
10200 case TYPE:
10201 case UNDER:
10202 case USING:
10203 case YES:
10204 case SHOW:
10205 case A:
10206 case DOUBLE:
10207 case DEC:
10208 case PRECISION:
10209 case INT:
10210 case NUMERIC:
10211 case NCHAR:
10212 case NVARCHAR2:
10213 case STRING:
10214 case UROWID:
10215 case VARRAY:
10216 case VARYING:
10217 case BFILE:
10218 case BLOB:
10219 case CLOB:
10220 case NCLOB:
10221 case YEAR:
10222 case LOCAL:
10223 case WITH:
10224 case ZONE:
10225 case CHARACTER:
10226 case AFTER:
10227 case BEFORE:
10228 case OLD:
10229 case PARENT:
10230 case CC_IF:
10231 case ANALYZE:
10232 case ASSOCIATE:
10233 case AUDIT:
10234 case COMPOUND:
10235 case DATABASE:
10236 case CALL:
10237 case DDL:
10238 case DISASSOCIATE:
10239 case EACH:
10240 case FOLLOWS:
10241 case LOGOFF:
10242 case LOGON:
10243 case NESTED:
10244 case NOAUDIT:
10245 case SCHEMA:
10246 case SERVERERROR:
10247 case SHUTDOWN:
10248 case STARTUP:
10249 case STATEMENT:
10250 case STATISTICS:
10251 case SUSPEND:
10252 case TRUNCATE:
10253 case WRAPPED:
10254 case LIBRARY:
10255 case NAME:
10256 case STRUCT:
10257 case CONTEXT:
10258 case PARAMETERS:
10259 case LENGTH:
10260 case TDO:
10261 case MAXLEN:
10262 case CHARSETID:
10263 case CHARSETFORM:
10264 case ACCEPT:
10265 case ACCESSIBLE:
10266 case COPY:
10267 case DEFINE:
10268 case DISCONNECT:
10269 case HOST:
10270 case PRINT:
10271 case QUIT:
10272 case REMARK:
10273 case UNDEFINE:
10274 case VARIABLE:
10275 case WHENEVER:
10276 case ATTACH:
10277 case CAST:
10278 case TREAT:
10279 case TRIM:
10280 case LEFT:
10281 case RIGHT:
10282 case BOTH:
10283 case EMPTY:
10284 case MULTISET:
10285 case SUBMULTISET:
10286 case LEADING:
10287 case TRAILING:
10288 case CHAR_CS:
10289 case NCHAR_CS:
10290 case DBTIMEZONE:
10291 case SESSIONTIMEZONE:
10292 case AUTHENTICATED:
10293 case LINK:
10294 case SHARED:
10295 case DIRECTORY:
10296 case USER:
10297 case IDENTIFIER:
10298 case UNSIGNED_NUMERIC_LITERAL:
10299 case CHARACTER_LITERAL:
10300 case STRING_LITERAL:
10301 case QUOTED_LITERAL:
10302 Expression();
10303 break;
10304 default:
10305 jj_la1[123] = jj_gen;
10306 ;
10307 }
10308 label_25:
10309 while (true) {
10310 switch (jj_nt.kind) {
10311 case WHEN:
10312 ;
10313 break;
10314 default:
10315 jj_la1[124] = jj_gen;
10316 break label_25;
10317 }
10318 CaseWhenClause();
10319 }
10320 switch (jj_nt.kind) {
10321 case ELSE:
10322 ElseClause();
10323 break;
10324 default:
10325 jj_la1[125] = jj_gen;
10326 ;
10327 }
10328 jj_consume_token(END);
10329 jj_consume_token(CASE);
10330 switch (jj_nt.kind) {
10331 case IDENTIFIER:
10332 jj_consume_token(IDENTIFIER);
10333 break;
10334 default:
10335 jj_la1[126] = jj_gen;
10336 ;
10337 }
10338 jjtree.closeNodeScope(jjtn000, true);
10339 jjtc000 = false;
10340 {if (true) return jjtn000 ;}
10341 } catch (Throwable jjte000) {
10342 if (jjtc000) {
10343 jjtree.clearNodeScope(jjtn000);
10344 jjtc000 = false;
10345 } else {
10346 jjtree.popNode();
10347 }
10348 if (jjte000 instanceof RuntimeException) {
10349 {if (true) throw (RuntimeException)jjte000;}
10350 }
10351 if (jjte000 instanceof ParseException) {
10352 {if (true) throw (ParseException)jjte000;}
10353 }
10354 {if (true) throw (Error)jjte000;}
10355 } finally {
10356 if (jjtc000) {
10357 jjtree.closeNodeScope(jjtn000, true);
10358 }
10359 }
10360 throw new Error("Missing return statement in function");
10361 }
10362
10363 final public ASTCaseWhenClause CaseWhenClause() throws ParseException {
10364
10365 ASTCaseWhenClause jjtn000 = new ASTCaseWhenClause(this, JJTCASEWHENCLAUSE);
10366 boolean jjtc000 = true;
10367 jjtree.openNodeScope(jjtn000);
10368 try {
10369 jj_consume_token(WHEN);
10370 Expression();
10371 jj_consume_token(THEN);
10372 label_26:
10373 while (true) {
10374 Statement();
10375 switch (jj_nt.kind) {
10376 case 5:
10377 case 16:
10378 case 17:
10379 case 21:
10380 case REPLACE:
10381 case DEFINER:
10382 case CURRENT_USER:
10383 case LANGUAGE:
10384 case INLINE:
10385 case ADD:
10386 case AGGREGATE:
10387 case ARRAY:
10388 case AT:
10389 case ATTRIBUTE:
10390 case AUTHID:
10391 case BEGIN:
10392 case BODY:
10393 case BULK:
10394 case BYTE:
10395 case CASCADE:
10396 case CASE:
10397 case CLOSE:
10398 case COALESCE:
10399 case COLLECT:
10400 case COLUMN:
10401 case COMMENT:
10402 case COMMIT:
10403 case CONSTRUCTOR:
10404 case CONTINUE:
10405 case CONVERT:
10406 case CURRENT:
10407 case CURSOR:
10408 case DATA:
10409 case DATE:
10410 case DAY:
10411 case DECLARE:
10412 case DELETE:
10413 case DISABLE:
10414 case EDITIONABLE:
10415 case ELEMENT:
10416 case ENABLE:
10417 case ESCAPE:
10418 case EXCEPT:
10419 case EXCEPTIONS:
10420 case EXECUTE:
10421 case EXIT:
10422 case EXTERNAL:
10423 case EXTENDS:
10424 case EXTRACT:
10425 case FALSE:
10426 case FETCH:
10427 case FINAL:
10428 case FOR:
10429 case FORALL:
10430 case FORCE:
10431 case FUNCTION:
10432 case GLOBAL:
10433 case GOTO:
10434 case HASH:
10435 case HEAP:
10436 case HOUR:
10437 case IF:
10438 case IMMEDIATE:
10439 case INDICES:
10440 case INDEXTYPE:
10441 case INDICATOR:
10442 case INSERT:
10443 case INSTANTIABLE:
10444 case INTERVAL:
10445 case INVALIDATE:
10446 case ISOLATION:
10447 case JAVA:
10448 case LEVEL:
10449 case LIMIT:
10450 case LOCK:
10451 case LOOP:
10452 case MAP:
10453 case MAX:
10454 case MEMBER:
10455 case MERGE:
10456 case MIN:
10457 case MINUTE:
10458 case MLSLABEL:
10459 case MODIFY:
10460 case MOD:
10461 case MONTH:
10462 case NATURAL:
10463 case NEW:
10464 case NEW_DOT:
10465 case NO:
10466 case NONEDITIONABLE:
10467 case NOT:
10468 case NULL:
10469 case NULLIF:
10470 case OBJECT:
10471 case OID:
10472 case OPAQUE:
10473 case OPEN:
10474 case OPERATOR:
10475 case ORGANIZATION:
10476 case OTHERS:
10477 case OVERRIDING:
10478 case PACKAGE:
10479 case PARTITION:
10480 case PIPE:
10481 case PRAGMA:
10482 case PRESERVE:
10483 case PRIVATE:
10484 case PROCEDURE:
10485 case RAISE:
10486 case RANGE:
10487 case RAW:
10488 case REAL:
10489 case RECORD:
10490 case REF:
10491 case RELEASE:
10492 case RELIES_ON:
10493 case RENAME:
10494 case RESULT:
10495 case RETURN:
10496 case RETURNING:
10497 case REVERSE:
10498 case ROLLBACK:
10499 case ROW:
10500 case ROWS:
10501 case ROWID:
10502 case ROWNUM:
10503 case SAVE:
10504 case SAVEPOINT:
10505 case SECOND:
10506 case SELECT:
10507 case SELF:
10508 case SET:
10509 case SPACE:
10510 case SQL:
10511 case SQLCODE:
10512 case SQLERRM:
10513 case STATIC:
10514 case SUBTYPE:
10515 case SUBSTITUTABLE:
10516 case SUCCESSFUL:
10517 case SYSDATE:
10518 case SYS_REFCURSOR:
10519 case TEMPORARY:
10520 case TIME:
10521 case TIMESTAMP:
10522 case TIMEZONE_REGION:
10523 case TIMEZONE_ABBR:
10524 case TIMEZONE_MINUTE:
10525 case TIMEZONE_HOUR:
10526 case TRANSACTION:
10527 case TRUE:
10528 case TYPE:
10529 case UNDER:
10530 case USING:
10531 case WHILE:
10532 case YES:
10533 case SHOW:
10534 case A:
10535 case UPDATE:
10536 case DOUBLE:
10537 case DEC:
10538 case PRECISION:
10539 case INT:
10540 case NUMERIC:
10541 case NCHAR:
10542 case NVARCHAR2:
10543 case STRING:
10544 case UROWID:
10545 case VARRAY:
10546 case VARYING:
10547 case BFILE:
10548 case BLOB:
10549 case CLOB:
10550 case NCLOB:
10551 case YEAR:
10552 case LOCAL:
10553 case WITH:
10554 case ZONE:
10555 case CHARACTER:
10556 case AFTER:
10557 case BEFORE:
10558 case OLD:
10559 case PARENT:
10560 case CC_IF:
10561 case CC_ERROR:
10562 case ANALYZE:
10563 case ASSOCIATE:
10564 case AUDIT:
10565 case COMPOUND:
10566 case DATABASE:
10567 case CALL:
10568 case DDL:
10569 case DISASSOCIATE:
10570 case EACH:
10571 case FOLLOWS:
10572 case LOGOFF:
10573 case LOGON:
10574 case NESTED:
10575 case NOAUDIT:
10576 case SCHEMA:
10577 case SERVERERROR:
10578 case SHUTDOWN:
10579 case STARTUP:
10580 case STATEMENT:
10581 case STATISTICS:
10582 case SUSPEND:
10583 case TRUNCATE:
10584 case WRAPPED:
10585 case LIBRARY:
10586 case NAME:
10587 case STRUCT:
10588 case CONTEXT:
10589 case PARAMETERS:
10590 case LENGTH:
10591 case TDO:
10592 case MAXLEN:
10593 case CHARSETID:
10594 case CHARSETFORM:
10595 case ACCEPT:
10596 case ACCESSIBLE:
10597 case COPY:
10598 case DEFINE:
10599 case DISCONNECT:
10600 case HOST:
10601 case PRINT:
10602 case QUIT:
10603 case REMARK:
10604 case UNDEFINE:
10605 case VARIABLE:
10606 case WHENEVER:
10607 case ATTACH:
10608 case CAST:
10609 case TREAT:
10610 case TRIM:
10611 case LEFT:
10612 case RIGHT:
10613 case BOTH:
10614 case EMPTY:
10615 case MULTISET:
10616 case SUBMULTISET:
10617 case LEADING:
10618 case TRAILING:
10619 case CHAR_CS:
10620 case NCHAR_CS:
10621 case DBTIMEZONE:
10622 case SESSIONTIMEZONE:
10623 case AUTHENTICATED:
10624 case LINK:
10625 case SHARED:
10626 case DIRECTORY:
10627 case USER:
10628 case IDENTIFIER:
10629 case UNSIGNED_NUMERIC_LITERAL:
10630 case CHARACTER_LITERAL:
10631 case STRING_LITERAL:
10632 case QUOTED_LITERAL:
10633 ;
10634 break;
10635 default:
10636 jj_la1[127] = jj_gen;
10637 break label_26;
10638 }
10639 }
10640 jjtree.closeNodeScope(jjtn000, true);
10641 jjtc000 = false;
10642 {if (true) return jjtn000 ;}
10643 } catch (Throwable jjte000) {
10644 if (jjtc000) {
10645 jjtree.clearNodeScope(jjtn000);
10646 jjtc000 = false;
10647 } else {
10648 jjtree.popNode();
10649 }
10650 if (jjte000 instanceof RuntimeException) {
10651 {if (true) throw (RuntimeException)jjte000;}
10652 }
10653 if (jjte000 instanceof ParseException) {
10654 {if (true) throw (ParseException)jjte000;}
10655 }
10656 {if (true) throw (Error)jjte000;}
10657 } finally {
10658 if (jjtc000) {
10659 jjtree.closeNodeScope(jjtn000, true);
10660 }
10661 }
10662 throw new Error("Missing return statement in function");
10663 }
10664
10665 final public ASTElseClause ElseClause() throws ParseException {
10666
10667 ASTElseClause jjtn000 = new ASTElseClause(this, JJTELSECLAUSE);
10668 boolean jjtc000 = true;
10669 jjtree.openNodeScope(jjtn000);
10670 try {
10671 jj_consume_token(ELSE);
10672 label_27:
10673 while (true) {
10674 Statement();
10675 switch (jj_nt.kind) {
10676 case 5:
10677 case 16:
10678 case 17:
10679 case 21:
10680 case REPLACE:
10681 case DEFINER:
10682 case CURRENT_USER:
10683 case LANGUAGE:
10684 case INLINE:
10685 case ADD:
10686 case AGGREGATE:
10687 case ARRAY:
10688 case AT:
10689 case ATTRIBUTE:
10690 case AUTHID:
10691 case BEGIN:
10692 case BODY:
10693 case BULK:
10694 case BYTE:
10695 case CASCADE:
10696 case CASE:
10697 case CLOSE:
10698 case COALESCE:
10699 case COLLECT:
10700 case COLUMN:
10701 case COMMENT:
10702 case COMMIT:
10703 case CONSTRUCTOR:
10704 case CONTINUE:
10705 case CONVERT:
10706 case CURRENT:
10707 case CURSOR:
10708 case DATA:
10709 case DATE:
10710 case DAY:
10711 case DECLARE:
10712 case DELETE:
10713 case DISABLE:
10714 case EDITIONABLE:
10715 case ELEMENT:
10716 case ENABLE:
10717 case ESCAPE:
10718 case EXCEPT:
10719 case EXCEPTIONS:
10720 case EXECUTE:
10721 case EXIT:
10722 case EXTERNAL:
10723 case EXTENDS:
10724 case EXTRACT:
10725 case FALSE:
10726 case FETCH:
10727 case FINAL:
10728 case FOR:
10729 case FORALL:
10730 case FORCE:
10731 case FUNCTION:
10732 case GLOBAL:
10733 case GOTO:
10734 case HASH:
10735 case HEAP:
10736 case HOUR:
10737 case IF:
10738 case IMMEDIATE:
10739 case INDICES:
10740 case INDEXTYPE:
10741 case INDICATOR:
10742 case INSERT:
10743 case INSTANTIABLE:
10744 case INTERVAL:
10745 case INVALIDATE:
10746 case ISOLATION:
10747 case JAVA:
10748 case LEVEL:
10749 case LIMIT:
10750 case LOCK:
10751 case LOOP:
10752 case MAP:
10753 case MAX:
10754 case MEMBER:
10755 case MERGE:
10756 case MIN:
10757 case MINUTE:
10758 case MLSLABEL:
10759 case MODIFY:
10760 case MOD:
10761 case MONTH:
10762 case NATURAL:
10763 case NEW:
10764 case NEW_DOT:
10765 case NO:
10766 case NONEDITIONABLE:
10767 case NOT:
10768 case NULL:
10769 case NULLIF:
10770 case OBJECT:
10771 case OID:
10772 case OPAQUE:
10773 case OPEN:
10774 case OPERATOR:
10775 case ORGANIZATION:
10776 case OTHERS:
10777 case OVERRIDING:
10778 case PACKAGE:
10779 case PARTITION:
10780 case PIPE:
10781 case PRAGMA:
10782 case PRESERVE:
10783 case PRIVATE:
10784 case PROCEDURE:
10785 case RAISE:
10786 case RANGE:
10787 case RAW:
10788 case REAL:
10789 case RECORD:
10790 case REF:
10791 case RELEASE:
10792 case RELIES_ON:
10793 case RENAME:
10794 case RESULT:
10795 case RETURN:
10796 case RETURNING:
10797 case REVERSE:
10798 case ROLLBACK:
10799 case ROW:
10800 case ROWS:
10801 case ROWID:
10802 case ROWNUM:
10803 case SAVE:
10804 case SAVEPOINT:
10805 case SECOND:
10806 case SELECT:
10807 case SELF:
10808 case SET:
10809 case SPACE:
10810 case SQL:
10811 case SQLCODE:
10812 case SQLERRM:
10813 case STATIC:
10814 case SUBTYPE:
10815 case SUBSTITUTABLE:
10816 case SUCCESSFUL:
10817 case SYSDATE:
10818 case SYS_REFCURSOR:
10819 case TEMPORARY:
10820 case TIME:
10821 case TIMESTAMP:
10822 case TIMEZONE_REGION:
10823 case TIMEZONE_ABBR:
10824 case TIMEZONE_MINUTE:
10825 case TIMEZONE_HOUR:
10826 case TRANSACTION:
10827 case TRUE:
10828 case TYPE:
10829 case UNDER:
10830 case USING:
10831 case WHILE:
10832 case YES:
10833 case SHOW:
10834 case A:
10835 case UPDATE:
10836 case DOUBLE:
10837 case DEC:
10838 case PRECISION:
10839 case INT:
10840 case NUMERIC:
10841 case NCHAR:
10842 case NVARCHAR2:
10843 case STRING:
10844 case UROWID:
10845 case VARRAY:
10846 case VARYING:
10847 case BFILE:
10848 case BLOB:
10849 case CLOB:
10850 case NCLOB:
10851 case YEAR:
10852 case LOCAL:
10853 case WITH:
10854 case ZONE:
10855 case CHARACTER:
10856 case AFTER:
10857 case BEFORE:
10858 case OLD:
10859 case PARENT:
10860 case CC_IF:
10861 case CC_ERROR:
10862 case ANALYZE:
10863 case ASSOCIATE:
10864 case AUDIT:
10865 case COMPOUND:
10866 case DATABASE:
10867 case CALL:
10868 case DDL:
10869 case DISASSOCIATE:
10870 case EACH:
10871 case FOLLOWS:
10872 case LOGOFF:
10873 case LOGON:
10874 case NESTED:
10875 case NOAUDIT:
10876 case SCHEMA:
10877 case SERVERERROR:
10878 case SHUTDOWN:
10879 case STARTUP:
10880 case STATEMENT:
10881 case STATISTICS:
10882 case SUSPEND:
10883 case TRUNCATE:
10884 case WRAPPED:
10885 case LIBRARY:
10886 case NAME:
10887 case STRUCT:
10888 case CONTEXT:
10889 case PARAMETERS:
10890 case LENGTH:
10891 case TDO:
10892 case MAXLEN:
10893 case CHARSETID:
10894 case CHARSETFORM:
10895 case ACCEPT:
10896 case ACCESSIBLE:
10897 case COPY:
10898 case DEFINE:
10899 case DISCONNECT:
10900 case HOST:
10901 case PRINT:
10902 case QUIT:
10903 case REMARK:
10904 case UNDEFINE:
10905 case VARIABLE:
10906 case WHENEVER:
10907 case ATTACH:
10908 case CAST:
10909 case TREAT:
10910 case TRIM:
10911 case LEFT:
10912 case RIGHT:
10913 case BOTH:
10914 case EMPTY:
10915 case MULTISET:
10916 case SUBMULTISET:
10917 case LEADING:
10918 case TRAILING:
10919 case CHAR_CS:
10920 case NCHAR_CS:
10921 case DBTIMEZONE:
10922 case SESSIONTIMEZONE:
10923 case AUTHENTICATED:
10924 case LINK:
10925 case SHARED:
10926 case DIRECTORY:
10927 case USER:
10928 case IDENTIFIER:
10929 case UNSIGNED_NUMERIC_LITERAL:
10930 case CHARACTER_LITERAL:
10931 case STRING_LITERAL:
10932 case QUOTED_LITERAL:
10933 ;
10934 break;
10935 default:
10936 jj_la1[128] = jj_gen;
10937 break label_27;
10938 }
10939 }
10940 jjtree.closeNodeScope(jjtn000, true);
10941 jjtc000 = false;
10942 {if (true) return jjtn000 ;}
10943 } catch (Throwable jjte000) {
10944 if (jjtc000) {
10945 jjtree.clearNodeScope(jjtn000);
10946 jjtc000 = false;
10947 } else {
10948 jjtree.popNode();
10949 }
10950 if (jjte000 instanceof RuntimeException) {
10951 {if (true) throw (RuntimeException)jjte000;}
10952 }
10953 if (jjte000 instanceof ParseException) {
10954 {if (true) throw (ParseException)jjte000;}
10955 }
10956 {if (true) throw (Error)jjte000;}
10957 } finally {
10958 if (jjtc000) {
10959 jjtree.closeNodeScope(jjtn000, true);
10960 }
10961 }
10962 throw new Error("Missing return statement in function");
10963 }
10964
10965 final public ASTElsifClause ElsifClause() throws ParseException {
10966
10967 ASTElsifClause jjtn000 = new ASTElsifClause(this, JJTELSIFCLAUSE);
10968 boolean jjtc000 = true;
10969 jjtree.openNodeScope(jjtn000);
10970 try {
10971 jj_consume_token(ELSIF);
10972 Expression();
10973 jj_consume_token(THEN);
10974 label_28:
10975 while (true) {
10976 Statement();
10977 switch (jj_nt.kind) {
10978 case 5:
10979 case 16:
10980 case 17:
10981 case 21:
10982 case REPLACE:
10983 case DEFINER:
10984 case CURRENT_USER:
10985 case LANGUAGE:
10986 case INLINE:
10987 case ADD:
10988 case AGGREGATE:
10989 case ARRAY:
10990 case AT:
10991 case ATTRIBUTE:
10992 case AUTHID:
10993 case BEGIN:
10994 case BODY:
10995 case BULK:
10996 case BYTE:
10997 case CASCADE:
10998 case CASE:
10999 case CLOSE:
11000 case COALESCE:
11001 case COLLECT:
11002 case COLUMN:
11003 case COMMENT:
11004 case COMMIT:
11005 case CONSTRUCTOR:
11006 case CONTINUE:
11007 case CONVERT:
11008 case CURRENT:
11009 case CURSOR:
11010 case DATA:
11011 case DATE:
11012 case DAY:
11013 case DECLARE:
11014 case DELETE:
11015 case DISABLE:
11016 case EDITIONABLE:
11017 case ELEMENT:
11018 case ENABLE:
11019 case ESCAPE:
11020 case EXCEPT:
11021 case EXCEPTIONS:
11022 case EXECUTE:
11023 case EXIT:
11024 case EXTERNAL:
11025 case EXTENDS:
11026 case EXTRACT:
11027 case FALSE:
11028 case FETCH:
11029 case FINAL:
11030 case FOR:
11031 case FORALL:
11032 case FORCE:
11033 case FUNCTION:
11034 case GLOBAL:
11035 case GOTO:
11036 case HASH:
11037 case HEAP:
11038 case HOUR:
11039 case IF:
11040 case IMMEDIATE:
11041 case INDICES:
11042 case INDEXTYPE:
11043 case INDICATOR:
11044 case INSERT:
11045 case INSTANTIABLE:
11046 case INTERVAL:
11047 case INVALIDATE:
11048 case ISOLATION:
11049 case JAVA:
11050 case LEVEL:
11051 case LIMIT:
11052 case LOCK:
11053 case LOOP:
11054 case MAP:
11055 case MAX:
11056 case MEMBER:
11057 case MERGE:
11058 case MIN:
11059 case MINUTE:
11060 case MLSLABEL:
11061 case MODIFY:
11062 case MOD:
11063 case MONTH:
11064 case NATURAL:
11065 case NEW:
11066 case NEW_DOT:
11067 case NO:
11068 case NONEDITIONABLE:
11069 case NOT:
11070 case NULL:
11071 case NULLIF:
11072 case OBJECT:
11073 case OID:
11074 case OPAQUE:
11075 case OPEN:
11076 case OPERATOR:
11077 case ORGANIZATION:
11078 case OTHERS:
11079 case OVERRIDING:
11080 case PACKAGE:
11081 case PARTITION:
11082 case PIPE:
11083 case PRAGMA:
11084 case PRESERVE:
11085 case PRIVATE:
11086 case PROCEDURE:
11087 case RAISE:
11088 case RANGE:
11089 case RAW:
11090 case REAL:
11091 case RECORD:
11092 case REF:
11093 case RELEASE:
11094 case RELIES_ON:
11095 case RENAME:
11096 case RESULT:
11097 case RETURN:
11098 case RETURNING:
11099 case REVERSE:
11100 case ROLLBACK:
11101 case ROW:
11102 case ROWS:
11103 case ROWID:
11104 case ROWNUM:
11105 case SAVE:
11106 case SAVEPOINT:
11107 case SECOND:
11108 case SELECT:
11109 case SELF:
11110 case SET:
11111 case SPACE:
11112 case SQL:
11113 case SQLCODE:
11114 case SQLERRM:
11115 case STATIC:
11116 case SUBTYPE:
11117 case SUBSTITUTABLE:
11118 case SUCCESSFUL:
11119 case SYSDATE:
11120 case SYS_REFCURSOR:
11121 case TEMPORARY:
11122 case TIME:
11123 case TIMESTAMP:
11124 case TIMEZONE_REGION:
11125 case TIMEZONE_ABBR:
11126 case TIMEZONE_MINUTE:
11127 case TIMEZONE_HOUR:
11128 case TRANSACTION:
11129 case TRUE:
11130 case TYPE:
11131 case UNDER:
11132 case USING:
11133 case WHILE:
11134 case YES:
11135 case SHOW:
11136 case A:
11137 case UPDATE:
11138 case DOUBLE:
11139 case DEC:
11140 case PRECISION:
11141 case INT:
11142 case NUMERIC:
11143 case NCHAR:
11144 case NVARCHAR2:
11145 case STRING:
11146 case UROWID:
11147 case VARRAY:
11148 case VARYING:
11149 case BFILE:
11150 case BLOB:
11151 case CLOB:
11152 case NCLOB:
11153 case YEAR:
11154 case LOCAL:
11155 case WITH:
11156 case ZONE:
11157 case CHARACTER:
11158 case AFTER:
11159 case BEFORE:
11160 case OLD:
11161 case PARENT:
11162 case CC_IF:
11163 case CC_ERROR:
11164 case ANALYZE:
11165 case ASSOCIATE:
11166 case AUDIT:
11167 case COMPOUND:
11168 case DATABASE:
11169 case CALL:
11170 case DDL:
11171 case DISASSOCIATE:
11172 case EACH:
11173 case FOLLOWS:
11174 case LOGOFF:
11175 case LOGON:
11176 case NESTED:
11177 case NOAUDIT:
11178 case SCHEMA:
11179 case SERVERERROR:
11180 case SHUTDOWN:
11181 case STARTUP:
11182 case STATEMENT:
11183 case STATISTICS:
11184 case SUSPEND:
11185 case TRUNCATE:
11186 case WRAPPED:
11187 case LIBRARY:
11188 case NAME:
11189 case STRUCT:
11190 case CONTEXT:
11191 case PARAMETERS:
11192 case LENGTH:
11193 case TDO:
11194 case MAXLEN:
11195 case CHARSETID:
11196 case CHARSETFORM:
11197 case ACCEPT:
11198 case ACCESSIBLE:
11199 case COPY:
11200 case DEFINE:
11201 case DISCONNECT:
11202 case HOST:
11203 case PRINT:
11204 case QUIT:
11205 case REMARK:
11206 case UNDEFINE:
11207 case VARIABLE:
11208 case WHENEVER:
11209 case ATTACH:
11210 case CAST:
11211 case TREAT:
11212 case TRIM:
11213 case LEFT:
11214 case RIGHT:
11215 case BOTH:
11216 case EMPTY:
11217 case MULTISET:
11218 case SUBMULTISET:
11219 case LEADING:
11220 case TRAILING:
11221 case CHAR_CS:
11222 case NCHAR_CS:
11223 case DBTIMEZONE:
11224 case SESSIONTIMEZONE:
11225 case AUTHENTICATED:
11226 case LINK:
11227 case SHARED:
11228 case DIRECTORY:
11229 case USER:
11230 case IDENTIFIER:
11231 case UNSIGNED_NUMERIC_LITERAL:
11232 case CHARACTER_LITERAL:
11233 case STRING_LITERAL:
11234 case QUOTED_LITERAL:
11235 ;
11236 break;
11237 default:
11238 jj_la1[129] = jj_gen;
11239 break label_28;
11240 }
11241 }
11242 jjtree.closeNodeScope(jjtn000, true);
11243 jjtc000 = false;
11244 {if (true) return jjtn000 ;}
11245 } catch (Throwable jjte000) {
11246 if (jjtc000) {
11247 jjtree.clearNodeScope(jjtn000);
11248 jjtc000 = false;
11249 } else {
11250 jjtree.popNode();
11251 }
11252 if (jjte000 instanceof RuntimeException) {
11253 {if (true) throw (RuntimeException)jjte000;}
11254 }
11255 if (jjte000 instanceof ParseException) {
11256 {if (true) throw (ParseException)jjte000;}
11257 }
11258 {if (true) throw (Error)jjte000;}
11259 } finally {
11260 if (jjtc000) {
11261 jjtree.closeNodeScope(jjtn000, true);
11262 }
11263 }
11264 throw new Error("Missing return statement in function");
11265 }
11266
11267 final public ASTLoopStatement LoopStatement() throws ParseException {
11268
11269 ASTLoopStatement jjtn000 = new ASTLoopStatement(this, JJTLOOPSTATEMENT);
11270 boolean jjtc000 = true;
11271 jjtree.openNodeScope(jjtn000);
11272 try {
11273 jj_consume_token(LOOP);
11274 label_29:
11275 while (true) {
11276 Statement();
11277 switch (jj_nt.kind) {
11278 case 5:
11279 case 16:
11280 case 17:
11281 case 21:
11282 case REPLACE:
11283 case DEFINER:
11284 case CURRENT_USER:
11285 case LANGUAGE:
11286 case INLINE:
11287 case ADD:
11288 case AGGREGATE:
11289 case ARRAY:
11290 case AT:
11291 case ATTRIBUTE:
11292 case AUTHID:
11293 case BEGIN:
11294 case BODY:
11295 case BULK:
11296 case BYTE:
11297 case CASCADE:
11298 case CASE:
11299 case CLOSE:
11300 case COALESCE:
11301 case COLLECT:
11302 case COLUMN:
11303 case COMMENT:
11304 case COMMIT:
11305 case CONSTRUCTOR:
11306 case CONTINUE:
11307 case CONVERT:
11308 case CURRENT:
11309 case CURSOR:
11310 case DATA:
11311 case DATE:
11312 case DAY:
11313 case DECLARE:
11314 case DELETE:
11315 case DISABLE:
11316 case EDITIONABLE:
11317 case ELEMENT:
11318 case ENABLE:
11319 case ESCAPE:
11320 case EXCEPT:
11321 case EXCEPTIONS:
11322 case EXECUTE:
11323 case EXIT:
11324 case EXTERNAL:
11325 case EXTENDS:
11326 case EXTRACT:
11327 case FALSE:
11328 case FETCH:
11329 case FINAL:
11330 case FOR:
11331 case FORALL:
11332 case FORCE:
11333 case FUNCTION:
11334 case GLOBAL:
11335 case GOTO:
11336 case HASH:
11337 case HEAP:
11338 case HOUR:
11339 case IF:
11340 case IMMEDIATE:
11341 case INDICES:
11342 case INDEXTYPE:
11343 case INDICATOR:
11344 case INSERT:
11345 case INSTANTIABLE:
11346 case INTERVAL:
11347 case INVALIDATE:
11348 case ISOLATION:
11349 case JAVA:
11350 case LEVEL:
11351 case LIMIT:
11352 case LOCK:
11353 case LOOP:
11354 case MAP:
11355 case MAX:
11356 case MEMBER:
11357 case MERGE:
11358 case MIN:
11359 case MINUTE:
11360 case MLSLABEL:
11361 case MODIFY:
11362 case MOD:
11363 case MONTH:
11364 case NATURAL:
11365 case NEW:
11366 case NEW_DOT:
11367 case NO:
11368 case NONEDITIONABLE:
11369 case NOT:
11370 case NULL:
11371 case NULLIF:
11372 case OBJECT:
11373 case OID:
11374 case OPAQUE:
11375 case OPEN:
11376 case OPERATOR:
11377 case ORGANIZATION:
11378 case OTHERS:
11379 case OVERRIDING:
11380 case PACKAGE:
11381 case PARTITION:
11382 case PIPE:
11383 case PRAGMA:
11384 case PRESERVE:
11385 case PRIVATE:
11386 case PROCEDURE:
11387 case RAISE:
11388 case RANGE:
11389 case RAW:
11390 case REAL:
11391 case RECORD:
11392 case REF:
11393 case RELEASE:
11394 case RELIES_ON:
11395 case RENAME:
11396 case RESULT:
11397 case RETURN:
11398 case RETURNING:
11399 case REVERSE:
11400 case ROLLBACK:
11401 case ROW:
11402 case ROWS:
11403 case ROWID:
11404 case ROWNUM:
11405 case SAVE:
11406 case SAVEPOINT:
11407 case SECOND:
11408 case SELECT:
11409 case SELF:
11410 case SET:
11411 case SPACE:
11412 case SQL:
11413 case SQLCODE:
11414 case SQLERRM:
11415 case STATIC:
11416 case SUBTYPE:
11417 case SUBSTITUTABLE:
11418 case SUCCESSFUL:
11419 case SYSDATE:
11420 case SYS_REFCURSOR:
11421 case TEMPORARY:
11422 case TIME:
11423 case TIMESTAMP:
11424 case TIMEZONE_REGION:
11425 case TIMEZONE_ABBR:
11426 case TIMEZONE_MINUTE:
11427 case TIMEZONE_HOUR:
11428 case TRANSACTION:
11429 case TRUE:
11430 case TYPE:
11431 case UNDER:
11432 case USING:
11433 case WHILE:
11434 case YES:
11435 case SHOW:
11436 case A:
11437 case UPDATE:
11438 case DOUBLE:
11439 case DEC:
11440 case PRECISION:
11441 case INT:
11442 case NUMERIC:
11443 case NCHAR:
11444 case NVARCHAR2:
11445 case STRING:
11446 case UROWID:
11447 case VARRAY:
11448 case VARYING:
11449 case BFILE:
11450 case BLOB:
11451 case CLOB:
11452 case NCLOB:
11453 case YEAR:
11454 case LOCAL:
11455 case WITH:
11456 case ZONE:
11457 case CHARACTER:
11458 case AFTER:
11459 case BEFORE:
11460 case OLD:
11461 case PARENT:
11462 case CC_IF:
11463 case CC_ERROR:
11464 case ANALYZE:
11465 case ASSOCIATE:
11466 case AUDIT:
11467 case COMPOUND:
11468 case DATABASE:
11469 case CALL:
11470 case DDL:
11471 case DISASSOCIATE:
11472 case EACH:
11473 case FOLLOWS:
11474 case LOGOFF:
11475 case LOGON:
11476 case NESTED:
11477 case NOAUDIT:
11478 case SCHEMA:
11479 case SERVERERROR:
11480 case SHUTDOWN:
11481 case STARTUP:
11482 case STATEMENT:
11483 case STATISTICS:
11484 case SUSPEND:
11485 case TRUNCATE:
11486 case WRAPPED:
11487 case LIBRARY:
11488 case NAME:
11489 case STRUCT:
11490 case CONTEXT:
11491 case PARAMETERS:
11492 case LENGTH:
11493 case TDO:
11494 case MAXLEN:
11495 case CHARSETID:
11496 case CHARSETFORM:
11497 case ACCEPT:
11498 case ACCESSIBLE:
11499 case COPY:
11500 case DEFINE:
11501 case DISCONNECT:
11502 case HOST:
11503 case PRINT:
11504 case QUIT:
11505 case REMARK:
11506 case UNDEFINE:
11507 case VARIABLE:
11508 case WHENEVER:
11509 case ATTACH:
11510 case CAST:
11511 case TREAT:
11512 case TRIM:
11513 case LEFT:
11514 case RIGHT:
11515 case BOTH:
11516 case EMPTY:
11517 case MULTISET:
11518 case SUBMULTISET:
11519 case LEADING:
11520 case TRAILING:
11521 case CHAR_CS:
11522 case NCHAR_CS:
11523 case DBTIMEZONE:
11524 case SESSIONTIMEZONE:
11525 case AUTHENTICATED:
11526 case LINK:
11527 case SHARED:
11528 case DIRECTORY:
11529 case USER:
11530 case IDENTIFIER:
11531 case UNSIGNED_NUMERIC_LITERAL:
11532 case CHARACTER_LITERAL:
11533 case STRING_LITERAL:
11534 case QUOTED_LITERAL:
11535 ;
11536 break;
11537 default:
11538 jj_la1[130] = jj_gen;
11539 break label_29;
11540 }
11541 }
11542 jj_consume_token(END);
11543 jj_consume_token(LOOP);
11544 switch (jj_nt.kind) {
11545 case IDENTIFIER:
11546 jj_consume_token(IDENTIFIER);
11547 break;
11548 default:
11549 jj_la1[131] = jj_gen;
11550 ;
11551 }
11552 jjtree.closeNodeScope(jjtn000, true);
11553 jjtc000 = false;
11554 {if (true) return jjtn000 ;}
11555 } catch (Throwable jjte000) {
11556 if (jjtc000) {
11557 jjtree.clearNodeScope(jjtn000);
11558 jjtc000 = false;
11559 } else {
11560 jjtree.popNode();
11561 }
11562 if (jjte000 instanceof RuntimeException) {
11563 {if (true) throw (RuntimeException)jjte000;}
11564 }
11565 if (jjte000 instanceof ParseException) {
11566 {if (true) throw (ParseException)jjte000;}
11567 }
11568 {if (true) throw (Error)jjte000;}
11569 } finally {
11570 if (jjtc000) {
11571 jjtree.closeNodeScope(jjtn000, true);
11572 }
11573 }
11574 throw new Error("Missing return statement in function");
11575 }
11576
11577
11578 final public ASTForStatement ForStatement() throws ParseException {
11579
11580 ASTForStatement jjtn000 = new ASTForStatement(this, JJTFORSTATEMENT);
11581 boolean jjtc000 = true;
11582 jjtree.openNodeScope(jjtn000);
11583 try {
11584 jj_consume_token(FOR);
11585 ForIndex();
11586 jj_consume_token(IN);
11587 switch (jj_nt.kind) {
11588 case REVERSE:
11589 jj_consume_token(REVERSE);
11590 break;
11591 default:
11592 jj_la1[132] = jj_gen;
11593 ;
11594 }
11595 Expression();
11596 switch (jj_nt.kind) {
11597 case 12:
11598 jj_consume_token(12);
11599 Expression();
11600 break;
11601 default:
11602 jj_la1[133] = jj_gen;
11603 ;
11604 }
11605 jj_consume_token(LOOP);
11606 label_30:
11607 while (true) {
11608 Statement();
11609 switch (jj_nt.kind) {
11610 case 5:
11611 case 16:
11612 case 17:
11613 case 21:
11614 case REPLACE:
11615 case DEFINER:
11616 case CURRENT_USER:
11617 case LANGUAGE:
11618 case INLINE:
11619 case ADD:
11620 case AGGREGATE:
11621 case ARRAY:
11622 case AT:
11623 case ATTRIBUTE:
11624 case AUTHID:
11625 case BEGIN:
11626 case BODY:
11627 case BULK:
11628 case BYTE:
11629 case CASCADE:
11630 case CASE:
11631 case CLOSE:
11632 case COALESCE:
11633 case COLLECT:
11634 case COLUMN:
11635 case COMMENT:
11636 case COMMIT:
11637 case CONSTRUCTOR:
11638 case CONTINUE:
11639 case CONVERT:
11640 case CURRENT:
11641 case CURSOR:
11642 case DATA:
11643 case DATE:
11644 case DAY:
11645 case DECLARE:
11646 case DELETE:
11647 case DISABLE:
11648 case EDITIONABLE:
11649 case ELEMENT:
11650 case ENABLE:
11651 case ESCAPE:
11652 case EXCEPT:
11653 case EXCEPTIONS:
11654 case EXECUTE:
11655 case EXIT:
11656 case EXTERNAL:
11657 case EXTENDS:
11658 case EXTRACT:
11659 case FALSE:
11660 case FETCH:
11661 case FINAL:
11662 case FOR:
11663 case FORALL:
11664 case FORCE:
11665 case FUNCTION:
11666 case GLOBAL:
11667 case GOTO:
11668 case HASH:
11669 case HEAP:
11670 case HOUR:
11671 case IF:
11672 case IMMEDIATE:
11673 case INDICES:
11674 case INDEXTYPE:
11675 case INDICATOR:
11676 case INSERT:
11677 case INSTANTIABLE:
11678 case INTERVAL:
11679 case INVALIDATE:
11680 case ISOLATION:
11681 case JAVA:
11682 case LEVEL:
11683 case LIMIT:
11684 case LOCK:
11685 case LOOP:
11686 case MAP:
11687 case MAX:
11688 case MEMBER:
11689 case MERGE:
11690 case MIN:
11691 case MINUTE:
11692 case MLSLABEL:
11693 case MODIFY:
11694 case MOD:
11695 case MONTH:
11696 case NATURAL:
11697 case NEW:
11698 case NEW_DOT:
11699 case NO:
11700 case NONEDITIONABLE:
11701 case NOT:
11702 case NULL:
11703 case NULLIF:
11704 case OBJECT:
11705 case OID:
11706 case OPAQUE:
11707 case OPEN:
11708 case OPERATOR:
11709 case ORGANIZATION:
11710 case OTHERS:
11711 case OVERRIDING:
11712 case PACKAGE:
11713 case PARTITION:
11714 case PIPE:
11715 case PRAGMA:
11716 case PRESERVE:
11717 case PRIVATE:
11718 case PROCEDURE:
11719 case RAISE:
11720 case RANGE:
11721 case RAW:
11722 case REAL:
11723 case RECORD:
11724 case REF:
11725 case RELEASE:
11726 case RELIES_ON:
11727 case RENAME:
11728 case RESULT:
11729 case RETURN:
11730 case RETURNING:
11731 case REVERSE:
11732 case ROLLBACK:
11733 case ROW:
11734 case ROWS:
11735 case ROWID:
11736 case ROWNUM:
11737 case SAVE:
11738 case SAVEPOINT:
11739 case SECOND:
11740 case SELECT:
11741 case SELF:
11742 case SET:
11743 case SPACE:
11744 case SQL:
11745 case SQLCODE:
11746 case SQLERRM:
11747 case STATIC:
11748 case SUBTYPE:
11749 case SUBSTITUTABLE:
11750 case SUCCESSFUL:
11751 case SYSDATE:
11752 case SYS_REFCURSOR:
11753 case TEMPORARY:
11754 case TIME:
11755 case TIMESTAMP:
11756 case TIMEZONE_REGION:
11757 case TIMEZONE_ABBR:
11758 case TIMEZONE_MINUTE:
11759 case TIMEZONE_HOUR:
11760 case TRANSACTION:
11761 case TRUE:
11762 case TYPE:
11763 case UNDER:
11764 case USING:
11765 case WHILE:
11766 case YES:
11767 case SHOW:
11768 case A:
11769 case UPDATE:
11770 case DOUBLE:
11771 case DEC:
11772 case PRECISION:
11773 case INT:
11774 case NUMERIC:
11775 case NCHAR:
11776 case NVARCHAR2:
11777 case STRING:
11778 case UROWID:
11779 case VARRAY:
11780 case VARYING:
11781 case BFILE:
11782 case BLOB:
11783 case CLOB:
11784 case NCLOB:
11785 case YEAR:
11786 case LOCAL:
11787 case WITH:
11788 case ZONE:
11789 case CHARACTER:
11790 case AFTER:
11791 case BEFORE:
11792 case OLD:
11793 case PARENT:
11794 case CC_IF:
11795 case CC_ERROR:
11796 case ANALYZE:
11797 case ASSOCIATE:
11798 case AUDIT:
11799 case COMPOUND:
11800 case DATABASE:
11801 case CALL:
11802 case DDL:
11803 case DISASSOCIATE:
11804 case EACH:
11805 case FOLLOWS:
11806 case LOGOFF:
11807 case LOGON:
11808 case NESTED:
11809 case NOAUDIT:
11810 case SCHEMA:
11811 case SERVERERROR:
11812 case SHUTDOWN:
11813 case STARTUP:
11814 case STATEMENT:
11815 case STATISTICS:
11816 case SUSPEND:
11817 case TRUNCATE:
11818 case WRAPPED:
11819 case LIBRARY:
11820 case NAME:
11821 case STRUCT:
11822 case CONTEXT:
11823 case PARAMETERS:
11824 case LENGTH:
11825 case TDO:
11826 case MAXLEN:
11827 case CHARSETID:
11828 case CHARSETFORM:
11829 case ACCEPT:
11830 case ACCESSIBLE:
11831 case COPY:
11832 case DEFINE:
11833 case DISCONNECT:
11834 case HOST:
11835 case PRINT:
11836 case QUIT:
11837 case REMARK:
11838 case UNDEFINE:
11839 case VARIABLE:
11840 case WHENEVER:
11841 case ATTACH:
11842 case CAST:
11843 case TREAT:
11844 case TRIM:
11845 case LEFT:
11846 case RIGHT:
11847 case BOTH:
11848 case EMPTY:
11849 case MULTISET:
11850 case SUBMULTISET:
11851 case LEADING:
11852 case TRAILING:
11853 case CHAR_CS:
11854 case NCHAR_CS:
11855 case DBTIMEZONE:
11856 case SESSIONTIMEZONE:
11857 case AUTHENTICATED:
11858 case LINK:
11859 case SHARED:
11860 case DIRECTORY:
11861 case USER:
11862 case IDENTIFIER:
11863 case UNSIGNED_NUMERIC_LITERAL:
11864 case CHARACTER_LITERAL:
11865 case STRING_LITERAL:
11866 case QUOTED_LITERAL:
11867 ;
11868 break;
11869 default:
11870 jj_la1[134] = jj_gen;
11871 break label_30;
11872 }
11873 }
11874 jj_consume_token(END);
11875 jj_consume_token(LOOP);
11876 switch (jj_nt.kind) {
11877 case IDENTIFIER:
11878 jj_consume_token(IDENTIFIER);
11879 break;
11880 default:
11881 jj_la1[135] = jj_gen;
11882 ;
11883 }
11884 jjtree.closeNodeScope(jjtn000, true);
11885 jjtc000 = false;
11886 {if (true) return jjtn000 ;}
11887 } catch (Throwable jjte000) {
11888 if (jjtc000) {
11889 jjtree.clearNodeScope(jjtn000);
11890 jjtc000 = false;
11891 } else {
11892 jjtree.popNode();
11893 }
11894 if (jjte000 instanceof RuntimeException) {
11895 {if (true) throw (RuntimeException)jjte000;}
11896 }
11897 if (jjte000 instanceof ParseException) {
11898 {if (true) throw (ParseException)jjte000;}
11899 }
11900 {if (true) throw (Error)jjte000;}
11901 } finally {
11902 if (jjtc000) {
11903 jjtree.closeNodeScope(jjtn000, true);
11904 }
11905 }
11906 throw new Error("Missing return statement in function");
11907 }
11908
11909 final public ASTWhileStatement WhileStatement() throws ParseException {
11910
11911 ASTWhileStatement jjtn000 = new ASTWhileStatement(this, JJTWHILESTATEMENT);
11912 boolean jjtc000 = true;
11913 jjtree.openNodeScope(jjtn000);
11914 try {
11915 jj_consume_token(WHILE);
11916 Expression();
11917 jj_consume_token(LOOP);
11918 label_31:
11919 while (true) {
11920 Statement();
11921 switch (jj_nt.kind) {
11922 case 5:
11923 case 16:
11924 case 17:
11925 case 21:
11926 case REPLACE:
11927 case DEFINER:
11928 case CURRENT_USER:
11929 case LANGUAGE:
11930 case INLINE:
11931 case ADD:
11932 case AGGREGATE:
11933 case ARRAY:
11934 case AT:
11935 case ATTRIBUTE:
11936 case AUTHID:
11937 case BEGIN:
11938 case BODY:
11939 case BULK:
11940 case BYTE:
11941 case CASCADE:
11942 case CASE:
11943 case CLOSE:
11944 case COALESCE:
11945 case COLLECT:
11946 case COLUMN:
11947 case COMMENT:
11948 case COMMIT:
11949 case CONSTRUCTOR:
11950 case CONTINUE:
11951 case CONVERT:
11952 case CURRENT:
11953 case CURSOR:
11954 case DATA:
11955 case DATE:
11956 case DAY:
11957 case DECLARE:
11958 case DELETE:
11959 case DISABLE:
11960 case EDITIONABLE:
11961 case ELEMENT:
11962 case ENABLE:
11963 case ESCAPE:
11964 case EXCEPT:
11965 case EXCEPTIONS:
11966 case EXECUTE:
11967 case EXIT:
11968 case EXTERNAL:
11969 case EXTENDS:
11970 case EXTRACT:
11971 case FALSE:
11972 case FETCH:
11973 case FINAL:
11974 case FOR:
11975 case FORALL:
11976 case FORCE:
11977 case FUNCTION:
11978 case GLOBAL:
11979 case GOTO:
11980 case HASH:
11981 case HEAP:
11982 case HOUR:
11983 case IF:
11984 case IMMEDIATE:
11985 case INDICES:
11986 case INDEXTYPE:
11987 case INDICATOR:
11988 case INSERT:
11989 case INSTANTIABLE:
11990 case INTERVAL:
11991 case INVALIDATE:
11992 case ISOLATION:
11993 case JAVA:
11994 case LEVEL:
11995 case LIMIT:
11996 case LOCK:
11997 case LOOP:
11998 case MAP:
11999 case MAX:
12000 case MEMBER:
12001 case MERGE:
12002 case MIN:
12003 case MINUTE:
12004 case MLSLABEL:
12005 case MODIFY:
12006 case MOD:
12007 case MONTH:
12008 case NATURAL:
12009 case NEW:
12010 case NEW_DOT:
12011 case NO:
12012 case NONEDITIONABLE:
12013 case NOT:
12014 case NULL:
12015 case NULLIF:
12016 case OBJECT:
12017 case OID:
12018 case OPAQUE:
12019 case OPEN:
12020 case OPERATOR:
12021 case ORGANIZATION:
12022 case OTHERS:
12023 case OVERRIDING:
12024 case PACKAGE:
12025 case PARTITION:
12026 case PIPE:
12027 case PRAGMA:
12028 case PRESERVE:
12029 case PRIVATE:
12030 case PROCEDURE:
12031 case RAISE:
12032 case RANGE:
12033 case RAW:
12034 case REAL:
12035 case RECORD:
12036 case REF:
12037 case RELEASE:
12038 case RELIES_ON:
12039 case RENAME:
12040 case RESULT:
12041 case RETURN:
12042 case RETURNING:
12043 case REVERSE:
12044 case ROLLBACK:
12045 case ROW:
12046 case ROWS:
12047 case ROWID:
12048 case ROWNUM:
12049 case SAVE:
12050 case SAVEPOINT:
12051 case SECOND:
12052 case SELECT:
12053 case SELF:
12054 case SET:
12055 case SPACE:
12056 case SQL:
12057 case SQLCODE:
12058 case SQLERRM:
12059 case STATIC:
12060 case SUBTYPE:
12061 case SUBSTITUTABLE:
12062 case SUCCESSFUL:
12063 case SYSDATE:
12064 case SYS_REFCURSOR:
12065 case TEMPORARY:
12066 case TIME:
12067 case TIMESTAMP:
12068 case TIMEZONE_REGION:
12069 case TIMEZONE_ABBR:
12070 case TIMEZONE_MINUTE:
12071 case TIMEZONE_HOUR:
12072 case TRANSACTION:
12073 case TRUE:
12074 case TYPE:
12075 case UNDER:
12076 case USING:
12077 case WHILE:
12078 case YES:
12079 case SHOW:
12080 case A:
12081 case UPDATE:
12082 case DOUBLE:
12083 case DEC:
12084 case PRECISION:
12085 case INT:
12086 case NUMERIC:
12087 case NCHAR:
12088 case NVARCHAR2:
12089 case STRING:
12090 case UROWID:
12091 case VARRAY:
12092 case VARYING:
12093 case BFILE:
12094 case BLOB:
12095 case CLOB:
12096 case NCLOB:
12097 case YEAR:
12098 case LOCAL:
12099 case WITH:
12100 case ZONE:
12101 case CHARACTER:
12102 case AFTER:
12103 case BEFORE:
12104 case OLD:
12105 case PARENT:
12106 case CC_IF:
12107 case CC_ERROR:
12108 case ANALYZE:
12109 case ASSOCIATE:
12110 case AUDIT:
12111 case COMPOUND:
12112 case DATABASE:
12113 case CALL:
12114 case DDL:
12115 case DISASSOCIATE:
12116 case EACH:
12117 case FOLLOWS:
12118 case LOGOFF:
12119 case LOGON:
12120 case NESTED:
12121 case NOAUDIT:
12122 case SCHEMA:
12123 case SERVERERROR:
12124 case SHUTDOWN:
12125 case STARTUP:
12126 case STATEMENT:
12127 case STATISTICS:
12128 case SUSPEND:
12129 case TRUNCATE:
12130 case WRAPPED:
12131 case LIBRARY:
12132 case NAME:
12133 case STRUCT:
12134 case CONTEXT:
12135 case PARAMETERS:
12136 case LENGTH:
12137 case TDO:
12138 case MAXLEN:
12139 case CHARSETID:
12140 case CHARSETFORM:
12141 case ACCEPT:
12142 case ACCESSIBLE:
12143 case COPY:
12144 case DEFINE:
12145 case DISCONNECT:
12146 case HOST:
12147 case PRINT:
12148 case QUIT:
12149 case REMARK:
12150 case UNDEFINE:
12151 case VARIABLE:
12152 case WHENEVER:
12153 case ATTACH:
12154 case CAST:
12155 case TREAT:
12156 case TRIM:
12157 case LEFT:
12158 case RIGHT:
12159 case BOTH:
12160 case EMPTY:
12161 case MULTISET:
12162 case SUBMULTISET:
12163 case LEADING:
12164 case TRAILING:
12165 case CHAR_CS:
12166 case NCHAR_CS:
12167 case DBTIMEZONE:
12168 case SESSIONTIMEZONE:
12169 case AUTHENTICATED:
12170 case LINK:
12171 case SHARED:
12172 case DIRECTORY:
12173 case USER:
12174 case IDENTIFIER:
12175 case UNSIGNED_NUMERIC_LITERAL:
12176 case CHARACTER_LITERAL:
12177 case STRING_LITERAL:
12178 case QUOTED_LITERAL:
12179 ;
12180 break;
12181 default:
12182 jj_la1[136] = jj_gen;
12183 break label_31;
12184 }
12185 }
12186 jj_consume_token(END);
12187 jj_consume_token(LOOP);
12188 switch (jj_nt.kind) {
12189 case IDENTIFIER:
12190 jj_consume_token(IDENTIFIER);
12191 break;
12192 default:
12193 jj_la1[137] = jj_gen;
12194 ;
12195 }
12196 jjtree.closeNodeScope(jjtn000, true);
12197 jjtc000 = false;
12198 {if (true) return jjtn000 ;}
12199 } catch (Throwable jjte000) {
12200 if (jjtc000) {
12201 jjtree.clearNodeScope(jjtn000);
12202 jjtc000 = false;
12203 } else {
12204 jjtree.popNode();
12205 }
12206 if (jjte000 instanceof RuntimeException) {
12207 {if (true) throw (RuntimeException)jjte000;}
12208 }
12209 if (jjte000 instanceof ParseException) {
12210 {if (true) throw (ParseException)jjte000;}
12211 }
12212 {if (true) throw (Error)jjte000;}
12213 } finally {
12214 if (jjtc000) {
12215 jjtree.closeNodeScope(jjtn000, true);
12216 }
12217 }
12218 throw new Error("Missing return statement in function");
12219 }
12220
12221 final public ASTIfStatement IfStatement() throws ParseException {
12222
12223 ASTIfStatement jjtn000 = new ASTIfStatement(this, JJTIFSTATEMENT);
12224 boolean jjtc000 = true;
12225 jjtree.openNodeScope(jjtn000);
12226 try {
12227 jj_consume_token(IF);
12228 Expression();
12229 jj_consume_token(THEN);
12230 label_32:
12231 while (true) {
12232 Statement();
12233 switch (jj_nt.kind) {
12234 case 5:
12235 case 16:
12236 case 17:
12237 case 21:
12238 case REPLACE:
12239 case DEFINER:
12240 case CURRENT_USER:
12241 case LANGUAGE:
12242 case INLINE:
12243 case ADD:
12244 case AGGREGATE:
12245 case ARRAY:
12246 case AT:
12247 case ATTRIBUTE:
12248 case AUTHID:
12249 case BEGIN:
12250 case BODY:
12251 case BULK:
12252 case BYTE:
12253 case CASCADE:
12254 case CASE:
12255 case CLOSE:
12256 case COALESCE:
12257 case COLLECT:
12258 case COLUMN:
12259 case COMMENT:
12260 case COMMIT:
12261 case CONSTRUCTOR:
12262 case CONTINUE:
12263 case CONVERT:
12264 case CURRENT:
12265 case CURSOR:
12266 case DATA:
12267 case DATE:
12268 case DAY:
12269 case DECLARE:
12270 case DELETE:
12271 case DISABLE:
12272 case EDITIONABLE:
12273 case ELEMENT:
12274 case ENABLE:
12275 case ESCAPE:
12276 case EXCEPT:
12277 case EXCEPTIONS:
12278 case EXECUTE:
12279 case EXIT:
12280 case EXTERNAL:
12281 case EXTENDS:
12282 case EXTRACT:
12283 case FALSE:
12284 case FETCH:
12285 case FINAL:
12286 case FOR:
12287 case FORALL:
12288 case FORCE:
12289 case FUNCTION:
12290 case GLOBAL:
12291 case GOTO:
12292 case HASH:
12293 case HEAP:
12294 case HOUR:
12295 case IF:
12296 case IMMEDIATE:
12297 case INDICES:
12298 case INDEXTYPE:
12299 case INDICATOR:
12300 case INSERT:
12301 case INSTANTIABLE:
12302 case INTERVAL:
12303 case INVALIDATE:
12304 case ISOLATION:
12305 case JAVA:
12306 case LEVEL:
12307 case LIMIT:
12308 case LOCK:
12309 case LOOP:
12310 case MAP:
12311 case MAX:
12312 case MEMBER:
12313 case MERGE:
12314 case MIN:
12315 case MINUTE:
12316 case MLSLABEL:
12317 case MODIFY:
12318 case MOD:
12319 case MONTH:
12320 case NATURAL:
12321 case NEW:
12322 case NEW_DOT:
12323 case NO:
12324 case NONEDITIONABLE:
12325 case NOT:
12326 case NULL:
12327 case NULLIF:
12328 case OBJECT:
12329 case OID:
12330 case OPAQUE:
12331 case OPEN:
12332 case OPERATOR:
12333 case ORGANIZATION:
12334 case OTHERS:
12335 case OVERRIDING:
12336 case PACKAGE:
12337 case PARTITION:
12338 case PIPE:
12339 case PRAGMA:
12340 case PRESERVE:
12341 case PRIVATE:
12342 case PROCEDURE:
12343 case RAISE:
12344 case RANGE:
12345 case RAW:
12346 case REAL:
12347 case RECORD:
12348 case REF:
12349 case RELEASE:
12350 case RELIES_ON:
12351 case RENAME:
12352 case RESULT:
12353 case RETURN:
12354 case RETURNING:
12355 case REVERSE:
12356 case ROLLBACK:
12357 case ROW:
12358 case ROWS:
12359 case ROWID:
12360 case ROWNUM:
12361 case SAVE:
12362 case SAVEPOINT:
12363 case SECOND:
12364 case SELECT:
12365 case SELF:
12366 case SET:
12367 case SPACE:
12368 case SQL:
12369 case SQLCODE:
12370 case SQLERRM:
12371 case STATIC:
12372 case SUBTYPE:
12373 case SUBSTITUTABLE:
12374 case SUCCESSFUL:
12375 case SYSDATE:
12376 case SYS_REFCURSOR:
12377 case TEMPORARY:
12378 case TIME:
12379 case TIMESTAMP:
12380 case TIMEZONE_REGION:
12381 case TIMEZONE_ABBR:
12382 case TIMEZONE_MINUTE:
12383 case TIMEZONE_HOUR:
12384 case TRANSACTION:
12385 case TRUE:
12386 case TYPE:
12387 case UNDER:
12388 case USING:
12389 case WHILE:
12390 case YES:
12391 case SHOW:
12392 case A:
12393 case UPDATE:
12394 case DOUBLE:
12395 case DEC:
12396 case PRECISION:
12397 case INT:
12398 case NUMERIC:
12399 case NCHAR:
12400 case NVARCHAR2:
12401 case STRING:
12402 case UROWID:
12403 case VARRAY:
12404 case VARYING:
12405 case BFILE:
12406 case BLOB:
12407 case CLOB:
12408 case NCLOB:
12409 case YEAR:
12410 case LOCAL:
12411 case WITH:
12412 case ZONE:
12413 case CHARACTER:
12414 case AFTER:
12415 case BEFORE:
12416 case OLD:
12417 case PARENT:
12418 case CC_IF:
12419 case CC_ERROR:
12420 case ANALYZE:
12421 case ASSOCIATE:
12422 case AUDIT:
12423 case COMPOUND:
12424 case DATABASE:
12425 case CALL:
12426 case DDL:
12427 case DISASSOCIATE:
12428 case EACH:
12429 case FOLLOWS:
12430 case LOGOFF:
12431 case LOGON:
12432 case NESTED:
12433 case NOAUDIT:
12434 case SCHEMA:
12435 case SERVERERROR:
12436 case SHUTDOWN:
12437 case STARTUP:
12438 case STATEMENT:
12439 case STATISTICS:
12440 case SUSPEND:
12441 case TRUNCATE:
12442 case WRAPPED:
12443 case LIBRARY:
12444 case NAME:
12445 case STRUCT:
12446 case CONTEXT:
12447 case PARAMETERS:
12448 case LENGTH:
12449 case TDO:
12450 case MAXLEN:
12451 case CHARSETID:
12452 case CHARSETFORM:
12453 case ACCEPT:
12454 case ACCESSIBLE:
12455 case COPY:
12456 case DEFINE:
12457 case DISCONNECT:
12458 case HOST:
12459 case PRINT:
12460 case QUIT:
12461 case REMARK:
12462 case UNDEFINE:
12463 case VARIABLE:
12464 case WHENEVER:
12465 case ATTACH:
12466 case CAST:
12467 case TREAT:
12468 case TRIM:
12469 case LEFT:
12470 case RIGHT:
12471 case BOTH:
12472 case EMPTY:
12473 case MULTISET:
12474 case SUBMULTISET:
12475 case LEADING:
12476 case TRAILING:
12477 case CHAR_CS:
12478 case NCHAR_CS:
12479 case DBTIMEZONE:
12480 case SESSIONTIMEZONE:
12481 case AUTHENTICATED:
12482 case LINK:
12483 case SHARED:
12484 case DIRECTORY:
12485 case USER:
12486 case IDENTIFIER:
12487 case UNSIGNED_NUMERIC_LITERAL:
12488 case CHARACTER_LITERAL:
12489 case STRING_LITERAL:
12490 case QUOTED_LITERAL:
12491 ;
12492 break;
12493 default:
12494 jj_la1[138] = jj_gen;
12495 break label_32;
12496 }
12497 }
12498 label_33:
12499 while (true) {
12500 switch (jj_nt.kind) {
12501 case ELSIF:
12502 ;
12503 break;
12504 default:
12505 jj_la1[139] = jj_gen;
12506 break label_33;
12507 }
12508 ElsifClause();
12509 jjtn000.setHasElse();
12510 }
12511 switch (jj_nt.kind) {
12512 case ELSE:
12513 ElseClause();
12514 jjtn000.setHasElse();
12515 break;
12516 default:
12517 jj_la1[140] = jj_gen;
12518 ;
12519 }
12520 jj_consume_token(END);
12521 jj_consume_token(IF);
12522 jjtree.closeNodeScope(jjtn000, true);
12523 jjtc000 = false;
12524 {if (true) return jjtn000 ;}
12525 } catch (Throwable jjte000) {
12526 if (jjtc000) {
12527 jjtree.clearNodeScope(jjtn000);
12528 jjtc000 = false;
12529 } else {
12530 jjtree.popNode();
12531 }
12532 if (jjte000 instanceof RuntimeException) {
12533 {if (true) throw (RuntimeException)jjte000;}
12534 }
12535 if (jjte000 instanceof ParseException) {
12536 {if (true) throw (ParseException)jjte000;}
12537 }
12538 {if (true) throw (Error)jjte000;}
12539 } finally {
12540 if (jjtc000) {
12541 jjtree.closeNodeScope(jjtn000, true);
12542 }
12543 }
12544 throw new Error("Missing return statement in function");
12545 }
12546
12547
12548
12549
12550
12551 final public ASTForIndex ForIndex() throws ParseException {
12552
12553 ASTForIndex jjtn000 = new ASTForIndex(this, JJTFORINDEX);
12554 boolean jjtc000 = true;
12555 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
12556 try {
12557 simpleNode = ID();
12558 jjtree.closeNodeScope(jjtn000, true);
12559 jjtc000 = false;
12560 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
12561 } catch (Throwable jjte000) {
12562 if (jjtc000) {
12563 jjtree.clearNodeScope(jjtn000);
12564 jjtc000 = false;
12565 } else {
12566 jjtree.popNode();
12567 }
12568 if (jjte000 instanceof RuntimeException) {
12569 {if (true) throw (RuntimeException)jjte000;}
12570 }
12571 if (jjte000 instanceof ParseException) {
12572 {if (true) throw (ParseException)jjte000;}
12573 }
12574 {if (true) throw (Error)jjte000;}
12575 } finally {
12576 if (jjtc000) {
12577 jjtree.closeNodeScope(jjtn000, true);
12578 }
12579 }
12580 throw new Error("Missing return statement in function");
12581 }
12582
12583
12584
12585
12586 final public ASTForAllIndex ForAllIndex() throws ParseException {
12587
12588 ASTForAllIndex jjtn000 = new ASTForAllIndex(this, JJTFORALLINDEX);
12589 boolean jjtc000 = true;
12590 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
12591 try {
12592 simpleNode = ID();
12593 jjtree.closeNodeScope(jjtn000, true);
12594 jjtc000 = false;
12595 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
12596 } catch (Throwable jjte000) {
12597 if (jjtc000) {
12598 jjtree.clearNodeScope(jjtn000);
12599 jjtc000 = false;
12600 } else {
12601 jjtree.popNode();
12602 }
12603 if (jjte000 instanceof RuntimeException) {
12604 {if (true) throw (RuntimeException)jjte000;}
12605 }
12606 if (jjte000 instanceof ParseException) {
12607 {if (true) throw (ParseException)jjte000;}
12608 }
12609 {if (true) throw (Error)jjte000;}
12610 } finally {
12611 if (jjtc000) {
12612 jjtree.closeNodeScope(jjtn000, true);
12613 }
12614 }
12615 throw new Error("Missing return statement in function");
12616 }
12617
12618 final public ASTForAllStatement ForAllStatement() throws ParseException {
12619
12620 ASTForAllStatement jjtn000 = new ASTForAllStatement(this, JJTFORALLSTATEMENT);
12621 boolean jjtc000 = true;
12622 jjtree.openNodeScope(jjtn000);
12623 try {
12624 jj_consume_token(FORALL);
12625 ForAllIndex();
12626 jj_consume_token(IN);
12627 switch (jj_nt.kind) {
12628 case INDICES:
12629 case VALUES:
12630 switch (jj_nt.kind) {
12631 case INDICES:
12632 jj_consume_token(INDICES);
12633 break;
12634 case VALUES:
12635 jj_consume_token(VALUES);
12636 break;
12637 default:
12638 jj_la1[141] = jj_gen;
12639 jj_consume_token(-1);
12640 throw new ParseException();
12641 }
12642 jj_consume_token(OF);
12643 Expression();
12644 break;
12645 case 5:
12646 case 16:
12647 case 17:
12648 case REPLACE:
12649 case DEFINER:
12650 case CURRENT_USER:
12651 case LANGUAGE:
12652 case INLINE:
12653 case ADD:
12654 case AGGREGATE:
12655 case ARRAY:
12656 case AT:
12657 case ATTRIBUTE:
12658 case AUTHID:
12659 case BODY:
12660 case BULK:
12661 case BYTE:
12662 case CASCADE:
12663 case CASE:
12664 case CLOSE:
12665 case COALESCE:
12666 case COLLECT:
12667 case COLUMN:
12668 case COMMENT:
12669 case COMMIT:
12670 case CONSTRUCTOR:
12671 case CONTINUE:
12672 case CONVERT:
12673 case CURRENT:
12674 case CURSOR:
12675 case DATA:
12676 case DATE:
12677 case DAY:
12678 case DISABLE:
12679 case EDITIONABLE:
12680 case ELEMENT:
12681 case ENABLE:
12682 case ESCAPE:
12683 case EXCEPT:
12684 case EXCEPTIONS:
12685 case EXIT:
12686 case EXTERNAL:
12687 case EXTENDS:
12688 case EXTRACT:
12689 case FALSE:
12690 case FINAL:
12691 case FORCE:
12692 case FUNCTION:
12693 case GLOBAL:
12694 case HASH:
12695 case HEAP:
12696 case HOUR:
12697 case IMMEDIATE:
12698 case INDEXTYPE:
12699 case INDICATOR:
12700 case INSTANTIABLE:
12701 case INTERVAL:
12702 case INVALIDATE:
12703 case ISOLATION:
12704 case JAVA:
12705 case LEVEL:
12706 case LIMIT:
12707 case LOOP:
12708 case MAP:
12709 case MAX:
12710 case MEMBER:
12711 case MERGE:
12712 case MIN:
12713 case MINUTE:
12714 case MLSLABEL:
12715 case MODIFY:
12716 case MOD:
12717 case MONTH:
12718 case NATURAL:
12719 case NEW:
12720 case NEW_DOT:
12721 case NO:
12722 case NONEDITIONABLE:
12723 case NOT:
12724 case NULL:
12725 case NULLIF:
12726 case OBJECT:
12727 case OID:
12728 case OPAQUE:
12729 case OPEN:
12730 case OPERATOR:
12731 case ORGANIZATION:
12732 case OTHERS:
12733 case OVERRIDING:
12734 case PACKAGE:
12735 case PARTITION:
12736 case PRESERVE:
12737 case PRIVATE:
12738 case PROCEDURE:
12739 case RANGE:
12740 case RAW:
12741 case REAL:
12742 case RECORD:
12743 case REF:
12744 case RELEASE:
12745 case RELIES_ON:
12746 case RENAME:
12747 case RESULT:
12748 case RETURN:
12749 case RETURNING:
12750 case REVERSE:
12751 case ROLLBACK:
12752 case ROW:
12753 case ROWS:
12754 case ROWID:
12755 case ROWNUM:
12756 case SAVE:
12757 case SAVEPOINT:
12758 case SECOND:
12759 case SELECT:
12760 case SELF:
12761 case SET:
12762 case SPACE:
12763 case SQL:
12764 case SQLCODE:
12765 case SQLERRM:
12766 case STATIC:
12767 case SUBTYPE:
12768 case SUBSTITUTABLE:
12769 case SUCCESSFUL:
12770 case SYSDATE:
12771 case SYS_REFCURSOR:
12772 case TEMPORARY:
12773 case TIME:
12774 case TIMESTAMP:
12775 case TIMEZONE_REGION:
12776 case TIMEZONE_ABBR:
12777 case TIMEZONE_MINUTE:
12778 case TIMEZONE_HOUR:
12779 case TRANSACTION:
12780 case TRUE:
12781 case TYPE:
12782 case UNDER:
12783 case USING:
12784 case YES:
12785 case SHOW:
12786 case A:
12787 case DOUBLE:
12788 case DEC:
12789 case PRECISION:
12790 case INT:
12791 case NUMERIC:
12792 case NCHAR:
12793 case NVARCHAR2:
12794 case STRING:
12795 case UROWID:
12796 case VARRAY:
12797 case VARYING:
12798 case BFILE:
12799 case BLOB:
12800 case CLOB:
12801 case NCLOB:
12802 case YEAR:
12803 case LOCAL:
12804 case WITH:
12805 case ZONE:
12806 case CHARACTER:
12807 case AFTER:
12808 case BEFORE:
12809 case OLD:
12810 case PARENT:
12811 case CC_IF:
12812 case ANALYZE:
12813 case ASSOCIATE:
12814 case AUDIT:
12815 case COMPOUND:
12816 case DATABASE:
12817 case CALL:
12818 case DDL:
12819 case DISASSOCIATE:
12820 case EACH:
12821 case FOLLOWS:
12822 case LOGOFF:
12823 case LOGON:
12824 case NESTED:
12825 case NOAUDIT:
12826 case SCHEMA:
12827 case SERVERERROR:
12828 case SHUTDOWN:
12829 case STARTUP:
12830 case STATEMENT:
12831 case STATISTICS:
12832 case SUSPEND:
12833 case TRUNCATE:
12834 case WRAPPED:
12835 case LIBRARY:
12836 case NAME:
12837 case STRUCT:
12838 case CONTEXT:
12839 case PARAMETERS:
12840 case LENGTH:
12841 case TDO:
12842 case MAXLEN:
12843 case CHARSETID:
12844 case CHARSETFORM:
12845 case ACCEPT:
12846 case ACCESSIBLE:
12847 case COPY:
12848 case DEFINE:
12849 case DISCONNECT:
12850 case HOST:
12851 case PRINT:
12852 case QUIT:
12853 case REMARK:
12854 case UNDEFINE:
12855 case VARIABLE:
12856 case WHENEVER:
12857 case ATTACH:
12858 case CAST:
12859 case TREAT:
12860 case TRIM:
12861 case LEFT:
12862 case RIGHT:
12863 case BOTH:
12864 case EMPTY:
12865 case MULTISET:
12866 case SUBMULTISET:
12867 case LEADING:
12868 case TRAILING:
12869 case CHAR_CS:
12870 case NCHAR_CS:
12871 case DBTIMEZONE:
12872 case SESSIONTIMEZONE:
12873 case AUTHENTICATED:
12874 case LINK:
12875 case SHARED:
12876 case DIRECTORY:
12877 case USER:
12878 case IDENTIFIER:
12879 case UNSIGNED_NUMERIC_LITERAL:
12880 case CHARACTER_LITERAL:
12881 case STRING_LITERAL:
12882 case QUOTED_LITERAL:
12883 Expression();
12884 switch (jj_nt.kind) {
12885 case 12:
12886 jj_consume_token(12);
12887 Expression();
12888 break;
12889 default:
12890 jj_la1[142] = jj_gen;
12891 ;
12892 }
12893 break;
12894 default:
12895 jj_la1[143] = jj_gen;
12896 jj_consume_token(-1);
12897 throw new ParseException();
12898 }
12899 switch (jj_nt.kind) {
12900 case SAVE:
12901 jj_consume_token(SAVE);
12902 jj_consume_token(EXCEPTIONS);
12903 break;
12904 default:
12905 jj_la1[144] = jj_gen;
12906 ;
12907 }
12908 SqlStatement(null,";");
12909 jjtree.closeNodeScope(jjtn000, true);
12910 jjtc000 = false;
12911 {if (true) return jjtn000 ;}
12912 } catch (Throwable jjte000) {
12913 if (jjtc000) {
12914 jjtree.clearNodeScope(jjtn000);
12915 jjtc000 = false;
12916 } else {
12917 jjtree.popNode();
12918 }
12919 if (jjte000 instanceof RuntimeException) {
12920 {if (true) throw (RuntimeException)jjte000;}
12921 }
12922 if (jjte000 instanceof ParseException) {
12923 {if (true) throw (ParseException)jjte000;}
12924 }
12925 {if (true) throw (Error)jjte000;}
12926 } finally {
12927 if (jjtc000) {
12928 jjtree.closeNodeScope(jjtn000, true);
12929 }
12930 }
12931 throw new Error("Missing return statement in function");
12932 }
12933
12934 final public ASTGotoStatement GotoStatement() throws ParseException {
12935
12936 ASTGotoStatement jjtn000 = new ASTGotoStatement(this, JJTGOTOSTATEMENT);
12937 boolean jjtc000 = true;
12938 jjtree.openNodeScope(jjtn000);PLSQLNode label = null;
12939 try {
12940 jj_consume_token(GOTO);
12941 label = QualifiedName();
12942 jjtree.closeNodeScope(jjtn000, true);
12943 jjtc000 = false;
12944 jjtn000.setImage(label.getImage()) ; {if (true) return jjtn000 ;}
12945 } catch (Throwable jjte000) {
12946 if (jjtc000) {
12947 jjtree.clearNodeScope(jjtn000);
12948 jjtc000 = false;
12949 } else {
12950 jjtree.popNode();
12951 }
12952 if (jjte000 instanceof RuntimeException) {
12953 {if (true) throw (RuntimeException)jjte000;}
12954 }
12955 if (jjte000 instanceof ParseException) {
12956 {if (true) throw (ParseException)jjte000;}
12957 }
12958 {if (true) throw (Error)jjte000;}
12959 } finally {
12960 if (jjtc000) {
12961 jjtree.closeNodeScope(jjtn000, true);
12962 }
12963 }
12964 throw new Error("Missing return statement in function");
12965 }
12966
12967 final public ASTReturnStatement ReturnStatement() throws ParseException {
12968
12969 ASTReturnStatement jjtn000 = new ASTReturnStatement(this, JJTRETURNSTATEMENT);
12970 boolean jjtc000 = true;
12971 jjtree.openNodeScope(jjtn000);
12972 try {
12973 jj_consume_token(RETURN);
12974 switch (jj_nt.kind) {
12975 case 5:
12976 case 16:
12977 case 17:
12978 case REPLACE:
12979 case DEFINER:
12980 case CURRENT_USER:
12981 case LANGUAGE:
12982 case INLINE:
12983 case ADD:
12984 case AGGREGATE:
12985 case ARRAY:
12986 case AT:
12987 case ATTRIBUTE:
12988 case AUTHID:
12989 case BODY:
12990 case BULK:
12991 case BYTE:
12992 case CASCADE:
12993 case CASE:
12994 case CLOSE:
12995 case COALESCE:
12996 case COLLECT:
12997 case COLUMN:
12998 case COMMENT:
12999 case COMMIT:
13000 case CONSTRUCTOR:
13001 case CONTINUE:
13002 case CONVERT:
13003 case CURRENT:
13004 case CURSOR:
13005 case DATA:
13006 case DATE:
13007 case DAY:
13008 case DISABLE:
13009 case EDITIONABLE:
13010 case ELEMENT:
13011 case ENABLE:
13012 case ESCAPE:
13013 case EXCEPT:
13014 case EXCEPTIONS:
13015 case EXIT:
13016 case EXTERNAL:
13017 case EXTENDS:
13018 case EXTRACT:
13019 case FALSE:
13020 case FINAL:
13021 case FORCE:
13022 case FUNCTION:
13023 case GLOBAL:
13024 case HASH:
13025 case HEAP:
13026 case HOUR:
13027 case IMMEDIATE:
13028 case INDICES:
13029 case INDEXTYPE:
13030 case INDICATOR:
13031 case INSTANTIABLE:
13032 case INTERVAL:
13033 case INVALIDATE:
13034 case ISOLATION:
13035 case JAVA:
13036 case LEVEL:
13037 case LIMIT:
13038 case LOOP:
13039 case MAP:
13040 case MAX:
13041 case MEMBER:
13042 case MERGE:
13043 case MIN:
13044 case MINUTE:
13045 case MLSLABEL:
13046 case MODIFY:
13047 case MOD:
13048 case MONTH:
13049 case NATURAL:
13050 case NEW:
13051 case NEW_DOT:
13052 case NO:
13053 case NONEDITIONABLE:
13054 case NOT:
13055 case NULL:
13056 case NULLIF:
13057 case OBJECT:
13058 case OID:
13059 case OPAQUE:
13060 case OPEN:
13061 case OPERATOR:
13062 case ORGANIZATION:
13063 case OTHERS:
13064 case OVERRIDING:
13065 case PACKAGE:
13066 case PARTITION:
13067 case PRESERVE:
13068 case PRIVATE:
13069 case PROCEDURE:
13070 case RANGE:
13071 case RAW:
13072 case REAL:
13073 case RECORD:
13074 case REF:
13075 case RELEASE:
13076 case RELIES_ON:
13077 case RENAME:
13078 case RESULT:
13079 case RETURN:
13080 case RETURNING:
13081 case REVERSE:
13082 case ROLLBACK:
13083 case ROW:
13084 case ROWS:
13085 case ROWID:
13086 case ROWNUM:
13087 case SAVE:
13088 case SAVEPOINT:
13089 case SECOND:
13090 case SELECT:
13091 case SELF:
13092 case SET:
13093 case SPACE:
13094 case SQL:
13095 case SQLCODE:
13096 case SQLERRM:
13097 case STATIC:
13098 case SUBTYPE:
13099 case SUBSTITUTABLE:
13100 case SUCCESSFUL:
13101 case SYSDATE:
13102 case SYS_REFCURSOR:
13103 case TEMPORARY:
13104 case TIME:
13105 case TIMESTAMP:
13106 case TIMEZONE_REGION:
13107 case TIMEZONE_ABBR:
13108 case TIMEZONE_MINUTE:
13109 case TIMEZONE_HOUR:
13110 case TRANSACTION:
13111 case TRUE:
13112 case TYPE:
13113 case UNDER:
13114 case USING:
13115 case YES:
13116 case SHOW:
13117 case A:
13118 case DOUBLE:
13119 case DEC:
13120 case PRECISION:
13121 case INT:
13122 case NUMERIC:
13123 case NCHAR:
13124 case NVARCHAR2:
13125 case STRING:
13126 case UROWID:
13127 case VARRAY:
13128 case VARYING:
13129 case BFILE:
13130 case BLOB:
13131 case CLOB:
13132 case NCLOB:
13133 case YEAR:
13134 case LOCAL:
13135 case WITH:
13136 case ZONE:
13137 case CHARACTER:
13138 case AFTER:
13139 case BEFORE:
13140 case OLD:
13141 case PARENT:
13142 case CC_IF:
13143 case ANALYZE:
13144 case ASSOCIATE:
13145 case AUDIT:
13146 case COMPOUND:
13147 case DATABASE:
13148 case CALL:
13149 case DDL:
13150 case DISASSOCIATE:
13151 case EACH:
13152 case FOLLOWS:
13153 case LOGOFF:
13154 case LOGON:
13155 case NESTED:
13156 case NOAUDIT:
13157 case SCHEMA:
13158 case SERVERERROR:
13159 case SHUTDOWN:
13160 case STARTUP:
13161 case STATEMENT:
13162 case STATISTICS:
13163 case SUSPEND:
13164 case TRUNCATE:
13165 case WRAPPED:
13166 case LIBRARY:
13167 case NAME:
13168 case STRUCT:
13169 case CONTEXT:
13170 case PARAMETERS:
13171 case LENGTH:
13172 case TDO:
13173 case MAXLEN:
13174 case CHARSETID:
13175 case CHARSETFORM:
13176 case ACCEPT:
13177 case ACCESSIBLE:
13178 case COPY:
13179 case DEFINE:
13180 case DISCONNECT:
13181 case HOST:
13182 case PRINT:
13183 case QUIT:
13184 case REMARK:
13185 case UNDEFINE:
13186 case VARIABLE:
13187 case WHENEVER:
13188 case ATTACH:
13189 case CAST:
13190 case TREAT:
13191 case TRIM:
13192 case LEFT:
13193 case RIGHT:
13194 case BOTH:
13195 case EMPTY:
13196 case MULTISET:
13197 case SUBMULTISET:
13198 case LEADING:
13199 case TRAILING:
13200 case CHAR_CS:
13201 case NCHAR_CS:
13202 case DBTIMEZONE:
13203 case SESSIONTIMEZONE:
13204 case AUTHENTICATED:
13205 case LINK:
13206 case SHARED:
13207 case DIRECTORY:
13208 case USER:
13209 case IDENTIFIER:
13210 case UNSIGNED_NUMERIC_LITERAL:
13211 case CHARACTER_LITERAL:
13212 case STRING_LITERAL:
13213 case QUOTED_LITERAL:
13214 Expression();
13215 break;
13216 default:
13217 jj_la1[145] = jj_gen;
13218 ;
13219 }
13220 jjtree.closeNodeScope(jjtn000, true);
13221 jjtc000 = false;
13222 {if (true) return jjtn000 ;}
13223 } catch (Throwable jjte000) {
13224 if (jjtc000) {
13225 jjtree.clearNodeScope(jjtn000);
13226 jjtc000 = false;
13227 } else {
13228 jjtree.popNode();
13229 }
13230 if (jjte000 instanceof RuntimeException) {
13231 {if (true) throw (RuntimeException)jjte000;}
13232 }
13233 if (jjte000 instanceof ParseException) {
13234 {if (true) throw (ParseException)jjte000;}
13235 }
13236 {if (true) throw (Error)jjte000;}
13237 } finally {
13238 if (jjtc000) {
13239 jjtree.closeNodeScope(jjtn000, true);
13240 }
13241 }
13242 throw new Error("Missing return statement in function");
13243 }
13244
13245 final public ASTContinueStatement ContinueStatement() throws ParseException {
13246
13247 ASTContinueStatement jjtn000 = new ASTContinueStatement(this, JJTCONTINUESTATEMENT);
13248 boolean jjtc000 = true;
13249 jjtree.openNodeScope(jjtn000);PLSQLNode label = null;
13250 try {
13251 jj_consume_token(CONTINUE);
13252 switch (jj_nt.kind) {
13253 case REPLACE:
13254 case DEFINER:
13255 case CURRENT_USER:
13256 case LANGUAGE:
13257 case INLINE:
13258 case ADD:
13259 case AGGREGATE:
13260 case ARRAY:
13261 case AT:
13262 case ATTRIBUTE:
13263 case AUTHID:
13264 case BODY:
13265 case BULK:
13266 case BYTE:
13267 case CASCADE:
13268 case CLOSE:
13269 case COALESCE:
13270 case COLLECT:
13271 case COLUMN:
13272 case COMMENT:
13273 case COMMIT:
13274 case CONSTRUCTOR:
13275 case CONTINUE:
13276 case CONVERT:
13277 case CURRENT:
13278 case CURSOR:
13279 case DATA:
13280 case DAY:
13281 case DISABLE:
13282 case EDITIONABLE:
13283 case ELEMENT:
13284 case ENABLE:
13285 case ESCAPE:
13286 case EXCEPT:
13287 case EXCEPTIONS:
13288 case EXIT:
13289 case EXTERNAL:
13290 case EXTENDS:
13291 case EXTRACT:
13292 case FALSE:
13293 case FINAL:
13294 case FORCE:
13295 case FUNCTION:
13296 case GLOBAL:
13297 case HASH:
13298 case HEAP:
13299 case HOUR:
13300 case IMMEDIATE:
13301 case INDICES:
13302 case INDEXTYPE:
13303 case INDICATOR:
13304 case INSTANTIABLE:
13305 case INTERVAL:
13306 case INVALIDATE:
13307 case ISOLATION:
13308 case JAVA:
13309 case LEVEL:
13310 case LIMIT:
13311 case LOOP:
13312 case MAP:
13313 case MAX:
13314 case MEMBER:
13315 case MERGE:
13316 case MIN:
13317 case MINUTE:
13318 case MLSLABEL:
13319 case MODIFY:
13320 case MOD:
13321 case MONTH:
13322 case NATURAL:
13323 case NEW:
13324 case NO:
13325 case NONEDITIONABLE:
13326 case NULLIF:
13327 case OBJECT:
13328 case OID:
13329 case OPAQUE:
13330 case OPEN:
13331 case OPERATOR:
13332 case ORGANIZATION:
13333 case OTHERS:
13334 case OVERRIDING:
13335 case PACKAGE:
13336 case PARTITION:
13337 case PRESERVE:
13338 case PRIVATE:
13339 case PROCEDURE:
13340 case RANGE:
13341 case RAW:
13342 case REAL:
13343 case RECORD:
13344 case REF:
13345 case RELEASE:
13346 case RELIES_ON:
13347 case RENAME:
13348 case RESULT:
13349 case RETURN:
13350 case RETURNING:
13351 case REVERSE:
13352 case ROLLBACK:
13353 case ROW:
13354 case ROWS:
13355 case ROWID:
13356 case ROWNUM:
13357 case SAVE:
13358 case SAVEPOINT:
13359 case SECOND:
13360 case SELF:
13361 case SET:
13362 case SPACE:
13363 case SQL:
13364 case SQLCODE:
13365 case SQLERRM:
13366 case STATIC:
13367 case SUBTYPE:
13368 case SUBSTITUTABLE:
13369 case SUCCESSFUL:
13370 case SYSDATE:
13371 case SYS_REFCURSOR:
13372 case TEMPORARY:
13373 case TIME:
13374 case TIMESTAMP:
13375 case TIMEZONE_REGION:
13376 case TIMEZONE_ABBR:
13377 case TIMEZONE_MINUTE:
13378 case TIMEZONE_HOUR:
13379 case TRANSACTION:
13380 case TRUE:
13381 case TYPE:
13382 case UNDER:
13383 case USING:
13384 case YES:
13385 case SHOW:
13386 case A:
13387 case DOUBLE:
13388 case DEC:
13389 case PRECISION:
13390 case INT:
13391 case NUMERIC:
13392 case NCHAR:
13393 case NVARCHAR2:
13394 case STRING:
13395 case UROWID:
13396 case VARRAY:
13397 case VARYING:
13398 case BFILE:
13399 case BLOB:
13400 case CLOB:
13401 case NCLOB:
13402 case YEAR:
13403 case LOCAL:
13404 case ZONE:
13405 case CHARACTER:
13406 case AFTER:
13407 case BEFORE:
13408 case OLD:
13409 case PARENT:
13410 case ANALYZE:
13411 case ASSOCIATE:
13412 case AUDIT:
13413 case COMPOUND:
13414 case DATABASE:
13415 case CALL:
13416 case DDL:
13417 case DISASSOCIATE:
13418 case EACH:
13419 case FOLLOWS:
13420 case LOGOFF:
13421 case LOGON:
13422 case NESTED:
13423 case NOAUDIT:
13424 case SCHEMA:
13425 case SERVERERROR:
13426 case SHUTDOWN:
13427 case STARTUP:
13428 case STATEMENT:
13429 case STATISTICS:
13430 case SUSPEND:
13431 case TRUNCATE:
13432 case WRAPPED:
13433 case LIBRARY:
13434 case NAME:
13435 case STRUCT:
13436 case CONTEXT:
13437 case PARAMETERS:
13438 case LENGTH:
13439 case TDO:
13440 case MAXLEN:
13441 case CHARSETID:
13442 case CHARSETFORM:
13443 case ACCEPT:
13444 case ACCESSIBLE:
13445 case COPY:
13446 case DEFINE:
13447 case DISCONNECT:
13448 case HOST:
13449 case PRINT:
13450 case QUIT:
13451 case REMARK:
13452 case UNDEFINE:
13453 case VARIABLE:
13454 case WHENEVER:
13455 case ATTACH:
13456 case CAST:
13457 case TREAT:
13458 case TRIM:
13459 case LEFT:
13460 case RIGHT:
13461 case BOTH:
13462 case EMPTY:
13463 case MULTISET:
13464 case SUBMULTISET:
13465 case LEADING:
13466 case TRAILING:
13467 case CHAR_CS:
13468 case NCHAR_CS:
13469 case DBTIMEZONE:
13470 case SESSIONTIMEZONE:
13471 case AUTHENTICATED:
13472 case LINK:
13473 case SHARED:
13474 case DIRECTORY:
13475 case USER:
13476 case IDENTIFIER:
13477 case QUOTED_LITERAL:
13478 label = UnqualifiedID();
13479 break;
13480 default:
13481 jj_la1[146] = jj_gen;
13482 ;
13483 }
13484 switch (jj_nt.kind) {
13485 case WHEN:
13486 jj_consume_token(WHEN);
13487 Expression();
13488 break;
13489 default:
13490 jj_la1[147] = jj_gen;
13491 ;
13492 }
13493 jjtree.closeNodeScope(jjtn000, true);
13494 jjtc000 = false;
13495 if (null != label) { jjtn000.setImage(label.getImage()) ; } {if (true) return jjtn000 ;}
13496 } catch (Throwable jjte000) {
13497 if (jjtc000) {
13498 jjtree.clearNodeScope(jjtn000);
13499 jjtc000 = false;
13500 } else {
13501 jjtree.popNode();
13502 }
13503 if (jjte000 instanceof RuntimeException) {
13504 {if (true) throw (RuntimeException)jjte000;}
13505 }
13506 if (jjte000 instanceof ParseException) {
13507 {if (true) throw (ParseException)jjte000;}
13508 }
13509 {if (true) throw (Error)jjte000;}
13510 } finally {
13511 if (jjtc000) {
13512 jjtree.closeNodeScope(jjtn000, true);
13513 }
13514 }
13515 throw new Error("Missing return statement in function");
13516 }
13517
13518 final public ASTExitStatement ExitStatement() throws ParseException {
13519
13520 ASTExitStatement jjtn000 = new ASTExitStatement(this, JJTEXITSTATEMENT);
13521 boolean jjtc000 = true;
13522 jjtree.openNodeScope(jjtn000);PLSQLNode label = null;
13523 try {
13524 jj_consume_token(EXIT);
13525 switch (jj_nt.kind) {
13526 case REPLACE:
13527 case DEFINER:
13528 case CURRENT_USER:
13529 case LANGUAGE:
13530 case INLINE:
13531 case ADD:
13532 case AGGREGATE:
13533 case ARRAY:
13534 case AT:
13535 case ATTRIBUTE:
13536 case AUTHID:
13537 case BODY:
13538 case BULK:
13539 case BYTE:
13540 case CASCADE:
13541 case CLOSE:
13542 case COALESCE:
13543 case COLLECT:
13544 case COLUMN:
13545 case COMMENT:
13546 case COMMIT:
13547 case CONSTRUCTOR:
13548 case CONTINUE:
13549 case CONVERT:
13550 case CURRENT:
13551 case CURSOR:
13552 case DATA:
13553 case DAY:
13554 case DISABLE:
13555 case EDITIONABLE:
13556 case ELEMENT:
13557 case ENABLE:
13558 case ESCAPE:
13559 case EXCEPT:
13560 case EXCEPTIONS:
13561 case EXIT:
13562 case EXTERNAL:
13563 case EXTENDS:
13564 case EXTRACT:
13565 case FALSE:
13566 case FINAL:
13567 case FORCE:
13568 case FUNCTION:
13569 case GLOBAL:
13570 case HASH:
13571 case HEAP:
13572 case HOUR:
13573 case IMMEDIATE:
13574 case INDICES:
13575 case INDEXTYPE:
13576 case INDICATOR:
13577 case INSTANTIABLE:
13578 case INTERVAL:
13579 case INVALIDATE:
13580 case ISOLATION:
13581 case JAVA:
13582 case LEVEL:
13583 case LIMIT:
13584 case LOOP:
13585 case MAP:
13586 case MAX:
13587 case MEMBER:
13588 case MERGE:
13589 case MIN:
13590 case MINUTE:
13591 case MLSLABEL:
13592 case MODIFY:
13593 case MOD:
13594 case MONTH:
13595 case NATURAL:
13596 case NEW:
13597 case NO:
13598 case NONEDITIONABLE:
13599 case NULLIF:
13600 case OBJECT:
13601 case OID:
13602 case OPAQUE:
13603 case OPEN:
13604 case OPERATOR:
13605 case ORGANIZATION:
13606 case OTHERS:
13607 case OVERRIDING:
13608 case PACKAGE:
13609 case PARTITION:
13610 case PRESERVE:
13611 case PRIVATE:
13612 case PROCEDURE:
13613 case RANGE:
13614 case RAW:
13615 case REAL:
13616 case RECORD:
13617 case REF:
13618 case RELEASE:
13619 case RELIES_ON:
13620 case RENAME:
13621 case RESULT:
13622 case RETURN:
13623 case RETURNING:
13624 case REVERSE:
13625 case ROLLBACK:
13626 case ROW:
13627 case ROWS:
13628 case ROWID:
13629 case ROWNUM:
13630 case SAVE:
13631 case SAVEPOINT:
13632 case SECOND:
13633 case SELF:
13634 case SET:
13635 case SPACE:
13636 case SQL:
13637 case SQLCODE:
13638 case SQLERRM:
13639 case STATIC:
13640 case SUBTYPE:
13641 case SUBSTITUTABLE:
13642 case SUCCESSFUL:
13643 case SYSDATE:
13644 case SYS_REFCURSOR:
13645 case TEMPORARY:
13646 case TIME:
13647 case TIMESTAMP:
13648 case TIMEZONE_REGION:
13649 case TIMEZONE_ABBR:
13650 case TIMEZONE_MINUTE:
13651 case TIMEZONE_HOUR:
13652 case TRANSACTION:
13653 case TRUE:
13654 case TYPE:
13655 case UNDER:
13656 case USING:
13657 case YES:
13658 case SHOW:
13659 case A:
13660 case DOUBLE:
13661 case DEC:
13662 case PRECISION:
13663 case INT:
13664 case NUMERIC:
13665 case NCHAR:
13666 case NVARCHAR2:
13667 case STRING:
13668 case UROWID:
13669 case VARRAY:
13670 case VARYING:
13671 case BFILE:
13672 case BLOB:
13673 case CLOB:
13674 case NCLOB:
13675 case YEAR:
13676 case LOCAL:
13677 case ZONE:
13678 case CHARACTER:
13679 case AFTER:
13680 case BEFORE:
13681 case OLD:
13682 case PARENT:
13683 case ANALYZE:
13684 case ASSOCIATE:
13685 case AUDIT:
13686 case COMPOUND:
13687 case DATABASE:
13688 case CALL:
13689 case DDL:
13690 case DISASSOCIATE:
13691 case EACH:
13692 case FOLLOWS:
13693 case LOGOFF:
13694 case LOGON:
13695 case NESTED:
13696 case NOAUDIT:
13697 case SCHEMA:
13698 case SERVERERROR:
13699 case SHUTDOWN:
13700 case STARTUP:
13701 case STATEMENT:
13702 case STATISTICS:
13703 case SUSPEND:
13704 case TRUNCATE:
13705 case WRAPPED:
13706 case LIBRARY:
13707 case NAME:
13708 case STRUCT:
13709 case CONTEXT:
13710 case PARAMETERS:
13711 case LENGTH:
13712 case TDO:
13713 case MAXLEN:
13714 case CHARSETID:
13715 case CHARSETFORM:
13716 case ACCEPT:
13717 case ACCESSIBLE:
13718 case COPY:
13719 case DEFINE:
13720 case DISCONNECT:
13721 case HOST:
13722 case PRINT:
13723 case QUIT:
13724 case REMARK:
13725 case UNDEFINE:
13726 case VARIABLE:
13727 case WHENEVER:
13728 case ATTACH:
13729 case CAST:
13730 case TREAT:
13731 case TRIM:
13732 case LEFT:
13733 case RIGHT:
13734 case BOTH:
13735 case EMPTY:
13736 case MULTISET:
13737 case SUBMULTISET:
13738 case LEADING:
13739 case TRAILING:
13740 case CHAR_CS:
13741 case NCHAR_CS:
13742 case DBTIMEZONE:
13743 case SESSIONTIMEZONE:
13744 case AUTHENTICATED:
13745 case LINK:
13746 case SHARED:
13747 case DIRECTORY:
13748 case USER:
13749 case IDENTIFIER:
13750 case QUOTED_LITERAL:
13751 label = UnqualifiedID();
13752 break;
13753 default:
13754 jj_la1[148] = jj_gen;
13755 ;
13756 }
13757 switch (jj_nt.kind) {
13758 case WHEN:
13759 jj_consume_token(WHEN);
13760 Expression();
13761 break;
13762 default:
13763 jj_la1[149] = jj_gen;
13764 ;
13765 }
13766 jjtree.closeNodeScope(jjtn000, true);
13767 jjtc000 = false;
13768 if (null != label) { jjtn000.setImage(label.getImage()) ; } {if (true) return jjtn000 ;}
13769 } catch (Throwable jjte000) {
13770 if (jjtc000) {
13771 jjtree.clearNodeScope(jjtn000);
13772 jjtc000 = false;
13773 } else {
13774 jjtree.popNode();
13775 }
13776 if (jjte000 instanceof RuntimeException) {
13777 {if (true) throw (RuntimeException)jjte000;}
13778 }
13779 if (jjte000 instanceof ParseException) {
13780 {if (true) throw (ParseException)jjte000;}
13781 }
13782 {if (true) throw (Error)jjte000;}
13783 } finally {
13784 if (jjtc000) {
13785 jjtree.closeNodeScope(jjtn000, true);
13786 }
13787 }
13788 throw new Error("Missing return statement in function");
13789 }
13790
13791 final public ASTRaiseStatement RaiseStatement() throws ParseException {
13792
13793 ASTRaiseStatement jjtn000 = new ASTRaiseStatement(this, JJTRAISESTATEMENT);
13794 boolean jjtc000 = true;
13795 jjtree.openNodeScope(jjtn000);PLSQLNode exception = null ;
13796 try {
13797 jj_consume_token(RAISE);
13798 switch (jj_nt.kind) {
13799 case REPLACE:
13800 case DEFINER:
13801 case CURRENT_USER:
13802 case LANGUAGE:
13803 case INLINE:
13804 case ADD:
13805 case AGGREGATE:
13806 case ARRAY:
13807 case AT:
13808 case ATTRIBUTE:
13809 case AUTHID:
13810 case BODY:
13811 case BULK:
13812 case BYTE:
13813 case CASCADE:
13814 case CLOSE:
13815 case COALESCE:
13816 case COLLECT:
13817 case COLUMN:
13818 case COMMENT:
13819 case COMMIT:
13820 case CONSTRUCTOR:
13821 case CONTINUE:
13822 case CONVERT:
13823 case CURRENT:
13824 case CURSOR:
13825 case DATA:
13826 case DAY:
13827 case DISABLE:
13828 case EDITIONABLE:
13829 case ELEMENT:
13830 case ENABLE:
13831 case ESCAPE:
13832 case EXCEPT:
13833 case EXCEPTIONS:
13834 case EXIT:
13835 case EXTERNAL:
13836 case EXTENDS:
13837 case EXTRACT:
13838 case FALSE:
13839 case FINAL:
13840 case FORCE:
13841 case FUNCTION:
13842 case GLOBAL:
13843 case HASH:
13844 case HEAP:
13845 case HOUR:
13846 case IMMEDIATE:
13847 case INDICES:
13848 case INDEXTYPE:
13849 case INDICATOR:
13850 case INSTANTIABLE:
13851 case INTERVAL:
13852 case INVALIDATE:
13853 case ISOLATION:
13854 case JAVA:
13855 case LEVEL:
13856 case LIMIT:
13857 case LOOP:
13858 case MAP:
13859 case MAX:
13860 case MEMBER:
13861 case MERGE:
13862 case MIN:
13863 case MINUTE:
13864 case MLSLABEL:
13865 case MODIFY:
13866 case MOD:
13867 case MONTH:
13868 case NATURAL:
13869 case NEW:
13870 case NO:
13871 case NONEDITIONABLE:
13872 case NULLIF:
13873 case OBJECT:
13874 case OID:
13875 case OPAQUE:
13876 case OPEN:
13877 case OPERATOR:
13878 case ORGANIZATION:
13879 case OTHERS:
13880 case OVERRIDING:
13881 case PACKAGE:
13882 case PARTITION:
13883 case PRESERVE:
13884 case PRIVATE:
13885 case PROCEDURE:
13886 case RANGE:
13887 case RAW:
13888 case REAL:
13889 case RECORD:
13890 case REF:
13891 case RELEASE:
13892 case RELIES_ON:
13893 case RENAME:
13894 case RESULT:
13895 case RETURN:
13896 case RETURNING:
13897 case REVERSE:
13898 case ROLLBACK:
13899 case ROW:
13900 case ROWS:
13901 case ROWID:
13902 case ROWNUM:
13903 case SAVE:
13904 case SAVEPOINT:
13905 case SECOND:
13906 case SELF:
13907 case SET:
13908 case SPACE:
13909 case SQL:
13910 case SQLCODE:
13911 case SQLERRM:
13912 case STATIC:
13913 case SUBTYPE:
13914 case SUBSTITUTABLE:
13915 case SUCCESSFUL:
13916 case SYSDATE:
13917 case SYS_REFCURSOR:
13918 case TEMPORARY:
13919 case TIME:
13920 case TIMESTAMP:
13921 case TIMEZONE_REGION:
13922 case TIMEZONE_ABBR:
13923 case TIMEZONE_MINUTE:
13924 case TIMEZONE_HOUR:
13925 case TRANSACTION:
13926 case TRUE:
13927 case TYPE:
13928 case UNDER:
13929 case USING:
13930 case YES:
13931 case SHOW:
13932 case A:
13933 case DOUBLE:
13934 case DEC:
13935 case PRECISION:
13936 case INT:
13937 case NUMERIC:
13938 case NCHAR:
13939 case NVARCHAR2:
13940 case STRING:
13941 case UROWID:
13942 case VARRAY:
13943 case VARYING:
13944 case BFILE:
13945 case BLOB:
13946 case CLOB:
13947 case NCLOB:
13948 case YEAR:
13949 case LOCAL:
13950 case ZONE:
13951 case CHARACTER:
13952 case AFTER:
13953 case BEFORE:
13954 case OLD:
13955 case PARENT:
13956 case ANALYZE:
13957 case ASSOCIATE:
13958 case AUDIT:
13959 case COMPOUND:
13960 case DATABASE:
13961 case CALL:
13962 case DDL:
13963 case DISASSOCIATE:
13964 case EACH:
13965 case FOLLOWS:
13966 case LOGOFF:
13967 case LOGON:
13968 case NESTED:
13969 case NOAUDIT:
13970 case SCHEMA:
13971 case SERVERERROR:
13972 case SHUTDOWN:
13973 case STARTUP:
13974 case STATEMENT:
13975 case STATISTICS:
13976 case SUSPEND:
13977 case TRUNCATE:
13978 case WRAPPED:
13979 case LIBRARY:
13980 case NAME:
13981 case STRUCT:
13982 case CONTEXT:
13983 case PARAMETERS:
13984 case LENGTH:
13985 case TDO:
13986 case MAXLEN:
13987 case CHARSETID:
13988 case CHARSETFORM:
13989 case ACCEPT:
13990 case ACCESSIBLE:
13991 case COPY:
13992 case DEFINE:
13993 case DISCONNECT:
13994 case HOST:
13995 case PRINT:
13996 case QUIT:
13997 case REMARK:
13998 case UNDEFINE:
13999 case VARIABLE:
14000 case WHENEVER:
14001 case ATTACH:
14002 case CAST:
14003 case TREAT:
14004 case TRIM:
14005 case LEFT:
14006 case RIGHT:
14007 case BOTH:
14008 case EMPTY:
14009 case MULTISET:
14010 case SUBMULTISET:
14011 case LEADING:
14012 case TRAILING:
14013 case CHAR_CS:
14014 case NCHAR_CS:
14015 case DBTIMEZONE:
14016 case SESSIONTIMEZONE:
14017 case AUTHENTICATED:
14018 case LINK:
14019 case SHARED:
14020 case DIRECTORY:
14021 case USER:
14022 case IDENTIFIER:
14023 case QUOTED_LITERAL:
14024 exception = QualifiedName();
14025 break;
14026 default:
14027 jj_la1[150] = jj_gen;
14028 ;
14029 }
14030 jjtree.closeNodeScope(jjtn000, true);
14031 jjtc000 = false;
14032 if (null != exception) { jjtn000.setImage(exception.getImage()) ; } {if (true) return jjtn000 ;}
14033 } catch (Throwable jjte000) {
14034 if (jjtc000) {
14035 jjtree.clearNodeScope(jjtn000);
14036 jjtc000 = false;
14037 } else {
14038 jjtree.popNode();
14039 }
14040 if (jjte000 instanceof RuntimeException) {
14041 {if (true) throw (RuntimeException)jjte000;}
14042 }
14043 if (jjte000 instanceof ParseException) {
14044 {if (true) throw (ParseException)jjte000;}
14045 }
14046 {if (true) throw (Error)jjte000;}
14047 } finally {
14048 if (jjtc000) {
14049 jjtree.closeNodeScope(jjtn000, true);
14050 }
14051 }
14052 throw new Error("Missing return statement in function");
14053 }
14054
14055 final public ASTCloseStatement CloseStatement() throws ParseException {
14056
14057 ASTCloseStatement jjtn000 = new ASTCloseStatement(this, JJTCLOSESTATEMENT);
14058 boolean jjtc000 = true;
14059 jjtree.openNodeScope(jjtn000);PLSQLNode cursor = null ;
14060 try {
14061 jj_consume_token(CLOSE);
14062 cursor = QualifiedName();
14063 jjtree.closeNodeScope(jjtn000, true);
14064 jjtc000 = false;
14065 jjtn000.setImage(cursor.getImage()) ; {if (true) return jjtn000 ;}
14066 } catch (Throwable jjte000) {
14067 if (jjtc000) {
14068 jjtree.clearNodeScope(jjtn000);
14069 jjtc000 = false;
14070 } else {
14071 jjtree.popNode();
14072 }
14073 if (jjte000 instanceof RuntimeException) {
14074 {if (true) throw (RuntimeException)jjte000;}
14075 }
14076 if (jjte000 instanceof ParseException) {
14077 {if (true) throw (ParseException)jjte000;}
14078 }
14079 {if (true) throw (Error)jjte000;}
14080 } finally {
14081 if (jjtc000) {
14082 jjtree.closeNodeScope(jjtn000, true);
14083 }
14084 }
14085 throw new Error("Missing return statement in function");
14086 }
14087
14088 final public ASTOpenStatement OpenStatement() throws ParseException {
14089
14090 ASTOpenStatement jjtn000 = new ASTOpenStatement(this, JJTOPENSTATEMENT);
14091 boolean jjtc000 = true;
14092 jjtree.openNodeScope(jjtn000);
14093 try {
14094 jj_consume_token(OPEN);
14095 switch (jj_nt.kind) {
14096 case 5:
14097 case 16:
14098 case 17:
14099 case REPLACE:
14100 case DEFINER:
14101 case CURRENT_USER:
14102 case LANGUAGE:
14103 case INLINE:
14104 case ADD:
14105 case AGGREGATE:
14106 case ARRAY:
14107 case AT:
14108 case ATTRIBUTE:
14109 case AUTHID:
14110 case BODY:
14111 case BULK:
14112 case BYTE:
14113 case CASCADE:
14114 case CASE:
14115 case CLOSE:
14116 case COALESCE:
14117 case COLLECT:
14118 case COLUMN:
14119 case COMMENT:
14120 case COMMIT:
14121 case CONSTRUCTOR:
14122 case CONTINUE:
14123 case CONVERT:
14124 case CURRENT:
14125 case CURSOR:
14126 case DATA:
14127 case DATE:
14128 case DAY:
14129 case DISABLE:
14130 case EDITIONABLE:
14131 case ELEMENT:
14132 case ENABLE:
14133 case ESCAPE:
14134 case EXCEPT:
14135 case EXCEPTIONS:
14136 case EXIT:
14137 case EXTERNAL:
14138 case EXTENDS:
14139 case EXTRACT:
14140 case FALSE:
14141 case FINAL:
14142 case FORCE:
14143 case FUNCTION:
14144 case GLOBAL:
14145 case HASH:
14146 case HEAP:
14147 case HOUR:
14148 case IMMEDIATE:
14149 case INDICES:
14150 case INDEXTYPE:
14151 case INDICATOR:
14152 case INSTANTIABLE:
14153 case INTERVAL:
14154 case INVALIDATE:
14155 case ISOLATION:
14156 case JAVA:
14157 case LEVEL:
14158 case LIMIT:
14159 case LOOP:
14160 case MAP:
14161 case MAX:
14162 case MEMBER:
14163 case MERGE:
14164 case MIN:
14165 case MINUTE:
14166 case MLSLABEL:
14167 case MODIFY:
14168 case MOD:
14169 case MONTH:
14170 case NATURAL:
14171 case NEW:
14172 case NEW_DOT:
14173 case NO:
14174 case NONEDITIONABLE:
14175 case NOT:
14176 case NULL:
14177 case NULLIF:
14178 case OBJECT:
14179 case OID:
14180 case OPAQUE:
14181 case OPEN:
14182 case OPERATOR:
14183 case ORGANIZATION:
14184 case OTHERS:
14185 case OVERRIDING:
14186 case PACKAGE:
14187 case PARTITION:
14188 case PRESERVE:
14189 case PRIVATE:
14190 case PROCEDURE:
14191 case RANGE:
14192 case RAW:
14193 case REAL:
14194 case RECORD:
14195 case REF:
14196 case RELEASE:
14197 case RELIES_ON:
14198 case RENAME:
14199 case RESULT:
14200 case RETURN:
14201 case RETURNING:
14202 case REVERSE:
14203 case ROLLBACK:
14204 case ROW:
14205 case ROWS:
14206 case ROWID:
14207 case ROWNUM:
14208 case SAVE:
14209 case SAVEPOINT:
14210 case SECOND:
14211 case SELECT:
14212 case SELF:
14213 case SET:
14214 case SPACE:
14215 case SQL:
14216 case SQLCODE:
14217 case SQLERRM:
14218 case STATIC:
14219 case SUBTYPE:
14220 case SUBSTITUTABLE:
14221 case SUCCESSFUL:
14222 case SYSDATE:
14223 case SYS_REFCURSOR:
14224 case TEMPORARY:
14225 case TIME:
14226 case TIMESTAMP:
14227 case TIMEZONE_REGION:
14228 case TIMEZONE_ABBR:
14229 case TIMEZONE_MINUTE:
14230 case TIMEZONE_HOUR:
14231 case TRANSACTION:
14232 case TRUE:
14233 case TYPE:
14234 case UNDER:
14235 case USING:
14236 case YES:
14237 case SHOW:
14238 case A:
14239 case DOUBLE:
14240 case DEC:
14241 case PRECISION:
14242 case INT:
14243 case NUMERIC:
14244 case NCHAR:
14245 case NVARCHAR2:
14246 case STRING:
14247 case UROWID:
14248 case VARRAY:
14249 case VARYING:
14250 case BFILE:
14251 case BLOB:
14252 case CLOB:
14253 case NCLOB:
14254 case YEAR:
14255 case LOCAL:
14256 case WITH:
14257 case ZONE:
14258 case CHARACTER:
14259 case AFTER:
14260 case BEFORE:
14261 case OLD:
14262 case PARENT:
14263 case CC_IF:
14264 case ANALYZE:
14265 case ASSOCIATE:
14266 case AUDIT:
14267 case COMPOUND:
14268 case DATABASE:
14269 case CALL:
14270 case DDL:
14271 case DISASSOCIATE:
14272 case EACH:
14273 case FOLLOWS:
14274 case LOGOFF:
14275 case LOGON:
14276 case NESTED:
14277 case NOAUDIT:
14278 case SCHEMA:
14279 case SERVERERROR:
14280 case SHUTDOWN:
14281 case STARTUP:
14282 case STATEMENT:
14283 case STATISTICS:
14284 case SUSPEND:
14285 case TRUNCATE:
14286 case WRAPPED:
14287 case LIBRARY:
14288 case NAME:
14289 case STRUCT:
14290 case CONTEXT:
14291 case PARAMETERS:
14292 case LENGTH:
14293 case TDO:
14294 case MAXLEN:
14295 case CHARSETID:
14296 case CHARSETFORM:
14297 case ACCEPT:
14298 case ACCESSIBLE:
14299 case COPY:
14300 case DEFINE:
14301 case DISCONNECT:
14302 case HOST:
14303 case PRINT:
14304 case QUIT:
14305 case REMARK:
14306 case UNDEFINE:
14307 case VARIABLE:
14308 case WHENEVER:
14309 case ATTACH:
14310 case CAST:
14311 case TREAT:
14312 case TRIM:
14313 case LEFT:
14314 case RIGHT:
14315 case BOTH:
14316 case EMPTY:
14317 case MULTISET:
14318 case SUBMULTISET:
14319 case LEADING:
14320 case TRAILING:
14321 case CHAR_CS:
14322 case NCHAR_CS:
14323 case DBTIMEZONE:
14324 case SESSIONTIMEZONE:
14325 case AUTHENTICATED:
14326 case LINK:
14327 case SHARED:
14328 case DIRECTORY:
14329 case USER:
14330 case IDENTIFIER:
14331 case UNSIGNED_NUMERIC_LITERAL:
14332 case CHARACTER_LITERAL:
14333 case STRING_LITERAL:
14334 case QUOTED_LITERAL:
14335 Expression();
14336 break;
14337 default:
14338 jj_la1[151] = jj_gen;
14339 ;
14340 }
14341 switch (jj_nt.kind) {
14342 case FOR:
14343 jj_consume_token(FOR);
14344 Expression();
14345 switch (jj_nt.kind) {
14346 case USING:
14347 jj_consume_token(USING);
14348 Expression();
14349 label_34:
14350 while (true) {
14351 switch (jj_nt.kind) {
14352 case 6:
14353 ;
14354 break;
14355 default:
14356 jj_la1[152] = jj_gen;
14357 break label_34;
14358 }
14359 jj_consume_token(6);
14360 Expression();
14361 }
14362 break;
14363 default:
14364 jj_la1[153] = jj_gen;
14365 ;
14366 }
14367 break;
14368 default:
14369 jj_la1[154] = jj_gen;
14370 ;
14371 }
14372 jjtree.closeNodeScope(jjtn000, true);
14373 jjtc000 = false;
14374 {if (true) return jjtn000 ;}
14375 } catch (Throwable jjte000) {
14376 if (jjtc000) {
14377 jjtree.clearNodeScope(jjtn000);
14378 jjtc000 = false;
14379 } else {
14380 jjtree.popNode();
14381 }
14382 if (jjte000 instanceof RuntimeException) {
14383 {if (true) throw (RuntimeException)jjte000;}
14384 }
14385 if (jjte000 instanceof ParseException) {
14386 {if (true) throw (ParseException)jjte000;}
14387 }
14388 {if (true) throw (Error)jjte000;}
14389 } finally {
14390 if (jjtc000) {
14391 jjtree.closeNodeScope(jjtn000, true);
14392 }
14393 }
14394 throw new Error("Missing return statement in function");
14395 }
14396
14397 final public ASTFetchStatement FetchStatement() throws ParseException {
14398
14399 ASTFetchStatement jjtn000 = new ASTFetchStatement(this, JJTFETCHSTATEMENT);
14400 boolean jjtc000 = true;
14401 jjtree.openNodeScope(jjtn000);
14402 try {
14403 jj_consume_token(FETCH);
14404 QualifiedName();
14405 switch (jj_nt.kind) {
14406 case BULK:
14407 jj_consume_token(BULK);
14408 jj_consume_token(COLLECT);
14409 break;
14410 default:
14411 jj_la1[155] = jj_gen;
14412 ;
14413 }
14414 jj_consume_token(INTO);
14415 Expression();
14416 label_35:
14417 while (true) {
14418 switch (jj_nt.kind) {
14419 case 6:
14420 ;
14421 break;
14422 default:
14423 jj_la1[156] = jj_gen;
14424 break label_35;
14425 }
14426 jj_consume_token(6);
14427 Expression();
14428 }
14429 switch (jj_nt.kind) {
14430 case LIMIT:
14431 jj_consume_token(LIMIT);
14432 Expression();
14433 break;
14434 default:
14435 jj_la1[157] = jj_gen;
14436 ;
14437 }
14438 jjtree.closeNodeScope(jjtn000, true);
14439 jjtc000 = false;
14440 {if (true) return jjtn000 ;}
14441 } catch (Throwable jjte000) {
14442 if (jjtc000) {
14443 jjtree.clearNodeScope(jjtn000);
14444 jjtc000 = false;
14445 } else {
14446 jjtree.popNode();
14447 }
14448 if (jjte000 instanceof RuntimeException) {
14449 {if (true) throw (RuntimeException)jjte000;}
14450 }
14451 if (jjte000 instanceof ParseException) {
14452 {if (true) throw (ParseException)jjte000;}
14453 }
14454 {if (true) throw (Error)jjte000;}
14455 } finally {
14456 if (jjtc000) {
14457 jjtree.closeNodeScope(jjtn000, true);
14458 }
14459 }
14460 throw new Error("Missing return statement in function");
14461 }
14462
14463 final public ASTEmbeddedSqlStatement EmbeddedSqlStatement() throws ParseException {
14464
14465 ASTEmbeddedSqlStatement jjtn000 = new ASTEmbeddedSqlStatement(this, JJTEMBEDDEDSQLSTATEMENT);
14466 boolean jjtc000 = true;
14467 jjtree.openNodeScope(jjtn000);
14468 try {
14469 jj_consume_token(EXECUTE);
14470 jj_consume_token(IMMEDIATE);
14471 Expression();
14472 switch (jj_nt.kind) {
14473 case INTO:
14474 jj_consume_token(INTO);
14475 Name();
14476 label_36:
14477 while (true) {
14478 switch (jj_nt.kind) {
14479 case 6:
14480 ;
14481 break;
14482 default:
14483 jj_la1[158] = jj_gen;
14484 break label_36;
14485 }
14486 jj_consume_token(6);
14487 Name();
14488 }
14489 break;
14490 default:
14491 jj_la1[159] = jj_gen;
14492 ;
14493 }
14494 switch (jj_nt.kind) {
14495 case USING:
14496 jj_consume_token(USING);
14497 switch (jj_nt.kind) {
14498 case IN:
14499 case OUT:
14500 switch (jj_nt.kind) {
14501 case IN:
14502 jj_consume_token(IN);
14503 switch (jj_nt.kind) {
14504 case OUT:
14505 jj_consume_token(OUT);
14506 break;
14507 default:
14508 jj_la1[160] = jj_gen;
14509 ;
14510 }
14511 break;
14512 case OUT:
14513 jj_consume_token(OUT);
14514 break;
14515 default:
14516 jj_la1[161] = jj_gen;
14517 jj_consume_token(-1);
14518 throw new ParseException();
14519 }
14520 break;
14521 default:
14522 jj_la1[162] = jj_gen;
14523 ;
14524 }
14525 Expression();
14526 label_37:
14527 while (true) {
14528 switch (jj_nt.kind) {
14529 case 6:
14530 ;
14531 break;
14532 default:
14533 jj_la1[163] = jj_gen;
14534 break label_37;
14535 }
14536 jj_consume_token(6);
14537 switch (jj_nt.kind) {
14538 case IN:
14539 case OUT:
14540 switch (jj_nt.kind) {
14541 case IN:
14542 jj_consume_token(IN);
14543 switch (jj_nt.kind) {
14544 case OUT:
14545 jj_consume_token(OUT);
14546 break;
14547 default:
14548 jj_la1[164] = jj_gen;
14549 ;
14550 }
14551 break;
14552 case OUT:
14553 jj_consume_token(OUT);
14554 break;
14555 default:
14556 jj_la1[165] = jj_gen;
14557 jj_consume_token(-1);
14558 throw new ParseException();
14559 }
14560 break;
14561 default:
14562 jj_la1[166] = jj_gen;
14563 ;
14564 }
14565 Expression();
14566 }
14567 break;
14568 default:
14569 jj_la1[167] = jj_gen;
14570 ;
14571 }
14572 switch (jj_nt.kind) {
14573 case RETURN:
14574 case RETURNING:
14575 switch (jj_nt.kind) {
14576 case RETURN:
14577 jj_consume_token(RETURN);
14578 break;
14579 case RETURNING:
14580 jj_consume_token(RETURNING);
14581 break;
14582 default:
14583 jj_la1[168] = jj_gen;
14584 jj_consume_token(-1);
14585 throw new ParseException();
14586 }
14587 jj_consume_token(INTO);
14588 Expression();
14589 label_38:
14590 while (true) {
14591 switch (jj_nt.kind) {
14592 case 6:
14593 ;
14594 break;
14595 default:
14596 jj_la1[169] = jj_gen;
14597 break label_38;
14598 }
14599 jj_consume_token(6);
14600 Expression();
14601 }
14602 break;
14603 default:
14604 jj_la1[170] = jj_gen;
14605 ;
14606 }
14607 jj_consume_token(4);
14608 jjtree.closeNodeScope(jjtn000, true);
14609 jjtc000 = false;
14610 {if (true) return jjtn000 ;}
14611 } catch (Throwable jjte000) {
14612 if (jjtc000) {
14613 jjtree.clearNodeScope(jjtn000);
14614 jjtc000 = false;
14615 } else {
14616 jjtree.popNode();
14617 }
14618 if (jjte000 instanceof RuntimeException) {
14619 {if (true) throw (RuntimeException)jjte000;}
14620 }
14621 if (jjte000 instanceof ParseException) {
14622 {if (true) throw (ParseException)jjte000;}
14623 }
14624 {if (true) throw (Error)jjte000;}
14625 } finally {
14626 if (jjtc000) {
14627 jjtree.closeNodeScope(jjtn000, true);
14628 }
14629 }
14630 throw new Error("Missing return statement in function");
14631 }
14632
14633 final public ASTPipelineStatement PipelineStatement() throws ParseException {
14634
14635 ASTPipelineStatement jjtn000 = new ASTPipelineStatement(this, JJTPIPELINESTATEMENT);
14636 boolean jjtc000 = true;
14637 jjtree.openNodeScope(jjtn000);
14638 try {
14639 jj_consume_token(PIPE);
14640 jj_consume_token(ROW);
14641 Expression();
14642 jjtree.closeNodeScope(jjtn000, true);
14643 jjtc000 = false;
14644 {if (true) return jjtn000 ;}
14645 } catch (Throwable jjte000) {
14646 if (jjtc000) {
14647 jjtree.clearNodeScope(jjtn000);
14648 jjtc000 = false;
14649 } else {
14650 jjtree.popNode();
14651 }
14652 if (jjte000 instanceof RuntimeException) {
14653 {if (true) throw (RuntimeException)jjte000;}
14654 }
14655 if (jjte000 instanceof ParseException) {
14656 {if (true) throw (ParseException)jjte000;}
14657 }
14658 {if (true) throw (Error)jjte000;}
14659 } finally {
14660 if (jjtc000) {
14661 jjtree.closeNodeScope(jjtn000, true);
14662 }
14663 }
14664 throw new Error("Missing return statement in function");
14665 }
14666
14667 final public ASTConditionalCompilationStatement ConditionalCompilationStatement() throws ParseException {
14668
14669 ASTConditionalCompilationStatement jjtn000 = new ASTConditionalCompilationStatement(this, JJTCONDITIONALCOMPILATIONSTATEMENT);
14670 boolean jjtc000 = true;
14671 jjtree.openNodeScope(jjtn000);
14672 try {
14673 switch (jj_nt.kind) {
14674 case CC_IF:
14675 jj_consume_token(CC_IF);
14676 ConditionalOrExpression();
14677 jj_consume_token(CC_THEN);
14678 label_39:
14679 while (true) {
14680 switch (jj_nt.kind) {
14681 case 5:
14682 case 16:
14683 case 17:
14684 case 21:
14685 case REPLACE:
14686 case DEFINER:
14687 case CURRENT_USER:
14688 case LANGUAGE:
14689 case INLINE:
14690 case ADD:
14691 case AGGREGATE:
14692 case ARRAY:
14693 case AT:
14694 case ATTRIBUTE:
14695 case AUTHID:
14696 case BEGIN:
14697 case BODY:
14698 case BULK:
14699 case BYTE:
14700 case CASCADE:
14701 case CASE:
14702 case CLOSE:
14703 case COALESCE:
14704 case COLLECT:
14705 case COLUMN:
14706 case COMMENT:
14707 case COMMIT:
14708 case CONSTRUCTOR:
14709 case CONTINUE:
14710 case CONVERT:
14711 case CURRENT:
14712 case CURSOR:
14713 case DATA:
14714 case DATE:
14715 case DAY:
14716 case DECLARE:
14717 case DELETE:
14718 case DISABLE:
14719 case EDITIONABLE:
14720 case ELEMENT:
14721 case ENABLE:
14722 case ESCAPE:
14723 case EXCEPT:
14724 case EXCEPTIONS:
14725 case EXECUTE:
14726 case EXIT:
14727 case EXTERNAL:
14728 case EXTENDS:
14729 case EXTRACT:
14730 case FALSE:
14731 case FETCH:
14732 case FINAL:
14733 case FOR:
14734 case FORALL:
14735 case FORCE:
14736 case FUNCTION:
14737 case GLOBAL:
14738 case GOTO:
14739 case HASH:
14740 case HEAP:
14741 case HOUR:
14742 case IF:
14743 case IMMEDIATE:
14744 case INDICES:
14745 case INDEXTYPE:
14746 case INDICATOR:
14747 case INSERT:
14748 case INSTANTIABLE:
14749 case INTERVAL:
14750 case INVALIDATE:
14751 case ISOLATION:
14752 case JAVA:
14753 case LEVEL:
14754 case LIMIT:
14755 case LOCK:
14756 case LOOP:
14757 case MAP:
14758 case MAX:
14759 case MEMBER:
14760 case MERGE:
14761 case MIN:
14762 case MINUTE:
14763 case MLSLABEL:
14764 case MODIFY:
14765 case MOD:
14766 case MONTH:
14767 case NATURAL:
14768 case NEW:
14769 case NEW_DOT:
14770 case NO:
14771 case NONEDITIONABLE:
14772 case NOT:
14773 case NULL:
14774 case NULLIF:
14775 case OBJECT:
14776 case OID:
14777 case OPAQUE:
14778 case OPEN:
14779 case OPERATOR:
14780 case ORGANIZATION:
14781 case OTHERS:
14782 case OVERRIDING:
14783 case PACKAGE:
14784 case PARTITION:
14785 case PIPE:
14786 case PRAGMA:
14787 case PRESERVE:
14788 case PRIVATE:
14789 case PROCEDURE:
14790 case RAISE:
14791 case RANGE:
14792 case RAW:
14793 case REAL:
14794 case RECORD:
14795 case REF:
14796 case RELEASE:
14797 case RELIES_ON:
14798 case RENAME:
14799 case RESULT:
14800 case RETURN:
14801 case RETURNING:
14802 case REVERSE:
14803 case ROLLBACK:
14804 case ROW:
14805 case ROWS:
14806 case ROWID:
14807 case ROWNUM:
14808 case SAVE:
14809 case SAVEPOINT:
14810 case SECOND:
14811 case SELECT:
14812 case SELF:
14813 case SET:
14814 case SPACE:
14815 case SQL:
14816 case SQLCODE:
14817 case SQLERRM:
14818 case STATIC:
14819 case SUBTYPE:
14820 case SUBSTITUTABLE:
14821 case SUCCESSFUL:
14822 case SYSDATE:
14823 case SYS_REFCURSOR:
14824 case TEMPORARY:
14825 case TIME:
14826 case TIMESTAMP:
14827 case TIMEZONE_REGION:
14828 case TIMEZONE_ABBR:
14829 case TIMEZONE_MINUTE:
14830 case TIMEZONE_HOUR:
14831 case TRANSACTION:
14832 case TRUE:
14833 case TYPE:
14834 case UNDER:
14835 case USING:
14836 case WHILE:
14837 case YES:
14838 case SHOW:
14839 case A:
14840 case UPDATE:
14841 case DOUBLE:
14842 case DEC:
14843 case PRECISION:
14844 case INT:
14845 case NUMERIC:
14846 case NCHAR:
14847 case NVARCHAR2:
14848 case STRING:
14849 case UROWID:
14850 case VARRAY:
14851 case VARYING:
14852 case BFILE:
14853 case BLOB:
14854 case CLOB:
14855 case NCLOB:
14856 case YEAR:
14857 case LOCAL:
14858 case WITH:
14859 case ZONE:
14860 case CHARACTER:
14861 case AFTER:
14862 case BEFORE:
14863 case OLD:
14864 case PARENT:
14865 case CC_IF:
14866 case CC_ERROR:
14867 case ANALYZE:
14868 case ASSOCIATE:
14869 case AUDIT:
14870 case COMPOUND:
14871 case DATABASE:
14872 case CALL:
14873 case DDL:
14874 case DISASSOCIATE:
14875 case EACH:
14876 case FOLLOWS:
14877 case LOGOFF:
14878 case LOGON:
14879 case NESTED:
14880 case NOAUDIT:
14881 case SCHEMA:
14882 case SERVERERROR:
14883 case SHUTDOWN:
14884 case STARTUP:
14885 case STATEMENT:
14886 case STATISTICS:
14887 case SUSPEND:
14888 case TRUNCATE:
14889 case WRAPPED:
14890 case LIBRARY:
14891 case NAME:
14892 case STRUCT:
14893 case CONTEXT:
14894 case PARAMETERS:
14895 case LENGTH:
14896 case TDO:
14897 case MAXLEN:
14898 case CHARSETID:
14899 case CHARSETFORM:
14900 case ACCEPT:
14901 case ACCESSIBLE:
14902 case COPY:
14903 case DEFINE:
14904 case DISCONNECT:
14905 case HOST:
14906 case PRINT:
14907 case QUIT:
14908 case REMARK:
14909 case UNDEFINE:
14910 case VARIABLE:
14911 case WHENEVER:
14912 case ATTACH:
14913 case CAST:
14914 case TREAT:
14915 case TRIM:
14916 case LEFT:
14917 case RIGHT:
14918 case BOTH:
14919 case EMPTY:
14920 case MULTISET:
14921 case SUBMULTISET:
14922 case LEADING:
14923 case TRAILING:
14924 case CHAR_CS:
14925 case NCHAR_CS:
14926 case DBTIMEZONE:
14927 case SESSIONTIMEZONE:
14928 case AUTHENTICATED:
14929 case LINK:
14930 case SHARED:
14931 case DIRECTORY:
14932 case USER:
14933 case IDENTIFIER:
14934 case UNSIGNED_NUMERIC_LITERAL:
14935 case CHARACTER_LITERAL:
14936 case STRING_LITERAL:
14937 case QUOTED_LITERAL:
14938 ;
14939 break;
14940 default:
14941 jj_la1[171] = jj_gen;
14942 break label_39;
14943 }
14944 Statement();
14945 }
14946 label_40:
14947 while (true) {
14948 switch (jj_nt.kind) {
14949 case CC_ELSIF:
14950 ;
14951 break;
14952 default:
14953 jj_la1[172] = jj_gen;
14954 break label_40;
14955 }
14956 jj_consume_token(CC_ELSIF);
14957 ConditionalOrExpression();
14958 jj_consume_token(CC_THEN);
14959 label_41:
14960 while (true) {
14961 Statement();
14962 switch (jj_nt.kind) {
14963 case 5:
14964 case 16:
14965 case 17:
14966 case 21:
14967 case REPLACE:
14968 case DEFINER:
14969 case CURRENT_USER:
14970 case LANGUAGE:
14971 case INLINE:
14972 case ADD:
14973 case AGGREGATE:
14974 case ARRAY:
14975 case AT:
14976 case ATTRIBUTE:
14977 case AUTHID:
14978 case BEGIN:
14979 case BODY:
14980 case BULK:
14981 case BYTE:
14982 case CASCADE:
14983 case CASE:
14984 case CLOSE:
14985 case COALESCE:
14986 case COLLECT:
14987 case COLUMN:
14988 case COMMENT:
14989 case COMMIT:
14990 case CONSTRUCTOR:
14991 case CONTINUE:
14992 case CONVERT:
14993 case CURRENT:
14994 case CURSOR:
14995 case DATA:
14996 case DATE:
14997 case DAY:
14998 case DECLARE:
14999 case DELETE:
15000 case DISABLE:
15001 case EDITIONABLE:
15002 case ELEMENT:
15003 case ENABLE:
15004 case ESCAPE:
15005 case EXCEPT:
15006 case EXCEPTIONS:
15007 case EXECUTE:
15008 case EXIT:
15009 case EXTERNAL:
15010 case EXTENDS:
15011 case EXTRACT:
15012 case FALSE:
15013 case FETCH:
15014 case FINAL:
15015 case FOR:
15016 case FORALL:
15017 case FORCE:
15018 case FUNCTION:
15019 case GLOBAL:
15020 case GOTO:
15021 case HASH:
15022 case HEAP:
15023 case HOUR:
15024 case IF:
15025 case IMMEDIATE:
15026 case INDICES:
15027 case INDEXTYPE:
15028 case INDICATOR:
15029 case INSERT:
15030 case INSTANTIABLE:
15031 case INTERVAL:
15032 case INVALIDATE:
15033 case ISOLATION:
15034 case JAVA:
15035 case LEVEL:
15036 case LIMIT:
15037 case LOCK:
15038 case LOOP:
15039 case MAP:
15040 case MAX:
15041 case MEMBER:
15042 case MERGE:
15043 case MIN:
15044 case MINUTE:
15045 case MLSLABEL:
15046 case MODIFY:
15047 case MOD:
15048 case MONTH:
15049 case NATURAL:
15050 case NEW:
15051 case NEW_DOT:
15052 case NO:
15053 case NONEDITIONABLE:
15054 case NOT:
15055 case NULL:
15056 case NULLIF:
15057 case OBJECT:
15058 case OID:
15059 case OPAQUE:
15060 case OPEN:
15061 case OPERATOR:
15062 case ORGANIZATION:
15063 case OTHERS:
15064 case OVERRIDING:
15065 case PACKAGE:
15066 case PARTITION:
15067 case PIPE:
15068 case PRAGMA:
15069 case PRESERVE:
15070 case PRIVATE:
15071 case PROCEDURE:
15072 case RAISE:
15073 case RANGE:
15074 case RAW:
15075 case REAL:
15076 case RECORD:
15077 case REF:
15078 case RELEASE:
15079 case RELIES_ON:
15080 case RENAME:
15081 case RESULT:
15082 case RETURN:
15083 case RETURNING:
15084 case REVERSE:
15085 case ROLLBACK:
15086 case ROW:
15087 case ROWS:
15088 case ROWID:
15089 case ROWNUM:
15090 case SAVE:
15091 case SAVEPOINT:
15092 case SECOND:
15093 case SELECT:
15094 case SELF:
15095 case SET:
15096 case SPACE:
15097 case SQL:
15098 case SQLCODE:
15099 case SQLERRM:
15100 case STATIC:
15101 case SUBTYPE:
15102 case SUBSTITUTABLE:
15103 case SUCCESSFUL:
15104 case SYSDATE:
15105 case SYS_REFCURSOR:
15106 case TEMPORARY:
15107 case TIME:
15108 case TIMESTAMP:
15109 case TIMEZONE_REGION:
15110 case TIMEZONE_ABBR:
15111 case TIMEZONE_MINUTE:
15112 case TIMEZONE_HOUR:
15113 case TRANSACTION:
15114 case TRUE:
15115 case TYPE:
15116 case UNDER:
15117 case USING:
15118 case WHILE:
15119 case YES:
15120 case SHOW:
15121 case A:
15122 case UPDATE:
15123 case DOUBLE:
15124 case DEC:
15125 case PRECISION:
15126 case INT:
15127 case NUMERIC:
15128 case NCHAR:
15129 case NVARCHAR2:
15130 case STRING:
15131 case UROWID:
15132 case VARRAY:
15133 case VARYING:
15134 case BFILE:
15135 case BLOB:
15136 case CLOB:
15137 case NCLOB:
15138 case YEAR:
15139 case LOCAL:
15140 case WITH:
15141 case ZONE:
15142 case CHARACTER:
15143 case AFTER:
15144 case BEFORE:
15145 case OLD:
15146 case PARENT:
15147 case CC_IF:
15148 case CC_ERROR:
15149 case ANALYZE:
15150 case ASSOCIATE:
15151 case AUDIT:
15152 case COMPOUND:
15153 case DATABASE:
15154 case CALL:
15155 case DDL:
15156 case DISASSOCIATE:
15157 case EACH:
15158 case FOLLOWS:
15159 case LOGOFF:
15160 case LOGON:
15161 case NESTED:
15162 case NOAUDIT:
15163 case SCHEMA:
15164 case SERVERERROR:
15165 case SHUTDOWN:
15166 case STARTUP:
15167 case STATEMENT:
15168 case STATISTICS:
15169 case SUSPEND:
15170 case TRUNCATE:
15171 case WRAPPED:
15172 case LIBRARY:
15173 case NAME:
15174 case STRUCT:
15175 case CONTEXT:
15176 case PARAMETERS:
15177 case LENGTH:
15178 case TDO:
15179 case MAXLEN:
15180 case CHARSETID:
15181 case CHARSETFORM:
15182 case ACCEPT:
15183 case ACCESSIBLE:
15184 case COPY:
15185 case DEFINE:
15186 case DISCONNECT:
15187 case HOST:
15188 case PRINT:
15189 case QUIT:
15190 case REMARK:
15191 case UNDEFINE:
15192 case VARIABLE:
15193 case WHENEVER:
15194 case ATTACH:
15195 case CAST:
15196 case TREAT:
15197 case TRIM:
15198 case LEFT:
15199 case RIGHT:
15200 case BOTH:
15201 case EMPTY:
15202 case MULTISET:
15203 case SUBMULTISET:
15204 case LEADING:
15205 case TRAILING:
15206 case CHAR_CS:
15207 case NCHAR_CS:
15208 case DBTIMEZONE:
15209 case SESSIONTIMEZONE:
15210 case AUTHENTICATED:
15211 case LINK:
15212 case SHARED:
15213 case DIRECTORY:
15214 case USER:
15215 case IDENTIFIER:
15216 case UNSIGNED_NUMERIC_LITERAL:
15217 case CHARACTER_LITERAL:
15218 case STRING_LITERAL:
15219 case QUOTED_LITERAL:
15220 ;
15221 break;
15222 default:
15223 jj_la1[173] = jj_gen;
15224 break label_41;
15225 }
15226 }
15227 }
15228 label_42:
15229 while (true) {
15230 switch (jj_nt.kind) {
15231 case CC_ELSE:
15232 ;
15233 break;
15234 default:
15235 jj_la1[174] = jj_gen;
15236 break label_42;
15237 }
15238 jj_consume_token(CC_ELSE);
15239 label_43:
15240 while (true) {
15241 Statement();
15242 switch (jj_nt.kind) {
15243 case 5:
15244 case 16:
15245 case 17:
15246 case 21:
15247 case REPLACE:
15248 case DEFINER:
15249 case CURRENT_USER:
15250 case LANGUAGE:
15251 case INLINE:
15252 case ADD:
15253 case AGGREGATE:
15254 case ARRAY:
15255 case AT:
15256 case ATTRIBUTE:
15257 case AUTHID:
15258 case BEGIN:
15259 case BODY:
15260 case BULK:
15261 case BYTE:
15262 case CASCADE:
15263 case CASE:
15264 case CLOSE:
15265 case COALESCE:
15266 case COLLECT:
15267 case COLUMN:
15268 case COMMENT:
15269 case COMMIT:
15270 case CONSTRUCTOR:
15271 case CONTINUE:
15272 case CONVERT:
15273 case CURRENT:
15274 case CURSOR:
15275 case DATA:
15276 case DATE:
15277 case DAY:
15278 case DECLARE:
15279 case DELETE:
15280 case DISABLE:
15281 case EDITIONABLE:
15282 case ELEMENT:
15283 case ENABLE:
15284 case ESCAPE:
15285 case EXCEPT:
15286 case EXCEPTIONS:
15287 case EXECUTE:
15288 case EXIT:
15289 case EXTERNAL:
15290 case EXTENDS:
15291 case EXTRACT:
15292 case FALSE:
15293 case FETCH:
15294 case FINAL:
15295 case FOR:
15296 case FORALL:
15297 case FORCE:
15298 case FUNCTION:
15299 case GLOBAL:
15300 case GOTO:
15301 case HASH:
15302 case HEAP:
15303 case HOUR:
15304 case IF:
15305 case IMMEDIATE:
15306 case INDICES:
15307 case INDEXTYPE:
15308 case INDICATOR:
15309 case INSERT:
15310 case INSTANTIABLE:
15311 case INTERVAL:
15312 case INVALIDATE:
15313 case ISOLATION:
15314 case JAVA:
15315 case LEVEL:
15316 case LIMIT:
15317 case LOCK:
15318 case LOOP:
15319 case MAP:
15320 case MAX:
15321 case MEMBER:
15322 case MERGE:
15323 case MIN:
15324 case MINUTE:
15325 case MLSLABEL:
15326 case MODIFY:
15327 case MOD:
15328 case MONTH:
15329 case NATURAL:
15330 case NEW:
15331 case NEW_DOT:
15332 case NO:
15333 case NONEDITIONABLE:
15334 case NOT:
15335 case NULL:
15336 case NULLIF:
15337 case OBJECT:
15338 case OID:
15339 case OPAQUE:
15340 case OPEN:
15341 case OPERATOR:
15342 case ORGANIZATION:
15343 case OTHERS:
15344 case OVERRIDING:
15345 case PACKAGE:
15346 case PARTITION:
15347 case PIPE:
15348 case PRAGMA:
15349 case PRESERVE:
15350 case PRIVATE:
15351 case PROCEDURE:
15352 case RAISE:
15353 case RANGE:
15354 case RAW:
15355 case REAL:
15356 case RECORD:
15357 case REF:
15358 case RELEASE:
15359 case RELIES_ON:
15360 case RENAME:
15361 case RESULT:
15362 case RETURN:
15363 case RETURNING:
15364 case REVERSE:
15365 case ROLLBACK:
15366 case ROW:
15367 case ROWS:
15368 case ROWID:
15369 case ROWNUM:
15370 case SAVE:
15371 case SAVEPOINT:
15372 case SECOND:
15373 case SELECT:
15374 case SELF:
15375 case SET:
15376 case SPACE:
15377 case SQL:
15378 case SQLCODE:
15379 case SQLERRM:
15380 case STATIC:
15381 case SUBTYPE:
15382 case SUBSTITUTABLE:
15383 case SUCCESSFUL:
15384 case SYSDATE:
15385 case SYS_REFCURSOR:
15386 case TEMPORARY:
15387 case TIME:
15388 case TIMESTAMP:
15389 case TIMEZONE_REGION:
15390 case TIMEZONE_ABBR:
15391 case TIMEZONE_MINUTE:
15392 case TIMEZONE_HOUR:
15393 case TRANSACTION:
15394 case TRUE:
15395 case TYPE:
15396 case UNDER:
15397 case USING:
15398 case WHILE:
15399 case YES:
15400 case SHOW:
15401 case A:
15402 case UPDATE:
15403 case DOUBLE:
15404 case DEC:
15405 case PRECISION:
15406 case INT:
15407 case NUMERIC:
15408 case NCHAR:
15409 case NVARCHAR2:
15410 case STRING:
15411 case UROWID:
15412 case VARRAY:
15413 case VARYING:
15414 case BFILE:
15415 case BLOB:
15416 case CLOB:
15417 case NCLOB:
15418 case YEAR:
15419 case LOCAL:
15420 case WITH:
15421 case ZONE:
15422 case CHARACTER:
15423 case AFTER:
15424 case BEFORE:
15425 case OLD:
15426 case PARENT:
15427 case CC_IF:
15428 case CC_ERROR:
15429 case ANALYZE:
15430 case ASSOCIATE:
15431 case AUDIT:
15432 case COMPOUND:
15433 case DATABASE:
15434 case CALL:
15435 case DDL:
15436 case DISASSOCIATE:
15437 case EACH:
15438 case FOLLOWS:
15439 case LOGOFF:
15440 case LOGON:
15441 case NESTED:
15442 case NOAUDIT:
15443 case SCHEMA:
15444 case SERVERERROR:
15445 case SHUTDOWN:
15446 case STARTUP:
15447 case STATEMENT:
15448 case STATISTICS:
15449 case SUSPEND:
15450 case TRUNCATE:
15451 case WRAPPED:
15452 case LIBRARY:
15453 case NAME:
15454 case STRUCT:
15455 case CONTEXT:
15456 case PARAMETERS:
15457 case LENGTH:
15458 case TDO:
15459 case MAXLEN:
15460 case CHARSETID:
15461 case CHARSETFORM:
15462 case ACCEPT:
15463 case ACCESSIBLE:
15464 case COPY:
15465 case DEFINE:
15466 case DISCONNECT:
15467 case HOST:
15468 case PRINT:
15469 case QUIT:
15470 case REMARK:
15471 case UNDEFINE:
15472 case VARIABLE:
15473 case WHENEVER:
15474 case ATTACH:
15475 case CAST:
15476 case TREAT:
15477 case TRIM:
15478 case LEFT:
15479 case RIGHT:
15480 case BOTH:
15481 case EMPTY:
15482 case MULTISET:
15483 case SUBMULTISET:
15484 case LEADING:
15485 case TRAILING:
15486 case CHAR_CS:
15487 case NCHAR_CS:
15488 case DBTIMEZONE:
15489 case SESSIONTIMEZONE:
15490 case AUTHENTICATED:
15491 case LINK:
15492 case SHARED:
15493 case DIRECTORY:
15494 case USER:
15495 case IDENTIFIER:
15496 case UNSIGNED_NUMERIC_LITERAL:
15497 case CHARACTER_LITERAL:
15498 case STRING_LITERAL:
15499 case QUOTED_LITERAL:
15500 ;
15501 break;
15502 default:
15503 jj_la1[175] = jj_gen;
15504 break label_43;
15505 }
15506 }
15507 }
15508 jj_consume_token(CC_END);
15509 break;
15510 case CC_ERROR:
15511 jj_consume_token(CC_ERROR);
15512 Expression();
15513 jj_consume_token(CC_END);
15514 break;
15515 default:
15516 jj_la1[176] = jj_gen;
15517 jj_consume_token(-1);
15518 throw new ParseException();
15519 }
15520 jjtree.closeNodeScope(jjtn000, true);
15521 jjtc000 = false;
15522 {if (true) return jjtn000 ;}
15523 } catch (Throwable jjte000) {
15524 if (jjtc000) {
15525 jjtree.clearNodeScope(jjtn000);
15526 jjtc000 = false;
15527 } else {
15528 jjtree.popNode();
15529 }
15530 if (jjte000 instanceof RuntimeException) {
15531 {if (true) throw (RuntimeException)jjte000;}
15532 }
15533 if (jjte000 instanceof ParseException) {
15534 {if (true) throw (ParseException)jjte000;}
15535 }
15536 {if (true) throw (Error)jjte000;}
15537 } finally {
15538 if (jjtc000) {
15539 jjtree.closeNodeScope(jjtn000, true);
15540 }
15541 }
15542 throw new Error("Missing return statement in function");
15543 }
15544
15545 final public ASTSubTypeDefinition SubTypeDefinition() throws ParseException {
15546
15547 ASTSubTypeDefinition jjtn000 = new ASTSubTypeDefinition(this, JJTSUBTYPEDEFINITION);
15548 boolean jjtc000 = true;
15549 jjtree.openNodeScope(jjtn000);Token start, subtype_name=null, constraint=null, base_type=null;
15550 Token collection = null, collection2 = null;
15551 PLSQLNode name = null;
15552 PLSQLNode startElement = null, endElement = null;
15553 PLSQLNode baseType = null, returnType = null, indexBy = null ;
15554 int lastField = 0;
15555 try {
15556 switch (jj_nt.kind) {
15557 case SUBTYPE:
15558 jj_consume_token(SUBTYPE);
15559 name = QualifiedID();
15560 jj_consume_token(IS);
15561 Datatype();
15562 switch (jj_nt.kind) {
15563 case 5:
15564 case RANGE:
15565 switch (jj_nt.kind) {
15566 case 5:
15567 jj_consume_token(5);
15568 jj_consume_token(IDENTIFIER);
15569 jj_consume_token(7);
15570 break;
15571 case RANGE:
15572 jj_consume_token(RANGE);
15573 UnaryExpression(true);
15574 jj_consume_token(12);
15575 UnaryExpression(true);
15576 break;
15577 default:
15578 jj_la1[177] = jj_gen;
15579 jj_consume_token(-1);
15580 throw new ParseException();
15581 }
15582 break;
15583 default:
15584 jj_la1[178] = jj_gen;
15585 ;
15586 }
15587 switch (jj_nt.kind) {
15588 case NOT:
15589 jj_consume_token(NOT);
15590 jj_consume_token(NULL);
15591 break;
15592 default:
15593 jj_la1[179] = jj_gen;
15594 ;
15595 }
15596 break;
15597 case TYPE:
15598 jj_consume_token(TYPE);
15599 name = QualifiedID();
15600 switch (jj_nt.kind) {
15601 case IS:
15602 jj_consume_token(IS);
15603 break;
15604 case AS:
15605 jj_consume_token(AS);
15606 break;
15607 default:
15608 jj_la1[180] = jj_gen;
15609 jj_consume_token(-1);
15610 throw new ParseException();
15611 }
15612 if (jj_2_44(2)) {
15613 jj_consume_token(NEW);
15614 switch (jj_nt.kind) {
15615 case CHAR_BASE:
15616 jj_consume_token(CHAR_BASE);
15617 break;
15618 case DATE_BASE:
15619 jj_consume_token(DATE_BASE);
15620 break;
15621 case CLOB_BASE:
15622 jj_consume_token(CLOB_BASE);
15623 break;
15624 case BLOB_BASE:
15625 jj_consume_token(BLOB_BASE);
15626 break;
15627 case BFILE_BASE:
15628 jj_consume_token(BFILE_BASE);
15629 break;
15630 case NUMBER_BASE:
15631 jj_consume_token(NUMBER_BASE);
15632 break;
15633 default:
15634 jj_la1[181] = jj_gen;
15635 jj_consume_token(-1);
15636 throw new ParseException();
15637 }
15638 } else {
15639 switch (jj_nt.kind) {
15640 case OBJECT:
15641 jj_consume_token(OBJECT);
15642 jj_consume_token(5);
15643 FieldDeclaration();
15644 label_44:
15645 while (true) {
15646 switch (jj_nt.kind) {
15647 case 6:
15648 ;
15649 break;
15650 default:
15651 jj_la1[182] = jj_gen;
15652 break label_44;
15653 }
15654 jj_consume_token(6);
15655 FieldDeclaration();
15656 }
15657 jj_consume_token(7);
15658 break;
15659 case RECORD:
15660 jj_consume_token(RECORD);
15661 jj_consume_token(5);
15662 FieldDeclaration();
15663 label_45:
15664 while (true) {
15665 switch (jj_nt.kind) {
15666 case 6:
15667 ;
15668 break;
15669 default:
15670 jj_la1[183] = jj_gen;
15671 break label_45;
15672 }
15673 jj_consume_token(6);
15674 FieldDeclaration();
15675 }
15676 jj_consume_token(7);
15677 break;
15678 case TABLE:
15679 case VARRAY:
15680 case VARYING:
15681 switch (jj_nt.kind) {
15682 case TABLE:
15683 jj_consume_token(TABLE);
15684 break;
15685 case VARRAY:
15686 jj_consume_token(VARRAY);
15687 break;
15688 case VARYING:
15689 jj_consume_token(VARYING);
15690 jj_consume_token(ARRAY);
15691 break;
15692 default:
15693 jj_la1[184] = jj_gen;
15694 jj_consume_token(-1);
15695 throw new ParseException();
15696 }
15697 switch (jj_nt.kind) {
15698 case 5:
15699 jj_consume_token(5);
15700 NumericLiteral();
15701 jj_consume_token(7);
15702 break;
15703 default:
15704 jj_la1[185] = jj_gen;
15705 ;
15706 }
15707 jj_consume_token(OF);
15708 Datatype();
15709 switch (jj_nt.kind) {
15710 case NOT:
15711 jj_consume_token(NOT);
15712 jj_consume_token(NULL);
15713 break;
15714 default:
15715 jj_la1[186] = jj_gen;
15716 ;
15717 }
15718 switch (jj_nt.kind) {
15719 case INDEX:
15720 jj_consume_token(INDEX);
15721 jj_consume_token(BY);
15722 Datatype();
15723 break;
15724 default:
15725 jj_la1[187] = jj_gen;
15726 ;
15727 }
15728 break;
15729 case REF:
15730 jj_consume_token(REF);
15731 jj_consume_token(CURSOR);
15732 switch (jj_nt.kind) {
15733 case RETURN:
15734 jj_consume_token(RETURN);
15735 Datatype();
15736 break;
15737 default:
15738 jj_la1[188] = jj_gen;
15739 ;
15740 }
15741 break;
15742 case 5:
15743 jj_consume_token(5);
15744 Expression();
15745 label_46:
15746 while (true) {
15747 switch (jj_nt.kind) {
15748 case 6:
15749 ;
15750 break;
15751 default:
15752 jj_la1[189] = jj_gen;
15753 break label_46;
15754 }
15755 jj_consume_token(6);
15756 Expression();
15757 }
15758 jj_consume_token(7);
15759 break;
15760 case REPLACE:
15761 case DEFINER:
15762 case CURRENT_USER:
15763 case LANGUAGE:
15764 case INLINE:
15765 case ADD:
15766 case AGGREGATE:
15767 case ARRAY:
15768 case AT:
15769 case ATTRIBUTE:
15770 case AUTHID:
15771 case BINARY_INTEGER:
15772 case BODY:
15773 case BOOLEAN:
15774 case BULK:
15775 case BYTE:
15776 case CASCADE:
15777 case CHAR:
15778 case CHAR_BASE:
15779 case CLOSE:
15780 case COALESCE:
15781 case COLLECT:
15782 case COLUMN:
15783 case COMMENT:
15784 case COMMIT:
15785 case CONSTRUCTOR:
15786 case CONTINUE:
15787 case CONVERT:
15788 case CURRENT:
15789 case CURSOR:
15790 case DATA:
15791 case DATE:
15792 case DAY:
15793 case DECIMAL:
15794 case DISABLE:
15795 case EDITIONABLE:
15796 case ELEMENT:
15797 case ENABLE:
15798 case ESCAPE:
15799 case EXCEPT:
15800 case EXCEPTIONS:
15801 case EXIT:
15802 case EXTERNAL:
15803 case EXTENDS:
15804 case EXTRACT:
15805 case FALSE:
15806 case FINAL:
15807 case FLOAT:
15808 case FORCE:
15809 case FUNCTION:
15810 case GLOBAL:
15811 case HASH:
15812 case HEAP:
15813 case HOUR:
15814 case IMMEDIATE:
15815 case INDICES:
15816 case INDEXTYPE:
15817 case INDICATOR:
15818 case INSTANTIABLE:
15819 case INTEGER:
15820 case INTERVAL:
15821 case INVALIDATE:
15822 case ISOLATION:
15823 case JAVA:
15824 case LEVEL:
15825 case LIMIT:
15826 case LONG:
15827 case LOOP:
15828 case MAP:
15829 case MAX:
15830 case MEMBER:
15831 case MERGE:
15832 case MIN:
15833 case MINUTE:
15834 case MLSLABEL:
15835 case MODIFY:
15836 case MOD:
15837 case MONTH:
15838 case NATURAL:
15839 case NATURALN:
15840 case NEW:
15841 case NO:
15842 case NONEDITIONABLE:
15843 case NULLIF:
15844 case NUMBER:
15845 case BFILE_BASE:
15846 case BLOB_BASE:
15847 case CLOB_BASE:
15848 case DATE_BASE:
15849 case NUMBER_BASE:
15850 case OID:
15851 case OPAQUE:
15852 case OPEN:
15853 case OPERATOR:
15854 case ORGANIZATION:
15855 case OTHERS:
15856 case OVERRIDING:
15857 case PACKAGE:
15858 case PARTITION:
15859 case PLS_INTEGER:
15860 case POSITIVE:
15861 case POSITIVEN:
15862 case PRESERVE:
15863 case PRIVATE:
15864 case PROCEDURE:
15865 case RANGE:
15866 case RAW:
15867 case REAL:
15868 case RELEASE:
15869 case RELIES_ON:
15870 case RENAME:
15871 case RESULT:
15872 case RETURN:
15873 case RETURNING:
15874 case REVERSE:
15875 case ROLLBACK:
15876 case ROW:
15877 case ROWS:
15878 case ROWID:
15879 case ROWNUM:
15880 case SAVE:
15881 case SAVEPOINT:
15882 case SECOND:
15883 case SELF:
15884 case SET:
15885 case SMALLINT:
15886 case SPACE:
15887 case SQL:
15888 case SQLCODE:
15889 case SQLERRM:
15890 case STATIC:
15891 case SUBTYPE:
15892 case SUBSTITUTABLE:
15893 case SUCCESSFUL:
15894 case SYSDATE:
15895 case SYS_REFCURSOR:
15896 case TEMPORARY:
15897 case TIME:
15898 case TIMESTAMP:
15899 case TIMEZONE_REGION:
15900 case TIMEZONE_ABBR:
15901 case TIMEZONE_MINUTE:
15902 case TIMEZONE_HOUR:
15903 case TRANSACTION:
15904 case TRUE:
15905 case TYPE:
15906 case UNDER:
15907 case USING:
15908 case YES:
15909 case SHOW:
15910 case A:
15911 case VARCHAR:
15912 case VARCHAR2:
15913 case DOUBLE:
15914 case DEC:
15915 case PRECISION:
15916 case INT:
15917 case NUMERIC:
15918 case SIGNTYPE:
15919 case NCHAR:
15920 case NVARCHAR2:
15921 case STRING:
15922 case UROWID:
15923 case BFILE:
15924 case BLOB:
15925 case CLOB:
15926 case NCLOB:
15927 case YEAR:
15928 case LOCAL:
15929 case ZONE:
15930 case CHARACTER:
15931 case AFTER:
15932 case BEFORE:
15933 case OLD:
15934 case PARENT:
15935 case CC_IF:
15936 case ANALYZE:
15937 case ASSOCIATE:
15938 case AUDIT:
15939 case COMPOUND:
15940 case DATABASE:
15941 case CALL:
15942 case DDL:
15943 case DISASSOCIATE:
15944 case EACH:
15945 case FOLLOWS:
15946 case LOGOFF:
15947 case LOGON:
15948 case NESTED:
15949 case NOAUDIT:
15950 case SCHEMA:
15951 case SERVERERROR:
15952 case SHUTDOWN:
15953 case STARTUP:
15954 case STATEMENT:
15955 case STATISTICS:
15956 case SUSPEND:
15957 case TRUNCATE:
15958 case WRAPPED:
15959 case LIBRARY:
15960 case NAME:
15961 case STRUCT:
15962 case CONTEXT:
15963 case PARAMETERS:
15964 case LENGTH:
15965 case TDO:
15966 case MAXLEN:
15967 case CHARSETID:
15968 case CHARSETFORM:
15969 case ACCEPT:
15970 case ACCESSIBLE:
15971 case COPY:
15972 case DEFINE:
15973 case DISCONNECT:
15974 case HOST:
15975 case PRINT:
15976 case QUIT:
15977 case REMARK:
15978 case UNDEFINE:
15979 case VARIABLE:
15980 case WHENEVER:
15981 case ATTACH:
15982 case CAST:
15983 case TREAT:
15984 case TRIM:
15985 case LEFT:
15986 case RIGHT:
15987 case BOTH:
15988 case EMPTY:
15989 case MULTISET:
15990 case SUBMULTISET:
15991 case LEADING:
15992 case TRAILING:
15993 case CHAR_CS:
15994 case NCHAR_CS:
15995 case DBTIMEZONE:
15996 case SESSIONTIMEZONE:
15997 case AUTHENTICATED:
15998 case LINK:
15999 case SHARED:
16000 case DIRECTORY:
16001 case USER:
16002 case IDENTIFIER:
16003 case QUOTED_LITERAL:
16004 Datatype();
16005 break;
16006 default:
16007 jj_la1[190] = jj_gen;
16008 jj_consume_token(-1);
16009 throw new ParseException();
16010 }
16011 }
16012 break;
16013 default:
16014 jj_la1[191] = jj_gen;
16015 jj_consume_token(-1);
16016 throw new ParseException();
16017 }
16018 jj_consume_token(4);
16019 jjtree.closeNodeScope(jjtn000, true);
16020 jjtc000 = false;
16021 jjtn000.setImage(name.getImage()) ; {if (true) return jjtn000 ;}
16022 } catch (Throwable jjte000) {
16023 if (jjtc000) {
16024 jjtree.clearNodeScope(jjtn000);
16025 jjtc000 = false;
16026 } else {
16027 jjtree.popNode();
16028 }
16029 if (jjte000 instanceof RuntimeException) {
16030 {if (true) throw (RuntimeException)jjte000;}
16031 }
16032 if (jjte000 instanceof ParseException) {
16033 {if (true) throw (ParseException)jjte000;}
16034 }
16035 {if (true) throw (Error)jjte000;}
16036 } finally {
16037 if (jjtc000) {
16038 jjtree.closeNodeScope(jjtn000, true);
16039 }
16040 }
16041 throw new Error("Missing return statement in function");
16042 }
16043
16044 final public ASTFieldDeclaration FieldDeclaration() throws ParseException {
16045
16046 ASTFieldDeclaration jjtn000 = new ASTFieldDeclaration(this, JJTFIELDDECLARATION);
16047 boolean jjtc000 = true;
16048 jjtree.openNodeScope(jjtn000);PLSQLNode name;
16049 PLSQLNode dataType;
16050 PLSQLNode defaultValue = null;
16051 try {
16052 name = ID();
16053 Datatype();
16054 switch (jj_nt.kind) {
16055 case NOT:
16056 case NULL:
16057 switch (jj_nt.kind) {
16058 case NOT:
16059 jj_consume_token(NOT);
16060 break;
16061 default:
16062 jj_la1[192] = jj_gen;
16063 ;
16064 }
16065 jj_consume_token(NULL);
16066 break;
16067 default:
16068 jj_la1[193] = jj_gen;
16069 ;
16070 }
16071 switch (jj_nt.kind) {
16072 case 9:
16073 case _DEFAULT:
16074 switch (jj_nt.kind) {
16075 case 9:
16076 jj_consume_token(9);
16077 jj_consume_token(10);
16078 break;
16079 case _DEFAULT:
16080 jj_consume_token(_DEFAULT);
16081 break;
16082 default:
16083 jj_la1[194] = jj_gen;
16084 jj_consume_token(-1);
16085 throw new ParseException();
16086 }
16087 Expression();
16088 break;
16089 default:
16090 jj_la1[195] = jj_gen;
16091 ;
16092 }
16093 jjtree.closeNodeScope(jjtn000, true);
16094 jjtc000 = false;
16095 jjtn000.setImage(name.getImage()) ; {if (true) return jjtn000 ;}
16096 } catch (Throwable jjte000) {
16097 if (jjtc000) {
16098 jjtree.clearNodeScope(jjtn000);
16099 jjtc000 = false;
16100 } else {
16101 jjtree.popNode();
16102 }
16103 if (jjte000 instanceof RuntimeException) {
16104 {if (true) throw (RuntimeException)jjte000;}
16105 }
16106 if (jjte000 instanceof ParseException) {
16107 {if (true) throw (ParseException)jjte000;}
16108 }
16109 {if (true) throw (Error)jjte000;}
16110 } finally {
16111 if (jjtc000) {
16112 jjtree.closeNodeScope(jjtn000, true);
16113 }
16114 }
16115 throw new Error("Missing return statement in function");
16116 }
16117
16118 final public ASTCollectionTypeDefinition CollectionTypeDefinition() throws ParseException {
16119
16120 ASTCollectionTypeDefinition jjtn000 = new ASTCollectionTypeDefinition(this, JJTCOLLECTIONTYPEDEFINITION);
16121 boolean jjtc000 = true;
16122 jjtree.openNodeScope(jjtn000);Token t = null ;
16123 try {
16124 t = jj_consume_token(IDENTIFIER);
16125 jjtree.closeNodeScope(jjtn000, true);
16126 jjtc000 = false;
16127 jjtn000.setImage(t.image) ; {if (true) return jjtn000 ;}
16128 } finally {
16129 if (jjtc000) {
16130 jjtree.closeNodeScope(jjtn000, true);
16131 }
16132 }
16133 throw new Error("Missing return statement in function");
16134 }
16135
16136 final public ASTCollectionDeclaration CollectionDeclaration() throws ParseException {
16137
16138 ASTCollectionDeclaration jjtn000 = new ASTCollectionDeclaration(this, JJTCOLLECTIONDECLARATION);
16139 boolean jjtc000 = true;
16140 jjtree.openNodeScope(jjtn000);Token t = null ;
16141 try {
16142 t = jj_consume_token(IDENTIFIER);
16143 jjtree.closeNodeScope(jjtn000, true);
16144 jjtc000 = false;
16145 jjtn000.setImage(t.image) ; {if (true) return jjtn000 ;}
16146 } finally {
16147 if (jjtc000) {
16148 jjtree.closeNodeScope(jjtn000, true);
16149 }
16150 }
16151 throw new Error("Missing return statement in function");
16152 }
16153
16154 final public ASTObjectDeclaration ObjectDeclaration() throws ParseException {
16155
16156 ASTObjectDeclaration jjtn000 = new ASTObjectDeclaration(this, JJTOBJECTDECLARATION);
16157 boolean jjtc000 = true;
16158 jjtree.openNodeScope(jjtn000);Token t = null ;
16159 try {
16160 t = jj_consume_token(IDENTIFIER);
16161 jjtree.closeNodeScope(jjtn000, true);
16162 jjtc000 = false;
16163 jjtn000.setImage(t.image) ; {if (true) return jjtn000 ;}
16164 } finally {
16165 if (jjtc000) {
16166 jjtree.closeNodeScope(jjtn000, true);
16167 }
16168 }
16169 throw new Error("Missing return statement in function");
16170 }
16171
16172
16173 final public ASTCallSpecTail CallSpecTail() throws ParseException {
16174
16175 ASTCallSpecTail jjtn000 = new ASTCallSpecTail(this, JJTCALLSPECTAIL);
16176 boolean jjtc000 = true;
16177 jjtree.openNodeScope(jjtn000);
16178 try {
16179 switch (jj_nt.kind) {
16180 case EXTERNAL:
16181 jj_consume_token(EXTERNAL);
16182 break;
16183 case LANGUAGE:
16184 jj_consume_token(LANGUAGE);
16185 switch (jj_nt.kind) {
16186 case IDENTIFIER:
16187 jj_consume_token(IDENTIFIER);
16188 break;
16189 case JAVA:
16190 jj_consume_token(JAVA);
16191 break;
16192 default:
16193 jj_la1[196] = jj_gen;
16194 jj_consume_token(-1);
16195 throw new ParseException();
16196 }
16197 break;
16198 default:
16199 jj_la1[197] = jj_gen;
16200 jj_consume_token(-1);
16201 throw new ParseException();
16202 }
16203 label_47:
16204 while (true) {
16205 switch (jj_nt.kind) {
16206 case WITH:
16207 case LIBRARY:
16208 case NAME:
16209 case PARAMETERS:
16210 ;
16211 break;
16212 default:
16213 jj_la1[198] = jj_gen;
16214 break label_47;
16215 }
16216 switch (jj_nt.kind) {
16217 case LIBRARY:
16218 jj_consume_token(LIBRARY);
16219 switch (jj_nt.kind) {
16220 case IDENTIFIER:
16221 jj_consume_token(IDENTIFIER);
16222 break;
16223 case QUOTED_LITERAL:
16224 jj_consume_token(QUOTED_LITERAL);
16225 break;
16226 case STRING_LITERAL:
16227 StringLiteral();
16228 break;
16229 default:
16230 jj_la1[199] = jj_gen;
16231 jj_consume_token(-1);
16232 throw new ParseException();
16233 }
16234 switch (jj_nt.kind) {
16235 case 3:
16236 jj_consume_token(3);
16237 switch (jj_nt.kind) {
16238 case IDENTIFIER:
16239 jj_consume_token(IDENTIFIER);
16240 break;
16241 case QUOTED_LITERAL:
16242 jj_consume_token(QUOTED_LITERAL);
16243 break;
16244 case STRING_LITERAL:
16245 StringLiteral();
16246 break;
16247 default:
16248 jj_la1[200] = jj_gen;
16249 jj_consume_token(-1);
16250 throw new ParseException();
16251 }
16252 break;
16253 default:
16254 jj_la1[201] = jj_gen;
16255 ;
16256 }
16257 break;
16258 case NAME:
16259 jj_consume_token(NAME);
16260 switch (jj_nt.kind) {
16261 case IDENTIFIER:
16262 jj_consume_token(IDENTIFIER);
16263 break;
16264 case QUOTED_LITERAL:
16265 jj_consume_token(QUOTED_LITERAL);
16266 break;
16267 case STRING_LITERAL:
16268 StringLiteral();
16269 break;
16270 default:
16271 jj_la1[202] = jj_gen;
16272 jj_consume_token(-1);
16273 throw new ParseException();
16274 }
16275 break;
16276 case WITH:
16277 jj_consume_token(WITH);
16278 jj_consume_token(CONTEXT);
16279 break;
16280 case PARAMETERS:
16281 jj_consume_token(PARAMETERS);
16282 SkipPastNextOccurrence(")");
16283 break;
16284 default:
16285 jj_la1[203] = jj_gen;
16286 jj_consume_token(-1);
16287 throw new ParseException();
16288 }
16289 }
16290 jjtree.closeNodeScope(jjtn000, true);
16291 jjtc000 = false;
16292 {if (true) return jjtn000 ;}
16293 } catch (Throwable jjte000) {
16294 if (jjtc000) {
16295 jjtree.clearNodeScope(jjtn000);
16296 jjtc000 = false;
16297 } else {
16298 jjtree.popNode();
16299 }
16300 if (jjte000 instanceof RuntimeException) {
16301 {if (true) throw (RuntimeException)jjte000;}
16302 }
16303 if (jjte000 instanceof ParseException) {
16304 {if (true) throw (ParseException)jjte000;}
16305 }
16306 {if (true) throw (Error)jjte000;}
16307 } finally {
16308 if (jjtc000) {
16309 jjtree.closeNodeScope(jjtn000, true);
16310 }
16311 }
16312 throw new Error("Missing return statement in function");
16313 }
16314
16315
16316 final public ASTCursorUnit CursorUnit() throws ParseException {
16317
16318 ASTCursorUnit jjtn000 = new ASTCursorUnit(this, JJTCURSORUNIT);
16319 boolean jjtc000 = true;
16320 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
16321 try {
16322 jj_consume_token(CURSOR);
16323 simpleNode = ID();
16324 switch (jj_nt.kind) {
16325 case 5:
16326 FormalParameters();
16327 break;
16328 default:
16329 jj_la1[204] = jj_gen;
16330 ;
16331 }
16332 switch (jj_nt.kind) {
16333 case RETURN:
16334 jj_consume_token(RETURN);
16335 Datatype();
16336 break;
16337 default:
16338 jj_la1[205] = jj_gen;
16339 ;
16340 }
16341 switch (jj_nt.kind) {
16342 case IS:
16343 jj_consume_token(IS);
16344 label_48:
16345 while (true) {
16346 switch (jj_nt.kind) {
16347 case 5:
16348 ;
16349 break;
16350 default:
16351 jj_la1[206] = jj_gen;
16352 break label_48;
16353 }
16354 jj_consume_token(5);
16355 }
16356 SqlStatement(null,";");
16357 break;
16358 default:
16359 jj_la1[207] = jj_gen;
16360 ;
16361 }
16362 jj_consume_token(4);
16363 jjtree.closeNodeScope(jjtn000, true);
16364 jjtc000 = false;
16365 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
16366 } catch (Throwable jjte000) {
16367 if (jjtc000) {
16368 jjtree.clearNodeScope(jjtn000);
16369 jjtc000 = false;
16370 } else {
16371 jjtree.popNode();
16372 }
16373 if (jjte000 instanceof RuntimeException) {
16374 {if (true) throw (RuntimeException)jjte000;}
16375 }
16376 if (jjte000 instanceof ParseException) {
16377 {if (true) throw (ParseException)jjte000;}
16378 }
16379 {if (true) throw (Error)jjte000;}
16380 } finally {
16381 if (jjtc000) {
16382 jjtree.closeNodeScope(jjtn000, true);
16383 }
16384 }
16385 throw new Error("Missing return statement in function");
16386 }
16387
16388 final public ASTCursorSpecification CursorSpecification() throws ParseException {
16389
16390 ASTCursorSpecification jjtn000 = new ASTCursorSpecification(this, JJTCURSORSPECIFICATION);
16391 boolean jjtc000 = true;
16392 jjtree.openNodeScope(jjtn000);
16393 try {
16394 CursorUnit();
16395 jjtree.closeNodeScope(jjtn000, true);
16396 jjtc000 = false;
16397 {if (true) return jjtn000 ;}
16398 } catch (Throwable jjte000) {
16399 if (jjtc000) {
16400 jjtree.clearNodeScope(jjtn000);
16401 jjtc000 = false;
16402 } else {
16403 jjtree.popNode();
16404 }
16405 if (jjte000 instanceof RuntimeException) {
16406 {if (true) throw (RuntimeException)jjte000;}
16407 }
16408 if (jjte000 instanceof ParseException) {
16409 {if (true) throw (ParseException)jjte000;}
16410 }
16411 {if (true) throw (Error)jjte000;}
16412 } finally {
16413 if (jjtc000) {
16414 jjtree.closeNodeScope(jjtn000, true);
16415 }
16416 }
16417 throw new Error("Missing return statement in function");
16418 }
16419
16420 final public ASTCursorBody CursorBody() throws ParseException {
16421
16422 ASTCursorBody jjtn000 = new ASTCursorBody(this, JJTCURSORBODY);
16423 boolean jjtc000 = true;
16424 jjtree.openNodeScope(jjtn000);
16425 try {
16426 CursorUnit();
16427 jjtree.closeNodeScope(jjtn000, true);
16428 jjtc000 = false;
16429 {if (true) return jjtn000 ;}
16430 } catch (Throwable jjte000) {
16431 if (jjtc000) {
16432 jjtree.clearNodeScope(jjtn000);
16433 jjtc000 = false;
16434 } else {
16435 jjtree.popNode();
16436 }
16437 if (jjte000 instanceof RuntimeException) {
16438 {if (true) throw (RuntimeException)jjte000;}
16439 }
16440 if (jjte000 instanceof ParseException) {
16441 {if (true) throw (ParseException)jjte000;}
16442 }
16443 {if (true) throw (Error)jjte000;}
16444 } finally {
16445 if (jjtc000) {
16446 jjtree.closeNodeScope(jjtn000, true);
16447 }
16448 }
16449 throw new Error("Missing return statement in function");
16450 }
16451
16452
16453
16454
16455
16456
16457
16458
16459
16460
16461
16462
16463
16464 final public ASTExpression Expression() throws ParseException {
16465
16466 ASTExpression jjtn000 = new ASTExpression(this, JJTEXPRESSION);
16467 boolean jjtc000 = true;
16468 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
16469 StringBuilder sb = new StringBuilder() ;
16470 try {
16471 if (jj_2_45(2147483647)) {
16472 simpleNode = Assignment();
16473 sb.append(simpleNode.getImage());
16474 } else {
16475 switch (jj_nt.kind) {
16476 case 5:
16477 case 16:
16478 case 17:
16479 case REPLACE:
16480 case DEFINER:
16481 case CURRENT_USER:
16482 case LANGUAGE:
16483 case INLINE:
16484 case ADD:
16485 case AGGREGATE:
16486 case ARRAY:
16487 case AT:
16488 case ATTRIBUTE:
16489 case AUTHID:
16490 case BODY:
16491 case BULK:
16492 case BYTE:
16493 case CASCADE:
16494 case CASE:
16495 case CLOSE:
16496 case COALESCE:
16497 case COLLECT:
16498 case COLUMN:
16499 case COMMENT:
16500 case COMMIT:
16501 case CONSTRUCTOR:
16502 case CONTINUE:
16503 case CONVERT:
16504 case CURRENT:
16505 case CURSOR:
16506 case DATA:
16507 case DATE:
16508 case DAY:
16509 case DISABLE:
16510 case EDITIONABLE:
16511 case ELEMENT:
16512 case ENABLE:
16513 case ESCAPE:
16514 case EXCEPT:
16515 case EXCEPTIONS:
16516 case EXIT:
16517 case EXTERNAL:
16518 case EXTENDS:
16519 case EXTRACT:
16520 case FALSE:
16521 case FINAL:
16522 case FORCE:
16523 case FUNCTION:
16524 case GLOBAL:
16525 case HASH:
16526 case HEAP:
16527 case HOUR:
16528 case IMMEDIATE:
16529 case INDICES:
16530 case INDEXTYPE:
16531 case INDICATOR:
16532 case INSTANTIABLE:
16533 case INTERVAL:
16534 case INVALIDATE:
16535 case ISOLATION:
16536 case JAVA:
16537 case LEVEL:
16538 case LIMIT:
16539 case LOOP:
16540 case MAP:
16541 case MAX:
16542 case MEMBER:
16543 case MERGE:
16544 case MIN:
16545 case MINUTE:
16546 case MLSLABEL:
16547 case MODIFY:
16548 case MOD:
16549 case MONTH:
16550 case NATURAL:
16551 case NEW:
16552 case NEW_DOT:
16553 case NO:
16554 case NONEDITIONABLE:
16555 case NOT:
16556 case NULL:
16557 case NULLIF:
16558 case OBJECT:
16559 case OID:
16560 case OPAQUE:
16561 case OPEN:
16562 case OPERATOR:
16563 case ORGANIZATION:
16564 case OTHERS:
16565 case OVERRIDING:
16566 case PACKAGE:
16567 case PARTITION:
16568 case PRESERVE:
16569 case PRIVATE:
16570 case PROCEDURE:
16571 case RANGE:
16572 case RAW:
16573 case REAL:
16574 case RECORD:
16575 case REF:
16576 case RELEASE:
16577 case RELIES_ON:
16578 case RENAME:
16579 case RESULT:
16580 case RETURN:
16581 case RETURNING:
16582 case REVERSE:
16583 case ROLLBACK:
16584 case ROW:
16585 case ROWS:
16586 case ROWID:
16587 case ROWNUM:
16588 case SAVE:
16589 case SAVEPOINT:
16590 case SECOND:
16591 case SELECT:
16592 case SELF:
16593 case SET:
16594 case SPACE:
16595 case SQL:
16596 case SQLCODE:
16597 case SQLERRM:
16598 case STATIC:
16599 case SUBTYPE:
16600 case SUBSTITUTABLE:
16601 case SUCCESSFUL:
16602 case SYSDATE:
16603 case SYS_REFCURSOR:
16604 case TEMPORARY:
16605 case TIME:
16606 case TIMESTAMP:
16607 case TIMEZONE_REGION:
16608 case TIMEZONE_ABBR:
16609 case TIMEZONE_MINUTE:
16610 case TIMEZONE_HOUR:
16611 case TRANSACTION:
16612 case TRUE:
16613 case TYPE:
16614 case UNDER:
16615 case USING:
16616 case YES:
16617 case SHOW:
16618 case A:
16619 case DOUBLE:
16620 case DEC:
16621 case PRECISION:
16622 case INT:
16623 case NUMERIC:
16624 case NCHAR:
16625 case NVARCHAR2:
16626 case STRING:
16627 case UROWID:
16628 case VARRAY:
16629 case VARYING:
16630 case BFILE:
16631 case BLOB:
16632 case CLOB:
16633 case NCLOB:
16634 case YEAR:
16635 case LOCAL:
16636 case WITH:
16637 case ZONE:
16638 case CHARACTER:
16639 case AFTER:
16640 case BEFORE:
16641 case OLD:
16642 case PARENT:
16643 case ANALYZE:
16644 case ASSOCIATE:
16645 case AUDIT:
16646 case COMPOUND:
16647 case DATABASE:
16648 case CALL:
16649 case DDL:
16650 case DISASSOCIATE:
16651 case EACH:
16652 case FOLLOWS:
16653 case LOGOFF:
16654 case LOGON:
16655 case NESTED:
16656 case NOAUDIT:
16657 case SCHEMA:
16658 case SERVERERROR:
16659 case SHUTDOWN:
16660 case STARTUP:
16661 case STATEMENT:
16662 case STATISTICS:
16663 case SUSPEND:
16664 case TRUNCATE:
16665 case WRAPPED:
16666 case LIBRARY:
16667 case NAME:
16668 case STRUCT:
16669 case CONTEXT:
16670 case PARAMETERS:
16671 case LENGTH:
16672 case TDO:
16673 case MAXLEN:
16674 case CHARSETID:
16675 case CHARSETFORM:
16676 case ACCEPT:
16677 case ACCESSIBLE:
16678 case COPY:
16679 case DEFINE:
16680 case DISCONNECT:
16681 case HOST:
16682 case PRINT:
16683 case QUIT:
16684 case REMARK:
16685 case UNDEFINE:
16686 case VARIABLE:
16687 case WHENEVER:
16688 case ATTACH:
16689 case CAST:
16690 case TREAT:
16691 case TRIM:
16692 case LEFT:
16693 case RIGHT:
16694 case BOTH:
16695 case EMPTY:
16696 case MULTISET:
16697 case SUBMULTISET:
16698 case LEADING:
16699 case TRAILING:
16700 case CHAR_CS:
16701 case NCHAR_CS:
16702 case DBTIMEZONE:
16703 case SESSIONTIMEZONE:
16704 case AUTHENTICATED:
16705 case LINK:
16706 case SHARED:
16707 case DIRECTORY:
16708 case USER:
16709 case IDENTIFIER:
16710 case UNSIGNED_NUMERIC_LITERAL:
16711 case CHARACTER_LITERAL:
16712 case STRING_LITERAL:
16713 case QUOTED_LITERAL:
16714 simpleNode = ConditionalOrExpression();
16715 sb.append(simpleNode.getImage());
16716 break;
16717 case CC_IF:
16718 simpleNode = CompilationExpression();
16719 sb.append(simpleNode.getImage());
16720 break;
16721 default:
16722 jj_la1[208] = jj_gen;
16723 jj_consume_token(-1);
16724 throw new ParseException();
16725 }
16726 }
16727 jjtree.closeNodeScope(jjtn000, true);
16728 jjtc000 = false;
16729 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
16730 } catch (Throwable jjte000) {
16731 if (jjtc000) {
16732 jjtree.clearNodeScope(jjtn000);
16733 jjtc000 = false;
16734 } else {
16735 jjtree.popNode();
16736 }
16737 if (jjte000 instanceof RuntimeException) {
16738 {if (true) throw (RuntimeException)jjte000;}
16739 }
16740 if (jjte000 instanceof ParseException) {
16741 {if (true) throw (ParseException)jjte000;}
16742 }
16743 {if (true) throw (Error)jjte000;}
16744 } finally {
16745 if (jjtc000) {
16746 jjtree.closeNodeScope(jjtn000, true);
16747 }
16748 }
16749 throw new Error("Missing return statement in function");
16750 }
16751
16752 final public ASTCompilationExpression CompilationExpression() throws ParseException {
16753
16754 ASTCompilationExpression jjtn000 = new ASTCompilationExpression(this, JJTCOMPILATIONEXPRESSION);
16755 boolean jjtc000 = true;
16756 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
16757 StringBuilder sb = new StringBuilder() ;
16758 try {
16759 jj_consume_token(CC_IF);
16760 sb.append(" "); sb.append(token.image) ;
16761 simpleNode = ConditionalOrExpression();
16762 sb.append(" "); sb.append(simpleNode.getImage());
16763 jj_consume_token(CC_THEN);
16764 sb.append(" "); sb.append(token.image);
16765 simpleNode = Expression();
16766 sb.append(" "); sb.append(simpleNode.getImage());
16767 label_49:
16768 while (true) {
16769 switch (jj_nt.kind) {
16770 case CC_ELSIF:
16771 ;
16772 break;
16773 default:
16774 jj_la1[209] = jj_gen;
16775 break label_49;
16776 }
16777 jj_consume_token(CC_ELSIF);
16778 sb.append(" "); sb.append(token.image);
16779 simpleNode = ConditionalOrExpression();
16780 sb.append(" "); sb.append(simpleNode.getImage());
16781 jj_consume_token(CC_THEN);
16782 sb.append(" "); sb.append(token.image);
16783 simpleNode = Expression();
16784 sb.append(" "); sb.append(simpleNode.getImage());
16785 }
16786 label_50:
16787 while (true) {
16788 switch (jj_nt.kind) {
16789 case CC_ELSE:
16790 ;
16791 break;
16792 default:
16793 jj_la1[210] = jj_gen;
16794 break label_50;
16795 }
16796 jj_consume_token(CC_ELSE);
16797 sb.append(" "); sb.append(token.image);
16798 simpleNode = Expression();
16799 sb.append(" "); sb.append(simpleNode.getImage());
16800 }
16801 jj_consume_token(CC_END);
16802 sb.append(" "); sb.append(token.image);
16803 jjtree.closeNodeScope(jjtn000, true);
16804 jjtc000 = false;
16805 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
16806 } catch (Throwable jjte000) {
16807 if (jjtc000) {
16808 jjtree.clearNodeScope(jjtn000);
16809 jjtc000 = false;
16810 } else {
16811 jjtree.popNode();
16812 }
16813 if (jjte000 instanceof RuntimeException) {
16814 {if (true) throw (RuntimeException)jjte000;}
16815 }
16816 if (jjte000 instanceof ParseException) {
16817 {if (true) throw (ParseException)jjte000;}
16818 }
16819 {if (true) throw (Error)jjte000;}
16820 } finally {
16821 if (jjtc000) {
16822 jjtree.closeNodeScope(jjtn000, true);
16823 }
16824 }
16825 throw new Error("Missing return statement in function");
16826 }
16827
16828 final public ASTAssignment Assignment() throws ParseException {
16829
16830 ASTAssignment jjtn000 = new ASTAssignment(this, JJTASSIGNMENT);
16831 boolean jjtc000 = true;
16832 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
16833 try {
16834 simpleNode = PrimaryExpression();
16835 sb.append(simpleNode.getImage());
16836 jj_consume_token(9);
16837 jj_consume_token(10);
16838 sb.append(" := ");
16839 simpleNode = Expression();
16840 sb.append(simpleNode.getImage());
16841 jjtree.closeNodeScope(jjtn000, true);
16842 jjtc000 = false;
16843 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
16844 } catch (Throwable jjte000) {
16845 if (jjtc000) {
16846 jjtree.clearNodeScope(jjtn000);
16847 jjtc000 = false;
16848 } else {
16849 jjtree.popNode();
16850 }
16851 if (jjte000 instanceof RuntimeException) {
16852 {if (true) throw (RuntimeException)jjte000;}
16853 }
16854 if (jjte000 instanceof ParseException) {
16855 {if (true) throw (ParseException)jjte000;}
16856 }
16857 {if (true) throw (Error)jjte000;}
16858 } finally {
16859 if (jjtc000) {
16860 jjtree.closeNodeScope(jjtn000, true);
16861 }
16862 }
16863 throw new Error("Missing return statement in function");
16864 }
16865
16866 final public ASTCaseExpression CaseExpression() throws ParseException {
16867
16868 ASTCaseExpression jjtn000 = new ASTCaseExpression(this, JJTCASEEXPRESSION);
16869 boolean jjtc000 = true;
16870 jjtree.openNodeScope(jjtn000);Token thisToken; PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
16871 try {
16872 thisToken = jj_consume_token(CASE);
16873 sb.append(thisToken.image);
16874 switch (jj_nt.kind) {
16875 case 5:
16876 case 16:
16877 case 17:
16878 case REPLACE:
16879 case DEFINER:
16880 case CURRENT_USER:
16881 case LANGUAGE:
16882 case INLINE:
16883 case ADD:
16884 case AGGREGATE:
16885 case ARRAY:
16886 case AT:
16887 case ATTRIBUTE:
16888 case AUTHID:
16889 case BODY:
16890 case BULK:
16891 case BYTE:
16892 case CASCADE:
16893 case CASE:
16894 case CLOSE:
16895 case COALESCE:
16896 case COLLECT:
16897 case COLUMN:
16898 case COMMENT:
16899 case COMMIT:
16900 case CONSTRUCTOR:
16901 case CONTINUE:
16902 case CONVERT:
16903 case CURRENT:
16904 case CURSOR:
16905 case DATA:
16906 case DATE:
16907 case DAY:
16908 case DISABLE:
16909 case EDITIONABLE:
16910 case ELEMENT:
16911 case ENABLE:
16912 case ESCAPE:
16913 case EXCEPT:
16914 case EXCEPTIONS:
16915 case EXIT:
16916 case EXTERNAL:
16917 case EXTENDS:
16918 case EXTRACT:
16919 case FALSE:
16920 case FINAL:
16921 case FORCE:
16922 case FUNCTION:
16923 case GLOBAL:
16924 case HASH:
16925 case HEAP:
16926 case HOUR:
16927 case IMMEDIATE:
16928 case INDICES:
16929 case INDEXTYPE:
16930 case INDICATOR:
16931 case INSTANTIABLE:
16932 case INTERVAL:
16933 case INVALIDATE:
16934 case ISOLATION:
16935 case JAVA:
16936 case LEVEL:
16937 case LIMIT:
16938 case LOOP:
16939 case MAP:
16940 case MAX:
16941 case MEMBER:
16942 case MERGE:
16943 case MIN:
16944 case MINUTE:
16945 case MLSLABEL:
16946 case MODIFY:
16947 case MOD:
16948 case MONTH:
16949 case NATURAL:
16950 case NEW:
16951 case NEW_DOT:
16952 case NO:
16953 case NONEDITIONABLE:
16954 case NOT:
16955 case NULL:
16956 case NULLIF:
16957 case OBJECT:
16958 case OID:
16959 case OPAQUE:
16960 case OPEN:
16961 case OPERATOR:
16962 case ORGANIZATION:
16963 case OTHERS:
16964 case OVERRIDING:
16965 case PACKAGE:
16966 case PARTITION:
16967 case PRESERVE:
16968 case PRIVATE:
16969 case PROCEDURE:
16970 case RANGE:
16971 case RAW:
16972 case REAL:
16973 case RECORD:
16974 case REF:
16975 case RELEASE:
16976 case RELIES_ON:
16977 case RENAME:
16978 case RESULT:
16979 case RETURN:
16980 case RETURNING:
16981 case REVERSE:
16982 case ROLLBACK:
16983 case ROW:
16984 case ROWS:
16985 case ROWID:
16986 case ROWNUM:
16987 case SAVE:
16988 case SAVEPOINT:
16989 case SECOND:
16990 case SELECT:
16991 case SELF:
16992 case SET:
16993 case SPACE:
16994 case SQL:
16995 case SQLCODE:
16996 case SQLERRM:
16997 case STATIC:
16998 case SUBTYPE:
16999 case SUBSTITUTABLE:
17000 case SUCCESSFUL:
17001 case SYSDATE:
17002 case SYS_REFCURSOR:
17003 case TEMPORARY:
17004 case TIME:
17005 case TIMESTAMP:
17006 case TIMEZONE_REGION:
17007 case TIMEZONE_ABBR:
17008 case TIMEZONE_MINUTE:
17009 case TIMEZONE_HOUR:
17010 case TRANSACTION:
17011 case TRUE:
17012 case TYPE:
17013 case UNDER:
17014 case USING:
17015 case YES:
17016 case SHOW:
17017 case A:
17018 case DOUBLE:
17019 case DEC:
17020 case PRECISION:
17021 case INT:
17022 case NUMERIC:
17023 case NCHAR:
17024 case NVARCHAR2:
17025 case STRING:
17026 case UROWID:
17027 case VARRAY:
17028 case VARYING:
17029 case BFILE:
17030 case BLOB:
17031 case CLOB:
17032 case NCLOB:
17033 case YEAR:
17034 case LOCAL:
17035 case WITH:
17036 case ZONE:
17037 case CHARACTER:
17038 case AFTER:
17039 case BEFORE:
17040 case OLD:
17041 case PARENT:
17042 case CC_IF:
17043 case ANALYZE:
17044 case ASSOCIATE:
17045 case AUDIT:
17046 case COMPOUND:
17047 case DATABASE:
17048 case CALL:
17049 case DDL:
17050 case DISASSOCIATE:
17051 case EACH:
17052 case FOLLOWS:
17053 case LOGOFF:
17054 case LOGON:
17055 case NESTED:
17056 case NOAUDIT:
17057 case SCHEMA:
17058 case SERVERERROR:
17059 case SHUTDOWN:
17060 case STARTUP:
17061 case STATEMENT:
17062 case STATISTICS:
17063 case SUSPEND:
17064 case TRUNCATE:
17065 case WRAPPED:
17066 case LIBRARY:
17067 case NAME:
17068 case STRUCT:
17069 case CONTEXT:
17070 case PARAMETERS:
17071 case LENGTH:
17072 case TDO:
17073 case MAXLEN:
17074 case CHARSETID:
17075 case CHARSETFORM:
17076 case ACCEPT:
17077 case ACCESSIBLE:
17078 case COPY:
17079 case DEFINE:
17080 case DISCONNECT:
17081 case HOST:
17082 case PRINT:
17083 case QUIT:
17084 case REMARK:
17085 case UNDEFINE:
17086 case VARIABLE:
17087 case WHENEVER:
17088 case ATTACH:
17089 case CAST:
17090 case TREAT:
17091 case TRIM:
17092 case LEFT:
17093 case RIGHT:
17094 case BOTH:
17095 case EMPTY:
17096 case MULTISET:
17097 case SUBMULTISET:
17098 case LEADING:
17099 case TRAILING:
17100 case CHAR_CS:
17101 case NCHAR_CS:
17102 case DBTIMEZONE:
17103 case SESSIONTIMEZONE:
17104 case AUTHENTICATED:
17105 case LINK:
17106 case SHARED:
17107 case DIRECTORY:
17108 case USER:
17109 case IDENTIFIER:
17110 case UNSIGNED_NUMERIC_LITERAL:
17111 case CHARACTER_LITERAL:
17112 case STRING_LITERAL:
17113 case QUOTED_LITERAL:
17114 simpleNode = Expression();
17115 sb.append(" "); sb.append(simpleNode.getImage());
17116 break;
17117 default:
17118 jj_la1[211] = jj_gen;
17119 ;
17120 }
17121 label_51:
17122 while (true) {
17123 thisToken = jj_consume_token(WHEN);
17124 sb.append(" "); sb.append(thisToken.image);
17125 simpleNode = Expression();
17126 sb.append(" "); sb.append(simpleNode.getImage());
17127 thisToken = jj_consume_token(THEN);
17128 sb.append(" "); sb.append(thisToken.image);
17129 Expression();
17130 sb.append(" "); sb.append(simpleNode.getImage());
17131 switch (jj_nt.kind) {
17132 case WHEN:
17133 ;
17134 break;
17135 default:
17136 jj_la1[212] = jj_gen;
17137 break label_51;
17138 }
17139 }
17140 switch (jj_nt.kind) {
17141 case ELSE:
17142 thisToken = jj_consume_token(ELSE);
17143 sb.append(" "); sb.append(thisToken.image);
17144 Expression();
17145 sb.append(" "); sb.append(simpleNode.getImage());
17146 break;
17147 default:
17148 jj_la1[213] = jj_gen;
17149 ;
17150 }
17151 thisToken = jj_consume_token(END);
17152 sb.append(" "); sb.append(thisToken.image);
17153 jjtree.closeNodeScope(jjtn000, true);
17154 jjtc000 = false;
17155 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
17156 } catch (Throwable jjte000) {
17157 if (jjtc000) {
17158 jjtree.clearNodeScope(jjtn000);
17159 jjtc000 = false;
17160 } else {
17161 jjtree.popNode();
17162 }
17163 if (jjte000 instanceof RuntimeException) {
17164 {if (true) throw (RuntimeException)jjte000;}
17165 }
17166 if (jjte000 instanceof ParseException) {
17167 {if (true) throw (ParseException)jjte000;}
17168 }
17169 {if (true) throw (Error)jjte000;}
17170 } finally {
17171 if (jjtc000) {
17172 jjtree.closeNodeScope(jjtn000, true);
17173 }
17174 }
17175 throw new Error("Missing return statement in function");
17176 }
17177
17178
17179
17180
17181 final public ASTLikeExpression LikeExpression() throws ParseException {
17182
17183 ASTLikeExpression jjtn000 = new ASTLikeExpression(this, JJTLIKEEXPRESSION);
17184 boolean jjtc000 = true;
17185 jjtree.openNodeScope(jjtn000);Token thisToken; PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
17186 try {
17187 simpleNode = PrimaryExpression();
17188 sb.append(" "); sb.append(simpleNode.getImage());
17189 thisToken = jj_consume_token(LIKE);
17190 sb.append(thisToken.image);
17191 simpleNode = StringExpression();
17192 sb.append(" "); sb.append(simpleNode.getImage());
17193 switch (jj_nt.kind) {
17194 case ESCAPE:
17195 jj_consume_token(ESCAPE);
17196 sb.append(" ESCAPE ");
17197 switch (jj_nt.kind) {
17198 case CHARACTER_LITERAL:
17199 jj_consume_token(CHARACTER_LITERAL);
17200 sb.append(" "); sb.append(token.toString());
17201 break;
17202 case STRING_LITERAL:
17203 simpleNode = StringLiteral();
17204 sb.append(" "); sb.append(simpleNode.getImage());
17205 break;
17206 default:
17207 jj_la1[214] = jj_gen;
17208 jj_consume_token(-1);
17209 throw new ParseException();
17210 }
17211 break;
17212 default:
17213 jj_la1[215] = jj_gen;
17214 ;
17215 }
17216 label_52:
17217 while (true) {
17218 switch (jj_nt.kind) {
17219 case 3:
17220 ;
17221 break;
17222 default:
17223 jj_la1[216] = jj_gen;
17224 break label_52;
17225 }
17226 jj_consume_token(3);
17227 simpleNode = Expression();
17228 sb.append("."); sb.append(simpleNode.getImage());
17229 }
17230 jjtree.closeNodeScope(jjtn000, true);
17231 jjtc000 = false;
17232 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
17233 } catch (Throwable jjte000) {
17234 if (jjtc000) {
17235 jjtree.clearNodeScope(jjtn000);
17236 jjtc000 = false;
17237 } else {
17238 jjtree.popNode();
17239 }
17240 if (jjte000 instanceof RuntimeException) {
17241 {if (true) throw (RuntimeException)jjte000;}
17242 }
17243 if (jjte000 instanceof ParseException) {
17244 {if (true) throw (ParseException)jjte000;}
17245 }
17246 {if (true) throw (Error)jjte000;}
17247 } finally {
17248 if (jjtc000) {
17249 jjtree.closeNodeScope(jjtn000, true);
17250 }
17251 }
17252 throw new Error("Missing return statement in function");
17253 }
17254
17255 final public ASTTrimExpression TrimExpression() throws ParseException {
17256
17257 ASTTrimExpression jjtn000 = new ASTTrimExpression(this, JJTTRIMEXPRESSION);
17258 boolean jjtc000 = true;
17259 jjtree.openNodeScope(jjtn000);Token thisToken; PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
17260 try {
17261 thisToken = jj_consume_token(TRIM);
17262 sb.append(thisToken.image);
17263 jj_consume_token(5);
17264 sb.append("(");
17265 switch (jj_nt.kind) {
17266 case BOTH:
17267 case LEADING:
17268 case TRAILING:
17269 switch (jj_nt.kind) {
17270 case LEADING:
17271 jj_consume_token(LEADING);
17272 break;
17273 case TRAILING:
17274 jj_consume_token(TRAILING);
17275 break;
17276 case BOTH:
17277 jj_consume_token(BOTH);
17278 break;
17279 default:
17280 jj_la1[217] = jj_gen;
17281 jj_consume_token(-1);
17282 throw new ParseException();
17283 }
17284 sb.append(" "); sb.append(token.toString());
17285 break;
17286 default:
17287 jj_la1[218] = jj_gen;
17288 ;
17289 }
17290 switch (jj_nt.kind) {
17291 case 5:
17292 case REPLACE:
17293 case DEFINER:
17294 case CURRENT_USER:
17295 case LANGUAGE:
17296 case INLINE:
17297 case ADD:
17298 case AGGREGATE:
17299 case ARRAY:
17300 case AT:
17301 case ATTRIBUTE:
17302 case AUTHID:
17303 case BODY:
17304 case BULK:
17305 case BYTE:
17306 case CASCADE:
17307 case CASE:
17308 case CLOSE:
17309 case COALESCE:
17310 case COLLECT:
17311 case COLUMN:
17312 case COMMENT:
17313 case COMMIT:
17314 case CONSTRUCTOR:
17315 case CONTINUE:
17316 case CONVERT:
17317 case CURRENT:
17318 case CURSOR:
17319 case DATA:
17320 case DATE:
17321 case DAY:
17322 case DISABLE:
17323 case EDITIONABLE:
17324 case ELEMENT:
17325 case ENABLE:
17326 case ESCAPE:
17327 case EXCEPT:
17328 case EXCEPTIONS:
17329 case EXIT:
17330 case EXTERNAL:
17331 case EXTENDS:
17332 case EXTRACT:
17333 case FALSE:
17334 case FINAL:
17335 case FORCE:
17336 case FUNCTION:
17337 case GLOBAL:
17338 case HASH:
17339 case HEAP:
17340 case HOUR:
17341 case IMMEDIATE:
17342 case INDICES:
17343 case INDEXTYPE:
17344 case INDICATOR:
17345 case INSTANTIABLE:
17346 case INTERVAL:
17347 case INVALIDATE:
17348 case ISOLATION:
17349 case JAVA:
17350 case LEVEL:
17351 case LIMIT:
17352 case LOOP:
17353 case MAP:
17354 case MAX:
17355 case MEMBER:
17356 case MERGE:
17357 case MIN:
17358 case MINUTE:
17359 case MLSLABEL:
17360 case MODIFY:
17361 case MOD:
17362 case MONTH:
17363 case NATURAL:
17364 case NEW:
17365 case NEW_DOT:
17366 case NO:
17367 case NONEDITIONABLE:
17368 case NULL:
17369 case NULLIF:
17370 case OBJECT:
17371 case OID:
17372 case OPAQUE:
17373 case OPEN:
17374 case OPERATOR:
17375 case ORGANIZATION:
17376 case OTHERS:
17377 case OVERRIDING:
17378 case PACKAGE:
17379 case PARTITION:
17380 case PRESERVE:
17381 case PRIVATE:
17382 case PROCEDURE:
17383 case RANGE:
17384 case RAW:
17385 case REAL:
17386 case RECORD:
17387 case REF:
17388 case RELEASE:
17389 case RELIES_ON:
17390 case RENAME:
17391 case RESULT:
17392 case RETURN:
17393 case RETURNING:
17394 case REVERSE:
17395 case ROLLBACK:
17396 case ROW:
17397 case ROWS:
17398 case ROWID:
17399 case ROWNUM:
17400 case SAVE:
17401 case SAVEPOINT:
17402 case SECOND:
17403 case SELECT:
17404 case SELF:
17405 case SET:
17406 case SPACE:
17407 case SQL:
17408 case SQLCODE:
17409 case SQLERRM:
17410 case STATIC:
17411 case SUBTYPE:
17412 case SUBSTITUTABLE:
17413 case SUCCESSFUL:
17414 case SYSDATE:
17415 case SYS_REFCURSOR:
17416 case TEMPORARY:
17417 case TIME:
17418 case TIMESTAMP:
17419 case TIMEZONE_REGION:
17420 case TIMEZONE_ABBR:
17421 case TIMEZONE_MINUTE:
17422 case TIMEZONE_HOUR:
17423 case TRANSACTION:
17424 case TRUE:
17425 case TYPE:
17426 case UNDER:
17427 case USING:
17428 case YES:
17429 case SHOW:
17430 case A:
17431 case DOUBLE:
17432 case DEC:
17433 case PRECISION:
17434 case INT:
17435 case NUMERIC:
17436 case NCHAR:
17437 case NVARCHAR2:
17438 case STRING:
17439 case UROWID:
17440 case VARRAY:
17441 case VARYING:
17442 case BFILE:
17443 case BLOB:
17444 case CLOB:
17445 case NCLOB:
17446 case YEAR:
17447 case LOCAL:
17448 case WITH:
17449 case ZONE:
17450 case CHARACTER:
17451 case AFTER:
17452 case BEFORE:
17453 case OLD:
17454 case PARENT:
17455 case ANALYZE:
17456 case ASSOCIATE:
17457 case AUDIT:
17458 case COMPOUND:
17459 case DATABASE:
17460 case CALL:
17461 case DDL:
17462 case DISASSOCIATE:
17463 case EACH:
17464 case FOLLOWS:
17465 case LOGOFF:
17466 case LOGON:
17467 case NESTED:
17468 case NOAUDIT:
17469 case SCHEMA:
17470 case SERVERERROR:
17471 case SHUTDOWN:
17472 case STARTUP:
17473 case STATEMENT:
17474 case STATISTICS:
17475 case SUSPEND:
17476 case TRUNCATE:
17477 case WRAPPED:
17478 case LIBRARY:
17479 case NAME:
17480 case STRUCT:
17481 case CONTEXT:
17482 case PARAMETERS:
17483 case LENGTH:
17484 case TDO:
17485 case MAXLEN:
17486 case CHARSETID:
17487 case CHARSETFORM:
17488 case ACCEPT:
17489 case ACCESSIBLE:
17490 case COPY:
17491 case DEFINE:
17492 case DISCONNECT:
17493 case HOST:
17494 case PRINT:
17495 case QUIT:
17496 case REMARK:
17497 case UNDEFINE:
17498 case VARIABLE:
17499 case WHENEVER:
17500 case ATTACH:
17501 case CAST:
17502 case TREAT:
17503 case TRIM:
17504 case LEFT:
17505 case RIGHT:
17506 case BOTH:
17507 case EMPTY:
17508 case MULTISET:
17509 case SUBMULTISET:
17510 case LEADING:
17511 case TRAILING:
17512 case CHAR_CS:
17513 case NCHAR_CS:
17514 case DBTIMEZONE:
17515 case SESSIONTIMEZONE:
17516 case AUTHENTICATED:
17517 case LINK:
17518 case SHARED:
17519 case DIRECTORY:
17520 case USER:
17521 case IDENTIFIER:
17522 case UNSIGNED_NUMERIC_LITERAL:
17523 case CHARACTER_LITERAL:
17524 case STRING_LITERAL:
17525 case QUOTED_LITERAL:
17526 simpleNode = StringExpression();
17527 sb.append(" "); sb.append(simpleNode.getImage());
17528 break;
17529 default:
17530 jj_la1[219] = jj_gen;
17531 ;
17532 }
17533 jj_consume_token(FROM);
17534 sb.append(thisToken.image);
17535 simpleNode = StringExpression();
17536 sb.append(" "); sb.append(simpleNode.getImage());
17537 jj_consume_token(7);
17538 sb.append(")");
17539 jjtree.closeNodeScope(jjtn000, true);
17540 jjtc000 = false;
17541 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
17542 } catch (Throwable jjte000) {
17543 if (jjtc000) {
17544 jjtree.clearNodeScope(jjtn000);
17545 jjtc000 = false;
17546 } else {
17547 jjtree.popNode();
17548 }
17549 if (jjte000 instanceof RuntimeException) {
17550 {if (true) throw (RuntimeException)jjte000;}
17551 }
17552 if (jjte000 instanceof ParseException) {
17553 {if (true) throw (ParseException)jjte000;}
17554 }
17555 {if (true) throw (Error)jjte000;}
17556 } finally {
17557 if (jjtc000) {
17558 jjtree.closeNodeScope(jjtn000, true);
17559 }
17560 }
17561 throw new Error("Missing return statement in function");
17562 }
17563
17564
17565
17566
17567
17568 final public ASTObjectExpression ObjectExpression() throws ParseException {
17569
17570 ASTObjectExpression jjtn000 = new ASTObjectExpression(this, JJTOBJECTEXPRESSION);
17571 boolean jjtc000 = true;
17572 jjtree.openNodeScope(jjtn000);Token thisToken; PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
17573 try {
17574 switch (jj_nt.kind) {
17575 case CAST:
17576 thisToken = jj_consume_token(CAST);
17577 break;
17578 case TREAT:
17579 thisToken = jj_consume_token(TREAT);
17580 break;
17581 default:
17582 jj_la1[220] = jj_gen;
17583 jj_consume_token(-1);
17584 throw new ParseException();
17585 }
17586 sb.append(thisToken.image);
17587 jj_consume_token(5);
17588 sb.append("(");
17589 simpleNode = Expression();
17590 sb.append(" "); sb.append(simpleNode.getImage());
17591 switch (jj_nt.kind) {
17592 case AT:
17593 jj_consume_token(AT);
17594 jj_consume_token(TIME);
17595 jj_consume_token(ZONE);
17596 simpleNode = PrimaryExpression();
17597 sb.append(" AT TIME ZONE "); sb.append(simpleNode.getImage());
17598 break;
17599 default:
17600 jj_la1[221] = jj_gen;
17601 ;
17602 }
17603 jj_consume_token(AS);
17604 sb.append(" AS ");
17605 simpleNode = Datatype();
17606 sb.append(" "); sb.append(simpleNode.getImage());
17607 jj_consume_token(7);
17608 sb.append(")");
17609 label_53:
17610 while (true) {
17611 switch (jj_nt.kind) {
17612 case 3:
17613 ;
17614 break;
17615 default:
17616 jj_la1[222] = jj_gen;
17617 break label_53;
17618 }
17619 jj_consume_token(3);
17620 Expression();
17621 }
17622 jjtree.closeNodeScope(jjtn000, true);
17623 jjtc000 = false;
17624 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
17625 } catch (Throwable jjte000) {
17626 if (jjtc000) {
17627 jjtree.clearNodeScope(jjtn000);
17628 jjtc000 = false;
17629 } else {
17630 jjtree.popNode();
17631 }
17632 if (jjte000 instanceof RuntimeException) {
17633 {if (true) throw (RuntimeException)jjte000;}
17634 }
17635 if (jjte000 instanceof ParseException) {
17636 {if (true) throw (ParseException)jjte000;}
17637 }
17638 {if (true) throw (Error)jjte000;}
17639 } finally {
17640 if (jjtc000) {
17641 jjtree.closeNodeScope(jjtn000, true);
17642 }
17643 }
17644 throw new Error("Missing return statement in function");
17645 }
17646
17647 final public ASTConditionalOrExpression ConditionalOrExpression() throws ParseException {
17648
17649 ASTConditionalOrExpression jjtn000 = new ASTConditionalOrExpression(this, JJTCONDITIONALOREXPRESSION);
17650 boolean jjtc000 = true;
17651 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
17652 try {
17653 simpleNode = ConditionalAndExpression();
17654 sb.append(simpleNode.getImage());
17655 label_54:
17656 while (true) {
17657 switch (jj_nt.kind) {
17658 case OR:
17659 ;
17660 break;
17661 default:
17662 jj_la1[223] = jj_gen;
17663 break label_54;
17664 }
17665 jj_consume_token(OR);
17666 sb.append(" OR ");
17667 simpleNode = ConditionalAndExpression();
17668 sb.append(simpleNode.getImage());
17669 }
17670 jjtree.closeNodeScope(jjtn000, true);
17671 jjtc000 = false;
17672 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
17673 } catch (Throwable jjte000) {
17674 if (jjtc000) {
17675 jjtree.clearNodeScope(jjtn000);
17676 jjtc000 = false;
17677 } else {
17678 jjtree.popNode();
17679 }
17680 if (jjte000 instanceof RuntimeException) {
17681 {if (true) throw (RuntimeException)jjte000;}
17682 }
17683 if (jjte000 instanceof ParseException) {
17684 {if (true) throw (ParseException)jjte000;}
17685 }
17686 {if (true) throw (Error)jjte000;}
17687 } finally {
17688 if (jjtc000) {
17689 jjtree.closeNodeScope(jjtn000, true);
17690 }
17691 }
17692 throw new Error("Missing return statement in function");
17693 }
17694
17695 final public ASTConditionalAndExpression ConditionalAndExpression() throws ParseException {
17696
17697 ASTConditionalAndExpression jjtn000 = new ASTConditionalAndExpression(this, JJTCONDITIONALANDEXPRESSION);
17698 boolean jjtc000 = true;
17699 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
17700 try {
17701 simpleNode = EqualityExpression();
17702 sb.append(simpleNode.getImage());
17703 label_55:
17704 while (true) {
17705 switch (jj_nt.kind) {
17706 case AND:
17707 ;
17708 break;
17709 default:
17710 jj_la1[224] = jj_gen;
17711 break label_55;
17712 }
17713 jj_consume_token(AND);
17714 sb.append(" AND ");
17715 simpleNode = EqualityExpression();
17716 sb.append(simpleNode.getImage());
17717 }
17718 jjtree.closeNodeScope(jjtn000, true);
17719 jjtc000 = false;
17720 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
17721 } catch (Throwable jjte000) {
17722 if (jjtc000) {
17723 jjtree.clearNodeScope(jjtn000);
17724 jjtc000 = false;
17725 } else {
17726 jjtree.popNode();
17727 }
17728 if (jjte000 instanceof RuntimeException) {
17729 {if (true) throw (RuntimeException)jjte000;}
17730 }
17731 if (jjte000 instanceof ParseException) {
17732 {if (true) throw (ParseException)jjte000;}
17733 }
17734 {if (true) throw (Error)jjte000;}
17735 } finally {
17736 if (jjtc000) {
17737 jjtree.closeNodeScope(jjtn000, true);
17738 }
17739 }
17740 throw new Error("Missing return statement in function");
17741 }
17742
17743 final public ASTEqualityExpression EqualityExpression() throws ParseException {
17744
17745 ASTEqualityExpression jjtn000 = new ASTEqualityExpression(this, JJTEQUALITYEXPRESSION);
17746 boolean jjtc000 = true;
17747 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
17748 try {
17749 simpleNode = RelationalExpression();
17750 sb.append(simpleNode.getImage());
17751 label_56:
17752 while (true) {
17753 switch (jj_nt.kind) {
17754 case 10:
17755 case 13:
17756 case IS:
17757 ;
17758 break;
17759 default:
17760 jj_la1[225] = jj_gen;
17761 break label_56;
17762 }
17763 switch (jj_nt.kind) {
17764 case 10:
17765 jj_consume_token(10);
17766 sb.append(" = ");
17767 break;
17768 case 13:
17769 jj_consume_token(13);
17770 jj_consume_token(10);
17771 sb.append(" != ");
17772 break;
17773 case IS:
17774 jj_consume_token(IS);
17775 sb.append(" IS ");
17776 break;
17777 default:
17778 jj_la1[226] = jj_gen;
17779 jj_consume_token(-1);
17780 throw new ParseException();
17781 }
17782 simpleNode = RelationalExpression();
17783 sb.append(simpleNode.getImage());
17784 }
17785 jjtree.closeNodeScope(jjtn000, true);
17786 jjtc000 = false;
17787 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
17788 } catch (Throwable jjte000) {
17789 if (jjtc000) {
17790 jjtree.clearNodeScope(jjtn000);
17791 jjtc000 = false;
17792 } else {
17793 jjtree.popNode();
17794 }
17795 if (jjte000 instanceof RuntimeException) {
17796 {if (true) throw (RuntimeException)jjte000;}
17797 }
17798 if (jjte000 instanceof ParseException) {
17799 {if (true) throw (ParseException)jjte000;}
17800 }
17801 {if (true) throw (Error)jjte000;}
17802 } finally {
17803 if (jjtc000) {
17804 jjtree.closeNodeScope(jjtn000, true);
17805 }
17806 }
17807 throw new Error("Missing return statement in function");
17808 }
17809
17810
17811
17812
17813 final public ASTRelationalExpression RelationalExpression() throws ParseException {
17814
17815 ASTRelationalExpression jjtn000 = new ASTRelationalExpression(this, JJTRELATIONALEXPRESSION);
17816 boolean jjtc000 = true;
17817 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
17818 try {
17819 simpleNode = AdditiveExpression();
17820 sb.append(simpleNode.getImage());
17821 label_57:
17822 while (true) {
17823 switch (jj_nt.kind) {
17824 case 14:
17825 case 15:
17826 case BETWEEN:
17827 case FROM:
17828 case IN:
17829 case LIKE:
17830 case MEMBER:
17831 case NOT:
17832 case MULTISET:
17833 case SUBMULTISET:
17834 ;
17835 break;
17836 default:
17837 jj_la1[227] = jj_gen;
17838 break label_57;
17839 }
17840 switch (jj_nt.kind) {
17841 case 14:
17842 case 15:
17843 switch (jj_nt.kind) {
17844 case 14:
17845 jj_consume_token(14);
17846 sb.append("<");
17847 switch (jj_nt.kind) {
17848 case 15:
17849 jj_consume_token(15);
17850 sb.append(">");
17851 break;
17852 default:
17853 jj_la1[228] = jj_gen;
17854 ;
17855 }
17856 break;
17857 case 15:
17858 jj_consume_token(15);
17859 sb.append(">");
17860 break;
17861 default:
17862 jj_la1[229] = jj_gen;
17863 jj_consume_token(-1);
17864 throw new ParseException();
17865 }
17866 switch (jj_nt.kind) {
17867 case 10:
17868 jj_consume_token(10);
17869 sb.append("=");
17870 break;
17871 default:
17872 jj_la1[230] = jj_gen;
17873 ;
17874 }
17875 sb.append(" ");
17876 break;
17877 case BETWEEN:
17878 case FROM:
17879 case IN:
17880 case LIKE:
17881 case MEMBER:
17882 case NOT:
17883 case SUBMULTISET:
17884 switch (jj_nt.kind) {
17885 case NOT:
17886 jj_consume_token(NOT);
17887 sb.append(" NOT ");
17888 break;
17889 default:
17890 jj_la1[231] = jj_gen;
17891 ;
17892 }
17893 switch (jj_nt.kind) {
17894 case IN:
17895 jj_consume_token(IN);
17896 sb.append(" IN ");
17897 break;
17898 case BETWEEN:
17899 jj_consume_token(BETWEEN);
17900 sb.append(" BETWEEN ");
17901 break;
17902 case LIKE:
17903 jj_consume_token(LIKE);
17904 sb.append(" LIKE ");
17905 break;
17906 case FROM:
17907 jj_consume_token(FROM);
17908 sb.append(" FROM ");
17909 break;
17910 case MEMBER:
17911 case SUBMULTISET:
17912 switch (jj_nt.kind) {
17913 case MEMBER:
17914 jj_consume_token(MEMBER);
17915 sb.append(" MEMBER ");
17916 break;
17917 case SUBMULTISET:
17918 jj_consume_token(SUBMULTISET);
17919 sb.append(" SUBMULTISET ");
17920 break;
17921 default:
17922 jj_la1[232] = jj_gen;
17923 jj_consume_token(-1);
17924 throw new ParseException();
17925 }
17926 switch (jj_nt.kind) {
17927 case OF:
17928 jj_consume_token(OF);
17929 sb.append(" OF ");
17930 break;
17931 default:
17932 jj_la1[233] = jj_gen;
17933 ;
17934 }
17935 break;
17936 default:
17937 jj_la1[234] = jj_gen;
17938 jj_consume_token(-1);
17939 throw new ParseException();
17940 }
17941 break;
17942 case MULTISET:
17943 jj_consume_token(MULTISET);
17944 sb.append (" MULTISET " );
17945 switch (jj_nt.kind) {
17946 case EXCEPT:
17947 jj_consume_token(EXCEPT);
17948 sb.append (" EXCEPT " );
17949 break;
17950 case INTERSECT:
17951 jj_consume_token(INTERSECT);
17952 sb.append (" INTERSECT " );
17953 break;
17954 case UNION:
17955 jj_consume_token(UNION);
17956 sb.append (" UNION " );
17957 break;
17958 default:
17959 jj_la1[235] = jj_gen;
17960 jj_consume_token(-1);
17961 throw new ParseException();
17962 }
17963 switch (jj_nt.kind) {
17964 case ALL:
17965 case DISTINCT:
17966 switch (jj_nt.kind) {
17967 case DISTINCT:
17968 jj_consume_token(DISTINCT);
17969 sb.append (" DISTINCT " );
17970 break;
17971 case ALL:
17972 jj_consume_token(ALL);
17973 sb.append (" ALL " );
17974 break;
17975 default:
17976 jj_la1[236] = jj_gen;
17977 jj_consume_token(-1);
17978 throw new ParseException();
17979 }
17980 break;
17981 default:
17982 jj_la1[237] = jj_gen;
17983 ;
17984 }
17985 break;
17986 default:
17987 jj_la1[238] = jj_gen;
17988 jj_consume_token(-1);
17989 throw new ParseException();
17990 }
17991 AdditiveExpression();
17992 sb.append(simpleNode.getImage());
17993 switch (jj_nt.kind) {
17994 case ESCAPE:
17995 jj_consume_token(ESCAPE);
17996 sb.append(" ESCAPE ");
17997 switch (jj_nt.kind) {
17998 case CHARACTER_LITERAL:
17999 jj_consume_token(CHARACTER_LITERAL);
18000 sb.append(" "); sb.append(token.toString());
18001 break;
18002 case STRING_LITERAL:
18003 simpleNode = StringLiteral();
18004 sb.append(" "); sb.append(simpleNode.getImage());
18005 break;
18006 default:
18007 jj_la1[239] = jj_gen;
18008 jj_consume_token(-1);
18009 throw new ParseException();
18010 }
18011 break;
18012 default:
18013 jj_la1[240] = jj_gen;
18014 ;
18015 }
18016 }
18017 jjtree.closeNodeScope(jjtn000, true);
18018 jjtc000 = false;
18019 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
18020 } catch (Throwable jjte000) {
18021 if (jjtc000) {
18022 jjtree.clearNodeScope(jjtn000);
18023 jjtc000 = false;
18024 } else {
18025 jjtree.popNode();
18026 }
18027 if (jjte000 instanceof RuntimeException) {
18028 {if (true) throw (RuntimeException)jjte000;}
18029 }
18030 if (jjte000 instanceof ParseException) {
18031 {if (true) throw (ParseException)jjte000;}
18032 }
18033 {if (true) throw (Error)jjte000;}
18034 } finally {
18035 if (jjtc000) {
18036 jjtree.closeNodeScope(jjtn000, true);
18037 }
18038 }
18039 throw new Error("Missing return statement in function");
18040 }
18041
18042 final public ASTAdditiveExpression AdditiveExpression() throws ParseException {
18043
18044 ASTAdditiveExpression jjtn000 = new ASTAdditiveExpression(this, JJTADDITIVEEXPRESSION);
18045 boolean jjtc000 = true;
18046 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
18047 try {
18048 simpleNode = MultiplicativeExpression();
18049 sb.append(simpleNode.getImage());
18050 label_58:
18051 while (true) {
18052 switch (jj_nt.kind) {
18053 case 16:
18054 case 17:
18055 case 18:
18056 ;
18057 break;
18058 default:
18059 jj_la1[241] = jj_gen;
18060 break label_58;
18061 }
18062 switch (jj_nt.kind) {
18063 case 16:
18064 jj_consume_token(16);
18065 sb.append(" + ");
18066 break;
18067 case 17:
18068 jj_consume_token(17);
18069 sb.append(" - ");
18070 break;
18071 case 18:
18072 jj_consume_token(18);
18073 sb.append(" || ");
18074 break;
18075 default:
18076 jj_la1[242] = jj_gen;
18077 jj_consume_token(-1);
18078 throw new ParseException();
18079 }
18080 simpleNode = MultiplicativeExpression();
18081 sb.append(simpleNode.getImage());
18082 }
18083 jjtree.closeNodeScope(jjtn000, true);
18084 jjtc000 = false;
18085 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
18086 } catch (Throwable jjte000) {
18087 if (jjtc000) {
18088 jjtree.clearNodeScope(jjtn000);
18089 jjtc000 = false;
18090 } else {
18091 jjtree.popNode();
18092 }
18093 if (jjte000 instanceof RuntimeException) {
18094 {if (true) throw (RuntimeException)jjte000;}
18095 }
18096 if (jjte000 instanceof ParseException) {
18097 {if (true) throw (ParseException)jjte000;}
18098 }
18099 {if (true) throw (Error)jjte000;}
18100 } finally {
18101 if (jjtc000) {
18102 jjtree.closeNodeScope(jjtn000, true);
18103 }
18104 }
18105 throw new Error("Missing return statement in function");
18106 }
18107
18108 final public ASTStringExpression StringExpression() throws ParseException {
18109
18110 ASTStringExpression jjtn000 = new ASTStringExpression(this, JJTSTRINGEXPRESSION);
18111 boolean jjtc000 = true;
18112 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
18113 try {
18114 simpleNode = PrimaryExpression();
18115 sb.append(simpleNode.getImage());
18116 label_59:
18117 while (true) {
18118 switch (jj_nt.kind) {
18119 case 18:
18120 ;
18121 break;
18122 default:
18123 jj_la1[243] = jj_gen;
18124 break label_59;
18125 }
18126 jj_consume_token(18);
18127 sb.append(" || ");
18128 simpleNode = PrimaryExpression();
18129 sb.append(simpleNode.getImage());
18130 }
18131 jjtree.closeNodeScope(jjtn000, true);
18132 jjtc000 = false;
18133 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
18134 } catch (Throwable jjte000) {
18135 if (jjtc000) {
18136 jjtree.clearNodeScope(jjtn000);
18137 jjtc000 = false;
18138 } else {
18139 jjtree.popNode();
18140 }
18141 if (jjte000 instanceof RuntimeException) {
18142 {if (true) throw (RuntimeException)jjte000;}
18143 }
18144 if (jjte000 instanceof ParseException) {
18145 {if (true) throw (ParseException)jjte000;}
18146 }
18147 {if (true) throw (Error)jjte000;}
18148 } finally {
18149 if (jjtc000) {
18150 jjtree.closeNodeScope(jjtn000, true);
18151 }
18152 }
18153 throw new Error("Missing return statement in function");
18154 }
18155
18156 final public ASTMultiplicativeExpression MultiplicativeExpression() throws ParseException {
18157
18158 ASTMultiplicativeExpression jjtn000 = new ASTMultiplicativeExpression(this, JJTMULTIPLICATIVEEXPRESSION);
18159 boolean jjtc000 = true;
18160 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
18161 try {
18162 simpleNode = UnaryExpression(true);
18163 sb.append(simpleNode.getImage());
18164 label_60:
18165 while (true) {
18166 switch (jj_nt.kind) {
18167 case 1:
18168 case 19:
18169 case 20:
18170 case MOD:
18171 ;
18172 break;
18173 default:
18174 jj_la1[244] = jj_gen;
18175 break label_60;
18176 }
18177 switch (jj_nt.kind) {
18178 case 19:
18179 jj_consume_token(19);
18180 sb.append(" ** ");
18181 break;
18182 case 20:
18183 jj_consume_token(20);
18184 sb.append(" * ");
18185 break;
18186 case 1:
18187 jj_consume_token(1);
18188 sb.append(" / ");
18189 break;
18190 case MOD:
18191 jj_consume_token(MOD);
18192 sb.append(" MOD ");
18193 break;
18194 default:
18195 jj_la1[245] = jj_gen;
18196 jj_consume_token(-1);
18197 throw new ParseException();
18198 }
18199 simpleNode = UnaryExpression(true);
18200 sb.append(simpleNode.getImage());
18201 }
18202 jjtree.closeNodeScope(jjtn000, true);
18203 jjtc000 = false;
18204 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
18205 } catch (Throwable jjte000) {
18206 if (jjtc000) {
18207 jjtree.clearNodeScope(jjtn000);
18208 jjtc000 = false;
18209 } else {
18210 jjtree.popNode();
18211 }
18212 if (jjte000 instanceof RuntimeException) {
18213 {if (true) throw (RuntimeException)jjte000;}
18214 }
18215 if (jjte000 instanceof ParseException) {
18216 {if (true) throw (ParseException)jjte000;}
18217 }
18218 {if (true) throw (Error)jjte000;}
18219 } finally {
18220 if (jjtc000) {
18221 jjtree.closeNodeScope(jjtn000, true);
18222 }
18223 }
18224 throw new Error("Missing return statement in function");
18225 }
18226
18227 final public ASTUnaryExpression UnaryExpression(boolean isUnarySign) throws ParseException {
18228
18229 ASTUnaryExpression jjtn000 = new ASTUnaryExpression(this, JJTUNARYEXPRESSION);
18230 boolean jjtc000 = true;
18231 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
18232 try {
18233 switch (jj_nt.kind) {
18234 case 16:
18235 case 17:
18236 switch (jj_nt.kind) {
18237 case 16:
18238 jj_consume_token(16);
18239 sb.append(isUnarySign ? " +" : " + ");
18240 break;
18241 case 17:
18242 jj_consume_token(17);
18243 sb.append(isUnarySign ? " -" : " - ");
18244 break;
18245 default:
18246 jj_la1[246] = jj_gen;
18247 jj_consume_token(-1);
18248 throw new ParseException();
18249 }
18250 simpleNode = UnaryExpression(false);
18251 sb.append(simpleNode.getImage());
18252 break;
18253 case 5:
18254 case REPLACE:
18255 case DEFINER:
18256 case CURRENT_USER:
18257 case LANGUAGE:
18258 case INLINE:
18259 case ADD:
18260 case AGGREGATE:
18261 case ARRAY:
18262 case AT:
18263 case ATTRIBUTE:
18264 case AUTHID:
18265 case BODY:
18266 case BULK:
18267 case BYTE:
18268 case CASCADE:
18269 case CASE:
18270 case CLOSE:
18271 case COALESCE:
18272 case COLLECT:
18273 case COLUMN:
18274 case COMMENT:
18275 case COMMIT:
18276 case CONSTRUCTOR:
18277 case CONTINUE:
18278 case CONVERT:
18279 case CURRENT:
18280 case CURSOR:
18281 case DATA:
18282 case DATE:
18283 case DAY:
18284 case DISABLE:
18285 case EDITIONABLE:
18286 case ELEMENT:
18287 case ENABLE:
18288 case ESCAPE:
18289 case EXCEPT:
18290 case EXCEPTIONS:
18291 case EXIT:
18292 case EXTERNAL:
18293 case EXTENDS:
18294 case EXTRACT:
18295 case FALSE:
18296 case FINAL:
18297 case FORCE:
18298 case FUNCTION:
18299 case GLOBAL:
18300 case HASH:
18301 case HEAP:
18302 case HOUR:
18303 case IMMEDIATE:
18304 case INDICES:
18305 case INDEXTYPE:
18306 case INDICATOR:
18307 case INSTANTIABLE:
18308 case INTERVAL:
18309 case INVALIDATE:
18310 case ISOLATION:
18311 case JAVA:
18312 case LEVEL:
18313 case LIMIT:
18314 case LOOP:
18315 case MAP:
18316 case MAX:
18317 case MEMBER:
18318 case MERGE:
18319 case MIN:
18320 case MINUTE:
18321 case MLSLABEL:
18322 case MODIFY:
18323 case MOD:
18324 case MONTH:
18325 case NATURAL:
18326 case NEW:
18327 case NEW_DOT:
18328 case NO:
18329 case NONEDITIONABLE:
18330 case NOT:
18331 case NULL:
18332 case NULLIF:
18333 case OBJECT:
18334 case OID:
18335 case OPAQUE:
18336 case OPEN:
18337 case OPERATOR:
18338 case ORGANIZATION:
18339 case OTHERS:
18340 case OVERRIDING:
18341 case PACKAGE:
18342 case PARTITION:
18343 case PRESERVE:
18344 case PRIVATE:
18345 case PROCEDURE:
18346 case RANGE:
18347 case RAW:
18348 case REAL:
18349 case RECORD:
18350 case REF:
18351 case RELEASE:
18352 case RELIES_ON:
18353 case RENAME:
18354 case RESULT:
18355 case RETURN:
18356 case RETURNING:
18357 case REVERSE:
18358 case ROLLBACK:
18359 case ROW:
18360 case ROWS:
18361 case ROWID:
18362 case ROWNUM:
18363 case SAVE:
18364 case SAVEPOINT:
18365 case SECOND:
18366 case SELECT:
18367 case SELF:
18368 case SET:
18369 case SPACE:
18370 case SQL:
18371 case SQLCODE:
18372 case SQLERRM:
18373 case STATIC:
18374 case SUBTYPE:
18375 case SUBSTITUTABLE:
18376 case SUCCESSFUL:
18377 case SYSDATE:
18378 case SYS_REFCURSOR:
18379 case TEMPORARY:
18380 case TIME:
18381 case TIMESTAMP:
18382 case TIMEZONE_REGION:
18383 case TIMEZONE_ABBR:
18384 case TIMEZONE_MINUTE:
18385 case TIMEZONE_HOUR:
18386 case TRANSACTION:
18387 case TRUE:
18388 case TYPE:
18389 case UNDER:
18390 case USING:
18391 case YES:
18392 case SHOW:
18393 case A:
18394 case DOUBLE:
18395 case DEC:
18396 case PRECISION:
18397 case INT:
18398 case NUMERIC:
18399 case NCHAR:
18400 case NVARCHAR2:
18401 case STRING:
18402 case UROWID:
18403 case VARRAY:
18404 case VARYING:
18405 case BFILE:
18406 case BLOB:
18407 case CLOB:
18408 case NCLOB:
18409 case YEAR:
18410 case LOCAL:
18411 case WITH:
18412 case ZONE:
18413 case CHARACTER:
18414 case AFTER:
18415 case BEFORE:
18416 case OLD:
18417 case PARENT:
18418 case ANALYZE:
18419 case ASSOCIATE:
18420 case AUDIT:
18421 case COMPOUND:
18422 case DATABASE:
18423 case CALL:
18424 case DDL:
18425 case DISASSOCIATE:
18426 case EACH:
18427 case FOLLOWS:
18428 case LOGOFF:
18429 case LOGON:
18430 case NESTED:
18431 case NOAUDIT:
18432 case SCHEMA:
18433 case SERVERERROR:
18434 case SHUTDOWN:
18435 case STARTUP:
18436 case STATEMENT:
18437 case STATISTICS:
18438 case SUSPEND:
18439 case TRUNCATE:
18440 case WRAPPED:
18441 case LIBRARY:
18442 case NAME:
18443 case STRUCT:
18444 case CONTEXT:
18445 case PARAMETERS:
18446 case LENGTH:
18447 case TDO:
18448 case MAXLEN:
18449 case CHARSETID:
18450 case CHARSETFORM:
18451 case ACCEPT:
18452 case ACCESSIBLE:
18453 case COPY:
18454 case DEFINE:
18455 case DISCONNECT:
18456 case HOST:
18457 case PRINT:
18458 case QUIT:
18459 case REMARK:
18460 case UNDEFINE:
18461 case VARIABLE:
18462 case WHENEVER:
18463 case ATTACH:
18464 case CAST:
18465 case TREAT:
18466 case TRIM:
18467 case LEFT:
18468 case RIGHT:
18469 case BOTH:
18470 case EMPTY:
18471 case MULTISET:
18472 case SUBMULTISET:
18473 case LEADING:
18474 case TRAILING:
18475 case CHAR_CS:
18476 case NCHAR_CS:
18477 case DBTIMEZONE:
18478 case SESSIONTIMEZONE:
18479 case AUTHENTICATED:
18480 case LINK:
18481 case SHARED:
18482 case DIRECTORY:
18483 case USER:
18484 case IDENTIFIER:
18485 case UNSIGNED_NUMERIC_LITERAL:
18486 case CHARACTER_LITERAL:
18487 case STRING_LITERAL:
18488 case QUOTED_LITERAL:
18489 simpleNode = UnaryExpressionNotPlusMinus();
18490 sb.append(simpleNode.getImage());
18491 break;
18492 default:
18493 jj_la1[247] = jj_gen;
18494 jj_consume_token(-1);
18495 throw new ParseException();
18496 }
18497 jjtree.closeNodeScope(jjtn000, true);
18498 jjtc000 = false;
18499 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
18500 } catch (Throwable jjte000) {
18501 if (jjtc000) {
18502 jjtree.clearNodeScope(jjtn000);
18503 jjtc000 = false;
18504 } else {
18505 jjtree.popNode();
18506 }
18507 if (jjte000 instanceof RuntimeException) {
18508 {if (true) throw (RuntimeException)jjte000;}
18509 }
18510 if (jjte000 instanceof ParseException) {
18511 {if (true) throw (ParseException)jjte000;}
18512 }
18513 {if (true) throw (Error)jjte000;}
18514 } finally {
18515 if (jjtc000) {
18516 jjtree.closeNodeScope(jjtn000, true);
18517 }
18518 }
18519 throw new Error("Missing return statement in function");
18520 }
18521
18522 final public ASTUnaryExpressionNotPlusMinus UnaryExpressionNotPlusMinus() throws ParseException {
18523
18524 ASTUnaryExpressionNotPlusMinus jjtn000 = new ASTUnaryExpressionNotPlusMinus(this, JJTUNARYEXPRESSIONNOTPLUSMINUS);
18525 boolean jjtc000 = true;
18526 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
18527 try {
18528 switch (jj_nt.kind) {
18529 case NOT:
18530 jj_consume_token(NOT);
18531 sb.append(" NOT ");
18532 simpleNode = UnaryExpression(false);
18533 sb.append(simpleNode.getImage());
18534 break;
18535 case 5:
18536 case REPLACE:
18537 case DEFINER:
18538 case CURRENT_USER:
18539 case LANGUAGE:
18540 case INLINE:
18541 case ADD:
18542 case AGGREGATE:
18543 case ARRAY:
18544 case AT:
18545 case ATTRIBUTE:
18546 case AUTHID:
18547 case BODY:
18548 case BULK:
18549 case BYTE:
18550 case CASCADE:
18551 case CASE:
18552 case CLOSE:
18553 case COALESCE:
18554 case COLLECT:
18555 case COLUMN:
18556 case COMMENT:
18557 case COMMIT:
18558 case CONSTRUCTOR:
18559 case CONTINUE:
18560 case CONVERT:
18561 case CURRENT:
18562 case CURSOR:
18563 case DATA:
18564 case DATE:
18565 case DAY:
18566 case DISABLE:
18567 case EDITIONABLE:
18568 case ELEMENT:
18569 case ENABLE:
18570 case ESCAPE:
18571 case EXCEPT:
18572 case EXCEPTIONS:
18573 case EXIT:
18574 case EXTERNAL:
18575 case EXTENDS:
18576 case EXTRACT:
18577 case FALSE:
18578 case FINAL:
18579 case FORCE:
18580 case FUNCTION:
18581 case GLOBAL:
18582 case HASH:
18583 case HEAP:
18584 case HOUR:
18585 case IMMEDIATE:
18586 case INDICES:
18587 case INDEXTYPE:
18588 case INDICATOR:
18589 case INSTANTIABLE:
18590 case INTERVAL:
18591 case INVALIDATE:
18592 case ISOLATION:
18593 case JAVA:
18594 case LEVEL:
18595 case LIMIT:
18596 case LOOP:
18597 case MAP:
18598 case MAX:
18599 case MEMBER:
18600 case MERGE:
18601 case MIN:
18602 case MINUTE:
18603 case MLSLABEL:
18604 case MODIFY:
18605 case MOD:
18606 case MONTH:
18607 case NATURAL:
18608 case NEW:
18609 case NEW_DOT:
18610 case NO:
18611 case NONEDITIONABLE:
18612 case NULL:
18613 case NULLIF:
18614 case OBJECT:
18615 case OID:
18616 case OPAQUE:
18617 case OPEN:
18618 case OPERATOR:
18619 case ORGANIZATION:
18620 case OTHERS:
18621 case OVERRIDING:
18622 case PACKAGE:
18623 case PARTITION:
18624 case PRESERVE:
18625 case PRIVATE:
18626 case PROCEDURE:
18627 case RANGE:
18628 case RAW:
18629 case REAL:
18630 case RECORD:
18631 case REF:
18632 case RELEASE:
18633 case RELIES_ON:
18634 case RENAME:
18635 case RESULT:
18636 case RETURN:
18637 case RETURNING:
18638 case REVERSE:
18639 case ROLLBACK:
18640 case ROW:
18641 case ROWS:
18642 case ROWID:
18643 case ROWNUM:
18644 case SAVE:
18645 case SAVEPOINT:
18646 case SECOND:
18647 case SELECT:
18648 case SELF:
18649 case SET:
18650 case SPACE:
18651 case SQL:
18652 case SQLCODE:
18653 case SQLERRM:
18654 case STATIC:
18655 case SUBTYPE:
18656 case SUBSTITUTABLE:
18657 case SUCCESSFUL:
18658 case SYSDATE:
18659 case SYS_REFCURSOR:
18660 case TEMPORARY:
18661 case TIME:
18662 case TIMESTAMP:
18663 case TIMEZONE_REGION:
18664 case TIMEZONE_ABBR:
18665 case TIMEZONE_MINUTE:
18666 case TIMEZONE_HOUR:
18667 case TRANSACTION:
18668 case TRUE:
18669 case TYPE:
18670 case UNDER:
18671 case USING:
18672 case YES:
18673 case SHOW:
18674 case A:
18675 case DOUBLE:
18676 case DEC:
18677 case PRECISION:
18678 case INT:
18679 case NUMERIC:
18680 case NCHAR:
18681 case NVARCHAR2:
18682 case STRING:
18683 case UROWID:
18684 case VARRAY:
18685 case VARYING:
18686 case BFILE:
18687 case BLOB:
18688 case CLOB:
18689 case NCLOB:
18690 case YEAR:
18691 case LOCAL:
18692 case WITH:
18693 case ZONE:
18694 case CHARACTER:
18695 case AFTER:
18696 case BEFORE:
18697 case OLD:
18698 case PARENT:
18699 case ANALYZE:
18700 case ASSOCIATE:
18701 case AUDIT:
18702 case COMPOUND:
18703 case DATABASE:
18704 case CALL:
18705 case DDL:
18706 case DISASSOCIATE:
18707 case EACH:
18708 case FOLLOWS:
18709 case LOGOFF:
18710 case LOGON:
18711 case NESTED:
18712 case NOAUDIT:
18713 case SCHEMA:
18714 case SERVERERROR:
18715 case SHUTDOWN:
18716 case STARTUP:
18717 case STATEMENT:
18718 case STATISTICS:
18719 case SUSPEND:
18720 case TRUNCATE:
18721 case WRAPPED:
18722 case LIBRARY:
18723 case NAME:
18724 case STRUCT:
18725 case CONTEXT:
18726 case PARAMETERS:
18727 case LENGTH:
18728 case TDO:
18729 case MAXLEN:
18730 case CHARSETID:
18731 case CHARSETFORM:
18732 case ACCEPT:
18733 case ACCESSIBLE:
18734 case COPY:
18735 case DEFINE:
18736 case DISCONNECT:
18737 case HOST:
18738 case PRINT:
18739 case QUIT:
18740 case REMARK:
18741 case UNDEFINE:
18742 case VARIABLE:
18743 case WHENEVER:
18744 case ATTACH:
18745 case CAST:
18746 case TREAT:
18747 case TRIM:
18748 case LEFT:
18749 case RIGHT:
18750 case BOTH:
18751 case EMPTY:
18752 case MULTISET:
18753 case SUBMULTISET:
18754 case LEADING:
18755 case TRAILING:
18756 case CHAR_CS:
18757 case NCHAR_CS:
18758 case DBTIMEZONE:
18759 case SESSIONTIMEZONE:
18760 case AUTHENTICATED:
18761 case LINK:
18762 case SHARED:
18763 case DIRECTORY:
18764 case USER:
18765 case IDENTIFIER:
18766 case UNSIGNED_NUMERIC_LITERAL:
18767 case CHARACTER_LITERAL:
18768 case STRING_LITERAL:
18769 case QUOTED_LITERAL:
18770 simpleNode = PrimaryExpression();
18771 sb.append(simpleNode.getImage());
18772 break;
18773 default:
18774 jj_la1[248] = jj_gen;
18775 jj_consume_token(-1);
18776 throw new ParseException();
18777 }
18778 jjtree.closeNodeScope(jjtn000, true);
18779 jjtc000 = false;
18780 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
18781 } catch (Throwable jjte000) {
18782 if (jjtc000) {
18783 jjtree.clearNodeScope(jjtn000);
18784 jjtc000 = false;
18785 } else {
18786 jjtree.popNode();
18787 }
18788 if (jjte000 instanceof RuntimeException) {
18789 {if (true) throw (RuntimeException)jjte000;}
18790 }
18791 if (jjte000 instanceof ParseException) {
18792 {if (true) throw (ParseException)jjte000;}
18793 }
18794 {if (true) throw (Error)jjte000;}
18795 } finally {
18796 if (jjtc000) {
18797 jjtree.closeNodeScope(jjtn000, true);
18798 }
18799 }
18800 throw new Error("Missing return statement in function");
18801 }
18802
18803
18804
18805
18806
18807
18808 final public ASTPrimaryExpression PrimaryExpression() throws ParseException {
18809
18810 ASTPrimaryExpression jjtn000 = new ASTPrimaryExpression(this, JJTPRIMARYEXPRESSION);
18811 boolean jjtc000 = true;
18812 jjtree.openNodeScope(jjtn000);Token thisToken ; PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
18813 try {
18814 switch (jj_nt.kind) {
18815 case NEW_DOT:
18816 jj_consume_token(NEW_DOT);
18817 simpleNode = QualifiedID();
18818 sb.append(" NEW."); sb.append(simpleNode.getImage());
18819 break;
18820 case 5:
18821 case REPLACE:
18822 case DEFINER:
18823 case CURRENT_USER:
18824 case LANGUAGE:
18825 case INLINE:
18826 case ADD:
18827 case AGGREGATE:
18828 case ARRAY:
18829 case AT:
18830 case ATTRIBUTE:
18831 case AUTHID:
18832 case BODY:
18833 case BULK:
18834 case BYTE:
18835 case CASCADE:
18836 case CASE:
18837 case CLOSE:
18838 case COALESCE:
18839 case COLLECT:
18840 case COLUMN:
18841 case COMMENT:
18842 case COMMIT:
18843 case CONSTRUCTOR:
18844 case CONTINUE:
18845 case CONVERT:
18846 case CURRENT:
18847 case CURSOR:
18848 case DATA:
18849 case DATE:
18850 case DAY:
18851 case DISABLE:
18852 case EDITIONABLE:
18853 case ELEMENT:
18854 case ENABLE:
18855 case ESCAPE:
18856 case EXCEPT:
18857 case EXCEPTIONS:
18858 case EXIT:
18859 case EXTERNAL:
18860 case EXTENDS:
18861 case EXTRACT:
18862 case FALSE:
18863 case FINAL:
18864 case FORCE:
18865 case FUNCTION:
18866 case GLOBAL:
18867 case HASH:
18868 case HEAP:
18869 case HOUR:
18870 case IMMEDIATE:
18871 case INDICES:
18872 case INDEXTYPE:
18873 case INDICATOR:
18874 case INSTANTIABLE:
18875 case INTERVAL:
18876 case INVALIDATE:
18877 case ISOLATION:
18878 case JAVA:
18879 case LEVEL:
18880 case LIMIT:
18881 case LOOP:
18882 case MAP:
18883 case MAX:
18884 case MEMBER:
18885 case MERGE:
18886 case MIN:
18887 case MINUTE:
18888 case MLSLABEL:
18889 case MODIFY:
18890 case MOD:
18891 case MONTH:
18892 case NATURAL:
18893 case NEW:
18894 case NO:
18895 case NONEDITIONABLE:
18896 case NULL:
18897 case NULLIF:
18898 case OBJECT:
18899 case OID:
18900 case OPAQUE:
18901 case OPEN:
18902 case OPERATOR:
18903 case ORGANIZATION:
18904 case OTHERS:
18905 case OVERRIDING:
18906 case PACKAGE:
18907 case PARTITION:
18908 case PRESERVE:
18909 case PRIVATE:
18910 case PROCEDURE:
18911 case RANGE:
18912 case RAW:
18913 case REAL:
18914 case RECORD:
18915 case REF:
18916 case RELEASE:
18917 case RELIES_ON:
18918 case RENAME:
18919 case RESULT:
18920 case RETURN:
18921 case RETURNING:
18922 case REVERSE:
18923 case ROLLBACK:
18924 case ROW:
18925 case ROWS:
18926 case ROWID:
18927 case ROWNUM:
18928 case SAVE:
18929 case SAVEPOINT:
18930 case SECOND:
18931 case SELECT:
18932 case SELF:
18933 case SET:
18934 case SPACE:
18935 case SQL:
18936 case SQLCODE:
18937 case SQLERRM:
18938 case STATIC:
18939 case SUBTYPE:
18940 case SUBSTITUTABLE:
18941 case SUCCESSFUL:
18942 case SYSDATE:
18943 case SYS_REFCURSOR:
18944 case TEMPORARY:
18945 case TIME:
18946 case TIMESTAMP:
18947 case TIMEZONE_REGION:
18948 case TIMEZONE_ABBR:
18949 case TIMEZONE_MINUTE:
18950 case TIMEZONE_HOUR:
18951 case TRANSACTION:
18952 case TRUE:
18953 case TYPE:
18954 case UNDER:
18955 case USING:
18956 case YES:
18957 case SHOW:
18958 case A:
18959 case DOUBLE:
18960 case DEC:
18961 case PRECISION:
18962 case INT:
18963 case NUMERIC:
18964 case NCHAR:
18965 case NVARCHAR2:
18966 case STRING:
18967 case UROWID:
18968 case VARRAY:
18969 case VARYING:
18970 case BFILE:
18971 case BLOB:
18972 case CLOB:
18973 case NCLOB:
18974 case YEAR:
18975 case LOCAL:
18976 case WITH:
18977 case ZONE:
18978 case CHARACTER:
18979 case AFTER:
18980 case BEFORE:
18981 case OLD:
18982 case PARENT:
18983 case ANALYZE:
18984 case ASSOCIATE:
18985 case AUDIT:
18986 case COMPOUND:
18987 case DATABASE:
18988 case CALL:
18989 case DDL:
18990 case DISASSOCIATE:
18991 case EACH:
18992 case FOLLOWS:
18993 case LOGOFF:
18994 case LOGON:
18995 case NESTED:
18996 case NOAUDIT:
18997 case SCHEMA:
18998 case SERVERERROR:
18999 case SHUTDOWN:
19000 case STARTUP:
19001 case STATEMENT:
19002 case STATISTICS:
19003 case SUSPEND:
19004 case TRUNCATE:
19005 case WRAPPED:
19006 case LIBRARY:
19007 case NAME:
19008 case STRUCT:
19009 case CONTEXT:
19010 case PARAMETERS:
19011 case LENGTH:
19012 case TDO:
19013 case MAXLEN:
19014 case CHARSETID:
19015 case CHARSETFORM:
19016 case ACCEPT:
19017 case ACCESSIBLE:
19018 case COPY:
19019 case DEFINE:
19020 case DISCONNECT:
19021 case HOST:
19022 case PRINT:
19023 case QUIT:
19024 case REMARK:
19025 case UNDEFINE:
19026 case VARIABLE:
19027 case WHENEVER:
19028 case ATTACH:
19029 case CAST:
19030 case TREAT:
19031 case TRIM:
19032 case LEFT:
19033 case RIGHT:
19034 case BOTH:
19035 case EMPTY:
19036 case MULTISET:
19037 case SUBMULTISET:
19038 case LEADING:
19039 case TRAILING:
19040 case CHAR_CS:
19041 case NCHAR_CS:
19042 case DBTIMEZONE:
19043 case SESSIONTIMEZONE:
19044 case AUTHENTICATED:
19045 case LINK:
19046 case SHARED:
19047 case DIRECTORY:
19048 case USER:
19049 case IDENTIFIER:
19050 case UNSIGNED_NUMERIC_LITERAL:
19051 case CHARACTER_LITERAL:
19052 case STRING_LITERAL:
19053 case QUOTED_LITERAL:
19054 if (jj_2_46(2147483647)) {
19055 jj_consume_token(NEW);
19056 sb.append(" NEW ");
19057 simpleNode = PrimaryPrefix();
19058 sb.append(simpleNode.getImage());
19059 } else {
19060 switch (jj_nt.kind) {
19061 case 5:
19062 case REPLACE:
19063 case DEFINER:
19064 case CURRENT_USER:
19065 case LANGUAGE:
19066 case INLINE:
19067 case ADD:
19068 case AGGREGATE:
19069 case ARRAY:
19070 case AT:
19071 case ATTRIBUTE:
19072 case AUTHID:
19073 case BODY:
19074 case BULK:
19075 case BYTE:
19076 case CASCADE:
19077 case CASE:
19078 case CLOSE:
19079 case COALESCE:
19080 case COLLECT:
19081 case COLUMN:
19082 case COMMENT:
19083 case COMMIT:
19084 case CONSTRUCTOR:
19085 case CONTINUE:
19086 case CONVERT:
19087 case CURRENT:
19088 case CURSOR:
19089 case DATA:
19090 case DATE:
19091 case DAY:
19092 case DISABLE:
19093 case EDITIONABLE:
19094 case ELEMENT:
19095 case ENABLE:
19096 case ESCAPE:
19097 case EXCEPT:
19098 case EXCEPTIONS:
19099 case EXIT:
19100 case EXTERNAL:
19101 case EXTENDS:
19102 case EXTRACT:
19103 case FALSE:
19104 case FINAL:
19105 case FORCE:
19106 case FUNCTION:
19107 case GLOBAL:
19108 case HASH:
19109 case HEAP:
19110 case HOUR:
19111 case IMMEDIATE:
19112 case INDICES:
19113 case INDEXTYPE:
19114 case INDICATOR:
19115 case INSTANTIABLE:
19116 case INTERVAL:
19117 case INVALIDATE:
19118 case ISOLATION:
19119 case JAVA:
19120 case LEVEL:
19121 case LIMIT:
19122 case LOOP:
19123 case MAP:
19124 case MAX:
19125 case MEMBER:
19126 case MERGE:
19127 case MIN:
19128 case MINUTE:
19129 case MLSLABEL:
19130 case MODIFY:
19131 case MOD:
19132 case MONTH:
19133 case NATURAL:
19134 case NEW:
19135 case NO:
19136 case NONEDITIONABLE:
19137 case NULL:
19138 case NULLIF:
19139 case OBJECT:
19140 case OID:
19141 case OPAQUE:
19142 case OPEN:
19143 case OPERATOR:
19144 case ORGANIZATION:
19145 case OTHERS:
19146 case OVERRIDING:
19147 case PACKAGE:
19148 case PARTITION:
19149 case PRESERVE:
19150 case PRIVATE:
19151 case PROCEDURE:
19152 case RANGE:
19153 case RAW:
19154 case REAL:
19155 case RECORD:
19156 case REF:
19157 case RELEASE:
19158 case RELIES_ON:
19159 case RENAME:
19160 case RESULT:
19161 case RETURN:
19162 case RETURNING:
19163 case REVERSE:
19164 case ROLLBACK:
19165 case ROW:
19166 case ROWS:
19167 case ROWID:
19168 case ROWNUM:
19169 case SAVE:
19170 case SAVEPOINT:
19171 case SECOND:
19172 case SELECT:
19173 case SELF:
19174 case SET:
19175 case SPACE:
19176 case SQL:
19177 case SQLCODE:
19178 case SQLERRM:
19179 case STATIC:
19180 case SUBTYPE:
19181 case SUBSTITUTABLE:
19182 case SUCCESSFUL:
19183 case SYSDATE:
19184 case SYS_REFCURSOR:
19185 case TEMPORARY:
19186 case TIME:
19187 case TIMESTAMP:
19188 case TIMEZONE_REGION:
19189 case TIMEZONE_ABBR:
19190 case TIMEZONE_MINUTE:
19191 case TIMEZONE_HOUR:
19192 case TRANSACTION:
19193 case TRUE:
19194 case TYPE:
19195 case UNDER:
19196 case USING:
19197 case YES:
19198 case SHOW:
19199 case A:
19200 case DOUBLE:
19201 case DEC:
19202 case PRECISION:
19203 case INT:
19204 case NUMERIC:
19205 case NCHAR:
19206 case NVARCHAR2:
19207 case STRING:
19208 case UROWID:
19209 case VARRAY:
19210 case VARYING:
19211 case BFILE:
19212 case BLOB:
19213 case CLOB:
19214 case NCLOB:
19215 case YEAR:
19216 case LOCAL:
19217 case WITH:
19218 case ZONE:
19219 case CHARACTER:
19220 case AFTER:
19221 case BEFORE:
19222 case OLD:
19223 case PARENT:
19224 case ANALYZE:
19225 case ASSOCIATE:
19226 case AUDIT:
19227 case COMPOUND:
19228 case DATABASE:
19229 case CALL:
19230 case DDL:
19231 case DISASSOCIATE:
19232 case EACH:
19233 case FOLLOWS:
19234 case LOGOFF:
19235 case LOGON:
19236 case NESTED:
19237 case NOAUDIT:
19238 case SCHEMA:
19239 case SERVERERROR:
19240 case SHUTDOWN:
19241 case STARTUP:
19242 case STATEMENT:
19243 case STATISTICS:
19244 case SUSPEND:
19245 case TRUNCATE:
19246 case WRAPPED:
19247 case LIBRARY:
19248 case NAME:
19249 case STRUCT:
19250 case CONTEXT:
19251 case PARAMETERS:
19252 case LENGTH:
19253 case TDO:
19254 case MAXLEN:
19255 case CHARSETID:
19256 case CHARSETFORM:
19257 case ACCEPT:
19258 case ACCESSIBLE:
19259 case COPY:
19260 case DEFINE:
19261 case DISCONNECT:
19262 case HOST:
19263 case PRINT:
19264 case QUIT:
19265 case REMARK:
19266 case UNDEFINE:
19267 case VARIABLE:
19268 case WHENEVER:
19269 case ATTACH:
19270 case CAST:
19271 case TREAT:
19272 case TRIM:
19273 case LEFT:
19274 case RIGHT:
19275 case BOTH:
19276 case EMPTY:
19277 case MULTISET:
19278 case SUBMULTISET:
19279 case LEADING:
19280 case TRAILING:
19281 case CHAR_CS:
19282 case NCHAR_CS:
19283 case DBTIMEZONE:
19284 case SESSIONTIMEZONE:
19285 case AUTHENTICATED:
19286 case LINK:
19287 case SHARED:
19288 case DIRECTORY:
19289 case USER:
19290 case IDENTIFIER:
19291 case UNSIGNED_NUMERIC_LITERAL:
19292 case CHARACTER_LITERAL:
19293 case STRING_LITERAL:
19294 case QUOTED_LITERAL:
19295 simpleNode = PrimaryPrefix();
19296 sb.append(simpleNode.getImage());
19297 break;
19298 default:
19299 jj_la1[249] = jj_gen;
19300 jj_consume_token(-1);
19301 throw new ParseException();
19302 }
19303 }
19304 label_61:
19305 while (true) {
19306 if (jj_2_47(2)) {
19307 ;
19308 } else {
19309 break label_61;
19310 }
19311 simpleNode = PrimarySuffix();
19312 sb.append(simpleNode.getImage());
19313 }
19314 break;
19315 default:
19316 jj_la1[250] = jj_gen;
19317 jj_consume_token(-1);
19318 throw new ParseException();
19319 }
19320 jjtree.closeNodeScope(jjtn000, true);
19321 jjtc000 = false;
19322 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
19323 } catch (Throwable jjte000) {
19324 if (jjtc000) {
19325 jjtree.clearNodeScope(jjtn000);
19326 jjtc000 = false;
19327 } else {
19328 jjtree.popNode();
19329 }
19330 if (jjte000 instanceof RuntimeException) {
19331 {if (true) throw (RuntimeException)jjte000;}
19332 }
19333 if (jjte000 instanceof ParseException) {
19334 {if (true) throw (ParseException)jjte000;}
19335 }
19336 {if (true) throw (Error)jjte000;}
19337 } finally {
19338 if (jjtc000) {
19339 jjtree.closeNodeScope(jjtn000, true);
19340 }
19341 }
19342 throw new Error("Missing return statement in function");
19343 }
19344
19345 final public ASTPrimaryPrefix PrimaryPrefix() throws ParseException {
19346
19347 ASTPrimaryPrefix jjtn000 = new ASTPrimaryPrefix(this, JJTPRIMARYPREFIX);
19348 boolean jjtc000 = true;
19349 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
19350 try {
19351 switch (jj_nt.kind) {
19352 case DATE:
19353 case FALSE:
19354 case INTERVAL:
19355 case NULL:
19356 case TIMESTAMP:
19357 case TRUE:
19358 case UNSIGNED_NUMERIC_LITERAL:
19359 case CHARACTER_LITERAL:
19360 case STRING_LITERAL:
19361 simpleNode = Literal();
19362 sb.append(simpleNode.getImage()) ;
19363 break;
19364 default:
19365 jj_la1[252] = jj_gen;
19366 if (jj_2_48(2147483647)) {
19367 simpleNode = MultiSetCondition();
19368 } else if (jj_2_49(2147483647)) {
19369 simpleNode = TrimExpression();
19370 } else if (jj_2_50(2147483647)) {
19371 simpleNode = CaseExpression();
19372 sb.append(simpleNode.getImage()) ;
19373 } else if (jj_2_51(2147483647)) {
19374 simpleNode = ObjectExpression();
19375 sb.append(simpleNode.getImage()) ;
19376 } else {
19377 switch (jj_nt.kind) {
19378 case REPLACE:
19379 case DEFINER:
19380 case CURRENT_USER:
19381 case LANGUAGE:
19382 case INLINE:
19383 case ADD:
19384 case AGGREGATE:
19385 case ARRAY:
19386 case AT:
19387 case ATTRIBUTE:
19388 case AUTHID:
19389 case BODY:
19390 case BULK:
19391 case BYTE:
19392 case CASCADE:
19393 case CLOSE:
19394 case COALESCE:
19395 case COLLECT:
19396 case COLUMN:
19397 case COMMENT:
19398 case COMMIT:
19399 case CONSTRUCTOR:
19400 case CONTINUE:
19401 case CONVERT:
19402 case CURRENT:
19403 case CURSOR:
19404 case DATA:
19405 case DAY:
19406 case DISABLE:
19407 case EDITIONABLE:
19408 case ELEMENT:
19409 case ENABLE:
19410 case ESCAPE:
19411 case EXCEPT:
19412 case EXCEPTIONS:
19413 case EXIT:
19414 case EXTERNAL:
19415 case EXTENDS:
19416 case EXTRACT:
19417 case FALSE:
19418 case FINAL:
19419 case FORCE:
19420 case FUNCTION:
19421 case GLOBAL:
19422 case HASH:
19423 case HEAP:
19424 case HOUR:
19425 case IMMEDIATE:
19426 case INDICES:
19427 case INDEXTYPE:
19428 case INDICATOR:
19429 case INSTANTIABLE:
19430 case INTERVAL:
19431 case INVALIDATE:
19432 case ISOLATION:
19433 case JAVA:
19434 case LEVEL:
19435 case LIMIT:
19436 case LOOP:
19437 case MAP:
19438 case MAX:
19439 case MEMBER:
19440 case MERGE:
19441 case MIN:
19442 case MINUTE:
19443 case MLSLABEL:
19444 case MODIFY:
19445 case MOD:
19446 case MONTH:
19447 case NATURAL:
19448 case NEW:
19449 case NO:
19450 case NONEDITIONABLE:
19451 case NULLIF:
19452 case OBJECT:
19453 case OID:
19454 case OPAQUE:
19455 case OPEN:
19456 case OPERATOR:
19457 case ORGANIZATION:
19458 case OTHERS:
19459 case OVERRIDING:
19460 case PACKAGE:
19461 case PARTITION:
19462 case PRESERVE:
19463 case PRIVATE:
19464 case PROCEDURE:
19465 case RANGE:
19466 case RAW:
19467 case REAL:
19468 case RECORD:
19469 case REF:
19470 case RELEASE:
19471 case RELIES_ON:
19472 case RENAME:
19473 case RESULT:
19474 case RETURN:
19475 case RETURNING:
19476 case REVERSE:
19477 case ROLLBACK:
19478 case ROW:
19479 case ROWS:
19480 case ROWID:
19481 case ROWNUM:
19482 case SAVE:
19483 case SAVEPOINT:
19484 case SECOND:
19485 case SELF:
19486 case SET:
19487 case SPACE:
19488 case SQL:
19489 case SQLCODE:
19490 case SQLERRM:
19491 case STATIC:
19492 case SUBTYPE:
19493 case SUBSTITUTABLE:
19494 case SUCCESSFUL:
19495 case SYSDATE:
19496 case SYS_REFCURSOR:
19497 case TEMPORARY:
19498 case TIME:
19499 case TIMESTAMP:
19500 case TIMEZONE_REGION:
19501 case TIMEZONE_ABBR:
19502 case TIMEZONE_MINUTE:
19503 case TIMEZONE_HOUR:
19504 case TRANSACTION:
19505 case TRUE:
19506 case TYPE:
19507 case UNDER:
19508 case USING:
19509 case YES:
19510 case SHOW:
19511 case A:
19512 case DOUBLE:
19513 case DEC:
19514 case PRECISION:
19515 case INT:
19516 case NUMERIC:
19517 case NCHAR:
19518 case NVARCHAR2:
19519 case STRING:
19520 case UROWID:
19521 case VARRAY:
19522 case VARYING:
19523 case BFILE:
19524 case BLOB:
19525 case CLOB:
19526 case NCLOB:
19527 case YEAR:
19528 case LOCAL:
19529 case ZONE:
19530 case CHARACTER:
19531 case AFTER:
19532 case BEFORE:
19533 case OLD:
19534 case PARENT:
19535 case ANALYZE:
19536 case ASSOCIATE:
19537 case AUDIT:
19538 case COMPOUND:
19539 case DATABASE:
19540 case CALL:
19541 case DDL:
19542 case DISASSOCIATE:
19543 case EACH:
19544 case FOLLOWS:
19545 case LOGOFF:
19546 case LOGON:
19547 case NESTED:
19548 case NOAUDIT:
19549 case SCHEMA:
19550 case SERVERERROR:
19551 case SHUTDOWN:
19552 case STARTUP:
19553 case STATEMENT:
19554 case STATISTICS:
19555 case SUSPEND:
19556 case TRUNCATE:
19557 case WRAPPED:
19558 case LIBRARY:
19559 case NAME:
19560 case STRUCT:
19561 case CONTEXT:
19562 case PARAMETERS:
19563 case LENGTH:
19564 case TDO:
19565 case MAXLEN:
19566 case CHARSETID:
19567 case CHARSETFORM:
19568 case ACCEPT:
19569 case ACCESSIBLE:
19570 case COPY:
19571 case DEFINE:
19572 case DISCONNECT:
19573 case HOST:
19574 case PRINT:
19575 case QUIT:
19576 case REMARK:
19577 case UNDEFINE:
19578 case VARIABLE:
19579 case WHENEVER:
19580 case ATTACH:
19581 case CAST:
19582 case TREAT:
19583 case TRIM:
19584 case LEFT:
19585 case RIGHT:
19586 case BOTH:
19587 case EMPTY:
19588 case MULTISET:
19589 case SUBMULTISET:
19590 case LEADING:
19591 case TRAILING:
19592 case CHAR_CS:
19593 case NCHAR_CS:
19594 case DBTIMEZONE:
19595 case SESSIONTIMEZONE:
19596 case AUTHENTICATED:
19597 case LINK:
19598 case SHARED:
19599 case DIRECTORY:
19600 case USER:
19601 case IDENTIFIER:
19602 case QUOTED_LITERAL:
19603 simpleNode = Name();
19604 sb.append(simpleNode.getImage()) ;
19605 break;
19606 default:
19607 jj_la1[253] = jj_gen;
19608 if (jj_2_52(2147483647)) {
19609 jj_consume_token(SELECT);
19610 sb.append("SELECT ...");
19611 Skip2NextTerminator(null,";");
19612 } else if (jj_2_53(2147483647)) {
19613 jj_consume_token(5);
19614 sb.append("(SELECT ...");
19615 Skip2NextTerminator("(",")");
19616 jj_consume_token(7);
19617 } else if (jj_2_54(2147483647)) {
19618 jj_consume_token(WITH);
19619 sb.append("WITH ...");
19620 Skip2NextTerminator(null,";");
19621 } else if (jj_2_55(2147483647)) {
19622 jj_consume_token(5);
19623 sb.append("(WITH ...");
19624 Skip2NextTerminator("(",")");
19625 jj_consume_token(7);
19626 } else {
19627 switch (jj_nt.kind) {
19628 case 5:
19629 jj_consume_token(5);
19630 sb.append("(");
19631 simpleNode = Expression();
19632 sb.append(simpleNode.getImage());
19633 label_62:
19634 while (true) {
19635 switch (jj_nt.kind) {
19636 case 6:
19637 ;
19638 break;
19639 default:
19640 jj_la1[251] = jj_gen;
19641 break label_62;
19642 }
19643 jj_consume_token(6);
19644 sb.append(", ");
19645 simpleNode = Expression();
19646 sb.append(simpleNode.getImage());
19647 }
19648 jj_consume_token(7);
19649 sb.append(")");
19650 break;
19651 default:
19652 jj_la1[254] = jj_gen;
19653 jj_consume_token(-1);
19654 throw new ParseException();
19655 }
19656 }
19657 }
19658 }
19659 }
19660 jjtree.closeNodeScope(jjtn000, true);
19661 jjtc000 = false;
19662 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
19663 } catch (Throwable jjte000) {
19664 if (jjtc000) {
19665 jjtree.clearNodeScope(jjtn000);
19666 jjtc000 = false;
19667 } else {
19668 jjtree.popNode();
19669 }
19670 if (jjte000 instanceof RuntimeException) {
19671 {if (true) throw (RuntimeException)jjte000;}
19672 }
19673 if (jjte000 instanceof ParseException) {
19674 {if (true) throw (ParseException)jjte000;}
19675 }
19676 {if (true) throw (Error)jjte000;}
19677 } finally {
19678 if (jjtc000) {
19679 jjtree.closeNodeScope(jjtn000, true);
19680 }
19681 }
19682 throw new Error("Missing return statement in function");
19683 }
19684
19685 final public ASTPrimarySuffix PrimarySuffix() throws ParseException {
19686
19687 ASTPrimarySuffix jjtn000 = new ASTPrimarySuffix(this, JJTPRIMARYSUFFIX);
19688 boolean jjtc000 = true;
19689 jjtree.openNodeScope(jjtn000);PLSQLNode suffixNode = null ; PLSQLNode arguments = null; StringBuilder sb = new StringBuilder() ;
19690 try {
19691 switch (jj_nt.kind) {
19692 case 3:
19693 jj_consume_token(3);
19694 sb.append(".");
19695 suffixNode = QualifiedID();
19696 sb.append(suffixNode.toString()) ;
19697 break;
19698 case 2:
19699 jj_consume_token(2);
19700 sb.append("@");
19701 suffixNode = QualifiedID();
19702 sb.append(suffixNode.toString()) ;
19703 break;
19704 case AT:
19705 jj_consume_token(AT);
19706 sb.append(" "); sb.append(token.image.toUpperCase());
19707 switch (jj_nt.kind) {
19708 case LOCAL:
19709 jj_consume_token(LOCAL);
19710 sb.append(" "); sb.append(token.image.toUpperCase());
19711 break;
19712 case TIME:
19713 jj_consume_token(TIME);
19714 jj_consume_token(ZONE);
19715 sb.append(" TIME ZONE");
19716 switch (jj_nt.kind) {
19717 case DBTIMEZONE:
19718 jj_consume_token(DBTIMEZONE);
19719 sb.append(" "); sb.append(token.image.toUpperCase());
19720 break;
19721 case SESSIONTIMEZONE:
19722 jj_consume_token(SESSIONTIMEZONE);
19723 sb.append(" "); sb.append(token.image.toUpperCase());
19724 break;
19725 case STRING_LITERAL:
19726 suffixNode = StringLiteral();
19727 sb.append(" "); sb.append(suffixNode.toString());
19728 break;
19729 case 5:
19730 case 16:
19731 case 17:
19732 case REPLACE:
19733 case DEFINER:
19734 case CURRENT_USER:
19735 case LANGUAGE:
19736 case INLINE:
19737 case ADD:
19738 case AGGREGATE:
19739 case ARRAY:
19740 case AT:
19741 case ATTRIBUTE:
19742 case AUTHID:
19743 case BODY:
19744 case BULK:
19745 case BYTE:
19746 case CASCADE:
19747 case CASE:
19748 case CLOSE:
19749 case COALESCE:
19750 case COLLECT:
19751 case COLUMN:
19752 case COMMENT:
19753 case COMMIT:
19754 case CONSTRUCTOR:
19755 case CONTINUE:
19756 case CONVERT:
19757 case CURRENT:
19758 case CURSOR:
19759 case DATA:
19760 case DATE:
19761 case DAY:
19762 case DISABLE:
19763 case EDITIONABLE:
19764 case ELEMENT:
19765 case ENABLE:
19766 case ESCAPE:
19767 case EXCEPT:
19768 case EXCEPTIONS:
19769 case EXIT:
19770 case EXTERNAL:
19771 case EXTENDS:
19772 case EXTRACT:
19773 case FALSE:
19774 case FINAL:
19775 case FORCE:
19776 case FUNCTION:
19777 case GLOBAL:
19778 case HASH:
19779 case HEAP:
19780 case HOUR:
19781 case IMMEDIATE:
19782 case INDICES:
19783 case INDEXTYPE:
19784 case INDICATOR:
19785 case INSTANTIABLE:
19786 case INTERVAL:
19787 case INVALIDATE:
19788 case ISOLATION:
19789 case JAVA:
19790 case LEVEL:
19791 case LIMIT:
19792 case LOOP:
19793 case MAP:
19794 case MAX:
19795 case MEMBER:
19796 case MERGE:
19797 case MIN:
19798 case MINUTE:
19799 case MLSLABEL:
19800 case MODIFY:
19801 case MOD:
19802 case MONTH:
19803 case NATURAL:
19804 case NEW:
19805 case NEW_DOT:
19806 case NO:
19807 case NONEDITIONABLE:
19808 case NOT:
19809 case NULL:
19810 case NULLIF:
19811 case OBJECT:
19812 case OID:
19813 case OPAQUE:
19814 case OPEN:
19815 case OPERATOR:
19816 case ORGANIZATION:
19817 case OTHERS:
19818 case OVERRIDING:
19819 case PACKAGE:
19820 case PARTITION:
19821 case PRESERVE:
19822 case PRIVATE:
19823 case PROCEDURE:
19824 case RANGE:
19825 case RAW:
19826 case REAL:
19827 case RECORD:
19828 case REF:
19829 case RELEASE:
19830 case RELIES_ON:
19831 case RENAME:
19832 case RESULT:
19833 case RETURN:
19834 case RETURNING:
19835 case REVERSE:
19836 case ROLLBACK:
19837 case ROW:
19838 case ROWS:
19839 case ROWID:
19840 case ROWNUM:
19841 case SAVE:
19842 case SAVEPOINT:
19843 case SECOND:
19844 case SELECT:
19845 case SELF:
19846 case SET:
19847 case SPACE:
19848 case SQL:
19849 case SQLCODE:
19850 case SQLERRM:
19851 case STATIC:
19852 case SUBTYPE:
19853 case SUBSTITUTABLE:
19854 case SUCCESSFUL:
19855 case SYSDATE:
19856 case SYS_REFCURSOR:
19857 case TEMPORARY:
19858 case TIME:
19859 case TIMESTAMP:
19860 case TIMEZONE_REGION:
19861 case TIMEZONE_ABBR:
19862 case TIMEZONE_MINUTE:
19863 case TIMEZONE_HOUR:
19864 case TRANSACTION:
19865 case TRUE:
19866 case TYPE:
19867 case UNDER:
19868 case USING:
19869 case YES:
19870 case SHOW:
19871 case A:
19872 case DOUBLE:
19873 case DEC:
19874 case PRECISION:
19875 case INT:
19876 case NUMERIC:
19877 case NCHAR:
19878 case NVARCHAR2:
19879 case STRING:
19880 case UROWID:
19881 case VARRAY:
19882 case VARYING:
19883 case BFILE:
19884 case BLOB:
19885 case CLOB:
19886 case NCLOB:
19887 case YEAR:
19888 case LOCAL:
19889 case WITH:
19890 case ZONE:
19891 case CHARACTER:
19892 case AFTER:
19893 case BEFORE:
19894 case OLD:
19895 case PARENT:
19896 case CC_IF:
19897 case ANALYZE:
19898 case ASSOCIATE:
19899 case AUDIT:
19900 case COMPOUND:
19901 case DATABASE:
19902 case CALL:
19903 case DDL:
19904 case DISASSOCIATE:
19905 case EACH:
19906 case FOLLOWS:
19907 case LOGOFF:
19908 case LOGON:
19909 case NESTED:
19910 case NOAUDIT:
19911 case SCHEMA:
19912 case SERVERERROR:
19913 case SHUTDOWN:
19914 case STARTUP:
19915 case STATEMENT:
19916 case STATISTICS:
19917 case SUSPEND:
19918 case TRUNCATE:
19919 case WRAPPED:
19920 case LIBRARY:
19921 case NAME:
19922 case STRUCT:
19923 case CONTEXT:
19924 case PARAMETERS:
19925 case LENGTH:
19926 case TDO:
19927 case MAXLEN:
19928 case CHARSETID:
19929 case CHARSETFORM:
19930 case ACCEPT:
19931 case ACCESSIBLE:
19932 case COPY:
19933 case DEFINE:
19934 case DISCONNECT:
19935 case HOST:
19936 case PRINT:
19937 case QUIT:
19938 case REMARK:
19939 case UNDEFINE:
19940 case VARIABLE:
19941 case WHENEVER:
19942 case ATTACH:
19943 case CAST:
19944 case TREAT:
19945 case TRIM:
19946 case LEFT:
19947 case RIGHT:
19948 case BOTH:
19949 case EMPTY:
19950 case MULTISET:
19951 case SUBMULTISET:
19952 case LEADING:
19953 case TRAILING:
19954 case CHAR_CS:
19955 case NCHAR_CS:
19956 case AUTHENTICATED:
19957 case LINK:
19958 case SHARED:
19959 case DIRECTORY:
19960 case USER:
19961 case IDENTIFIER:
19962 case UNSIGNED_NUMERIC_LITERAL:
19963 case CHARACTER_LITERAL:
19964 case QUOTED_LITERAL:
19965 suffixNode = Expression();
19966 sb.append(" "); sb.append(suffixNode.toString());
19967 break;
19968 default:
19969 jj_la1[255] = jj_gen;
19970 jj_consume_token(-1);
19971 throw new ParseException();
19972 }
19973 break;
19974 default:
19975 jj_la1[256] = jj_gen;
19976 jj_consume_token(-1);
19977 throw new ParseException();
19978 }
19979 break;
19980 case 5:
19981 arguments = Arguments();
19982 sb.append(arguments) ;
19983 break;
19984 default:
19985 jj_la1[257] = jj_gen;
19986 jj_consume_token(-1);
19987 throw new ParseException();
19988 }
19989 jjtree.closeNodeScope(jjtn000, true);
19990 jjtc000 = false;
19991 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
19992 } catch (Throwable jjte000) {
19993 if (jjtc000) {
19994 jjtree.clearNodeScope(jjtn000);
19995 jjtc000 = false;
19996 } else {
19997 jjtree.popNode();
19998 }
19999 if (jjte000 instanceof RuntimeException) {
20000 {if (true) throw (RuntimeException)jjte000;}
20001 }
20002 if (jjte000 instanceof ParseException) {
20003 {if (true) throw (ParseException)jjte000;}
20004 }
20005 {if (true) throw (Error)jjte000;}
20006 } finally {
20007 if (jjtc000) {
20008 jjtree.closeNodeScope(jjtn000, true);
20009 }
20010 }
20011 throw new Error("Missing return statement in function");
20012 }
20013
20014 final public ASTLiteral Literal() throws ParseException {
20015
20016 ASTLiteral jjtn000 = new ASTLiteral(this, JJTLITERAL);
20017 boolean jjtc000 = true;
20018 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
20019 Token t = null ;
20020 try {
20021 switch (jj_nt.kind) {
20022 case UNSIGNED_NUMERIC_LITERAL:
20023 simpleNode = NumericLiteral();
20024 break;
20025 case CHARACTER_LITERAL:
20026 t = jj_consume_token(CHARACTER_LITERAL);
20027 break;
20028 case STRING_LITERAL:
20029
20030 simpleNode = StringLiteral();
20031 break;
20032 case FALSE:
20033 case TRUE:
20034 simpleNode = BooleanLiteral();
20035 break;
20036 case NULL:
20037 simpleNode = NullLiteral();
20038 break;
20039 case DATE:
20040 case INTERVAL:
20041 case TIMESTAMP:
20042 simpleNode = DateTimeLiteral();
20043 break;
20044 default:
20045 jj_la1[258] = jj_gen;
20046 jj_consume_token(-1);
20047 throw new ParseException();
20048 }
20049 jjtree.closeNodeScope(jjtn000, true);
20050 jjtc000 = false;
20051 if (null != simpleNode)
20052 {
20053 jjtn000.setImage( simpleNode.getImage() ) ;
20054 }
20055 else if (null != t)
20056 {
20057 jjtn000.setImage( t.image ) ;
20058 }
20059 {if (true) return jjtn000 ;}
20060 } catch (Throwable jjte000) {
20061 if (jjtc000) {
20062 jjtree.clearNodeScope(jjtn000);
20063 jjtc000 = false;
20064 } else {
20065 jjtree.popNode();
20066 }
20067 if (jjte000 instanceof RuntimeException) {
20068 {if (true) throw (RuntimeException)jjte000;}
20069 }
20070 if (jjte000 instanceof ParseException) {
20071 {if (true) throw (ParseException)jjte000;}
20072 }
20073 {if (true) throw (Error)jjte000;}
20074 } finally {
20075 if (jjtc000) {
20076 jjtree.closeNodeScope(jjtn000, true);
20077 }
20078 }
20079 throw new Error("Missing return statement in function");
20080 }
20081
20082 final public ASTStringLiteral StringLiteral() throws ParseException {
20083
20084 ASTStringLiteral jjtn000 = new ASTStringLiteral(this, JJTSTRINGLITERAL);
20085 boolean jjtc000 = true;
20086 jjtree.openNodeScope(jjtn000);Token thisToken = null;
20087 StringBuilder literal = new StringBuilder() ;
20088 char startDelimiter ;
20089 char endDelimiter ;
20090 String terminator = null;
20091 try {
20092 thisToken = jj_consume_token(STRING_LITERAL);
20093 literal.append(thisToken.image);
20094
20095
20096
20097
20098
20099 if (thisToken.image.toUpperCase().startsWith("Q'")
20100 && thisToken.image.length() > 2
20101 )
20102 {
20103
20104
20105 startDelimiter= thisToken.image.charAt(2) ;
20106
20107
20108
20109
20110 switch (startDelimiter)
20111 {
20112 case '<' : endDelimiter = '>' ; break ;
20113 case '{' : endDelimiter = '}' ; break ;
20114 case '(' : endDelimiter = ')' ; break ;
20115 case '[' : endDelimiter = ']' ; break ;
20116 default: endDelimiter = startDelimiter ;
20117 }
20118
20119 terminator = new String(endDelimiter + "'");
20120 if (!thisToken.image.endsWith(terminator))
20121 {
20122
20123 literal.append(ReadPastNextOccurrence(terminator));
20124 }
20125 }
20126 jjtree.closeNodeScope(jjtn000, true);
20127 jjtc000 = false;
20128 jjtn000.setImage(literal.toString()) ; jjtn000.value = literal.toString() ; {if (true) return jjtn000 ;}
20129 } finally {
20130 if (jjtc000) {
20131 jjtree.closeNodeScope(jjtn000, true);
20132 }
20133 }
20134 throw new Error("Missing return statement in function");
20135 }
20136
20137 final public ASTBooleanLiteral BooleanLiteral() throws ParseException {
20138
20139 ASTBooleanLiteral jjtn000 = new ASTBooleanLiteral(this, JJTBOOLEANLITERAL);
20140 boolean jjtc000 = true;
20141 jjtree.openNodeScope(jjtn000);
20142 try {
20143 switch (jj_nt.kind) {
20144 case TRUE:
20145 jj_consume_token(TRUE);
20146 break;
20147 case FALSE:
20148 jj_consume_token(FALSE);
20149 break;
20150 default:
20151 jj_la1[259] = jj_gen;
20152 jj_consume_token(-1);
20153 throw new ParseException();
20154 }
20155 jjtree.closeNodeScope(jjtn000, true);
20156 jjtc000 = false;
20157 jjtn000.setImage(token.image) ;
20158 {if (true) return jjtn000;}
20159 } finally {
20160 if (jjtc000) {
20161 jjtree.closeNodeScope(jjtn000, true);
20162 }
20163 }
20164 throw new Error("Missing return statement in function");
20165 }
20166
20167 final public ASTNullLiteral NullLiteral() throws ParseException {
20168
20169 ASTNullLiteral jjtn000 = new ASTNullLiteral(this, JJTNULLLITERAL);
20170 boolean jjtc000 = true;
20171 jjtree.openNodeScope(jjtn000);
20172 try {
20173 jj_consume_token(NULL);
20174 jjtree.closeNodeScope(jjtn000, true);
20175 jjtc000 = false;
20176 jjtn000.setImage(token.image) ;
20177 {if (true) return jjtn000 ;}
20178 } finally {
20179 if (jjtc000) {
20180 jjtree.closeNodeScope(jjtn000, true);
20181 }
20182 }
20183 throw new Error("Missing return statement in function");
20184 }
20185
20186 final public ASTMultiSetCondition MultiSetCondition() throws ParseException {
20187
20188 ASTMultiSetCondition jjtn000 = new ASTMultiSetCondition(this, JJTMULTISETCONDITION);
20189 boolean jjtc000 = true;
20190 jjtree.openNodeScope(jjtn000);
20191 try {
20192 switch (jj_nt.kind) {
20193 case A:
20194 jj_consume_token(A);
20195 jj_consume_token(SET);
20196 break;
20197 case EMPTY:
20198 jj_consume_token(EMPTY);
20199 break;
20200 default:
20201 jj_la1[260] = jj_gen;
20202 jj_consume_token(-1);
20203 throw new ParseException();
20204 }
20205 jjtree.closeNodeScope(jjtn000, true);
20206 jjtc000 = false;
20207 {if (true) return jjtn000;}
20208 } finally {
20209 if (jjtc000) {
20210 jjtree.closeNodeScope(jjtn000, true);
20211 }
20212 }
20213 throw new Error("Missing return statement in function");
20214 }
20215
20216
20217
20218
20219
20220
20221 final public ASTNumericLiteral NumericLiteral() throws ParseException {
20222
20223 ASTNumericLiteral jjtn000 = new ASTNumericLiteral(this, JJTNUMERICLITERAL);
20224 boolean jjtc000 = true;
20225 jjtree.openNodeScope(jjtn000);Token t = null ;
20226 try {
20227
20228 t = jj_consume_token(UNSIGNED_NUMERIC_LITERAL);
20229 jjtree.closeNodeScope(jjtn000, true);
20230 jjtc000 = false;
20231 jjtn000.setImage(t.image) ;
20232 {if (true) return jjtn000;}
20233 } finally {
20234 if (jjtc000) {
20235 jjtree.closeNodeScope(jjtn000, true);
20236 }
20237 }
20238 throw new Error("Missing return statement in function");
20239 }
20240
20241
20242
20243 final public ASTLabel Label() throws ParseException {
20244
20245 ASTLabel jjtn000 = new ASTLabel(this, JJTLABEL);
20246 boolean jjtc000 = true;
20247 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
20248 try {
20249 jj_consume_token(21);
20250 simpleNode = UnqualifiedID();
20251 jj_consume_token(22);
20252 jjtree.closeNodeScope(jjtn000, true);
20253 jjtc000 = false;
20254 jjtn000.setImage( simpleNode.getImage() ) ;
20255 {if (true) return jjtn000;}
20256 } catch (Throwable jjte000) {
20257 if (jjtc000) {
20258 jjtree.clearNodeScope(jjtn000);
20259 jjtc000 = false;
20260 } else {
20261 jjtree.popNode();
20262 }
20263 if (jjte000 instanceof RuntimeException) {
20264 {if (true) throw (RuntimeException)jjte000;}
20265 }
20266 if (jjte000 instanceof ParseException) {
20267 {if (true) throw (ParseException)jjte000;}
20268 }
20269 {if (true) throw (Error)jjte000;}
20270 } finally {
20271 if (jjtc000) {
20272 jjtree.closeNodeScope(jjtn000, true);
20273 }
20274 }
20275 throw new Error("Missing return statement in function");
20276 }
20277
20278 final public ASTName Name() throws ParseException {
20279
20280 ASTName jjtn000 = new ASTName(this, JJTNAME);
20281 boolean jjtc000 = true;
20282 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
20283 StringBuilder sb = new StringBuilder();
20284 try {
20285 simpleNode = UnqualifiedID();
20286 sb.append(simpleNode.getImage()) ;
20287 label_63:
20288 while (true) {
20289 if (jj_2_56(2)) {
20290 ;
20291 } else {
20292 break label_63;
20293 }
20294 switch (jj_nt.kind) {
20295 case 3:
20296 jj_consume_token(3);
20297 sb.append(".") ;
20298 break;
20299 case 11:
20300 jj_consume_token(11);
20301 sb.append("%") ;
20302 break;
20303 default:
20304 jj_la1[261] = jj_gen;
20305 jj_consume_token(-1);
20306 throw new ParseException();
20307 }
20308
20309 simpleNode = QualifiedID();
20310 sb.append(simpleNode.getImage()) ;
20311 }
20312 jjtree.closeNodeScope(jjtn000, true);
20313 jjtc000 = false;
20314 jjtn000.setImage(sb.toString()) ;
20315 {if (true) return jjtn000;}
20316 } catch (Throwable jjte000) {
20317 if (jjtc000) {
20318 jjtree.clearNodeScope(jjtn000);
20319 jjtc000 = false;
20320 } else {
20321 jjtree.popNode();
20322 }
20323 if (jjte000 instanceof RuntimeException) {
20324 {if (true) throw (RuntimeException)jjte000;}
20325 }
20326 if (jjte000 instanceof ParseException) {
20327 {if (true) throw (ParseException)jjte000;}
20328 }
20329 {if (true) throw (Error)jjte000;}
20330 } finally {
20331 if (jjtc000) {
20332 jjtree.closeNodeScope(jjtn000, true);
20333 }
20334 }
20335 throw new Error("Missing return statement in function");
20336 }
20337
20338 final public ASTQualifiedName QualifiedName() throws ParseException {
20339
20340 ASTQualifiedName jjtn000 = new ASTQualifiedName(this, JJTQUALIFIEDNAME);
20341 boolean jjtc000 = true;
20342 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
20343 StringBuilder sb = new StringBuilder();
20344 try {
20345 simpleNode = UnqualifiedID();
20346 sb.append(simpleNode.getImage()) ;
20347 label_64:
20348 while (true) {
20349 switch (jj_nt.kind) {
20350 case 3:
20351 ;
20352 break;
20353 default:
20354 jj_la1[262] = jj_gen;
20355 break label_64;
20356 }
20357 jj_consume_token(3);
20358 simpleNode = QualifiedID();
20359 sb.append(".") ; sb.append(simpleNode.getImage()) ;
20360 }
20361 jjtree.closeNodeScope(jjtn000, true);
20362 jjtc000 = false;
20363 jjtn000.setImage(sb.toString()) ;
20364 {if (true) return jjtn000 ;}
20365 } catch (Throwable jjte000) {
20366 if (jjtc000) {
20367 jjtree.clearNodeScope(jjtn000);
20368 jjtc000 = false;
20369 } else {
20370 jjtree.popNode();
20371 }
20372 if (jjte000 instanceof RuntimeException) {
20373 {if (true) throw (RuntimeException)jjte000;}
20374 }
20375 if (jjte000 instanceof ParseException) {
20376 {if (true) throw (ParseException)jjte000;}
20377 }
20378 {if (true) throw (Error)jjte000;}
20379 } finally {
20380 if (jjtc000) {
20381 jjtree.closeNodeScope(jjtn000, true);
20382 }
20383 }
20384 throw new Error("Missing return statement in function");
20385 }
20386
20387 final public ASTArguments Arguments() throws ParseException {
20388
20389 ASTArguments jjtn000 = new ASTArguments(this, JJTARGUMENTS);
20390 boolean jjtc000 = true;
20391 jjtree.openNodeScope(jjtn000);
20392 try {
20393 jj_consume_token(5);
20394 switch (jj_nt.kind) {
20395 case 5:
20396 case 16:
20397 case 17:
20398 case REPLACE:
20399 case DEFINER:
20400 case CURRENT_USER:
20401 case LANGUAGE:
20402 case INLINE:
20403 case ADD:
20404 case AGGREGATE:
20405 case ARRAY:
20406 case AT:
20407 case ATTRIBUTE:
20408 case AUTHID:
20409 case BODY:
20410 case BULK:
20411 case BYTE:
20412 case CASCADE:
20413 case CASE:
20414 case CLOSE:
20415 case COALESCE:
20416 case COLLECT:
20417 case COLUMN:
20418 case COMMENT:
20419 case COMMIT:
20420 case CONSTRUCTOR:
20421 case CONTINUE:
20422 case CONVERT:
20423 case CURRENT:
20424 case CURSOR:
20425 case DATA:
20426 case DATE:
20427 case DAY:
20428 case DISABLE:
20429 case EDITIONABLE:
20430 case ELEMENT:
20431 case ENABLE:
20432 case ESCAPE:
20433 case EXCEPT:
20434 case EXCEPTIONS:
20435 case EXIT:
20436 case EXTERNAL:
20437 case EXTENDS:
20438 case EXTRACT:
20439 case FALSE:
20440 case FINAL:
20441 case FORCE:
20442 case FUNCTION:
20443 case GLOBAL:
20444 case HASH:
20445 case HEAP:
20446 case HOUR:
20447 case IMMEDIATE:
20448 case INDICES:
20449 case INDEXTYPE:
20450 case INDICATOR:
20451 case INSTANTIABLE:
20452 case INTERVAL:
20453 case INVALIDATE:
20454 case ISOLATION:
20455 case JAVA:
20456 case LEVEL:
20457 case LIMIT:
20458 case LOOP:
20459 case MAP:
20460 case MAX:
20461 case MEMBER:
20462 case MERGE:
20463 case MIN:
20464 case MINUTE:
20465 case MLSLABEL:
20466 case MODIFY:
20467 case MOD:
20468 case MONTH:
20469 case NATURAL:
20470 case NEW:
20471 case NEW_DOT:
20472 case NO:
20473 case NONEDITIONABLE:
20474 case NOT:
20475 case NULL:
20476 case NULLIF:
20477 case OBJECT:
20478 case OID:
20479 case OPAQUE:
20480 case OPEN:
20481 case OPERATOR:
20482 case ORGANIZATION:
20483 case OTHERS:
20484 case OVERRIDING:
20485 case PACKAGE:
20486 case PARTITION:
20487 case PRESERVE:
20488 case PRIVATE:
20489 case PROCEDURE:
20490 case RANGE:
20491 case RAW:
20492 case REAL:
20493 case RECORD:
20494 case REF:
20495 case RELEASE:
20496 case RELIES_ON:
20497 case RENAME:
20498 case RESULT:
20499 case RETURN:
20500 case RETURNING:
20501 case REVERSE:
20502 case ROLLBACK:
20503 case ROW:
20504 case ROWS:
20505 case ROWID:
20506 case ROWNUM:
20507 case SAVE:
20508 case SAVEPOINT:
20509 case SECOND:
20510 case SELECT:
20511 case SELF:
20512 case SET:
20513 case SPACE:
20514 case SQL:
20515 case SQLCODE:
20516 case SQLERRM:
20517 case STATIC:
20518 case SUBTYPE:
20519 case SUBSTITUTABLE:
20520 case SUCCESSFUL:
20521 case SYSDATE:
20522 case SYS_REFCURSOR:
20523 case TEMPORARY:
20524 case TIME:
20525 case TIMESTAMP:
20526 case TIMEZONE_REGION:
20527 case TIMEZONE_ABBR:
20528 case TIMEZONE_MINUTE:
20529 case TIMEZONE_HOUR:
20530 case TRANSACTION:
20531 case TRUE:
20532 case TYPE:
20533 case UNDER:
20534 case USING:
20535 case YES:
20536 case SHOW:
20537 case A:
20538 case DOUBLE:
20539 case DEC:
20540 case PRECISION:
20541 case INT:
20542 case NUMERIC:
20543 case NCHAR:
20544 case NVARCHAR2:
20545 case STRING:
20546 case UROWID:
20547 case VARRAY:
20548 case VARYING:
20549 case BFILE:
20550 case BLOB:
20551 case CLOB:
20552 case NCLOB:
20553 case YEAR:
20554 case LOCAL:
20555 case WITH:
20556 case ZONE:
20557 case CHARACTER:
20558 case AFTER:
20559 case BEFORE:
20560 case OLD:
20561 case PARENT:
20562 case CC_IF:
20563 case ANALYZE:
20564 case ASSOCIATE:
20565 case AUDIT:
20566 case COMPOUND:
20567 case DATABASE:
20568 case CALL:
20569 case DDL:
20570 case DISASSOCIATE:
20571 case EACH:
20572 case FOLLOWS:
20573 case LOGOFF:
20574 case LOGON:
20575 case NESTED:
20576 case NOAUDIT:
20577 case SCHEMA:
20578 case SERVERERROR:
20579 case SHUTDOWN:
20580 case STARTUP:
20581 case STATEMENT:
20582 case STATISTICS:
20583 case SUSPEND:
20584 case TRUNCATE:
20585 case WRAPPED:
20586 case LIBRARY:
20587 case NAME:
20588 case STRUCT:
20589 case CONTEXT:
20590 case PARAMETERS:
20591 case LENGTH:
20592 case TDO:
20593 case MAXLEN:
20594 case CHARSETID:
20595 case CHARSETFORM:
20596 case ACCEPT:
20597 case ACCESSIBLE:
20598 case COPY:
20599 case DEFINE:
20600 case DISCONNECT:
20601 case HOST:
20602 case PRINT:
20603 case QUIT:
20604 case REMARK:
20605 case UNDEFINE:
20606 case VARIABLE:
20607 case WHENEVER:
20608 case ATTACH:
20609 case CAST:
20610 case TREAT:
20611 case TRIM:
20612 case LEFT:
20613 case RIGHT:
20614 case BOTH:
20615 case EMPTY:
20616 case MULTISET:
20617 case SUBMULTISET:
20618 case LEADING:
20619 case TRAILING:
20620 case CHAR_CS:
20621 case NCHAR_CS:
20622 case DBTIMEZONE:
20623 case SESSIONTIMEZONE:
20624 case AUTHENTICATED:
20625 case LINK:
20626 case SHARED:
20627 case DIRECTORY:
20628 case USER:
20629 case IDENTIFIER:
20630 case UNSIGNED_NUMERIC_LITERAL:
20631 case CHARACTER_LITERAL:
20632 case STRING_LITERAL:
20633 case QUOTED_LITERAL:
20634 ArgumentList();
20635 break;
20636 default:
20637 jj_la1[263] = jj_gen;
20638 ;
20639 }
20640 jj_consume_token(7);
20641 jjtree.closeNodeScope(jjtn000, true);
20642 jjtc000 = false;
20643 {if (true) return jjtn000 ;}
20644 } catch (Throwable jjte000) {
20645 if (jjtc000) {
20646 jjtree.clearNodeScope(jjtn000);
20647 jjtc000 = false;
20648 } else {
20649 jjtree.popNode();
20650 }
20651 if (jjte000 instanceof RuntimeException) {
20652 {if (true) throw (RuntimeException)jjte000;}
20653 }
20654 if (jjte000 instanceof ParseException) {
20655 {if (true) throw (ParseException)jjte000;}
20656 }
20657 {if (true) throw (Error)jjte000;}
20658 } finally {
20659 if (jjtc000) {
20660 jjtree.closeNodeScope(jjtn000, true);
20661 }
20662 }
20663 throw new Error("Missing return statement in function");
20664 }
20665
20666 final public ASTArgumentList ArgumentList() throws ParseException {
20667
20668 ASTArgumentList jjtn000 = new ASTArgumentList(this, JJTARGUMENTLIST);
20669 boolean jjtc000 = true;
20670 jjtree.openNodeScope(jjtn000);
20671 try {
20672 Argument();
20673 label_65:
20674 while (true) {
20675 switch (jj_nt.kind) {
20676 case 6:
20677 ;
20678 break;
20679 default:
20680 jj_la1[264] = jj_gen;
20681 break label_65;
20682 }
20683 jj_consume_token(6);
20684 Argument();
20685 }
20686 jjtree.closeNodeScope(jjtn000, true);
20687 jjtc000 = false;
20688 {if (true) return jjtn000 ;}
20689 } catch (Throwable jjte000) {
20690 if (jjtc000) {
20691 jjtree.clearNodeScope(jjtn000);
20692 jjtc000 = false;
20693 } else {
20694 jjtree.popNode();
20695 }
20696 if (jjte000 instanceof RuntimeException) {
20697 {if (true) throw (RuntimeException)jjte000;}
20698 }
20699 if (jjte000 instanceof ParseException) {
20700 {if (true) throw (ParseException)jjte000;}
20701 }
20702 {if (true) throw (Error)jjte000;}
20703 } finally {
20704 if (jjtc000) {
20705 jjtree.closeNodeScope(jjtn000, true);
20706 }
20707 }
20708 throw new Error("Missing return statement in function");
20709 }
20710
20711 final public ASTArgument Argument() throws ParseException {
20712
20713 ASTArgument jjtn000 = new ASTArgument(this, JJTARGUMENT);
20714 boolean jjtc000 = true;
20715 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
20716 try {
20717 if (jj_2_57(2)) {
20718 simpleNode = UnqualifiedID();
20719 switch (jj_nt.kind) {
20720 case 23:
20721 jj_consume_token(23);
20722 break;
20723 case AS:
20724 jj_consume_token(AS);
20725 break;
20726 default:
20727 jj_la1[265] = jj_gen;
20728 jj_consume_token(-1);
20729 throw new ParseException();
20730 }
20731 } else {
20732 ;
20733 }
20734 Expression();
20735 switch (jj_nt.kind) {
20736 case USING:
20737 jj_consume_token(USING);
20738 switch (jj_nt.kind) {
20739 case CHAR_CS:
20740 jj_consume_token(CHAR_CS);
20741 break;
20742 case NCHAR_CS:
20743 jj_consume_token(NCHAR_CS);
20744 break;
20745 default:
20746 jj_la1[266] = jj_gen;
20747 jj_consume_token(-1);
20748 throw new ParseException();
20749 }
20750 break;
20751 default:
20752 jj_la1[267] = jj_gen;
20753 ;
20754 }
20755 jjtree.closeNodeScope(jjtn000, true);
20756 jjtc000 = false;
20757 if (null != simpleNode) { jjtn000.setImage(simpleNode.getImage()) ; }
20758 {if (true) return jjtn000 ;}
20759 } catch (Throwable jjte000) {
20760 if (jjtc000) {
20761 jjtree.clearNodeScope(jjtn000);
20762 jjtc000 = false;
20763 } else {
20764 jjtree.popNode();
20765 }
20766 if (jjte000 instanceof RuntimeException) {
20767 {if (true) throw (RuntimeException)jjte000;}
20768 }
20769 if (jjte000 instanceof ParseException) {
20770 {if (true) throw (ParseException)jjte000;}
20771 }
20772 {if (true) throw (Error)jjte000;}
20773 } finally {
20774 if (jjtc000) {
20775 jjtree.closeNodeScope(jjtn000, true);
20776 }
20777 }
20778 throw new Error("Missing return statement in function");
20779 }
20780
20781
20782
20783
20784 final public ASTVariableOrConstantDeclaration VariableOrConstantDeclaration() throws ParseException {
20785
20786 ASTVariableOrConstantDeclaration jjtn000 = new ASTVariableOrConstantDeclaration(this, JJTVARIABLEORCONSTANTDECLARATION);
20787 boolean jjtc000 = true;
20788 jjtree.openNodeScope(jjtn000);
20789 try {
20790 VariableOrConstantDeclarator();
20791 jj_consume_token(4);
20792 jjtree.closeNodeScope(jjtn000, true);
20793 jjtc000 = false;
20794 {if (true) return jjtn000 ;}
20795 } catch (Throwable jjte000) {
20796 if (jjtc000) {
20797 jjtree.clearNodeScope(jjtn000);
20798 jjtc000 = false;
20799 } else {
20800 jjtree.popNode();
20801 }
20802 if (jjte000 instanceof RuntimeException) {
20803 {if (true) throw (RuntimeException)jjte000;}
20804 }
20805 if (jjte000 instanceof ParseException) {
20806 {if (true) throw (ParseException)jjte000;}
20807 }
20808 {if (true) throw (Error)jjte000;}
20809 } finally {
20810 if (jjtc000) {
20811 jjtree.closeNodeScope(jjtn000, true);
20812 }
20813 }
20814 throw new Error("Missing return statement in function");
20815 }
20816
20817 final public ASTDatatypeDeclaration DatatypeDeclaration() throws ParseException {
20818
20819 ASTDatatypeDeclaration jjtn000 = new ASTDatatypeDeclaration(this, JJTDATATYPEDECLARATION);
20820 boolean jjtc000 = true;
20821 jjtree.openNodeScope(jjtn000);Token t ;
20822 try {
20823 t = jj_consume_token(IDENTIFIER);
20824 jjtree.closeNodeScope(jjtn000, true);
20825 jjtc000 = false;
20826 jjtn000.setImage(t.image) ; {if (true) return jjtn000 ;}
20827 } finally {
20828 if (jjtc000) {
20829 jjtree.closeNodeScope(jjtn000, true);
20830 }
20831 }
20832 throw new Error("Missing return statement in function");
20833 }
20834
20835 final public ASTPragma Pragma() throws ParseException {
20836
20837 ASTPragma jjtn000 = new ASTPragma(this, JJTPRAGMA);
20838 boolean jjtc000 = true;
20839 jjtree.openNodeScope(jjtn000);
20840 try {
20841 jj_consume_token(PRAGMA);
20842 switch (jj_nt.kind) {
20843 case SERIALLY_REUSABLE:
20844 jj_consume_token(SERIALLY_REUSABLE);
20845 break;
20846 case AUTONOMOUS_TRANSACTION:
20847 jj_consume_token(AUTONOMOUS_TRANSACTION);
20848 break;
20849 case TIMESTAMP:
20850 jj_consume_token(TIMESTAMP);
20851 jj_consume_token(5);
20852 StringLiteral();
20853 jj_consume_token(7);
20854 break;
20855 case RESTRICT_REFERENCES:
20856 jj_consume_token(RESTRICT_REFERENCES);
20857 jj_consume_token(5);
20858 ID();
20859 label_66:
20860 while (true) {
20861 jj_consume_token(6);
20862 switch (jj_nt.kind) {
20863 case REPLACE:
20864 case DEFINER:
20865 case CURRENT_USER:
20866 case SERIALLY_REUSABLE:
20867 case RESTRICT_REFERENCES:
20868 case EXCEPTION_INIT:
20869 case AUTONOMOUS_TRANSACTION:
20870 case LANGUAGE:
20871 case INLINE:
20872 case ADD:
20873 case AGGREGATE:
20874 case ALL:
20875 case ALTER:
20876 case AND:
20877 case ANY:
20878 case ARRAY:
20879 case AS:
20880 case ASC:
20881 case AT:
20882 case ATTRIBUTE:
20883 case AUTHID:
20884 case AVG:
20885 case BETWEEN:
20886 case BINARY_INTEGER:
20887 case BODY:
20888 case BOOLEAN:
20889 case BULK:
20890 case BY:
20891 case BYTE:
20892 case CASCADE:
20893 case CASE:
20894 case CHAR:
20895 case CHAR_BASE:
20896 case CHECK:
20897 case CLOSE:
20898 case CLUSTER:
20899 case COALESCE:
20900 case COLLECT:
20901 case COLUMN:
20902 case COMMENT:
20903 case COMMIT:
20904 case COMPRESS:
20905 case CONNECT:
20906 case CONSTANT:
20907 case CONSTRUCTOR:
20908 case CONTINUE:
20909 case CONVERT:
20910 case CREATE:
20911 case CURRENT:
20912 case CURRVAL:
20913 case CURSOR:
20914 case DATA:
20915 case DATE:
20916 case DAY:
20917 case DECLARE:
20918 case DECIMAL:
20919 case _DEFAULT:
20920 case DELETE:
20921 case DESC:
20922 case DISABLE:
20923 case DISTINCT:
20924 case DO:
20925 case DROP:
20926 case EDITIONABLE:
20927 case ELEMENT:
20928 case ELSE:
20929 case ELSIF:
20930 case ENABLE:
20931 case ESCAPE:
20932 case EXCEPT:
20933 case EXCEPTION:
20934 case EXCEPTIONS:
20935 case EXCLUSIVE:
20936 case EXECUTE:
20937 case EXISTS:
20938 case EXIT:
20939 case EXTERNAL:
20940 case EXTENDS:
20941 case EXTRACT:
20942 case FALSE:
20943 case FETCH:
20944 case FINAL:
20945 case FLOAT:
20946 case FOR:
20947 case FORALL:
20948 case FORCE:
20949 case FROM:
20950 case FUNCTION:
20951 case GLOBAL:
20952 case GOTO:
20953 case GROUP:
20954 case HASH:
20955 case HAVING:
20956 case HEAP:
20957 case HOUR:
20958 case IF:
20959 case IMMEDIATE:
20960 case IN:
20961 case INDEX:
20962 case INDICES:
20963 case INDEXTYPE:
20964 case INDICATOR:
20965 case INSERT:
20966 case INSTANTIABLE:
20967 case INTEGER:
20968 case INTERFACE:
20969 case INTERSECT:
20970 case INTERVAL:
20971 case INTO:
20972 case INVALIDATE:
20973 case IS:
20974 case ISOLATION:
20975 case JAVA:
20976 case LEVEL:
20977 case LIKE:
20978 case LIMIT:
20979 case LIMITED:
20980 case LOCK:
20981 case LONG:
20982 case LOOP:
20983 case MAP:
20984 case MAX:
20985 case MEMBER:
20986 case MERGE:
20987 case MIN:
20988 case MINUS:
20989 case MINUTE:
20990 case MLSLABEL:
20991 case MODIFY:
20992 case MOD:
20993 case MODE:
20994 case MONTH:
20995 case NATURAL:
20996 case NATURALN:
20997 case NEW:
20998 case NEXTVAL:
20999 case NO:
21000 case NOCOPY:
21001 case NONEDITIONABLE:
21002 case NOT:
21003 case NOWAIT:
21004 case NULL:
21005 case NULLIF:
21006 case NUMBER:
21007 case BFILE_BASE:
21008 case BLOB_BASE:
21009 case CLOB_BASE:
21010 case DATE_BASE:
21011 case NUMBER_BASE:
21012 case OBJECT:
21013 case OCIROWID:
21014 case OF:
21015 case OID:
21016 case ON:
21017 case OPAQUE:
21018 case OPEN:
21019 case OPERATOR:
21020 case OPTION:
21021 case OR:
21022 case ORDER:
21023 case ORGANIZATION:
21024 case OTHERS:
21025 case OUT:
21026 case OVERRIDING:
21027 case PACKAGE:
21028 case PARTITION:
21029 case PCTFREE:
21030 case PLS_INTEGER:
21031 case POSITIVE:
21032 case POSITIVEN:
21033 case PRESERVE:
21034 case PRIOR:
21035 case PROMPT:
21036 case PRIVATE:
21037 case PROCEDURE:
21038 case PUBLIC:
21039 case RAISE:
21040 case RANGE:
21041 case RAW:
21042 case REAL:
21043 case RECORD:
21044 case REF:
21045 case RELEASE:
21046 case RELIES_ON:
21047 case RENAME:
21048 case RESULT:
21049 case RETURN:
21050 case RETURNING:
21051 case REVERSE:
21052 case ROLLBACK:
21053 case ROW:
21054 case ROWS:
21055 case ROWID:
21056 case ROWNUM:
21057 case ROWTYPE:
21058 case SAVE:
21059 case SAVEPOINT:
21060 case SECOND:
21061 case SELECT:
21062 case SELF:
21063 case SEPARATE:
21064 case SET:
21065 case SHARE:
21066 case SMALLINT:
21067 case SPACE:
21068 case SQL:
21069 case SQLCODE:
21070 case SQLERRM:
21071 case START:
21072 case STATIC:
21073 case STDDEV:
21074 case SUBTYPE:
21075 case SUBSTITUTABLE:
21076 case SUCCESSFUL:
21077 case SUM:
21078 case SYNONYM:
21079 case SYSDATE:
21080 case SYS_REFCURSOR:
21081 case TABLE:
21082 case TEMPORARY:
21083 case THEN:
21084 case TIME:
21085 case TIMESTAMP:
21086 case TIMEZONE_REGION:
21087 case TIMEZONE_ABBR:
21088 case TIMEZONE_MINUTE:
21089 case TIMEZONE_HOUR:
21090 case TO:
21091 case TRANSACTION:
21092 case TRIGGER:
21093 case TRUE:
21094 case TYPE:
21095 case UI:
21096 case UNDER:
21097 case USING:
21098 case WHILE:
21099 case YES:
21100 case SHOW:
21101 case A:
21102 case UPDATE:
21103 case VARCHAR:
21104 case VARCHAR2:
21105 case DOUBLE:
21106 case DEC:
21107 case PRECISION:
21108 case INT:
21109 case NUMERIC:
21110 case SIGNTYPE:
21111 case NCHAR:
21112 case NVARCHAR2:
21113 case STRING:
21114 case UROWID:
21115 case VARRAY:
21116 case VARYING:
21117 case BFILE:
21118 case BLOB:
21119 case CLOB:
21120 case NCLOB:
21121 case YEAR:
21122 case LOCAL:
21123 case WITH:
21124 case ZONE:
21125 case CHARACTER:
21126 case AFTER:
21127 case BEFORE:
21128 case OLD:
21129 case PARENT:
21130 case ANALYZE:
21131 case ASSOCIATE:
21132 case AUDIT:
21133 case COMPOUND:
21134 case DATABASE:
21135 case CALL:
21136 case DDL:
21137 case DISASSOCIATE:
21138 case EACH:
21139 case FOLLOWS:
21140 case LOGOFF:
21141 case LOGON:
21142 case NESTED:
21143 case NOAUDIT:
21144 case SCHEMA:
21145 case SERVERERROR:
21146 case SHUTDOWN:
21147 case STARTUP:
21148 case STATEMENT:
21149 case STATISTICS:
21150 case SUSPEND:
21151 case TRUNCATE:
21152 case WRAPPED:
21153 case LIBRARY:
21154 case NAME:
21155 case STRUCT:
21156 case CONTEXT:
21157 case PARAMETERS:
21158 case LENGTH:
21159 case TDO:
21160 case MAXLEN:
21161 case CHARSETID:
21162 case CHARSETFORM:
21163 case ACCEPT:
21164 case ACCESSIBLE:
21165 case COPY:
21166 case DEFINE:
21167 case DISCONNECT:
21168 case HOST:
21169 case PRINT:
21170 case QUIT:
21171 case REMARK:
21172 case UNDEFINE:
21173 case VARIABLE:
21174 case WHENEVER:
21175 case ATTACH:
21176 case CAST:
21177 case TREAT:
21178 case TRIM:
21179 case LEFT:
21180 case RIGHT:
21181 case BOTH:
21182 case EMPTY:
21183 case MULTISET:
21184 case SUBMULTISET:
21185 case LEADING:
21186 case TRAILING:
21187 case CHAR_CS:
21188 case NCHAR_CS:
21189 case DBTIMEZONE:
21190 case SESSIONTIMEZONE:
21191 case AUTHENTICATED:
21192 case LINK:
21193 case SHARED:
21194 case DIRECTORY:
21195 case USER:
21196 case IDENTIFIER:
21197 case QUOTED_LITERAL:
21198 case SQLDATA_CLASS:
21199 case CUSTOMDATUM_CLASS:
21200 case ORADATA_CLASS:
21201 case JAVA_INTERFACE_CLASS:
21202 ID();
21203 break;
21204 case STRING_LITERAL:
21205 StringLiteral();
21206 break;
21207 default:
21208 jj_la1[268] = jj_gen;
21209 jj_consume_token(-1);
21210 throw new ParseException();
21211 }
21212 switch (jj_nt.kind) {
21213 case 6:
21214 ;
21215 break;
21216 default:
21217 jj_la1[269] = jj_gen;
21218 break label_66;
21219 }
21220 }
21221 jj_consume_token(7);
21222 break;
21223 case EXCEPTION_INIT:
21224 jj_consume_token(EXCEPTION_INIT);
21225 jj_consume_token(5);
21226 jj_consume_token(IDENTIFIER);
21227 jj_consume_token(6);
21228 switch (jj_nt.kind) {
21229 case 16:
21230 case 17:
21231 switch (jj_nt.kind) {
21232 case 16:
21233 jj_consume_token(16);
21234 break;
21235 case 17:
21236 jj_consume_token(17);
21237 break;
21238 default:
21239 jj_la1[270] = jj_gen;
21240 jj_consume_token(-1);
21241 throw new ParseException();
21242 }
21243 break;
21244 default:
21245 jj_la1[271] = jj_gen;
21246 ;
21247 }
21248 NumericLiteral();
21249 jj_consume_token(7);
21250 break;
21251 case INTERFACE:
21252 jj_consume_token(INTERFACE);
21253 jj_consume_token(5);
21254 jj_consume_token(IDENTIFIER);
21255 jj_consume_token(6);
21256 ID();
21257 switch (jj_nt.kind) {
21258 case 6:
21259 jj_consume_token(6);
21260 NumericLiteral();
21261 break;
21262 default:
21263 jj_la1[272] = jj_gen;
21264 ;
21265 }
21266 jj_consume_token(7);
21267 break;
21268 case REPLACE:
21269 case DEFINER:
21270 case CURRENT_USER:
21271 case LANGUAGE:
21272 case INLINE:
21273 case ADD:
21274 case AGGREGATE:
21275 case ARRAY:
21276 case AT:
21277 case ATTRIBUTE:
21278 case AUTHID:
21279 case BODY:
21280 case BULK:
21281 case BYTE:
21282 case CASCADE:
21283 case CLOSE:
21284 case COALESCE:
21285 case COLLECT:
21286 case COLUMN:
21287 case COMMENT:
21288 case COMMIT:
21289 case CONSTRUCTOR:
21290 case CONTINUE:
21291 case CONVERT:
21292 case CURRENT:
21293 case CURSOR:
21294 case DATA:
21295 case DAY:
21296 case DISABLE:
21297 case EDITIONABLE:
21298 case ELEMENT:
21299 case ENABLE:
21300 case ESCAPE:
21301 case EXCEPT:
21302 case EXCEPTIONS:
21303 case EXIT:
21304 case EXTERNAL:
21305 case EXTENDS:
21306 case EXTRACT:
21307 case FALSE:
21308 case FINAL:
21309 case FORCE:
21310 case FUNCTION:
21311 case GLOBAL:
21312 case HASH:
21313 case HEAP:
21314 case HOUR:
21315 case IMMEDIATE:
21316 case INDICES:
21317 case INDEXTYPE:
21318 case INDICATOR:
21319 case INSTANTIABLE:
21320 case INTERVAL:
21321 case INVALIDATE:
21322 case ISOLATION:
21323 case JAVA:
21324 case LEVEL:
21325 case LIMIT:
21326 case LOOP:
21327 case MAP:
21328 case MAX:
21329 case MEMBER:
21330 case MERGE:
21331 case MIN:
21332 case MINUTE:
21333 case MLSLABEL:
21334 case MODIFY:
21335 case MOD:
21336 case MONTH:
21337 case NATURAL:
21338 case NEW:
21339 case NO:
21340 case NONEDITIONABLE:
21341 case NULLIF:
21342 case OBJECT:
21343 case OID:
21344 case OPAQUE:
21345 case OPEN:
21346 case OPERATOR:
21347 case ORGANIZATION:
21348 case OTHERS:
21349 case OVERRIDING:
21350 case PACKAGE:
21351 case PARTITION:
21352 case PRESERVE:
21353 case PRIVATE:
21354 case PROCEDURE:
21355 case RANGE:
21356 case RAW:
21357 case REAL:
21358 case RECORD:
21359 case REF:
21360 case RELEASE:
21361 case RELIES_ON:
21362 case RENAME:
21363 case RESULT:
21364 case RETURN:
21365 case RETURNING:
21366 case REVERSE:
21367 case ROLLBACK:
21368 case ROW:
21369 case ROWS:
21370 case ROWID:
21371 case ROWNUM:
21372 case SAVE:
21373 case SAVEPOINT:
21374 case SECOND:
21375 case SELF:
21376 case SET:
21377 case SPACE:
21378 case SQL:
21379 case SQLCODE:
21380 case SQLERRM:
21381 case STATIC:
21382 case SUBTYPE:
21383 case SUBSTITUTABLE:
21384 case SUCCESSFUL:
21385 case SYSDATE:
21386 case SYS_REFCURSOR:
21387 case TEMPORARY:
21388 case TIME:
21389 case TIMEZONE_REGION:
21390 case TIMEZONE_ABBR:
21391 case TIMEZONE_MINUTE:
21392 case TIMEZONE_HOUR:
21393 case TRANSACTION:
21394 case TRUE:
21395 case TYPE:
21396 case UNDER:
21397 case USING:
21398 case YES:
21399 case SHOW:
21400 case A:
21401 case DOUBLE:
21402 case DEC:
21403 case PRECISION:
21404 case INT:
21405 case NUMERIC:
21406 case NCHAR:
21407 case NVARCHAR2:
21408 case STRING:
21409 case UROWID:
21410 case VARRAY:
21411 case VARYING:
21412 case BFILE:
21413 case BLOB:
21414 case CLOB:
21415 case NCLOB:
21416 case YEAR:
21417 case LOCAL:
21418 case ZONE:
21419 case CHARACTER:
21420 case AFTER:
21421 case BEFORE:
21422 case OLD:
21423 case PARENT:
21424 case ANALYZE:
21425 case ASSOCIATE:
21426 case AUDIT:
21427 case COMPOUND:
21428 case DATABASE:
21429 case CALL:
21430 case DDL:
21431 case DISASSOCIATE:
21432 case EACH:
21433 case FOLLOWS:
21434 case LOGOFF:
21435 case LOGON:
21436 case NESTED:
21437 case NOAUDIT:
21438 case SCHEMA:
21439 case SERVERERROR:
21440 case SHUTDOWN:
21441 case STARTUP:
21442 case STATEMENT:
21443 case STATISTICS:
21444 case SUSPEND:
21445 case TRUNCATE:
21446 case WRAPPED:
21447 case LIBRARY:
21448 case NAME:
21449 case STRUCT:
21450 case CONTEXT:
21451 case PARAMETERS:
21452 case LENGTH:
21453 case TDO:
21454 case MAXLEN:
21455 case CHARSETID:
21456 case CHARSETFORM:
21457 case ACCEPT:
21458 case ACCESSIBLE:
21459 case COPY:
21460 case DEFINE:
21461 case DISCONNECT:
21462 case HOST:
21463 case PRINT:
21464 case QUIT:
21465 case REMARK:
21466 case UNDEFINE:
21467 case VARIABLE:
21468 case WHENEVER:
21469 case ATTACH:
21470 case CAST:
21471 case TREAT:
21472 case TRIM:
21473 case LEFT:
21474 case RIGHT:
21475 case BOTH:
21476 case EMPTY:
21477 case MULTISET:
21478 case SUBMULTISET:
21479 case LEADING:
21480 case TRAILING:
21481 case CHAR_CS:
21482 case NCHAR_CS:
21483 case DBTIMEZONE:
21484 case SESSIONTIMEZONE:
21485 case AUTHENTICATED:
21486 case LINK:
21487 case SHARED:
21488 case DIRECTORY:
21489 case USER:
21490 case IDENTIFIER:
21491 case QUOTED_LITERAL:
21492 QualifiedName();
21493 jj_consume_token(5);
21494 ReadPastNextOccurrence(")");
21495 break;
21496 default:
21497 jj_la1[273] = jj_gen;
21498 jj_consume_token(-1);
21499 throw new ParseException();
21500 }
21501 jj_consume_token(4);
21502 jjtree.closeNodeScope(jjtn000, true);
21503 jjtc000 = false;
21504 {if (true) return jjtn000 ;}
21505 } catch (Throwable jjte000) {
21506 if (jjtc000) {
21507 jjtree.clearNodeScope(jjtn000);
21508 jjtc000 = false;
21509 } else {
21510 jjtree.popNode();
21511 }
21512 if (jjte000 instanceof RuntimeException) {
21513 {if (true) throw (RuntimeException)jjte000;}
21514 }
21515 if (jjte000 instanceof ParseException) {
21516 {if (true) throw (ParseException)jjte000;}
21517 }
21518 {if (true) throw (Error)jjte000;}
21519 } finally {
21520 if (jjtc000) {
21521 jjtree.closeNodeScope(jjtn000, true);
21522 }
21523 }
21524 throw new Error("Missing return statement in function");
21525 }
21526
21527 final public ASTInlinePragma InlinePragma() throws ParseException {
21528
21529 ASTInlinePragma jjtn000 = new ASTInlinePragma(this, JJTINLINEPRAGMA);
21530 boolean jjtc000 = true;
21531 jjtree.openNodeScope(jjtn000);
21532 try {
21533 jj_consume_token(PRAGMA);
21534 jj_consume_token(INLINE);
21535 jj_consume_token(5);
21536 QualifiedName();
21537 jj_consume_token(6);
21538 StringLiteral();
21539 jj_consume_token(7);
21540 jjtree.closeNodeScope(jjtn000, true);
21541 jjtc000 = false;
21542 {if (true) return jjtn000 ;}
21543 } catch (Throwable jjte000) {
21544 if (jjtc000) {
21545 jjtree.clearNodeScope(jjtn000);
21546 jjtc000 = false;
21547 } else {
21548 jjtree.popNode();
21549 }
21550 if (jjte000 instanceof RuntimeException) {
21551 {if (true) throw (RuntimeException)jjte000;}
21552 }
21553 if (jjte000 instanceof ParseException) {
21554 {if (true) throw (ParseException)jjte000;}
21555 }
21556 {if (true) throw (Error)jjte000;}
21557 } finally {
21558 if (jjtc000) {
21559 jjtree.closeNodeScope(jjtn000, true);
21560 }
21561 }
21562 throw new Error("Missing return statement in function");
21563 }
21564
21565 final public ASTExceptionDeclaration ExceptionDeclaration() throws ParseException {
21566
21567 ASTExceptionDeclaration jjtn000 = new ASTExceptionDeclaration(this, JJTEXCEPTIONDECLARATION);
21568 boolean jjtc000 = true;
21569 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
21570 try {
21571 simpleNode = ID();
21572 jj_consume_token(EXCEPTION);
21573 jj_consume_token(4);
21574 jjtree.closeNodeScope(jjtn000, true);
21575 jjtc000 = false;
21576 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
21577 } catch (Throwable jjte000) {
21578 if (jjtc000) {
21579 jjtree.clearNodeScope(jjtn000);
21580 jjtc000 = false;
21581 } else {
21582 jjtree.popNode();
21583 }
21584 if (jjte000 instanceof RuntimeException) {
21585 {if (true) throw (RuntimeException)jjte000;}
21586 }
21587 if (jjte000 instanceof ParseException) {
21588 {if (true) throw (ParseException)jjte000;}
21589 }
21590 {if (true) throw (Error)jjte000;}
21591 } finally {
21592 if (jjtc000) {
21593 jjtree.closeNodeScope(jjtn000, true);
21594 }
21595 }
21596 throw new Error("Missing return statement in function");
21597 }
21598
21599 final public ASTParallelClause ParallelClause() throws ParseException {
21600
21601 ASTParallelClause jjtn000 = new ASTParallelClause(this, JJTPARALLELCLAUSE);
21602 boolean jjtc000 = true;
21603 jjtree.openNodeScope(jjtn000);
21604 try {
21605 jj_consume_token(5);
21606 jj_consume_token(PARTITION);
21607 ID();
21608 jj_consume_token(BY);
21609 switch (jj_nt.kind) {
21610 case ANY:
21611 jj_consume_token(ANY);
21612 break;
21613 case HASH:
21614 case RANGE:
21615 switch (jj_nt.kind) {
21616 case HASH:
21617 jj_consume_token(HASH);
21618 break;
21619 case RANGE:
21620 jj_consume_token(RANGE);
21621 break;
21622 default:
21623 jj_la1[274] = jj_gen;
21624 jj_consume_token(-1);
21625 throw new ParseException();
21626 }
21627 jj_consume_token(5);
21628 ID();
21629 label_67:
21630 while (true) {
21631 switch (jj_nt.kind) {
21632 case 6:
21633 ;
21634 break;
21635 default:
21636 jj_la1[275] = jj_gen;
21637 break label_67;
21638 }
21639 jj_consume_token(6);
21640 ID();
21641 }
21642 jj_consume_token(7);
21643 break;
21644 default:
21645 jj_la1[276] = jj_gen;
21646 jj_consume_token(-1);
21647 throw new ParseException();
21648 }
21649 jj_consume_token(7);
21650 switch (jj_nt.kind) {
21651 case CLUSTER:
21652 case ORDER:
21653 switch (jj_nt.kind) {
21654 case ORDER:
21655 jj_consume_token(ORDER);
21656 break;
21657 case CLUSTER:
21658 jj_consume_token(CLUSTER);
21659 break;
21660 default:
21661 jj_la1[277] = jj_gen;
21662 jj_consume_token(-1);
21663 throw new ParseException();
21664 }
21665 jj_consume_token(BY);
21666 jj_consume_token(5);
21667 ID();
21668 label_68:
21669 while (true) {
21670 switch (jj_nt.kind) {
21671 case 6:
21672 ;
21673 break;
21674 default:
21675 jj_la1[278] = jj_gen;
21676 break label_68;
21677 }
21678 jj_consume_token(6);
21679 ID();
21680 }
21681 jj_consume_token(7);
21682 break;
21683 default:
21684 jj_la1[279] = jj_gen;
21685 ;
21686 }
21687 jjtree.closeNodeScope(jjtn000, true);
21688 jjtc000 = false;
21689 {if (true) return jjtn000 ;}
21690 } catch (Throwable jjte000) {
21691 if (jjtc000) {
21692 jjtree.clearNodeScope(jjtn000);
21693 jjtc000 = false;
21694 } else {
21695 jjtree.popNode();
21696 }
21697 if (jjte000 instanceof RuntimeException) {
21698 {if (true) throw (RuntimeException)jjte000;}
21699 }
21700 if (jjte000 instanceof ParseException) {
21701 {if (true) throw (ParseException)jjte000;}
21702 }
21703 {if (true) throw (Error)jjte000;}
21704 } finally {
21705 if (jjtc000) {
21706 jjtree.closeNodeScope(jjtn000, true);
21707 }
21708 }
21709 throw new Error("Missing return statement in function");
21710 }
21711
21712 final public ASTAccessibleByClause AccessibleByClause() throws ParseException {
21713
21714 ASTAccessibleByClause jjtn000 = new ASTAccessibleByClause(this, JJTACCESSIBLEBYCLAUSE);
21715 boolean jjtc000 = true;
21716 jjtree.openNodeScope(jjtn000);
21717 try {
21718 jj_consume_token(ACCESSIBLE);
21719 jj_consume_token(BY);
21720 jj_consume_token(5);
21721 switch (jj_nt.kind) {
21722 case FUNCTION:
21723 case PACKAGE:
21724 case PROCEDURE:
21725 case TRIGGER:
21726 case TYPE:
21727 switch (jj_nt.kind) {
21728 case FUNCTION:
21729 jj_consume_token(FUNCTION);
21730 break;
21731 case PROCEDURE:
21732 jj_consume_token(PROCEDURE);
21733 break;
21734 case PACKAGE:
21735 jj_consume_token(PACKAGE);
21736 break;
21737 case TRIGGER:
21738 jj_consume_token(TRIGGER);
21739 break;
21740 case TYPE:
21741 jj_consume_token(TYPE);
21742 break;
21743 default:
21744 jj_la1[280] = jj_gen;
21745 jj_consume_token(-1);
21746 throw new ParseException();
21747 }
21748 break;
21749 default:
21750 jj_la1[281] = jj_gen;
21751 ;
21752 }
21753 QualifiedName();
21754 label_69:
21755 while (true) {
21756 switch (jj_nt.kind) {
21757 case 6:
21758 ;
21759 break;
21760 default:
21761 jj_la1[282] = jj_gen;
21762 break label_69;
21763 }
21764 jj_consume_token(6);
21765 switch (jj_nt.kind) {
21766 case FUNCTION:
21767 case PACKAGE:
21768 case PROCEDURE:
21769 case TRIGGER:
21770 case TYPE:
21771 switch (jj_nt.kind) {
21772 case FUNCTION:
21773 jj_consume_token(FUNCTION);
21774 break;
21775 case PROCEDURE:
21776 jj_consume_token(PROCEDURE);
21777 break;
21778 case PACKAGE:
21779 jj_consume_token(PACKAGE);
21780 break;
21781 case TRIGGER:
21782 jj_consume_token(TRIGGER);
21783 break;
21784 case TYPE:
21785 jj_consume_token(TYPE);
21786 break;
21787 default:
21788 jj_la1[283] = jj_gen;
21789 jj_consume_token(-1);
21790 throw new ParseException();
21791 }
21792 break;
21793 default:
21794 jj_la1[284] = jj_gen;
21795 ;
21796 }
21797 QualifiedName();
21798 }
21799 jj_consume_token(7);
21800 jjtree.closeNodeScope(jjtn000, true);
21801 jjtc000 = false;
21802 {if (true) return jjtn000 ;}
21803 } catch (Throwable jjte000) {
21804 if (jjtc000) {
21805 jjtree.clearNodeScope(jjtn000);
21806 jjtc000 = false;
21807 } else {
21808 jjtree.popNode();
21809 }
21810 if (jjte000 instanceof RuntimeException) {
21811 {if (true) throw (RuntimeException)jjte000;}
21812 }
21813 if (jjte000 instanceof ParseException) {
21814 {if (true) throw (ParseException)jjte000;}
21815 }
21816 {if (true) throw (Error)jjte000;}
21817 } finally {
21818 if (jjtc000) {
21819 jjtree.closeNodeScope(jjtn000, true);
21820 }
21821 }
21822 throw new Error("Missing return statement in function");
21823 }
21824
21825
21826
21827
21828
21829
21830
21831
21832 final public ASTTable Table() throws ParseException {
21833
21834 ASTTable jjtn000 = new ASTTable(this, JJTTABLE);
21835 boolean jjtc000 = true;
21836 jjtree.openNodeScope(jjtn000);
21837 try {
21838 jj_consume_token(CREATE);
21839 switch (jj_nt.kind) {
21840 case GLOBAL:
21841 jj_consume_token(GLOBAL);
21842 jj_consume_token(TEMPORARY);
21843 break;
21844 default:
21845 jj_la1[285] = jj_gen;
21846 ;
21847 }
21848 jj_consume_token(TABLE);
21849 ObjectNameDeclaration();
21850 jj_consume_token(5);
21851 TableColumn();
21852 label_70:
21853 while (true) {
21854 switch (jj_nt.kind) {
21855 case 6:
21856 ;
21857 break;
21858 default:
21859 jj_la1[286] = jj_gen;
21860 break label_70;
21861 }
21862 jj_consume_token(6);
21863 TableColumn();
21864 }
21865 jj_consume_token(7);
21866 if (jj_2_58(2)) {
21867 jj_consume_token(ON);
21868 jj_consume_token(COMMIT);
21869 switch (jj_nt.kind) {
21870 case DELETE:
21871 jj_consume_token(DELETE);
21872 break;
21873 case PRESERVE:
21874 jj_consume_token(PRESERVE);
21875 break;
21876 default:
21877 jj_la1[287] = jj_gen;
21878 jj_consume_token(-1);
21879 throw new ParseException();
21880 }
21881 jj_consume_token(ROWS);
21882 } else {
21883 ;
21884 }
21885 switch (jj_nt.kind) {
21886 case 4:
21887 jj_consume_token(4);
21888 break;
21889 default:
21890 jj_la1[288] = jj_gen;
21891 ;
21892 }
21893 jjtree.closeNodeScope(jjtn000, true);
21894 jjtc000 = false;
21895 {if (true) return jjtn000 ;}
21896 } catch (Throwable jjte000) {
21897 if (jjtc000) {
21898 jjtree.clearNodeScope(jjtn000);
21899 jjtc000 = false;
21900 } else {
21901 jjtree.popNode();
21902 }
21903 if (jjte000 instanceof RuntimeException) {
21904 {if (true) throw (RuntimeException)jjte000;}
21905 }
21906 if (jjte000 instanceof ParseException) {
21907 {if (true) throw (ParseException)jjte000;}
21908 }
21909 {if (true) throw (Error)jjte000;}
21910 } finally {
21911 if (jjtc000) {
21912 jjtree.closeNodeScope(jjtn000, true);
21913 }
21914 }
21915 throw new Error("Missing return statement in function");
21916 }
21917
21918 final public ASTTableColumn TableColumn() throws ParseException {
21919
21920 ASTTableColumn jjtn000 = new ASTTableColumn(this, JJTTABLECOLUMN);
21921 boolean jjtc000 = true;
21922 jjtree.openNodeScope(jjtn000);
21923 try {
21924 ID();
21925 Datatype();
21926 switch (jj_nt.kind) {
21927 case _DEFAULT:
21928 jj_consume_token(_DEFAULT);
21929 Expression();
21930 break;
21931 default:
21932 jj_la1[289] = jj_gen;
21933 ;
21934 }
21935 switch (jj_nt.kind) {
21936 case NOT:
21937 case NULL:
21938 switch (jj_nt.kind) {
21939 case NOT:
21940 jj_consume_token(NOT);
21941 break;
21942 default:
21943 jj_la1[290] = jj_gen;
21944 ;
21945 }
21946 jj_consume_token(NULL);
21947 break;
21948 default:
21949 jj_la1[291] = jj_gen;
21950 ;
21951 }
21952 jjtree.closeNodeScope(jjtn000, true);
21953 jjtc000 = false;
21954 {if (true) return jjtn000 ;}
21955 } catch (Throwable jjte000) {
21956 if (jjtc000) {
21957 jjtree.clearNodeScope(jjtn000);
21958 jjtc000 = false;
21959 } else {
21960 jjtree.popNode();
21961 }
21962 if (jjte000 instanceof RuntimeException) {
21963 {if (true) throw (RuntimeException)jjte000;}
21964 }
21965 if (jjte000 instanceof ParseException) {
21966 {if (true) throw (ParseException)jjte000;}
21967 }
21968 {if (true) throw (Error)jjte000;}
21969 } finally {
21970 if (jjtc000) {
21971 jjtree.closeNodeScope(jjtn000, true);
21972 }
21973 }
21974 throw new Error("Missing return statement in function");
21975 }
21976
21977 final public ASTView View() throws ParseException {
21978
21979 ASTView jjtn000 = new ASTView(this, JJTVIEW);
21980 boolean jjtc000 = true;
21981 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
21982 try {
21983 jj_consume_token(CREATE);
21984 switch (jj_nt.kind) {
21985 case OR:
21986 jj_consume_token(OR);
21987 jj_consume_token(REPLACE);
21988 break;
21989 default:
21990 jj_la1[292] = jj_gen;
21991 ;
21992 }
21993 switch (jj_nt.kind) {
21994 case FORCE:
21995 case NO:
21996 switch (jj_nt.kind) {
21997 case NO:
21998 jj_consume_token(NO);
21999 break;
22000 default:
22001 jj_la1[293] = jj_gen;
22002 ;
22003 }
22004 jj_consume_token(FORCE);
22005 break;
22006 default:
22007 jj_la1[294] = jj_gen;
22008 ;
22009 }
22010 jj_consume_token(VIEW);
22011 simpleNode = ObjectNameDeclaration();
22012 switch (jj_nt.kind) {
22013 case 5:
22014 jj_consume_token(5);
22015 ViewColumn();
22016 label_71:
22017 while (true) {
22018 switch (jj_nt.kind) {
22019 case 6:
22020 ;
22021 break;
22022 default:
22023 jj_la1[295] = jj_gen;
22024 break label_71;
22025 }
22026 jj_consume_token(6);
22027 ViewColumn();
22028 }
22029 jj_consume_token(7);
22030 break;
22031 default:
22032 jj_la1[296] = jj_gen;
22033 ;
22034 }
22035 jj_consume_token(AS);
22036 Statement();
22037 switch (jj_nt.kind) {
22038 case 4:
22039 jj_consume_token(4);
22040 break;
22041 case 1:
22042 jj_consume_token(1);
22043 break;
22044 default:
22045 jj_la1[297] = jj_gen;
22046 jj_consume_token(-1);
22047 throw new ParseException();
22048 }
22049 jjtree.closeNodeScope(jjtn000, true);
22050 jjtc000 = false;
22051 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
22052 } catch (Throwable jjte000) {
22053 if (jjtc000) {
22054 jjtree.clearNodeScope(jjtn000);
22055 jjtc000 = false;
22056 } else {
22057 jjtree.popNode();
22058 }
22059 if (jjte000 instanceof RuntimeException) {
22060 {if (true) throw (RuntimeException)jjte000;}
22061 }
22062 if (jjte000 instanceof ParseException) {
22063 {if (true) throw (ParseException)jjte000;}
22064 }
22065 {if (true) throw (Error)jjte000;}
22066 } finally {
22067 if (jjtc000) {
22068 jjtree.closeNodeScope(jjtn000, true);
22069 }
22070 }
22071 throw new Error("Missing return statement in function");
22072 }
22073
22074 final public ASTSynonym Synonym() throws ParseException {
22075
22076 ASTSynonym jjtn000 = new ASTSynonym(this, JJTSYNONYM);
22077 boolean jjtc000 = true;
22078 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
22079 try {
22080 jj_consume_token(CREATE);
22081 switch (jj_nt.kind) {
22082 case OR:
22083 jj_consume_token(OR);
22084 jj_consume_token(REPLACE);
22085 break;
22086 default:
22087 jj_la1[298] = jj_gen;
22088 ;
22089 }
22090 switch (jj_nt.kind) {
22091 case PUBLIC:
22092 jj_consume_token(PUBLIC);
22093 break;
22094 default:
22095 jj_la1[299] = jj_gen;
22096 ;
22097 }
22098 jj_consume_token(SYNONYM);
22099 simpleNode = ObjectNameDeclaration();
22100 jj_consume_token(FOR);
22101 ObjectNameDeclaration();
22102 switch (jj_nt.kind) {
22103 case 4:
22104 jj_consume_token(4);
22105 break;
22106 case 1:
22107 jj_consume_token(1);
22108 break;
22109 default:
22110 jj_la1[300] = jj_gen;
22111 jj_consume_token(-1);
22112 throw new ParseException();
22113 }
22114 jjtree.closeNodeScope(jjtn000, true);
22115 jjtc000 = false;
22116 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
22117 } catch (Throwable jjte000) {
22118 if (jjtc000) {
22119 jjtree.clearNodeScope(jjtn000);
22120 jjtc000 = false;
22121 } else {
22122 jjtree.popNode();
22123 }
22124 if (jjte000 instanceof RuntimeException) {
22125 {if (true) throw (RuntimeException)jjte000;}
22126 }
22127 if (jjte000 instanceof ParseException) {
22128 {if (true) throw (ParseException)jjte000;}
22129 }
22130 {if (true) throw (Error)jjte000;}
22131 } finally {
22132 if (jjtc000) {
22133 jjtree.closeNodeScope(jjtn000, true);
22134 }
22135 }
22136 throw new Error("Missing return statement in function");
22137 }
22138
22139 final public ASTDirectory Directory() throws ParseException {
22140
22141 ASTDirectory jjtn000 = new ASTDirectory(this, JJTDIRECTORY);
22142 boolean jjtc000 = true;
22143 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
22144 try {
22145 jj_consume_token(CREATE);
22146 switch (jj_nt.kind) {
22147 case OR:
22148 jj_consume_token(OR);
22149 jj_consume_token(REPLACE);
22150 break;
22151 default:
22152 jj_la1[301] = jj_gen;
22153 ;
22154 }
22155 jj_consume_token(DIRECTORY);
22156 simpleNode = ObjectNameDeclaration();
22157 jj_consume_token(AS);
22158 StringLiteral();
22159 switch (jj_nt.kind) {
22160 case 4:
22161 jj_consume_token(4);
22162 break;
22163 case 1:
22164 jj_consume_token(1);
22165 break;
22166 default:
22167 jj_la1[302] = jj_gen;
22168 jj_consume_token(-1);
22169 throw new ParseException();
22170 }
22171 jjtree.closeNodeScope(jjtn000, true);
22172 jjtc000 = false;
22173 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
22174 } catch (Throwable jjte000) {
22175 if (jjtc000) {
22176 jjtree.clearNodeScope(jjtn000);
22177 jjtc000 = false;
22178 } else {
22179 jjtree.popNode();
22180 }
22181 if (jjte000 instanceof RuntimeException) {
22182 {if (true) throw (RuntimeException)jjte000;}
22183 }
22184 if (jjte000 instanceof ParseException) {
22185 {if (true) throw (ParseException)jjte000;}
22186 }
22187 {if (true) throw (Error)jjte000;}
22188 } finally {
22189 if (jjtc000) {
22190 jjtree.closeNodeScope(jjtn000, true);
22191 }
22192 }
22193 throw new Error("Missing return statement in function");
22194 }
22195
22196 final public ASTDatabaseLink DatabaseLink() throws ParseException {
22197
22198 ASTDatabaseLink jjtn000 = new ASTDatabaseLink(this, JJTDATABASELINK);
22199 boolean jjtc000 = true;
22200 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
22201 try {
22202 jj_consume_token(CREATE);
22203 switch (jj_nt.kind) {
22204 case SHARED:
22205 jj_consume_token(SHARED);
22206 break;
22207 default:
22208 jj_la1[303] = jj_gen;
22209 ;
22210 }
22211 switch (jj_nt.kind) {
22212 case PUBLIC:
22213 jj_consume_token(PUBLIC);
22214 break;
22215 default:
22216 jj_la1[304] = jj_gen;
22217 ;
22218 }
22219 jj_consume_token(DATABASE);
22220 jj_consume_token(LINK);
22221 simpleNode = ObjectNameDeclaration();
22222 switch (jj_nt.kind) {
22223 case CONNECT:
22224 jj_consume_token(CONNECT);
22225 jj_consume_token(TO);
22226 switch (jj_nt.kind) {
22227 case CURRENT_USER:
22228 jj_consume_token(CURRENT_USER);
22229 break;
22230 case REPLACE:
22231 case DEFINER:
22232 case LANGUAGE:
22233 case INLINE:
22234 case ADD:
22235 case AGGREGATE:
22236 case ARRAY:
22237 case AT:
22238 case ATTRIBUTE:
22239 case AUTHID:
22240 case BODY:
22241 case BULK:
22242 case BYTE:
22243 case CASCADE:
22244 case CLOSE:
22245 case COALESCE:
22246 case COLLECT:
22247 case COLUMN:
22248 case COMMENT:
22249 case COMMIT:
22250 case CONSTRUCTOR:
22251 case CONTINUE:
22252 case CONVERT:
22253 case CURRENT:
22254 case CURSOR:
22255 case DATA:
22256 case DAY:
22257 case DISABLE:
22258 case EDITIONABLE:
22259 case ELEMENT:
22260 case ENABLE:
22261 case ESCAPE:
22262 case EXCEPT:
22263 case EXCEPTIONS:
22264 case EXIT:
22265 case EXTERNAL:
22266 case EXTENDS:
22267 case EXTRACT:
22268 case FALSE:
22269 case FINAL:
22270 case FORCE:
22271 case FUNCTION:
22272 case GLOBAL:
22273 case HASH:
22274 case HEAP:
22275 case HOUR:
22276 case IMMEDIATE:
22277 case INDICES:
22278 case INDEXTYPE:
22279 case INDICATOR:
22280 case INSTANTIABLE:
22281 case INTERVAL:
22282 case INVALIDATE:
22283 case ISOLATION:
22284 case JAVA:
22285 case LEVEL:
22286 case LIMIT:
22287 case LOOP:
22288 case MAP:
22289 case MAX:
22290 case MEMBER:
22291 case MERGE:
22292 case MIN:
22293 case MINUTE:
22294 case MLSLABEL:
22295 case MODIFY:
22296 case MOD:
22297 case MONTH:
22298 case NATURAL:
22299 case NEW:
22300 case NO:
22301 case NONEDITIONABLE:
22302 case NULLIF:
22303 case OBJECT:
22304 case OID:
22305 case OPAQUE:
22306 case OPEN:
22307 case OPERATOR:
22308 case ORGANIZATION:
22309 case OTHERS:
22310 case OVERRIDING:
22311 case PACKAGE:
22312 case PARTITION:
22313 case PRESERVE:
22314 case PRIVATE:
22315 case PROCEDURE:
22316 case RANGE:
22317 case RAW:
22318 case REAL:
22319 case RECORD:
22320 case REF:
22321 case RELEASE:
22322 case RELIES_ON:
22323 case RENAME:
22324 case RESULT:
22325 case RETURN:
22326 case RETURNING:
22327 case REVERSE:
22328 case ROLLBACK:
22329 case ROW:
22330 case ROWS:
22331 case ROWID:
22332 case ROWNUM:
22333 case SAVE:
22334 case SAVEPOINT:
22335 case SECOND:
22336 case SELF:
22337 case SET:
22338 case SPACE:
22339 case SQL:
22340 case SQLCODE:
22341 case SQLERRM:
22342 case STATIC:
22343 case SUBTYPE:
22344 case SUBSTITUTABLE:
22345 case SUCCESSFUL:
22346 case SYSDATE:
22347 case SYS_REFCURSOR:
22348 case TEMPORARY:
22349 case TIME:
22350 case TIMESTAMP:
22351 case TIMEZONE_REGION:
22352 case TIMEZONE_ABBR:
22353 case TIMEZONE_MINUTE:
22354 case TIMEZONE_HOUR:
22355 case TRANSACTION:
22356 case TRUE:
22357 case TYPE:
22358 case UNDER:
22359 case USING:
22360 case YES:
22361 case SHOW:
22362 case A:
22363 case DOUBLE:
22364 case DEC:
22365 case PRECISION:
22366 case INT:
22367 case NUMERIC:
22368 case NCHAR:
22369 case NVARCHAR2:
22370 case STRING:
22371 case UROWID:
22372 case VARRAY:
22373 case VARYING:
22374 case BFILE:
22375 case BLOB:
22376 case CLOB:
22377 case NCLOB:
22378 case YEAR:
22379 case LOCAL:
22380 case ZONE:
22381 case CHARACTER:
22382 case AFTER:
22383 case BEFORE:
22384 case OLD:
22385 case PARENT:
22386 case ANALYZE:
22387 case ASSOCIATE:
22388 case AUDIT:
22389 case COMPOUND:
22390 case DATABASE:
22391 case CALL:
22392 case DDL:
22393 case DISASSOCIATE:
22394 case EACH:
22395 case FOLLOWS:
22396 case LOGOFF:
22397 case LOGON:
22398 case NESTED:
22399 case NOAUDIT:
22400 case SCHEMA:
22401 case SERVERERROR:
22402 case SHUTDOWN:
22403 case STARTUP:
22404 case STATEMENT:
22405 case STATISTICS:
22406 case SUSPEND:
22407 case TRUNCATE:
22408 case WRAPPED:
22409 case LIBRARY:
22410 case NAME:
22411 case STRUCT:
22412 case CONTEXT:
22413 case PARAMETERS:
22414 case LENGTH:
22415 case TDO:
22416 case MAXLEN:
22417 case CHARSETID:
22418 case CHARSETFORM:
22419 case ACCEPT:
22420 case ACCESSIBLE:
22421 case COPY:
22422 case DEFINE:
22423 case DISCONNECT:
22424 case HOST:
22425 case PRINT:
22426 case QUIT:
22427 case REMARK:
22428 case UNDEFINE:
22429 case VARIABLE:
22430 case WHENEVER:
22431 case ATTACH:
22432 case CAST:
22433 case TREAT:
22434 case TRIM:
22435 case LEFT:
22436 case RIGHT:
22437 case BOTH:
22438 case EMPTY:
22439 case MULTISET:
22440 case SUBMULTISET:
22441 case LEADING:
22442 case TRAILING:
22443 case CHAR_CS:
22444 case NCHAR_CS:
22445 case DBTIMEZONE:
22446 case SESSIONTIMEZONE:
22447 case AUTHENTICATED:
22448 case LINK:
22449 case SHARED:
22450 case DIRECTORY:
22451 case USER:
22452 case IDENTIFIER:
22453 case QUOTED_LITERAL:
22454 UnqualifiedID();
22455 jj_consume_token(IDENTIFIED);
22456 jj_consume_token(BY);
22457 UnqualifiedID();
22458 jj_consume_token(AUTHENTICATED);
22459 jj_consume_token(BY);
22460 UnqualifiedID();
22461 jj_consume_token(IDENTIFIED);
22462 jj_consume_token(BY);
22463 UnqualifiedID();
22464 break;
22465 default:
22466 jj_la1[305] = jj_gen;
22467 jj_consume_token(-1);
22468 throw new ParseException();
22469 }
22470 break;
22471 case REPLACE:
22472 case DEFINER:
22473 case CURRENT_USER:
22474 case LANGUAGE:
22475 case INLINE:
22476 case ADD:
22477 case AGGREGATE:
22478 case ARRAY:
22479 case AT:
22480 case ATTRIBUTE:
22481 case AUTHID:
22482 case BODY:
22483 case BULK:
22484 case BYTE:
22485 case CASCADE:
22486 case CLOSE:
22487 case COALESCE:
22488 case COLLECT:
22489 case COLUMN:
22490 case COMMENT:
22491 case COMMIT:
22492 case CONSTRUCTOR:
22493 case CONTINUE:
22494 case CONVERT:
22495 case CURRENT:
22496 case CURSOR:
22497 case DATA:
22498 case DAY:
22499 case DISABLE:
22500 case EDITIONABLE:
22501 case ELEMENT:
22502 case ENABLE:
22503 case ESCAPE:
22504 case EXCEPT:
22505 case EXCEPTIONS:
22506 case EXIT:
22507 case EXTERNAL:
22508 case EXTENDS:
22509 case EXTRACT:
22510 case FALSE:
22511 case FINAL:
22512 case FORCE:
22513 case FUNCTION:
22514 case GLOBAL:
22515 case HASH:
22516 case HEAP:
22517 case HOUR:
22518 case IMMEDIATE:
22519 case INDICES:
22520 case INDEXTYPE:
22521 case INDICATOR:
22522 case INSTANTIABLE:
22523 case INTERVAL:
22524 case INVALIDATE:
22525 case ISOLATION:
22526 case JAVA:
22527 case LEVEL:
22528 case LIMIT:
22529 case LOOP:
22530 case MAP:
22531 case MAX:
22532 case MEMBER:
22533 case MERGE:
22534 case MIN:
22535 case MINUTE:
22536 case MLSLABEL:
22537 case MODIFY:
22538 case MOD:
22539 case MONTH:
22540 case NATURAL:
22541 case NEW:
22542 case NO:
22543 case NONEDITIONABLE:
22544 case NULLIF:
22545 case OBJECT:
22546 case OID:
22547 case OPAQUE:
22548 case OPEN:
22549 case OPERATOR:
22550 case ORGANIZATION:
22551 case OTHERS:
22552 case OVERRIDING:
22553 case PACKAGE:
22554 case PARTITION:
22555 case PRESERVE:
22556 case PRIVATE:
22557 case PROCEDURE:
22558 case RANGE:
22559 case RAW:
22560 case REAL:
22561 case RECORD:
22562 case REF:
22563 case RELEASE:
22564 case RELIES_ON:
22565 case RENAME:
22566 case RESULT:
22567 case RETURN:
22568 case RETURNING:
22569 case REVERSE:
22570 case ROLLBACK:
22571 case ROW:
22572 case ROWS:
22573 case ROWID:
22574 case ROWNUM:
22575 case SAVE:
22576 case SAVEPOINT:
22577 case SECOND:
22578 case SELF:
22579 case SET:
22580 case SPACE:
22581 case SQL:
22582 case SQLCODE:
22583 case SQLERRM:
22584 case STATIC:
22585 case SUBTYPE:
22586 case SUBSTITUTABLE:
22587 case SUCCESSFUL:
22588 case SYSDATE:
22589 case SYS_REFCURSOR:
22590 case TEMPORARY:
22591 case TIME:
22592 case TIMESTAMP:
22593 case TIMEZONE_REGION:
22594 case TIMEZONE_ABBR:
22595 case TIMEZONE_MINUTE:
22596 case TIMEZONE_HOUR:
22597 case TRANSACTION:
22598 case TRUE:
22599 case TYPE:
22600 case UNDER:
22601 case USING:
22602 case YES:
22603 case SHOW:
22604 case A:
22605 case DOUBLE:
22606 case DEC:
22607 case PRECISION:
22608 case INT:
22609 case NUMERIC:
22610 case NCHAR:
22611 case NVARCHAR2:
22612 case STRING:
22613 case UROWID:
22614 case VARRAY:
22615 case VARYING:
22616 case BFILE:
22617 case BLOB:
22618 case CLOB:
22619 case NCLOB:
22620 case YEAR:
22621 case LOCAL:
22622 case ZONE:
22623 case CHARACTER:
22624 case AFTER:
22625 case BEFORE:
22626 case OLD:
22627 case PARENT:
22628 case ANALYZE:
22629 case ASSOCIATE:
22630 case AUDIT:
22631 case COMPOUND:
22632 case DATABASE:
22633 case CALL:
22634 case DDL:
22635 case DISASSOCIATE:
22636 case EACH:
22637 case FOLLOWS:
22638 case LOGOFF:
22639 case LOGON:
22640 case NESTED:
22641 case NOAUDIT:
22642 case SCHEMA:
22643 case SERVERERROR:
22644 case SHUTDOWN:
22645 case STARTUP:
22646 case STATEMENT:
22647 case STATISTICS:
22648 case SUSPEND:
22649 case TRUNCATE:
22650 case WRAPPED:
22651 case LIBRARY:
22652 case NAME:
22653 case STRUCT:
22654 case CONTEXT:
22655 case PARAMETERS:
22656 case LENGTH:
22657 case TDO:
22658 case MAXLEN:
22659 case CHARSETID:
22660 case CHARSETFORM:
22661 case ACCEPT:
22662 case ACCESSIBLE:
22663 case COPY:
22664 case DEFINE:
22665 case DISCONNECT:
22666 case HOST:
22667 case PRINT:
22668 case QUIT:
22669 case REMARK:
22670 case UNDEFINE:
22671 case VARIABLE:
22672 case WHENEVER:
22673 case ATTACH:
22674 case CAST:
22675 case TREAT:
22676 case TRIM:
22677 case LEFT:
22678 case RIGHT:
22679 case BOTH:
22680 case EMPTY:
22681 case MULTISET:
22682 case SUBMULTISET:
22683 case LEADING:
22684 case TRAILING:
22685 case CHAR_CS:
22686 case NCHAR_CS:
22687 case DBTIMEZONE:
22688 case SESSIONTIMEZONE:
22689 case AUTHENTICATED:
22690 case LINK:
22691 case SHARED:
22692 case DIRECTORY:
22693 case USER:
22694 case IDENTIFIER:
22695 case QUOTED_LITERAL:
22696 UnqualifiedID();
22697 jj_consume_token(IDENTIFIED);
22698 jj_consume_token(BY);
22699 UnqualifiedID();
22700 break;
22701 default:
22702 jj_la1[306] = jj_gen;
22703 jj_consume_token(-1);
22704 throw new ParseException();
22705 }
22706 switch (jj_nt.kind) {
22707 case USING:
22708 jj_consume_token(USING);
22709 StringLiteral();
22710 break;
22711 default:
22712 jj_la1[307] = jj_gen;
22713 ;
22714 }
22715 switch (jj_nt.kind) {
22716 case 4:
22717 jj_consume_token(4);
22718 break;
22719 case 1:
22720 jj_consume_token(1);
22721 break;
22722 default:
22723 jj_la1[308] = jj_gen;
22724 jj_consume_token(-1);
22725 throw new ParseException();
22726 }
22727 jjtree.closeNodeScope(jjtn000, true);
22728 jjtc000 = false;
22729 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
22730 } catch (Throwable jjte000) {
22731 if (jjtc000) {
22732 jjtree.clearNodeScope(jjtn000);
22733 jjtc000 = false;
22734 } else {
22735 jjtree.popNode();
22736 }
22737 if (jjte000 instanceof RuntimeException) {
22738 {if (true) throw (RuntimeException)jjte000;}
22739 }
22740 if (jjte000 instanceof ParseException) {
22741 {if (true) throw (ParseException)jjte000;}
22742 }
22743 {if (true) throw (Error)jjte000;}
22744 } finally {
22745 if (jjtc000) {
22746 jjtree.closeNodeScope(jjtn000, true);
22747 }
22748 }
22749 throw new Error("Missing return statement in function");
22750 }
22751
22752 final public ASTViewColumn ViewColumn() throws ParseException {
22753
22754 ASTViewColumn jjtn000 = new ASTViewColumn(this, JJTVIEWCOLUMN);
22755 boolean jjtc000 = true;
22756 jjtree.openNodeScope(jjtn000);
22757 try {
22758 ID();
22759 jjtree.closeNodeScope(jjtn000, true);
22760 jjtc000 = false;
22761 {if (true) return jjtn000 ;}
22762 } catch (Throwable jjte000) {
22763 if (jjtc000) {
22764 jjtree.clearNodeScope(jjtn000);
22765 jjtc000 = false;
22766 } else {
22767 jjtree.popNode();
22768 }
22769 if (jjte000 instanceof RuntimeException) {
22770 {if (true) throw (RuntimeException)jjte000;}
22771 }
22772 if (jjte000 instanceof ParseException) {
22773 {if (true) throw (ParseException)jjte000;}
22774 }
22775 {if (true) throw (Error)jjte000;}
22776 } finally {
22777 if (jjtc000) {
22778 jjtree.closeNodeScope(jjtn000, true);
22779 }
22780 }
22781 throw new Error("Missing return statement in function");
22782 }
22783
22784 final public ASTComment Comment() throws ParseException {
22785
22786 ASTComment jjtn000 = new ASTComment(this, JJTCOMMENT);
22787 boolean jjtc000 = true;
22788 jjtree.openNodeScope(jjtn000);
22789 try {
22790 jj_consume_token(COMMENT);
22791 jj_consume_token(ON);
22792 switch (jj_nt.kind) {
22793 case INDEXTYPE:
22794 case OPERATOR:
22795 case TABLE:
22796 switch (jj_nt.kind) {
22797 case TABLE:
22798 jj_consume_token(TABLE);
22799 break;
22800 case OPERATOR:
22801 jj_consume_token(OPERATOR);
22802 break;
22803 case INDEXTYPE:
22804 jj_consume_token(INDEXTYPE);
22805 break;
22806 default:
22807 jj_la1[309] = jj_gen;
22808 jj_consume_token(-1);
22809 throw new ParseException();
22810 }
22811 if (jj_2_59(2)) {
22812 ID();
22813 jj_consume_token(3);
22814 } else {
22815 ;
22816 }
22817 ID();
22818 break;
22819 case COLUMN:
22820 jj_consume_token(COLUMN);
22821 if (jj_2_60(2147483647)) {
22822 ID();
22823 jj_consume_token(3);
22824 } else {
22825 ;
22826 }
22827 ID();
22828 jj_consume_token(3);
22829 ID();
22830 break;
22831 default:
22832 jj_la1[310] = jj_gen;
22833 jj_consume_token(-1);
22834 throw new ParseException();
22835 }
22836 jj_consume_token(IS);
22837 jj_consume_token(STRING_LITERAL);
22838 switch (jj_nt.kind) {
22839 case 4:
22840 jj_consume_token(4);
22841 break;
22842 default:
22843 jj_la1[311] = jj_gen;
22844 ;
22845 }
22846 jjtree.closeNodeScope(jjtn000, true);
22847 jjtc000 = false;
22848 {if (true) return jjtn000 ;}
22849 } catch (Throwable jjte000) {
22850 if (jjtc000) {
22851 jjtree.clearNodeScope(jjtn000);
22852 jjtc000 = false;
22853 } else {
22854 jjtree.popNode();
22855 }
22856 if (jjte000 instanceof RuntimeException) {
22857 {if (true) throw (RuntimeException)jjte000;}
22858 }
22859 if (jjte000 instanceof ParseException) {
22860 {if (true) throw (ParseException)jjte000;}
22861 }
22862 {if (true) throw (Error)jjte000;}
22863 } finally {
22864 if (jjtc000) {
22865 jjtree.closeNodeScope(jjtn000, true);
22866 }
22867 }
22868 throw new Error("Missing return statement in function");
22869 }
22870
22871
22872 final public ASTTypeMethod TypeMethod() throws ParseException {
22873
22874 ASTTypeMethod jjtn000 = new ASTTypeMethod(this, JJTTYPEMETHOD);
22875 boolean jjtc000 = true;
22876 jjtree.openNodeScope(jjtn000);
22877 try {
22878 getToken(1);
22879
22880
22881 label_72:
22882 while (true) {
22883 switch (jj_nt.kind) {
22884 case FINAL:
22885 case INSTANTIABLE:
22886 case NOT:
22887 case OVERRIDING:
22888 ;
22889 break;
22890 default:
22891 jj_la1[312] = jj_gen;
22892 break label_72;
22893 }
22894 switch (jj_nt.kind) {
22895 case NOT:
22896 jj_consume_token(NOT);
22897 break;
22898 default:
22899 jj_la1[313] = jj_gen;
22900 ;
22901 }
22902 switch (jj_nt.kind) {
22903 case OVERRIDING:
22904 jj_consume_token(OVERRIDING);
22905 break;
22906 case INSTANTIABLE:
22907 jj_consume_token(INSTANTIABLE);
22908 break;
22909 case FINAL:
22910 jj_consume_token(FINAL);
22911 break;
22912 default:
22913 jj_la1[314] = jj_gen;
22914 jj_consume_token(-1);
22915 throw new ParseException();
22916 }
22917 }
22918 switch (jj_nt.kind) {
22919 case MAP:
22920 case ORDER:
22921 switch (jj_nt.kind) {
22922 case MAP:
22923 jj_consume_token(MAP);
22924 break;
22925 case ORDER:
22926 jj_consume_token(ORDER);
22927 break;
22928 default:
22929 jj_la1[315] = jj_gen;
22930 jj_consume_token(-1);
22931 throw new ParseException();
22932 }
22933 break;
22934 default:
22935 jj_la1[316] = jj_gen;
22936 ;
22937 }
22938 switch (jj_nt.kind) {
22939 case CONSTRUCTOR:
22940 jj_consume_token(CONSTRUCTOR);
22941 break;
22942 case MEMBER:
22943 jj_consume_token(MEMBER);
22944 break;
22945 case STATIC:
22946 jj_consume_token(STATIC);
22947 break;
22948 default:
22949 jj_la1[317] = jj_gen;
22950 jj_consume_token(-1);
22951 throw new ParseException();
22952 }
22953 MethodDeclarator();
22954 switch (jj_nt.kind) {
22955 case DETERMINISTIC:
22956 jj_consume_token(DETERMINISTIC);
22957 break;
22958 default:
22959 jj_la1[318] = jj_gen;
22960 ;
22961 }
22962 switch (jj_nt.kind) {
22963 case PARALLEL_ENABLE:
22964 jj_consume_token(PARALLEL_ENABLE);
22965 break;
22966 default:
22967 jj_la1[319] = jj_gen;
22968 ;
22969 }
22970 switch (jj_nt.kind) {
22971 case PIPELINED:
22972 jj_consume_token(PIPELINED);
22973 break;
22974 default:
22975 jj_la1[320] = jj_gen;
22976 ;
22977 }
22978 switch (jj_nt.kind) {
22979 case RESULT_CACHE:
22980 jj_consume_token(RESULT_CACHE);
22981 break;
22982 default:
22983 jj_la1[321] = jj_gen;
22984 ;
22985 }
22986 switch (jj_nt.kind) {
22987 case AS:
22988 case IS:
22989 switch (jj_nt.kind) {
22990 case IS:
22991 jj_consume_token(IS);
22992 break;
22993 case AS:
22994 jj_consume_token(AS);
22995 break;
22996 default:
22997 jj_la1[322] = jj_gen;
22998 jj_consume_token(-1);
22999 throw new ParseException();
23000 }
23001 switch (jj_nt.kind) {
23002 case LANGUAGE:
23003 case EXTERNAL:
23004 CallSpecTail();
23005 switch (jj_nt.kind) {
23006 case 4:
23007 jj_consume_token(4);
23008 break;
23009 default:
23010 jj_la1[323] = jj_gen;
23011 ;
23012 }
23013 break;
23014 case REPLACE:
23015 case DEFINER:
23016 case CURRENT_USER:
23017 case SERIALLY_REUSABLE:
23018 case RESTRICT_REFERENCES:
23019 case EXCEPTION_INIT:
23020 case AUTONOMOUS_TRANSACTION:
23021 case INLINE:
23022 case ADD:
23023 case AGGREGATE:
23024 case ALL:
23025 case ALTER:
23026 case AND:
23027 case ANY:
23028 case ARRAY:
23029 case AS:
23030 case ASC:
23031 case AT:
23032 case ATTRIBUTE:
23033 case AUTHID:
23034 case AVG:
23035 case BEGIN:
23036 case BETWEEN:
23037 case BINARY_INTEGER:
23038 case BODY:
23039 case BOOLEAN:
23040 case BULK:
23041 case BY:
23042 case BYTE:
23043 case CASCADE:
23044 case CASE:
23045 case CHAR:
23046 case CHAR_BASE:
23047 case CHECK:
23048 case CLOSE:
23049 case CLUSTER:
23050 case COALESCE:
23051 case COLLECT:
23052 case COLUMN:
23053 case COMMENT:
23054 case COMMIT:
23055 case COMPRESS:
23056 case CONNECT:
23057 case CONSTANT:
23058 case CONSTRUCTOR:
23059 case CONTINUE:
23060 case CONVERT:
23061 case CREATE:
23062 case CURRENT:
23063 case CURRVAL:
23064 case CURSOR:
23065 case DATA:
23066 case DATE:
23067 case DAY:
23068 case DECLARE:
23069 case DECIMAL:
23070 case _DEFAULT:
23071 case DELETE:
23072 case DESC:
23073 case DISABLE:
23074 case DISTINCT:
23075 case DO:
23076 case DROP:
23077 case EDITIONABLE:
23078 case ELEMENT:
23079 case ELSE:
23080 case ELSIF:
23081 case ENABLE:
23082 case ESCAPE:
23083 case EXCEPT:
23084 case EXCEPTION:
23085 case EXCEPTIONS:
23086 case EXCLUSIVE:
23087 case EXECUTE:
23088 case EXISTS:
23089 case EXIT:
23090 case EXTENDS:
23091 case EXTRACT:
23092 case FALSE:
23093 case FETCH:
23094 case FINAL:
23095 case FLOAT:
23096 case FOR:
23097 case FORALL:
23098 case FORCE:
23099 case FROM:
23100 case FUNCTION:
23101 case GLOBAL:
23102 case GOTO:
23103 case GROUP:
23104 case HASH:
23105 case HAVING:
23106 case HEAP:
23107 case HOUR:
23108 case IF:
23109 case IMMEDIATE:
23110 case IN:
23111 case INDEX:
23112 case INDICES:
23113 case INDEXTYPE:
23114 case INDICATOR:
23115 case INSERT:
23116 case INSTANTIABLE:
23117 case INTEGER:
23118 case INTERFACE:
23119 case INTERSECT:
23120 case INTERVAL:
23121 case INTO:
23122 case INVALIDATE:
23123 case IS:
23124 case ISOLATION:
23125 case JAVA:
23126 case LEVEL:
23127 case LIKE:
23128 case LIMIT:
23129 case LIMITED:
23130 case LOCK:
23131 case LONG:
23132 case LOOP:
23133 case MAP:
23134 case MAX:
23135 case MEMBER:
23136 case MERGE:
23137 case MIN:
23138 case MINUS:
23139 case MINUTE:
23140 case MLSLABEL:
23141 case MODIFY:
23142 case MOD:
23143 case MODE:
23144 case MONTH:
23145 case NATURAL:
23146 case NATURALN:
23147 case NEW:
23148 case NEXTVAL:
23149 case NO:
23150 case NOCOPY:
23151 case NONEDITIONABLE:
23152 case NOT:
23153 case NOWAIT:
23154 case NULL:
23155 case NULLIF:
23156 case NUMBER:
23157 case BFILE_BASE:
23158 case BLOB_BASE:
23159 case CLOB_BASE:
23160 case DATE_BASE:
23161 case NUMBER_BASE:
23162 case OBJECT:
23163 case OCIROWID:
23164 case OF:
23165 case OID:
23166 case ON:
23167 case OPAQUE:
23168 case OPEN:
23169 case OPERATOR:
23170 case OPTION:
23171 case OR:
23172 case ORDER:
23173 case ORGANIZATION:
23174 case OTHERS:
23175 case OUT:
23176 case OVERRIDING:
23177 case PACKAGE:
23178 case PARTITION:
23179 case PCTFREE:
23180 case PLS_INTEGER:
23181 case POSITIVE:
23182 case POSITIVEN:
23183 case PRAGMA:
23184 case PRESERVE:
23185 case PRIOR:
23186 case PROMPT:
23187 case PRIVATE:
23188 case PROCEDURE:
23189 case PUBLIC:
23190 case RAISE:
23191 case RANGE:
23192 case RAW:
23193 case REAL:
23194 case RECORD:
23195 case REF:
23196 case RELEASE:
23197 case RELIES_ON:
23198 case RENAME:
23199 case RESULT:
23200 case RETURN:
23201 case RETURNING:
23202 case REVERSE:
23203 case ROLLBACK:
23204 case ROW:
23205 case ROWS:
23206 case ROWID:
23207 case ROWNUM:
23208 case ROWTYPE:
23209 case SAVE:
23210 case SAVEPOINT:
23211 case SECOND:
23212 case SELECT:
23213 case SELF:
23214 case SEPARATE:
23215 case SET:
23216 case SHARE:
23217 case SMALLINT:
23218 case SPACE:
23219 case SQL:
23220 case SQLCODE:
23221 case SQLERRM:
23222 case START:
23223 case STATIC:
23224 case STDDEV:
23225 case SUBTYPE:
23226 case SUBSTITUTABLE:
23227 case SUCCESSFUL:
23228 case SUM:
23229 case SYNONYM:
23230 case SYSDATE:
23231 case SYS_REFCURSOR:
23232 case TABLE:
23233 case TEMPORARY:
23234 case THEN:
23235 case TIME:
23236 case TIMESTAMP:
23237 case TIMEZONE_REGION:
23238 case TIMEZONE_ABBR:
23239 case TIMEZONE_MINUTE:
23240 case TIMEZONE_HOUR:
23241 case TO:
23242 case TRANSACTION:
23243 case TRIGGER:
23244 case TRUE:
23245 case TYPE:
23246 case UI:
23247 case UNDER:
23248 case USING:
23249 case WHILE:
23250 case YES:
23251 case SHOW:
23252 case A:
23253 case UPDATE:
23254 case VARCHAR:
23255 case VARCHAR2:
23256 case DOUBLE:
23257 case DEC:
23258 case PRECISION:
23259 case INT:
23260 case NUMERIC:
23261 case SIGNTYPE:
23262 case NCHAR:
23263 case NVARCHAR2:
23264 case STRING:
23265 case UROWID:
23266 case VARRAY:
23267 case VARYING:
23268 case BFILE:
23269 case BLOB:
23270 case CLOB:
23271 case NCLOB:
23272 case YEAR:
23273 case LOCAL:
23274 case WITH:
23275 case ZONE:
23276 case CHARACTER:
23277 case AFTER:
23278 case BEFORE:
23279 case OLD:
23280 case PARENT:
23281 case CC_IF:
23282 case ANALYZE:
23283 case ASSOCIATE:
23284 case AUDIT:
23285 case COMPOUND:
23286 case DATABASE:
23287 case CALL:
23288 case DDL:
23289 case DISASSOCIATE:
23290 case EACH:
23291 case FOLLOWS:
23292 case LOGOFF:
23293 case LOGON:
23294 case NESTED:
23295 case NOAUDIT:
23296 case SCHEMA:
23297 case SERVERERROR:
23298 case SHUTDOWN:
23299 case STARTUP:
23300 case STATEMENT:
23301 case STATISTICS:
23302 case SUSPEND:
23303 case TRUNCATE:
23304 case WRAPPED:
23305 case LIBRARY:
23306 case NAME:
23307 case STRUCT:
23308 case CONTEXT:
23309 case PARAMETERS:
23310 case LENGTH:
23311 case TDO:
23312 case MAXLEN:
23313 case CHARSETID:
23314 case CHARSETFORM:
23315 case ACCEPT:
23316 case ACCESSIBLE:
23317 case COPY:
23318 case DEFINE:
23319 case DISCONNECT:
23320 case HOST:
23321 case PRINT:
23322 case QUIT:
23323 case REMARK:
23324 case UNDEFINE:
23325 case VARIABLE:
23326 case WHENEVER:
23327 case ATTACH:
23328 case CAST:
23329 case TREAT:
23330 case TRIM:
23331 case LEFT:
23332 case RIGHT:
23333 case BOTH:
23334 case EMPTY:
23335 case MULTISET:
23336 case SUBMULTISET:
23337 case LEADING:
23338 case TRAILING:
23339 case CHAR_CS:
23340 case NCHAR_CS:
23341 case DBTIMEZONE:
23342 case SESSIONTIMEZONE:
23343 case AUTHENTICATED:
23344 case LINK:
23345 case SHARED:
23346 case DIRECTORY:
23347 case USER:
23348 case IDENTIFIER:
23349 case QUOTED_LITERAL:
23350 case SQLDATA_CLASS:
23351 case CUSTOMDATUM_CLASS:
23352 case ORADATA_CLASS:
23353 case JAVA_INTERFACE_CLASS:
23354 DeclarativeSection();
23355 jj_consume_token(BEGIN);
23356 label_73:
23357 while (true) {
23358 switch (jj_nt.kind) {
23359 case 5:
23360 case 16:
23361 case 17:
23362 case 21:
23363 case REPLACE:
23364 case DEFINER:
23365 case CURRENT_USER:
23366 case LANGUAGE:
23367 case INLINE:
23368 case ADD:
23369 case AGGREGATE:
23370 case ARRAY:
23371 case AT:
23372 case ATTRIBUTE:
23373 case AUTHID:
23374 case BEGIN:
23375 case BODY:
23376 case BULK:
23377 case BYTE:
23378 case CASCADE:
23379 case CASE:
23380 case CLOSE:
23381 case COALESCE:
23382 case COLLECT:
23383 case COLUMN:
23384 case COMMENT:
23385 case COMMIT:
23386 case CONSTRUCTOR:
23387 case CONTINUE:
23388 case CONVERT:
23389 case CURRENT:
23390 case CURSOR:
23391 case DATA:
23392 case DATE:
23393 case DAY:
23394 case DECLARE:
23395 case DELETE:
23396 case DISABLE:
23397 case EDITIONABLE:
23398 case ELEMENT:
23399 case ENABLE:
23400 case ESCAPE:
23401 case EXCEPT:
23402 case EXCEPTIONS:
23403 case EXECUTE:
23404 case EXIT:
23405 case EXTERNAL:
23406 case EXTENDS:
23407 case EXTRACT:
23408 case FALSE:
23409 case FETCH:
23410 case FINAL:
23411 case FOR:
23412 case FORALL:
23413 case FORCE:
23414 case FUNCTION:
23415 case GLOBAL:
23416 case GOTO:
23417 case HASH:
23418 case HEAP:
23419 case HOUR:
23420 case IF:
23421 case IMMEDIATE:
23422 case INDICES:
23423 case INDEXTYPE:
23424 case INDICATOR:
23425 case INSERT:
23426 case INSTANTIABLE:
23427 case INTERVAL:
23428 case INVALIDATE:
23429 case ISOLATION:
23430 case JAVA:
23431 case LEVEL:
23432 case LIMIT:
23433 case LOCK:
23434 case LOOP:
23435 case MAP:
23436 case MAX:
23437 case MEMBER:
23438 case MERGE:
23439 case MIN:
23440 case MINUTE:
23441 case MLSLABEL:
23442 case MODIFY:
23443 case MOD:
23444 case MONTH:
23445 case NATURAL:
23446 case NEW:
23447 case NEW_DOT:
23448 case NO:
23449 case NONEDITIONABLE:
23450 case NOT:
23451 case NULL:
23452 case NULLIF:
23453 case OBJECT:
23454 case OID:
23455 case OPAQUE:
23456 case OPEN:
23457 case OPERATOR:
23458 case ORGANIZATION:
23459 case OTHERS:
23460 case OVERRIDING:
23461 case PACKAGE:
23462 case PARTITION:
23463 case PIPE:
23464 case PRAGMA:
23465 case PRESERVE:
23466 case PRIVATE:
23467 case PROCEDURE:
23468 case RAISE:
23469 case RANGE:
23470 case RAW:
23471 case REAL:
23472 case RECORD:
23473 case REF:
23474 case RELEASE:
23475 case RELIES_ON:
23476 case RENAME:
23477 case RESULT:
23478 case RETURN:
23479 case RETURNING:
23480 case REVERSE:
23481 case ROLLBACK:
23482 case ROW:
23483 case ROWS:
23484 case ROWID:
23485 case ROWNUM:
23486 case SAVE:
23487 case SAVEPOINT:
23488 case SECOND:
23489 case SELECT:
23490 case SELF:
23491 case SET:
23492 case SPACE:
23493 case SQL:
23494 case SQLCODE:
23495 case SQLERRM:
23496 case STATIC:
23497 case SUBTYPE:
23498 case SUBSTITUTABLE:
23499 case SUCCESSFUL:
23500 case SYSDATE:
23501 case SYS_REFCURSOR:
23502 case TEMPORARY:
23503 case TIME:
23504 case TIMESTAMP:
23505 case TIMEZONE_REGION:
23506 case TIMEZONE_ABBR:
23507 case TIMEZONE_MINUTE:
23508 case TIMEZONE_HOUR:
23509 case TRANSACTION:
23510 case TRUE:
23511 case TYPE:
23512 case UNDER:
23513 case USING:
23514 case WHILE:
23515 case YES:
23516 case SHOW:
23517 case A:
23518 case UPDATE:
23519 case DOUBLE:
23520 case DEC:
23521 case PRECISION:
23522 case INT:
23523 case NUMERIC:
23524 case NCHAR:
23525 case NVARCHAR2:
23526 case STRING:
23527 case UROWID:
23528 case VARRAY:
23529 case VARYING:
23530 case BFILE:
23531 case BLOB:
23532 case CLOB:
23533 case NCLOB:
23534 case YEAR:
23535 case LOCAL:
23536 case WITH:
23537 case ZONE:
23538 case CHARACTER:
23539 case AFTER:
23540 case BEFORE:
23541 case OLD:
23542 case PARENT:
23543 case CC_IF:
23544 case CC_ERROR:
23545 case ANALYZE:
23546 case ASSOCIATE:
23547 case AUDIT:
23548 case COMPOUND:
23549 case DATABASE:
23550 case CALL:
23551 case DDL:
23552 case DISASSOCIATE:
23553 case EACH:
23554 case FOLLOWS:
23555 case LOGOFF:
23556 case LOGON:
23557 case NESTED:
23558 case NOAUDIT:
23559 case SCHEMA:
23560 case SERVERERROR:
23561 case SHUTDOWN:
23562 case STARTUP:
23563 case STATEMENT:
23564 case STATISTICS:
23565 case SUSPEND:
23566 case TRUNCATE:
23567 case WRAPPED:
23568 case LIBRARY:
23569 case NAME:
23570 case STRUCT:
23571 case CONTEXT:
23572 case PARAMETERS:
23573 case LENGTH:
23574 case TDO:
23575 case MAXLEN:
23576 case CHARSETID:
23577 case CHARSETFORM:
23578 case ACCEPT:
23579 case ACCESSIBLE:
23580 case COPY:
23581 case DEFINE:
23582 case DISCONNECT:
23583 case HOST:
23584 case PRINT:
23585 case QUIT:
23586 case REMARK:
23587 case UNDEFINE:
23588 case VARIABLE:
23589 case WHENEVER:
23590 case ATTACH:
23591 case CAST:
23592 case TREAT:
23593 case TRIM:
23594 case LEFT:
23595 case RIGHT:
23596 case BOTH:
23597 case EMPTY:
23598 case MULTISET:
23599 case SUBMULTISET:
23600 case LEADING:
23601 case TRAILING:
23602 case CHAR_CS:
23603 case NCHAR_CS:
23604 case DBTIMEZONE:
23605 case SESSIONTIMEZONE:
23606 case AUTHENTICATED:
23607 case LINK:
23608 case SHARED:
23609 case DIRECTORY:
23610 case USER:
23611 case IDENTIFIER:
23612 case UNSIGNED_NUMERIC_LITERAL:
23613 case CHARACTER_LITERAL:
23614 case STRING_LITERAL:
23615 case QUOTED_LITERAL:
23616 ;
23617 break;
23618 default:
23619 jj_la1[324] = jj_gen;
23620 break label_73;
23621 }
23622 Statement();
23623 }
23624 switch (jj_nt.kind) {
23625 case EXCEPTION:
23626 ExceptionHandler();
23627 break;
23628 default:
23629 jj_la1[325] = jj_gen;
23630 ;
23631 }
23632 jj_consume_token(END);
23633 switch (jj_nt.kind) {
23634 case REPLACE:
23635 case DEFINER:
23636 case CURRENT_USER:
23637 case SERIALLY_REUSABLE:
23638 case RESTRICT_REFERENCES:
23639 case EXCEPTION_INIT:
23640 case AUTONOMOUS_TRANSACTION:
23641 case LANGUAGE:
23642 case INLINE:
23643 case ADD:
23644 case AGGREGATE:
23645 case ALL:
23646 case ALTER:
23647 case AND:
23648 case ANY:
23649 case ARRAY:
23650 case AS:
23651 case ASC:
23652 case AT:
23653 case ATTRIBUTE:
23654 case AUTHID:
23655 case AVG:
23656 case BETWEEN:
23657 case BINARY_INTEGER:
23658 case BODY:
23659 case BOOLEAN:
23660 case BULK:
23661 case BY:
23662 case BYTE:
23663 case CASCADE:
23664 case CASE:
23665 case CHAR:
23666 case CHAR_BASE:
23667 case CHECK:
23668 case CLOSE:
23669 case CLUSTER:
23670 case COALESCE:
23671 case COLLECT:
23672 case COLUMN:
23673 case COMMENT:
23674 case COMMIT:
23675 case COMPRESS:
23676 case CONNECT:
23677 case CONSTANT:
23678 case CONSTRUCTOR:
23679 case CONTINUE:
23680 case CONVERT:
23681 case CREATE:
23682 case CURRENT:
23683 case CURRVAL:
23684 case CURSOR:
23685 case DATA:
23686 case DATE:
23687 case DAY:
23688 case DECLARE:
23689 case DECIMAL:
23690 case _DEFAULT:
23691 case DELETE:
23692 case DESC:
23693 case DISABLE:
23694 case DISTINCT:
23695 case DO:
23696 case DROP:
23697 case EDITIONABLE:
23698 case ELEMENT:
23699 case ELSE:
23700 case ELSIF:
23701 case ENABLE:
23702 case ESCAPE:
23703 case EXCEPT:
23704 case EXCEPTION:
23705 case EXCEPTIONS:
23706 case EXCLUSIVE:
23707 case EXECUTE:
23708 case EXISTS:
23709 case EXIT:
23710 case EXTERNAL:
23711 case EXTENDS:
23712 case EXTRACT:
23713 case FALSE:
23714 case FETCH:
23715 case FINAL:
23716 case FLOAT:
23717 case FOR:
23718 case FORALL:
23719 case FORCE:
23720 case FROM:
23721 case FUNCTION:
23722 case GLOBAL:
23723 case GOTO:
23724 case GROUP:
23725 case HASH:
23726 case HAVING:
23727 case HEAP:
23728 case HOUR:
23729 case IF:
23730 case IMMEDIATE:
23731 case IN:
23732 case INDEX:
23733 case INDICES:
23734 case INDEXTYPE:
23735 case INDICATOR:
23736 case INSERT:
23737 case INSTANTIABLE:
23738 case INTEGER:
23739 case INTERFACE:
23740 case INTERSECT:
23741 case INTERVAL:
23742 case INTO:
23743 case INVALIDATE:
23744 case IS:
23745 case ISOLATION:
23746 case JAVA:
23747 case LEVEL:
23748 case LIKE:
23749 case LIMIT:
23750 case LIMITED:
23751 case LOCK:
23752 case LONG:
23753 case LOOP:
23754 case MAP:
23755 case MAX:
23756 case MEMBER:
23757 case MERGE:
23758 case MIN:
23759 case MINUS:
23760 case MINUTE:
23761 case MLSLABEL:
23762 case MODIFY:
23763 case MOD:
23764 case MODE:
23765 case MONTH:
23766 case NATURAL:
23767 case NATURALN:
23768 case NEW:
23769 case NEXTVAL:
23770 case NO:
23771 case NOCOPY:
23772 case NONEDITIONABLE:
23773 case NOT:
23774 case NOWAIT:
23775 case NULL:
23776 case NULLIF:
23777 case NUMBER:
23778 case BFILE_BASE:
23779 case BLOB_BASE:
23780 case CLOB_BASE:
23781 case DATE_BASE:
23782 case NUMBER_BASE:
23783 case OBJECT:
23784 case OCIROWID:
23785 case OF:
23786 case OID:
23787 case ON:
23788 case OPAQUE:
23789 case OPEN:
23790 case OPERATOR:
23791 case OPTION:
23792 case OR:
23793 case ORDER:
23794 case ORGANIZATION:
23795 case OTHERS:
23796 case OUT:
23797 case OVERRIDING:
23798 case PACKAGE:
23799 case PARTITION:
23800 case PCTFREE:
23801 case PLS_INTEGER:
23802 case POSITIVE:
23803 case POSITIVEN:
23804 case PRESERVE:
23805 case PRIOR:
23806 case PROMPT:
23807 case PRIVATE:
23808 case PROCEDURE:
23809 case PUBLIC:
23810 case RAISE:
23811 case RANGE:
23812 case RAW:
23813 case REAL:
23814 case RECORD:
23815 case REF:
23816 case RELEASE:
23817 case RELIES_ON:
23818 case RENAME:
23819 case RESULT:
23820 case RETURN:
23821 case RETURNING:
23822 case REVERSE:
23823 case ROLLBACK:
23824 case ROW:
23825 case ROWS:
23826 case ROWID:
23827 case ROWNUM:
23828 case ROWTYPE:
23829 case SAVE:
23830 case SAVEPOINT:
23831 case SECOND:
23832 case SELECT:
23833 case SELF:
23834 case SEPARATE:
23835 case SET:
23836 case SHARE:
23837 case SMALLINT:
23838 case SPACE:
23839 case SQL:
23840 case SQLCODE:
23841 case SQLERRM:
23842 case START:
23843 case STATIC:
23844 case STDDEV:
23845 case SUBTYPE:
23846 case SUBSTITUTABLE:
23847 case SUCCESSFUL:
23848 case SUM:
23849 case SYNONYM:
23850 case SYSDATE:
23851 case SYS_REFCURSOR:
23852 case TABLE:
23853 case TEMPORARY:
23854 case THEN:
23855 case TIME:
23856 case TIMESTAMP:
23857 case TIMEZONE_REGION:
23858 case TIMEZONE_ABBR:
23859 case TIMEZONE_MINUTE:
23860 case TIMEZONE_HOUR:
23861 case TO:
23862 case TRANSACTION:
23863 case TRIGGER:
23864 case TRUE:
23865 case TYPE:
23866 case UI:
23867 case UNDER:
23868 case USING:
23869 case WHILE:
23870 case YES:
23871 case SHOW:
23872 case A:
23873 case UPDATE:
23874 case VARCHAR:
23875 case VARCHAR2:
23876 case DOUBLE:
23877 case DEC:
23878 case PRECISION:
23879 case INT:
23880 case NUMERIC:
23881 case SIGNTYPE:
23882 case NCHAR:
23883 case NVARCHAR2:
23884 case STRING:
23885 case UROWID:
23886 case VARRAY:
23887 case VARYING:
23888 case BFILE:
23889 case BLOB:
23890 case CLOB:
23891 case NCLOB:
23892 case YEAR:
23893 case LOCAL:
23894 case WITH:
23895 case ZONE:
23896 case CHARACTER:
23897 case AFTER:
23898 case BEFORE:
23899 case OLD:
23900 case PARENT:
23901 case ANALYZE:
23902 case ASSOCIATE:
23903 case AUDIT:
23904 case COMPOUND:
23905 case DATABASE:
23906 case CALL:
23907 case DDL:
23908 case DISASSOCIATE:
23909 case EACH:
23910 case FOLLOWS:
23911 case LOGOFF:
23912 case LOGON:
23913 case NESTED:
23914 case NOAUDIT:
23915 case SCHEMA:
23916 case SERVERERROR:
23917 case SHUTDOWN:
23918 case STARTUP:
23919 case STATEMENT:
23920 case STATISTICS:
23921 case SUSPEND:
23922 case TRUNCATE:
23923 case WRAPPED:
23924 case LIBRARY:
23925 case NAME:
23926 case STRUCT:
23927 case CONTEXT:
23928 case PARAMETERS:
23929 case LENGTH:
23930 case TDO:
23931 case MAXLEN:
23932 case CHARSETID:
23933 case CHARSETFORM:
23934 case ACCEPT:
23935 case ACCESSIBLE:
23936 case COPY:
23937 case DEFINE:
23938 case DISCONNECT:
23939 case HOST:
23940 case PRINT:
23941 case QUIT:
23942 case REMARK:
23943 case UNDEFINE:
23944 case VARIABLE:
23945 case WHENEVER:
23946 case ATTACH:
23947 case CAST:
23948 case TREAT:
23949 case TRIM:
23950 case LEFT:
23951 case RIGHT:
23952 case BOTH:
23953 case EMPTY:
23954 case MULTISET:
23955 case SUBMULTISET:
23956 case LEADING:
23957 case TRAILING:
23958 case CHAR_CS:
23959 case NCHAR_CS:
23960 case DBTIMEZONE:
23961 case SESSIONTIMEZONE:
23962 case AUTHENTICATED:
23963 case LINK:
23964 case SHARED:
23965 case DIRECTORY:
23966 case USER:
23967 case IDENTIFIER:
23968 case QUOTED_LITERAL:
23969 case SQLDATA_CLASS:
23970 case CUSTOMDATUM_CLASS:
23971 case ORADATA_CLASS:
23972 case JAVA_INTERFACE_CLASS:
23973 ID();
23974 break;
23975 default:
23976 jj_la1[326] = jj_gen;
23977 ;
23978 }
23979 jj_consume_token(4);
23980 break;
23981 default:
23982 jj_la1[327] = jj_gen;
23983 jj_consume_token(-1);
23984 throw new ParseException();
23985 }
23986 break;
23987 default:
23988 jj_la1[328] = jj_gen;
23989 ;
23990 }
23991 jjtree.closeNodeScope(jjtn000, true);
23992 jjtc000 = false;
23993 {if (true) return jjtn000 ;}
23994 } catch (Throwable jjte000) {
23995 if (jjtc000) {
23996 jjtree.clearNodeScope(jjtn000);
23997 jjtc000 = false;
23998 } else {
23999 jjtree.popNode();
24000 }
24001 if (jjte000 instanceof RuntimeException) {
24002 {if (true) throw (RuntimeException)jjte000;}
24003 }
24004 if (jjte000 instanceof ParseException) {
24005 {if (true) throw (ParseException)jjte000;}
24006 }
24007 {if (true) throw (Error)jjte000;}
24008 } finally {
24009 if (jjtc000) {
24010 jjtree.closeNodeScope(jjtn000, true);
24011 }
24012 }
24013 throw new Error("Missing return statement in function");
24014 }
24015
24016 final public ASTTypeSpecification TypeSpecification() throws ParseException {
24017
24018 ASTTypeSpecification jjtn000 = new ASTTypeSpecification(this, JJTTYPESPECIFICATION);
24019 boolean jjtc000 = true;
24020 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
24021 try {
24022 switch (jj_nt.kind) {
24023 case CREATE:
24024 jj_consume_token(CREATE);
24025 switch (jj_nt.kind) {
24026 case OR:
24027 jj_consume_token(OR);
24028 jj_consume_token(REPLACE);
24029 break;
24030 default:
24031 jj_la1[329] = jj_gen;
24032 ;
24033 }
24034 switch (jj_nt.kind) {
24035 case EDITIONABLE:
24036 case NONEDITIONABLE:
24037 switch (jj_nt.kind) {
24038 case EDITIONABLE:
24039 jj_consume_token(EDITIONABLE);
24040 break;
24041 case NONEDITIONABLE:
24042 jj_consume_token(NONEDITIONABLE);
24043 break;
24044 default:
24045 jj_la1[330] = jj_gen;
24046 jj_consume_token(-1);
24047 throw new ParseException();
24048 }
24049 break;
24050 default:
24051 jj_la1[331] = jj_gen;
24052 ;
24053 }
24054 break;
24055 default:
24056 jj_la1[332] = jj_gen;
24057 ;
24058 }
24059 jj_consume_token(TYPE);
24060 simpleNode = ObjectNameDeclaration();
24061 switch (jj_nt.kind) {
24062 case FORCE:
24063 jj_consume_token(FORCE);
24064 break;
24065 default:
24066 jj_la1[333] = jj_gen;
24067 ;
24068 }
24069 if (jj_2_61(2)) {
24070 jj_consume_token(OID);
24071 jj_consume_token(STRING_LITERAL);
24072 } else {
24073 ;
24074 }
24075 label_74:
24076 while (true) {
24077 if (jj_2_62(2)) {
24078 ;
24079 } else {
24080 break label_74;
24081 }
24082 switch (jj_nt.kind) {
24083 case AUTHID:
24084 jj_consume_token(AUTHID);
24085 switch (jj_nt.kind) {
24086 case CURRENT_USER:
24087 jj_consume_token(CURRENT_USER);
24088 break;
24089 case DEFINER:
24090 jj_consume_token(DEFINER);
24091 break;
24092 default:
24093 jj_la1[334] = jj_gen;
24094 jj_consume_token(-1);
24095 throw new ParseException();
24096 }
24097 break;
24098 case ACCESSIBLE:
24099 AccessibleByClause();
24100 break;
24101 default:
24102 jj_la1[335] = jj_gen;
24103 jj_consume_token(-1);
24104 throw new ParseException();
24105 }
24106 }
24107 switch (jj_nt.kind) {
24108 case AS:
24109 case IS:
24110 case UNDER:
24111 switch (jj_nt.kind) {
24112 case UNDER:
24113 jj_consume_token(UNDER);
24114 ObjectNameDeclaration();
24115 break;
24116 default:
24117 jj_la1[342] = jj_gen;
24118 if (jj_2_63(2)) {
24119 switch (jj_nt.kind) {
24120 case IS:
24121 jj_consume_token(IS);
24122 break;
24123 case AS:
24124 jj_consume_token(AS);
24125 break;
24126 default:
24127 jj_la1[336] = jj_gen;
24128 jj_consume_token(-1);
24129 throw new ParseException();
24130 }
24131 jj_consume_token(OBJECT);
24132 } else if (jj_2_64(2)) {
24133 switch (jj_nt.kind) {
24134 case IS:
24135 jj_consume_token(IS);
24136 break;
24137 case AS:
24138 jj_consume_token(AS);
24139 break;
24140 default:
24141 jj_la1[337] = jj_gen;
24142 jj_consume_token(-1);
24143 throw new ParseException();
24144 }
24145 jj_consume_token(OPAQUE);
24146 jj_consume_token(VARYING);
24147 jj_consume_token(24);
24148 jj_consume_token(USING);
24149 jj_consume_token(LIBRARY);
24150 switch (jj_nt.kind) {
24151 case IDENTIFIER:
24152 jj_consume_token(IDENTIFIER);
24153 break;
24154 case QUOTED_LITERAL:
24155 jj_consume_token(QUOTED_LITERAL);
24156 break;
24157 case STRING_LITERAL:
24158 StringLiteral();
24159 break;
24160 default:
24161 jj_la1[338] = jj_gen;
24162 jj_consume_token(-1);
24163 throw new ParseException();
24164 }
24165 switch (jj_nt.kind) {
24166 case 3:
24167 jj_consume_token(3);
24168 switch (jj_nt.kind) {
24169 case IDENTIFIER:
24170 jj_consume_token(IDENTIFIER);
24171 break;
24172 case QUOTED_LITERAL:
24173 jj_consume_token(QUOTED_LITERAL);
24174 break;
24175 case STRING_LITERAL:
24176 StringLiteral();
24177 break;
24178 default:
24179 jj_la1[339] = jj_gen;
24180 jj_consume_token(-1);
24181 throw new ParseException();
24182 }
24183 break;
24184 default:
24185 jj_la1[340] = jj_gen;
24186 ;
24187 }
24188 } else if (jj_2_65(2)) {
24189 switch (jj_nt.kind) {
24190 case IS:
24191 jj_consume_token(IS);
24192 break;
24193 case AS:
24194 jj_consume_token(AS);
24195 break;
24196 default:
24197 jj_la1[341] = jj_gen;
24198 jj_consume_token(-1);
24199 throw new ParseException();
24200 }
24201 CollectionTypeName();
24202 jj_consume_token(OF);
24203 Datatype();
24204 } else {
24205 jj_consume_token(-1);
24206 throw new ParseException();
24207 }
24208 }
24209 break;
24210 default:
24211 jj_la1[343] = jj_gen;
24212 ;
24213 }
24214 if (jj_2_66(8)) {
24215 jj_consume_token(EXTERNAL);
24216 jj_consume_token(IDENTIFIER);
24217 jj_consume_token(IDENTIFIER);
24218 jj_consume_token(LANGUAGE);
24219 jj_consume_token(JAVA);
24220 jj_consume_token(USING);
24221 jj_consume_token(IDENTIFIER);
24222 } else {
24223 ;
24224 }
24225 switch (jj_nt.kind) {
24226 case WRAPPED:
24227 WrappedObject();
24228 break;
24229 default:
24230 jj_la1[344] = jj_gen;
24231 ;
24232 }
24233 switch (jj_nt.kind) {
24234 case 5:
24235 jj_consume_token(5);
24236 label_75:
24237 while (true) {
24238 switch (jj_nt.kind) {
24239 case REPLACE:
24240 case DEFINER:
24241 case CURRENT_USER:
24242 case SERIALLY_REUSABLE:
24243 case RESTRICT_REFERENCES:
24244 case EXCEPTION_INIT:
24245 case AUTONOMOUS_TRANSACTION:
24246 case LANGUAGE:
24247 case INLINE:
24248 case ADD:
24249 case AGGREGATE:
24250 case ALL:
24251 case ALTER:
24252 case AND:
24253 case ANY:
24254 case ARRAY:
24255 case AS:
24256 case ASC:
24257 case AT:
24258 case ATTRIBUTE:
24259 case AUTHID:
24260 case AVG:
24261 case BETWEEN:
24262 case BINARY_INTEGER:
24263 case BODY:
24264 case BOOLEAN:
24265 case BULK:
24266 case BY:
24267 case BYTE:
24268 case CASCADE:
24269 case CASE:
24270 case CHAR:
24271 case CHAR_BASE:
24272 case CHECK:
24273 case CLOSE:
24274 case CLUSTER:
24275 case COALESCE:
24276 case COLLECT:
24277 case COLUMN:
24278 case COMMENT:
24279 case COMMIT:
24280 case COMPRESS:
24281 case CONNECT:
24282 case CONSTANT:
24283 case CONSTRUCTOR:
24284 case CONTINUE:
24285 case CONVERT:
24286 case CREATE:
24287 case CURRENT:
24288 case CURRVAL:
24289 case CURSOR:
24290 case DATA:
24291 case DATE:
24292 case DAY:
24293 case DECLARE:
24294 case DECIMAL:
24295 case _DEFAULT:
24296 case DELETE:
24297 case DESC:
24298 case DISABLE:
24299 case DISTINCT:
24300 case DO:
24301 case DROP:
24302 case EDITIONABLE:
24303 case ELEMENT:
24304 case ELSE:
24305 case ELSIF:
24306 case ENABLE:
24307 case ESCAPE:
24308 case EXCEPT:
24309 case EXCEPTION:
24310 case EXCEPTIONS:
24311 case EXCLUSIVE:
24312 case EXECUTE:
24313 case EXISTS:
24314 case EXIT:
24315 case EXTERNAL:
24316 case EXTENDS:
24317 case EXTRACT:
24318 case FALSE:
24319 case FETCH:
24320 case FINAL:
24321 case FLOAT:
24322 case FOR:
24323 case FORALL:
24324 case FORCE:
24325 case FROM:
24326 case FUNCTION:
24327 case GLOBAL:
24328 case GOTO:
24329 case GROUP:
24330 case HASH:
24331 case HAVING:
24332 case HEAP:
24333 case HOUR:
24334 case IF:
24335 case IMMEDIATE:
24336 case IN:
24337 case INDEX:
24338 case INDICES:
24339 case INDEXTYPE:
24340 case INDICATOR:
24341 case INSERT:
24342 case INSTANTIABLE:
24343 case INTEGER:
24344 case INTERFACE:
24345 case INTERSECT:
24346 case INTERVAL:
24347 case INTO:
24348 case INVALIDATE:
24349 case IS:
24350 case ISOLATION:
24351 case JAVA:
24352 case LEVEL:
24353 case LIKE:
24354 case LIMIT:
24355 case LIMITED:
24356 case LOCK:
24357 case LONG:
24358 case LOOP:
24359 case MAP:
24360 case MAX:
24361 case MEMBER:
24362 case MERGE:
24363 case MIN:
24364 case MINUS:
24365 case MINUTE:
24366 case MLSLABEL:
24367 case MODIFY:
24368 case MOD:
24369 case MODE:
24370 case MONTH:
24371 case NATURAL:
24372 case NATURALN:
24373 case NEW:
24374 case NEXTVAL:
24375 case NO:
24376 case NOCOPY:
24377 case NONEDITIONABLE:
24378 case NOT:
24379 case NOWAIT:
24380 case NULL:
24381 case NULLIF:
24382 case NUMBER:
24383 case BFILE_BASE:
24384 case BLOB_BASE:
24385 case CLOB_BASE:
24386 case DATE_BASE:
24387 case NUMBER_BASE:
24388 case OBJECT:
24389 case OCIROWID:
24390 case OF:
24391 case OID:
24392 case ON:
24393 case OPAQUE:
24394 case OPEN:
24395 case OPERATOR:
24396 case OPTION:
24397 case OR:
24398 case ORDER:
24399 case ORGANIZATION:
24400 case OTHERS:
24401 case OUT:
24402 case OVERRIDING:
24403 case PACKAGE:
24404 case PARTITION:
24405 case PCTFREE:
24406 case PLS_INTEGER:
24407 case POSITIVE:
24408 case POSITIVEN:
24409 case PRAGMA:
24410 case PRESERVE:
24411 case PRIOR:
24412 case PROMPT:
24413 case PRIVATE:
24414 case PROCEDURE:
24415 case PUBLIC:
24416 case RAISE:
24417 case RANGE:
24418 case RAW:
24419 case REAL:
24420 case RECORD:
24421 case REF:
24422 case RELEASE:
24423 case RELIES_ON:
24424 case RENAME:
24425 case RESULT:
24426 case RETURN:
24427 case RETURNING:
24428 case REVERSE:
24429 case ROLLBACK:
24430 case ROW:
24431 case ROWS:
24432 case ROWID:
24433 case ROWNUM:
24434 case ROWTYPE:
24435 case SAVE:
24436 case SAVEPOINT:
24437 case SECOND:
24438 case SELECT:
24439 case SELF:
24440 case SEPARATE:
24441 case SET:
24442 case SHARE:
24443 case SMALLINT:
24444 case SPACE:
24445 case SQL:
24446 case SQLCODE:
24447 case SQLERRM:
24448 case START:
24449 case STATIC:
24450 case STDDEV:
24451 case SUBTYPE:
24452 case SUBSTITUTABLE:
24453 case SUCCESSFUL:
24454 case SUM:
24455 case SYNONYM:
24456 case SYSDATE:
24457 case SYS_REFCURSOR:
24458 case TABLE:
24459 case TEMPORARY:
24460 case THEN:
24461 case TIME:
24462 case TIMESTAMP:
24463 case TIMEZONE_REGION:
24464 case TIMEZONE_ABBR:
24465 case TIMEZONE_MINUTE:
24466 case TIMEZONE_HOUR:
24467 case TO:
24468 case TRANSACTION:
24469 case TRIGGER:
24470 case TRUE:
24471 case TYPE:
24472 case UI:
24473 case UNDER:
24474 case USING:
24475 case WHILE:
24476 case YES:
24477 case SHOW:
24478 case A:
24479 case UPDATE:
24480 case VARCHAR:
24481 case VARCHAR2:
24482 case DOUBLE:
24483 case DEC:
24484 case PRECISION:
24485 case INT:
24486 case NUMERIC:
24487 case SIGNTYPE:
24488 case NCHAR:
24489 case NVARCHAR2:
24490 case STRING:
24491 case UROWID:
24492 case VARRAY:
24493 case VARYING:
24494 case BFILE:
24495 case BLOB:
24496 case CLOB:
24497 case NCLOB:
24498 case YEAR:
24499 case LOCAL:
24500 case WITH:
24501 case ZONE:
24502 case CHARACTER:
24503 case AFTER:
24504 case BEFORE:
24505 case OLD:
24506 case PARENT:
24507 case ANALYZE:
24508 case ASSOCIATE:
24509 case AUDIT:
24510 case COMPOUND:
24511 case DATABASE:
24512 case CALL:
24513 case DDL:
24514 case DISASSOCIATE:
24515 case EACH:
24516 case FOLLOWS:
24517 case LOGOFF:
24518 case LOGON:
24519 case NESTED:
24520 case NOAUDIT:
24521 case SCHEMA:
24522 case SERVERERROR:
24523 case SHUTDOWN:
24524 case STARTUP:
24525 case STATEMENT:
24526 case STATISTICS:
24527 case SUSPEND:
24528 case TRUNCATE:
24529 case WRAPPED:
24530 case LIBRARY:
24531 case NAME:
24532 case STRUCT:
24533 case CONTEXT:
24534 case PARAMETERS:
24535 case LENGTH:
24536 case TDO:
24537 case MAXLEN:
24538 case CHARSETID:
24539 case CHARSETFORM:
24540 case ACCEPT:
24541 case ACCESSIBLE:
24542 case COPY:
24543 case DEFINE:
24544 case DISCONNECT:
24545 case HOST:
24546 case PRINT:
24547 case QUIT:
24548 case REMARK:
24549 case UNDEFINE:
24550 case VARIABLE:
24551 case WHENEVER:
24552 case ATTACH:
24553 case CAST:
24554 case TREAT:
24555 case TRIM:
24556 case LEFT:
24557 case RIGHT:
24558 case BOTH:
24559 case EMPTY:
24560 case MULTISET:
24561 case SUBMULTISET:
24562 case LEADING:
24563 case TRAILING:
24564 case CHAR_CS:
24565 case NCHAR_CS:
24566 case DBTIMEZONE:
24567 case SESSIONTIMEZONE:
24568 case AUTHENTICATED:
24569 case LINK:
24570 case SHARED:
24571 case DIRECTORY:
24572 case USER:
24573 case IDENTIFIER:
24574 case QUOTED_LITERAL:
24575 case SQLDATA_CLASS:
24576 case CUSTOMDATUM_CLASS:
24577 case ORADATA_CLASS:
24578 case JAVA_INTERFACE_CLASS:
24579 ;
24580 break;
24581 default:
24582 jj_la1[345] = jj_gen;
24583 break label_75;
24584 }
24585 if (jj_2_67(2)) {
24586 TypeMethod();
24587 } else {
24588 switch (jj_nt.kind) {
24589 case REPLACE:
24590 case DEFINER:
24591 case CURRENT_USER:
24592 case SERIALLY_REUSABLE:
24593 case RESTRICT_REFERENCES:
24594 case EXCEPTION_INIT:
24595 case AUTONOMOUS_TRANSACTION:
24596 case LANGUAGE:
24597 case INLINE:
24598 case ADD:
24599 case AGGREGATE:
24600 case ALL:
24601 case ALTER:
24602 case AND:
24603 case ANY:
24604 case ARRAY:
24605 case AS:
24606 case ASC:
24607 case AT:
24608 case ATTRIBUTE:
24609 case AUTHID:
24610 case AVG:
24611 case BETWEEN:
24612 case BINARY_INTEGER:
24613 case BODY:
24614 case BOOLEAN:
24615 case BULK:
24616 case BY:
24617 case BYTE:
24618 case CASCADE:
24619 case CASE:
24620 case CHAR:
24621 case CHAR_BASE:
24622 case CHECK:
24623 case CLOSE:
24624 case CLUSTER:
24625 case COALESCE:
24626 case COLLECT:
24627 case COLUMN:
24628 case COMMENT:
24629 case COMMIT:
24630 case COMPRESS:
24631 case CONNECT:
24632 case CONSTANT:
24633 case CONSTRUCTOR:
24634 case CONTINUE:
24635 case CONVERT:
24636 case CREATE:
24637 case CURRENT:
24638 case CURRVAL:
24639 case CURSOR:
24640 case DATA:
24641 case DATE:
24642 case DAY:
24643 case DECLARE:
24644 case DECIMAL:
24645 case _DEFAULT:
24646 case DELETE:
24647 case DESC:
24648 case DISABLE:
24649 case DISTINCT:
24650 case DO:
24651 case DROP:
24652 case EDITIONABLE:
24653 case ELEMENT:
24654 case ELSE:
24655 case ELSIF:
24656 case ENABLE:
24657 case ESCAPE:
24658 case EXCEPT:
24659 case EXCEPTION:
24660 case EXCEPTIONS:
24661 case EXCLUSIVE:
24662 case EXECUTE:
24663 case EXISTS:
24664 case EXIT:
24665 case EXTERNAL:
24666 case EXTENDS:
24667 case EXTRACT:
24668 case FALSE:
24669 case FETCH:
24670 case FINAL:
24671 case FLOAT:
24672 case FOR:
24673 case FORALL:
24674 case FORCE:
24675 case FROM:
24676 case FUNCTION:
24677 case GLOBAL:
24678 case GOTO:
24679 case GROUP:
24680 case HASH:
24681 case HAVING:
24682 case HEAP:
24683 case HOUR:
24684 case IF:
24685 case IMMEDIATE:
24686 case IN:
24687 case INDEX:
24688 case INDICES:
24689 case INDEXTYPE:
24690 case INDICATOR:
24691 case INSERT:
24692 case INSTANTIABLE:
24693 case INTEGER:
24694 case INTERFACE:
24695 case INTERSECT:
24696 case INTERVAL:
24697 case INTO:
24698 case INVALIDATE:
24699 case IS:
24700 case ISOLATION:
24701 case JAVA:
24702 case LEVEL:
24703 case LIKE:
24704 case LIMIT:
24705 case LIMITED:
24706 case LOCK:
24707 case LONG:
24708 case LOOP:
24709 case MAP:
24710 case MAX:
24711 case MEMBER:
24712 case MERGE:
24713 case MIN:
24714 case MINUS:
24715 case MINUTE:
24716 case MLSLABEL:
24717 case MODIFY:
24718 case MOD:
24719 case MODE:
24720 case MONTH:
24721 case NATURAL:
24722 case NATURALN:
24723 case NEW:
24724 case NEXTVAL:
24725 case NO:
24726 case NOCOPY:
24727 case NONEDITIONABLE:
24728 case NOT:
24729 case NOWAIT:
24730 case NULL:
24731 case NULLIF:
24732 case NUMBER:
24733 case BFILE_BASE:
24734 case BLOB_BASE:
24735 case CLOB_BASE:
24736 case DATE_BASE:
24737 case NUMBER_BASE:
24738 case OBJECT:
24739 case OCIROWID:
24740 case OF:
24741 case OID:
24742 case ON:
24743 case OPAQUE:
24744 case OPEN:
24745 case OPERATOR:
24746 case OPTION:
24747 case OR:
24748 case ORDER:
24749 case ORGANIZATION:
24750 case OTHERS:
24751 case OUT:
24752 case OVERRIDING:
24753 case PACKAGE:
24754 case PARTITION:
24755 case PCTFREE:
24756 case PLS_INTEGER:
24757 case POSITIVE:
24758 case POSITIVEN:
24759 case PRESERVE:
24760 case PRIOR:
24761 case PROMPT:
24762 case PRIVATE:
24763 case PROCEDURE:
24764 case PUBLIC:
24765 case RAISE:
24766 case RANGE:
24767 case RAW:
24768 case REAL:
24769 case RECORD:
24770 case REF:
24771 case RELEASE:
24772 case RELIES_ON:
24773 case RENAME:
24774 case RESULT:
24775 case RETURN:
24776 case RETURNING:
24777 case REVERSE:
24778 case ROLLBACK:
24779 case ROW:
24780 case ROWS:
24781 case ROWID:
24782 case ROWNUM:
24783 case ROWTYPE:
24784 case SAVE:
24785 case SAVEPOINT:
24786 case SECOND:
24787 case SELECT:
24788 case SELF:
24789 case SEPARATE:
24790 case SET:
24791 case SHARE:
24792 case SMALLINT:
24793 case SPACE:
24794 case SQL:
24795 case SQLCODE:
24796 case SQLERRM:
24797 case START:
24798 case STATIC:
24799 case STDDEV:
24800 case SUBTYPE:
24801 case SUBSTITUTABLE:
24802 case SUCCESSFUL:
24803 case SUM:
24804 case SYNONYM:
24805 case SYSDATE:
24806 case SYS_REFCURSOR:
24807 case TABLE:
24808 case TEMPORARY:
24809 case THEN:
24810 case TIME:
24811 case TIMESTAMP:
24812 case TIMEZONE_REGION:
24813 case TIMEZONE_ABBR:
24814 case TIMEZONE_MINUTE:
24815 case TIMEZONE_HOUR:
24816 case TO:
24817 case TRANSACTION:
24818 case TRIGGER:
24819 case TRUE:
24820 case TYPE:
24821 case UI:
24822 case UNDER:
24823 case USING:
24824 case WHILE:
24825 case YES:
24826 case SHOW:
24827 case A:
24828 case UPDATE:
24829 case VARCHAR:
24830 case VARCHAR2:
24831 case DOUBLE:
24832 case DEC:
24833 case PRECISION:
24834 case INT:
24835 case NUMERIC:
24836 case SIGNTYPE:
24837 case NCHAR:
24838 case NVARCHAR2:
24839 case STRING:
24840 case UROWID:
24841 case VARRAY:
24842 case VARYING:
24843 case BFILE:
24844 case BLOB:
24845 case CLOB:
24846 case NCLOB:
24847 case YEAR:
24848 case LOCAL:
24849 case WITH:
24850 case ZONE:
24851 case CHARACTER:
24852 case AFTER:
24853 case BEFORE:
24854 case OLD:
24855 case PARENT:
24856 case ANALYZE:
24857 case ASSOCIATE:
24858 case AUDIT:
24859 case COMPOUND:
24860 case DATABASE:
24861 case CALL:
24862 case DDL:
24863 case DISASSOCIATE:
24864 case EACH:
24865 case FOLLOWS:
24866 case LOGOFF:
24867 case LOGON:
24868 case NESTED:
24869 case NOAUDIT:
24870 case SCHEMA:
24871 case SERVERERROR:
24872 case SHUTDOWN:
24873 case STARTUP:
24874 case STATEMENT:
24875 case STATISTICS:
24876 case SUSPEND:
24877 case TRUNCATE:
24878 case WRAPPED:
24879 case LIBRARY:
24880 case NAME:
24881 case STRUCT:
24882 case CONTEXT:
24883 case PARAMETERS:
24884 case LENGTH:
24885 case TDO:
24886 case MAXLEN:
24887 case CHARSETID:
24888 case CHARSETFORM:
24889 case ACCEPT:
24890 case ACCESSIBLE:
24891 case COPY:
24892 case DEFINE:
24893 case DISCONNECT:
24894 case HOST:
24895 case PRINT:
24896 case QUIT:
24897 case REMARK:
24898 case UNDEFINE:
24899 case VARIABLE:
24900 case WHENEVER:
24901 case ATTACH:
24902 case CAST:
24903 case TREAT:
24904 case TRIM:
24905 case LEFT:
24906 case RIGHT:
24907 case BOTH:
24908 case EMPTY:
24909 case MULTISET:
24910 case SUBMULTISET:
24911 case LEADING:
24912 case TRAILING:
24913 case CHAR_CS:
24914 case NCHAR_CS:
24915 case DBTIMEZONE:
24916 case SESSIONTIMEZONE:
24917 case AUTHENTICATED:
24918 case LINK:
24919 case SHARED:
24920 case DIRECTORY:
24921 case USER:
24922 case IDENTIFIER:
24923 case QUOTED_LITERAL:
24924 case SQLDATA_CLASS:
24925 case CUSTOMDATUM_CLASS:
24926 case ORADATA_CLASS:
24927 case JAVA_INTERFACE_CLASS:
24928 AttributeDeclaration();
24929 break;
24930 case PRAGMA:
24931 PragmaClause();
24932 break;
24933 default:
24934 jj_la1[346] = jj_gen;
24935 jj_consume_token(-1);
24936 throw new ParseException();
24937 }
24938 }
24939 }
24940 label_76:
24941 while (true) {
24942 switch (jj_nt.kind) {
24943 case 6:
24944 ;
24945 break;
24946 default:
24947 jj_la1[347] = jj_gen;
24948 break label_76;
24949 }
24950 jj_consume_token(6);
24951 switch (jj_nt.kind) {
24952 case CONSTRUCTOR:
24953 case FINAL:
24954 case INSTANTIABLE:
24955 case MAP:
24956 case MEMBER:
24957 case NOT:
24958 case ORDER:
24959 case OVERRIDING:
24960 case STATIC:
24961 TypeMethod();
24962 break;
24963 default:
24964 jj_la1[348] = jj_gen;
24965 if (jj_2_68(2)) {
24966 AttributeDeclaration();
24967 } else {
24968 switch (jj_nt.kind) {
24969 case PRAGMA:
24970 PragmaClause();
24971 break;
24972 default:
24973 jj_la1[349] = jj_gen;
24974 jj_consume_token(-1);
24975 throw new ParseException();
24976 }
24977 }
24978 }
24979 }
24980 jj_consume_token(7);
24981 break;
24982 default:
24983 jj_la1[350] = jj_gen;
24984 ;
24985 }
24986 label_77:
24987 while (true) {
24988 switch (jj_nt.kind) {
24989 case FINAL:
24990 case INSTANTIABLE:
24991 case NOT:
24992 case NULL:
24993 ;
24994 break;
24995 default:
24996 jj_la1[351] = jj_gen;
24997 break label_77;
24998 }
24999 switch (jj_nt.kind) {
25000 case NOT:
25001 jj_consume_token(NOT);
25002 break;
25003 default:
25004 jj_la1[352] = jj_gen;
25005 ;
25006 }
25007 switch (jj_nt.kind) {
25008 case FINAL:
25009 jj_consume_token(FINAL);
25010 break;
25011 case INSTANTIABLE:
25012 jj_consume_token(INSTANTIABLE);
25013 break;
25014 case NULL:
25015 jj_consume_token(NULL);
25016 break;
25017 default:
25018 jj_la1[353] = jj_gen;
25019 jj_consume_token(-1);
25020 throw new ParseException();
25021 }
25022 }
25023 label_78:
25024 while (true) {
25025 switch (jj_nt.kind) {
25026 case ALTER:
25027 ;
25028 break;
25029 default:
25030 jj_la1[354] = jj_gen;
25031 break label_78;
25032 }
25033 AlterTypeSpec();
25034 }
25035 switch (jj_nt.kind) {
25036 case 1:
25037 case 4:
25038 switch (jj_nt.kind) {
25039 case 4:
25040 jj_consume_token(4);
25041 break;
25042 case 1:
25043 jj_consume_token(1);
25044 break;
25045 default:
25046 jj_la1[355] = jj_gen;
25047 jj_consume_token(-1);
25048 throw new ParseException();
25049 }
25050 label_79:
25051 while (true) {
25052 switch (jj_nt.kind) {
25053 case ALTER:
25054 ;
25055 break;
25056 default:
25057 jj_la1[356] = jj_gen;
25058 break label_79;
25059 }
25060 AlterTypeSpec();
25061 switch (jj_nt.kind) {
25062 case 1:
25063 jj_consume_token(1);
25064 break;
25065 case 4:
25066 jj_consume_token(4);
25067 break;
25068 default:
25069 jj_la1[357] = jj_gen;
25070 jj_consume_token(-1);
25071 throw new ParseException();
25072 }
25073 }
25074 break;
25075 default:
25076 jj_la1[358] = jj_gen;
25077 ;
25078 }
25079 jjtree.closeNodeScope(jjtn000, true);
25080 jjtc000 = false;
25081 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
25082 } catch (Throwable jjte000) {
25083 if (jjtc000) {
25084 jjtree.clearNodeScope(jjtn000);
25085 jjtc000 = false;
25086 } else {
25087 jjtree.popNode();
25088 }
25089 if (jjte000 instanceof RuntimeException) {
25090 {if (true) throw (RuntimeException)jjte000;}
25091 }
25092 if (jjte000 instanceof ParseException) {
25093 {if (true) throw (ParseException)jjte000;}
25094 }
25095 {if (true) throw (Error)jjte000;}
25096 } finally {
25097 if (jjtc000) {
25098 jjtree.closeNodeScope(jjtn000, true);
25099 }
25100 }
25101 throw new Error("Missing return statement in function");
25102 }
25103
25104 final public ASTAlterTypeSpec AlterTypeSpec() throws ParseException {
25105
25106 ASTAlterTypeSpec jjtn000 = new ASTAlterTypeSpec(this, JJTALTERTYPESPEC);
25107 boolean jjtc000 = true;
25108 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
25109 try {
25110 jj_consume_token(ALTER);
25111 jj_consume_token(TYPE);
25112 simpleNode = QualifiedName();
25113 label_80:
25114 while (true) {
25115 switch (jj_nt.kind) {
25116 case 6:
25117 case ADD:
25118 case DROP:
25119 case MODIFY:
25120 ;
25121 break;
25122 default:
25123 jj_la1[359] = jj_gen;
25124 break label_80;
25125 }
25126 switch (jj_nt.kind) {
25127 case 6:
25128 case ADD:
25129 case MODIFY:
25130 switch (jj_nt.kind) {
25131 case 6:
25132 jj_consume_token(6);
25133 break;
25134 default:
25135 jj_la1[360] = jj_gen;
25136 ;
25137 }
25138 switch (jj_nt.kind) {
25139 case ADD:
25140 jj_consume_token(ADD);
25141 break;
25142 case MODIFY:
25143 jj_consume_token(MODIFY);
25144 break;
25145 default:
25146 jj_la1[361] = jj_gen;
25147 jj_consume_token(-1);
25148 throw new ParseException();
25149 }
25150 label_81:
25151 while (true) {
25152 switch (jj_nt.kind) {
25153 case CONSTRUCTOR:
25154 case FINAL:
25155 case INSTANTIABLE:
25156 case MAP:
25157 case MEMBER:
25158 case NOT:
25159 case ORDER:
25160 case OVERRIDING:
25161 case STATIC:
25162 TypeMethod();
25163 break;
25164 case ATTRIBUTE:
25165 jj_consume_token(ATTRIBUTE);
25166 label_82:
25167 while (true) {
25168 switch (jj_nt.kind) {
25169 case 5:
25170 ;
25171 break;
25172 default:
25173 jj_la1[362] = jj_gen;
25174 break label_82;
25175 }
25176 jj_consume_token(5);
25177 }
25178 AttributeDeclaration();
25179 label_83:
25180 while (true) {
25181 switch (jj_nt.kind) {
25182 case 6:
25183 ;
25184 break;
25185 default:
25186 jj_la1[363] = jj_gen;
25187 break label_83;
25188 }
25189 jj_consume_token(6);
25190 AttributeDeclaration();
25191 }
25192 label_84:
25193 while (true) {
25194 switch (jj_nt.kind) {
25195 case 7:
25196 ;
25197 break;
25198 default:
25199 jj_la1[364] = jj_gen;
25200 break label_84;
25201 }
25202 jj_consume_token(7);
25203 }
25204 break;
25205 case LIMIT:
25206 jj_consume_token(LIMIT);
25207 NumericLiteral();
25208 break;
25209 case ELEMENT:
25210 jj_consume_token(ELEMENT);
25211 jj_consume_token(TYPE);
25212 Datatype();
25213 break;
25214 default:
25215 jj_la1[365] = jj_gen;
25216 jj_consume_token(-1);
25217 throw new ParseException();
25218 }
25219 switch (jj_nt.kind) {
25220 case ATTRIBUTE:
25221 case CONSTRUCTOR:
25222 case ELEMENT:
25223 case FINAL:
25224 case INSTANTIABLE:
25225 case LIMIT:
25226 case MAP:
25227 case MEMBER:
25228 case NOT:
25229 case ORDER:
25230 case OVERRIDING:
25231 case STATIC:
25232 ;
25233 break;
25234 default:
25235 jj_la1[366] = jj_gen;
25236 break label_81;
25237 }
25238 }
25239 break;
25240 case DROP:
25241 jj_consume_token(DROP);
25242 label_85:
25243 while (true) {
25244 switch (jj_nt.kind) {
25245 case ATTRIBUTE:
25246 jj_consume_token(ATTRIBUTE);
25247 label_86:
25248 while (true) {
25249 switch (jj_nt.kind) {
25250 case 5:
25251 ;
25252 break;
25253 default:
25254 jj_la1[367] = jj_gen;
25255 break label_86;
25256 }
25257 jj_consume_token(5);
25258 }
25259 Attribute();
25260 label_87:
25261 while (true) {
25262 switch (jj_nt.kind) {
25263 case 6:
25264 ;
25265 break;
25266 default:
25267 jj_la1[368] = jj_gen;
25268 break label_87;
25269 }
25270 jj_consume_token(6);
25271 Attribute();
25272 }
25273 label_88:
25274 while (true) {
25275 switch (jj_nt.kind) {
25276 case 7:
25277 ;
25278 break;
25279 default:
25280 jj_la1[369] = jj_gen;
25281 break label_88;
25282 }
25283 jj_consume_token(7);
25284 }
25285 break;
25286 case CONSTRUCTOR:
25287 case FINAL:
25288 case INSTANTIABLE:
25289 case MAP:
25290 case MEMBER:
25291 case NOT:
25292 case ORDER:
25293 case OVERRIDING:
25294 case STATIC:
25295 TypeMethod();
25296 break;
25297 default:
25298 jj_la1[370] = jj_gen;
25299 jj_consume_token(-1);
25300 throw new ParseException();
25301 }
25302 switch (jj_nt.kind) {
25303 case ATTRIBUTE:
25304 case CONSTRUCTOR:
25305 case FINAL:
25306 case INSTANTIABLE:
25307 case MAP:
25308 case MEMBER:
25309 case NOT:
25310 case ORDER:
25311 case OVERRIDING:
25312 case STATIC:
25313 ;
25314 break;
25315 default:
25316 jj_la1[371] = jj_gen;
25317 break label_85;
25318 }
25319 }
25320 break;
25321 default:
25322 jj_la1[372] = jj_gen;
25323 jj_consume_token(-1);
25324 throw new ParseException();
25325 }
25326 }
25327 switch (jj_nt.kind) {
25328 case REPLACE:
25329 jj_consume_token(REPLACE);
25330 label_89:
25331 while (true) {
25332 if (jj_2_69(2)) {
25333 ;
25334 } else {
25335 break label_89;
25336 }
25337 switch (jj_nt.kind) {
25338 case AUTHID:
25339 jj_consume_token(AUTHID);
25340 switch (jj_nt.kind) {
25341 case CURRENT_USER:
25342 jj_consume_token(CURRENT_USER);
25343 break;
25344 case DEFINER:
25345 jj_consume_token(DEFINER);
25346 break;
25347 default:
25348 jj_la1[373] = jj_gen;
25349 jj_consume_token(-1);
25350 throw new ParseException();
25351 }
25352 break;
25353 case ACCESSIBLE:
25354 AccessibleByClause();
25355 break;
25356 default:
25357 jj_la1[374] = jj_gen;
25358 jj_consume_token(-1);
25359 throw new ParseException();
25360 }
25361 }
25362 switch (jj_nt.kind) {
25363 case IS:
25364 jj_consume_token(IS);
25365 break;
25366 case AS:
25367 jj_consume_token(AS);
25368 break;
25369 default:
25370 jj_la1[375] = jj_gen;
25371 jj_consume_token(-1);
25372 throw new ParseException();
25373 }
25374 jj_consume_token(OBJECT);
25375 jj_consume_token(5);
25376 if (jj_2_70(2)) {
25377 TypeMethod();
25378 } else {
25379 switch (jj_nt.kind) {
25380 case REPLACE:
25381 case DEFINER:
25382 case CURRENT_USER:
25383 case SERIALLY_REUSABLE:
25384 case RESTRICT_REFERENCES:
25385 case EXCEPTION_INIT:
25386 case AUTONOMOUS_TRANSACTION:
25387 case LANGUAGE:
25388 case INLINE:
25389 case ADD:
25390 case AGGREGATE:
25391 case ALL:
25392 case ALTER:
25393 case AND:
25394 case ANY:
25395 case ARRAY:
25396 case AS:
25397 case ASC:
25398 case AT:
25399 case ATTRIBUTE:
25400 case AUTHID:
25401 case AVG:
25402 case BETWEEN:
25403 case BINARY_INTEGER:
25404 case BODY:
25405 case BOOLEAN:
25406 case BULK:
25407 case BY:
25408 case BYTE:
25409 case CASCADE:
25410 case CASE:
25411 case CHAR:
25412 case CHAR_BASE:
25413 case CHECK:
25414 case CLOSE:
25415 case CLUSTER:
25416 case COALESCE:
25417 case COLLECT:
25418 case COLUMN:
25419 case COMMENT:
25420 case COMMIT:
25421 case COMPRESS:
25422 case CONNECT:
25423 case CONSTANT:
25424 case CONSTRUCTOR:
25425 case CONTINUE:
25426 case CONVERT:
25427 case CREATE:
25428 case CURRENT:
25429 case CURRVAL:
25430 case CURSOR:
25431 case DATA:
25432 case DATE:
25433 case DAY:
25434 case DECLARE:
25435 case DECIMAL:
25436 case _DEFAULT:
25437 case DELETE:
25438 case DESC:
25439 case DISABLE:
25440 case DISTINCT:
25441 case DO:
25442 case DROP:
25443 case EDITIONABLE:
25444 case ELEMENT:
25445 case ELSE:
25446 case ELSIF:
25447 case ENABLE:
25448 case ESCAPE:
25449 case EXCEPT:
25450 case EXCEPTION:
25451 case EXCEPTIONS:
25452 case EXCLUSIVE:
25453 case EXECUTE:
25454 case EXISTS:
25455 case EXIT:
25456 case EXTERNAL:
25457 case EXTENDS:
25458 case EXTRACT:
25459 case FALSE:
25460 case FETCH:
25461 case FINAL:
25462 case FLOAT:
25463 case FOR:
25464 case FORALL:
25465 case FORCE:
25466 case FROM:
25467 case FUNCTION:
25468 case GLOBAL:
25469 case GOTO:
25470 case GROUP:
25471 case HASH:
25472 case HAVING:
25473 case HEAP:
25474 case HOUR:
25475 case IF:
25476 case IMMEDIATE:
25477 case IN:
25478 case INDEX:
25479 case INDICES:
25480 case INDEXTYPE:
25481 case INDICATOR:
25482 case INSERT:
25483 case INSTANTIABLE:
25484 case INTEGER:
25485 case INTERFACE:
25486 case INTERSECT:
25487 case INTERVAL:
25488 case INTO:
25489 case INVALIDATE:
25490 case IS:
25491 case ISOLATION:
25492 case JAVA:
25493 case LEVEL:
25494 case LIKE:
25495 case LIMIT:
25496 case LIMITED:
25497 case LOCK:
25498 case LONG:
25499 case LOOP:
25500 case MAP:
25501 case MAX:
25502 case MEMBER:
25503 case MERGE:
25504 case MIN:
25505 case MINUS:
25506 case MINUTE:
25507 case MLSLABEL:
25508 case MODIFY:
25509 case MOD:
25510 case MODE:
25511 case MONTH:
25512 case NATURAL:
25513 case NATURALN:
25514 case NEW:
25515 case NEXTVAL:
25516 case NO:
25517 case NOCOPY:
25518 case NONEDITIONABLE:
25519 case NOT:
25520 case NOWAIT:
25521 case NULL:
25522 case NULLIF:
25523 case NUMBER:
25524 case BFILE_BASE:
25525 case BLOB_BASE:
25526 case CLOB_BASE:
25527 case DATE_BASE:
25528 case NUMBER_BASE:
25529 case OBJECT:
25530 case OCIROWID:
25531 case OF:
25532 case OID:
25533 case ON:
25534 case OPAQUE:
25535 case OPEN:
25536 case OPERATOR:
25537 case OPTION:
25538 case OR:
25539 case ORDER:
25540 case ORGANIZATION:
25541 case OTHERS:
25542 case OUT:
25543 case OVERRIDING:
25544 case PACKAGE:
25545 case PARTITION:
25546 case PCTFREE:
25547 case PLS_INTEGER:
25548 case POSITIVE:
25549 case POSITIVEN:
25550 case PRESERVE:
25551 case PRIOR:
25552 case PROMPT:
25553 case PRIVATE:
25554 case PROCEDURE:
25555 case PUBLIC:
25556 case RAISE:
25557 case RANGE:
25558 case RAW:
25559 case REAL:
25560 case RECORD:
25561 case REF:
25562 case RELEASE:
25563 case RELIES_ON:
25564 case RENAME:
25565 case RESULT:
25566 case RETURN:
25567 case RETURNING:
25568 case REVERSE:
25569 case ROLLBACK:
25570 case ROW:
25571 case ROWS:
25572 case ROWID:
25573 case ROWNUM:
25574 case ROWTYPE:
25575 case SAVE:
25576 case SAVEPOINT:
25577 case SECOND:
25578 case SELECT:
25579 case SELF:
25580 case SEPARATE:
25581 case SET:
25582 case SHARE:
25583 case SMALLINT:
25584 case SPACE:
25585 case SQL:
25586 case SQLCODE:
25587 case SQLERRM:
25588 case START:
25589 case STATIC:
25590 case STDDEV:
25591 case SUBTYPE:
25592 case SUBSTITUTABLE:
25593 case SUCCESSFUL:
25594 case SUM:
25595 case SYNONYM:
25596 case SYSDATE:
25597 case SYS_REFCURSOR:
25598 case TABLE:
25599 case TEMPORARY:
25600 case THEN:
25601 case TIME:
25602 case TIMESTAMP:
25603 case TIMEZONE_REGION:
25604 case TIMEZONE_ABBR:
25605 case TIMEZONE_MINUTE:
25606 case TIMEZONE_HOUR:
25607 case TO:
25608 case TRANSACTION:
25609 case TRIGGER:
25610 case TRUE:
25611 case TYPE:
25612 case UI:
25613 case UNDER:
25614 case USING:
25615 case WHILE:
25616 case YES:
25617 case SHOW:
25618 case A:
25619 case UPDATE:
25620 case VARCHAR:
25621 case VARCHAR2:
25622 case DOUBLE:
25623 case DEC:
25624 case PRECISION:
25625 case INT:
25626 case NUMERIC:
25627 case SIGNTYPE:
25628 case NCHAR:
25629 case NVARCHAR2:
25630 case STRING:
25631 case UROWID:
25632 case VARRAY:
25633 case VARYING:
25634 case BFILE:
25635 case BLOB:
25636 case CLOB:
25637 case NCLOB:
25638 case YEAR:
25639 case LOCAL:
25640 case WITH:
25641 case ZONE:
25642 case CHARACTER:
25643 case AFTER:
25644 case BEFORE:
25645 case OLD:
25646 case PARENT:
25647 case ANALYZE:
25648 case ASSOCIATE:
25649 case AUDIT:
25650 case COMPOUND:
25651 case DATABASE:
25652 case CALL:
25653 case DDL:
25654 case DISASSOCIATE:
25655 case EACH:
25656 case FOLLOWS:
25657 case LOGOFF:
25658 case LOGON:
25659 case NESTED:
25660 case NOAUDIT:
25661 case SCHEMA:
25662 case SERVERERROR:
25663 case SHUTDOWN:
25664 case STARTUP:
25665 case STATEMENT:
25666 case STATISTICS:
25667 case SUSPEND:
25668 case TRUNCATE:
25669 case WRAPPED:
25670 case LIBRARY:
25671 case NAME:
25672 case STRUCT:
25673 case CONTEXT:
25674 case PARAMETERS:
25675 case LENGTH:
25676 case TDO:
25677 case MAXLEN:
25678 case CHARSETID:
25679 case CHARSETFORM:
25680 case ACCEPT:
25681 case ACCESSIBLE:
25682 case COPY:
25683 case DEFINE:
25684 case DISCONNECT:
25685 case HOST:
25686 case PRINT:
25687 case QUIT:
25688 case REMARK:
25689 case UNDEFINE:
25690 case VARIABLE:
25691 case WHENEVER:
25692 case ATTACH:
25693 case CAST:
25694 case TREAT:
25695 case TRIM:
25696 case LEFT:
25697 case RIGHT:
25698 case BOTH:
25699 case EMPTY:
25700 case MULTISET:
25701 case SUBMULTISET:
25702 case LEADING:
25703 case TRAILING:
25704 case CHAR_CS:
25705 case NCHAR_CS:
25706 case DBTIMEZONE:
25707 case SESSIONTIMEZONE:
25708 case AUTHENTICATED:
25709 case LINK:
25710 case SHARED:
25711 case DIRECTORY:
25712 case USER:
25713 case IDENTIFIER:
25714 case QUOTED_LITERAL:
25715 case SQLDATA_CLASS:
25716 case CUSTOMDATUM_CLASS:
25717 case ORADATA_CLASS:
25718 case JAVA_INTERFACE_CLASS:
25719 AttributeDeclaration();
25720 break;
25721 default:
25722 jj_la1[376] = jj_gen;
25723 jj_consume_token(-1);
25724 throw new ParseException();
25725 }
25726 }
25727 label_90:
25728 while (true) {
25729 switch (jj_nt.kind) {
25730 case 6:
25731 ;
25732 break;
25733 default:
25734 jj_la1[377] = jj_gen;
25735 break label_90;
25736 }
25737 jj_consume_token(6);
25738 if (jj_2_71(2)) {
25739 TypeMethod();
25740 } else {
25741 switch (jj_nt.kind) {
25742 case REPLACE:
25743 case DEFINER:
25744 case CURRENT_USER:
25745 case SERIALLY_REUSABLE:
25746 case RESTRICT_REFERENCES:
25747 case EXCEPTION_INIT:
25748 case AUTONOMOUS_TRANSACTION:
25749 case LANGUAGE:
25750 case INLINE:
25751 case ADD:
25752 case AGGREGATE:
25753 case ALL:
25754 case ALTER:
25755 case AND:
25756 case ANY:
25757 case ARRAY:
25758 case AS:
25759 case ASC:
25760 case AT:
25761 case ATTRIBUTE:
25762 case AUTHID:
25763 case AVG:
25764 case BETWEEN:
25765 case BINARY_INTEGER:
25766 case BODY:
25767 case BOOLEAN:
25768 case BULK:
25769 case BY:
25770 case BYTE:
25771 case CASCADE:
25772 case CASE:
25773 case CHAR:
25774 case CHAR_BASE:
25775 case CHECK:
25776 case CLOSE:
25777 case CLUSTER:
25778 case COALESCE:
25779 case COLLECT:
25780 case COLUMN:
25781 case COMMENT:
25782 case COMMIT:
25783 case COMPRESS:
25784 case CONNECT:
25785 case CONSTANT:
25786 case CONSTRUCTOR:
25787 case CONTINUE:
25788 case CONVERT:
25789 case CREATE:
25790 case CURRENT:
25791 case CURRVAL:
25792 case CURSOR:
25793 case DATA:
25794 case DATE:
25795 case DAY:
25796 case DECLARE:
25797 case DECIMAL:
25798 case _DEFAULT:
25799 case DELETE:
25800 case DESC:
25801 case DISABLE:
25802 case DISTINCT:
25803 case DO:
25804 case DROP:
25805 case EDITIONABLE:
25806 case ELEMENT:
25807 case ELSE:
25808 case ELSIF:
25809 case ENABLE:
25810 case ESCAPE:
25811 case EXCEPT:
25812 case EXCEPTION:
25813 case EXCEPTIONS:
25814 case EXCLUSIVE:
25815 case EXECUTE:
25816 case EXISTS:
25817 case EXIT:
25818 case EXTERNAL:
25819 case EXTENDS:
25820 case EXTRACT:
25821 case FALSE:
25822 case FETCH:
25823 case FINAL:
25824 case FLOAT:
25825 case FOR:
25826 case FORALL:
25827 case FORCE:
25828 case FROM:
25829 case FUNCTION:
25830 case GLOBAL:
25831 case GOTO:
25832 case GROUP:
25833 case HASH:
25834 case HAVING:
25835 case HEAP:
25836 case HOUR:
25837 case IF:
25838 case IMMEDIATE:
25839 case IN:
25840 case INDEX:
25841 case INDICES:
25842 case INDEXTYPE:
25843 case INDICATOR:
25844 case INSERT:
25845 case INSTANTIABLE:
25846 case INTEGER:
25847 case INTERFACE:
25848 case INTERSECT:
25849 case INTERVAL:
25850 case INTO:
25851 case INVALIDATE:
25852 case IS:
25853 case ISOLATION:
25854 case JAVA:
25855 case LEVEL:
25856 case LIKE:
25857 case LIMIT:
25858 case LIMITED:
25859 case LOCK:
25860 case LONG:
25861 case LOOP:
25862 case MAP:
25863 case MAX:
25864 case MEMBER:
25865 case MERGE:
25866 case MIN:
25867 case MINUS:
25868 case MINUTE:
25869 case MLSLABEL:
25870 case MODIFY:
25871 case MOD:
25872 case MODE:
25873 case MONTH:
25874 case NATURAL:
25875 case NATURALN:
25876 case NEW:
25877 case NEXTVAL:
25878 case NO:
25879 case NOCOPY:
25880 case NONEDITIONABLE:
25881 case NOT:
25882 case NOWAIT:
25883 case NULL:
25884 case NULLIF:
25885 case NUMBER:
25886 case BFILE_BASE:
25887 case BLOB_BASE:
25888 case CLOB_BASE:
25889 case DATE_BASE:
25890 case NUMBER_BASE:
25891 case OBJECT:
25892 case OCIROWID:
25893 case OF:
25894 case OID:
25895 case ON:
25896 case OPAQUE:
25897 case OPEN:
25898 case OPERATOR:
25899 case OPTION:
25900 case OR:
25901 case ORDER:
25902 case ORGANIZATION:
25903 case OTHERS:
25904 case OUT:
25905 case OVERRIDING:
25906 case PACKAGE:
25907 case PARTITION:
25908 case PCTFREE:
25909 case PLS_INTEGER:
25910 case POSITIVE:
25911 case POSITIVEN:
25912 case PRESERVE:
25913 case PRIOR:
25914 case PROMPT:
25915 case PRIVATE:
25916 case PROCEDURE:
25917 case PUBLIC:
25918 case RAISE:
25919 case RANGE:
25920 case RAW:
25921 case REAL:
25922 case RECORD:
25923 case REF:
25924 case RELEASE:
25925 case RELIES_ON:
25926 case RENAME:
25927 case RESULT:
25928 case RETURN:
25929 case RETURNING:
25930 case REVERSE:
25931 case ROLLBACK:
25932 case ROW:
25933 case ROWS:
25934 case ROWID:
25935 case ROWNUM:
25936 case ROWTYPE:
25937 case SAVE:
25938 case SAVEPOINT:
25939 case SECOND:
25940 case SELECT:
25941 case SELF:
25942 case SEPARATE:
25943 case SET:
25944 case SHARE:
25945 case SMALLINT:
25946 case SPACE:
25947 case SQL:
25948 case SQLCODE:
25949 case SQLERRM:
25950 case START:
25951 case STATIC:
25952 case STDDEV:
25953 case SUBTYPE:
25954 case SUBSTITUTABLE:
25955 case SUCCESSFUL:
25956 case SUM:
25957 case SYNONYM:
25958 case SYSDATE:
25959 case SYS_REFCURSOR:
25960 case TABLE:
25961 case TEMPORARY:
25962 case THEN:
25963 case TIME:
25964 case TIMESTAMP:
25965 case TIMEZONE_REGION:
25966 case TIMEZONE_ABBR:
25967 case TIMEZONE_MINUTE:
25968 case TIMEZONE_HOUR:
25969 case TO:
25970 case TRANSACTION:
25971 case TRIGGER:
25972 case TRUE:
25973 case TYPE:
25974 case UI:
25975 case UNDER:
25976 case USING:
25977 case WHILE:
25978 case YES:
25979 case SHOW:
25980 case A:
25981 case UPDATE:
25982 case VARCHAR:
25983 case VARCHAR2:
25984 case DOUBLE:
25985 case DEC:
25986 case PRECISION:
25987 case INT:
25988 case NUMERIC:
25989 case SIGNTYPE:
25990 case NCHAR:
25991 case NVARCHAR2:
25992 case STRING:
25993 case UROWID:
25994 case VARRAY:
25995 case VARYING:
25996 case BFILE:
25997 case BLOB:
25998 case CLOB:
25999 case NCLOB:
26000 case YEAR:
26001 case LOCAL:
26002 case WITH:
26003 case ZONE:
26004 case CHARACTER:
26005 case AFTER:
26006 case BEFORE:
26007 case OLD:
26008 case PARENT:
26009 case ANALYZE:
26010 case ASSOCIATE:
26011 case AUDIT:
26012 case COMPOUND:
26013 case DATABASE:
26014 case CALL:
26015 case DDL:
26016 case DISASSOCIATE:
26017 case EACH:
26018 case FOLLOWS:
26019 case LOGOFF:
26020 case LOGON:
26021 case NESTED:
26022 case NOAUDIT:
26023 case SCHEMA:
26024 case SERVERERROR:
26025 case SHUTDOWN:
26026 case STARTUP:
26027 case STATEMENT:
26028 case STATISTICS:
26029 case SUSPEND:
26030 case TRUNCATE:
26031 case WRAPPED:
26032 case LIBRARY:
26033 case NAME:
26034 case STRUCT:
26035 case CONTEXT:
26036 case PARAMETERS:
26037 case LENGTH:
26038 case TDO:
26039 case MAXLEN:
26040 case CHARSETID:
26041 case CHARSETFORM:
26042 case ACCEPT:
26043 case ACCESSIBLE:
26044 case COPY:
26045 case DEFINE:
26046 case DISCONNECT:
26047 case HOST:
26048 case PRINT:
26049 case QUIT:
26050 case REMARK:
26051 case UNDEFINE:
26052 case VARIABLE:
26053 case WHENEVER:
26054 case ATTACH:
26055 case CAST:
26056 case TREAT:
26057 case TRIM:
26058 case LEFT:
26059 case RIGHT:
26060 case BOTH:
26061 case EMPTY:
26062 case MULTISET:
26063 case SUBMULTISET:
26064 case LEADING:
26065 case TRAILING:
26066 case CHAR_CS:
26067 case NCHAR_CS:
26068 case DBTIMEZONE:
26069 case SESSIONTIMEZONE:
26070 case AUTHENTICATED:
26071 case LINK:
26072 case SHARED:
26073 case DIRECTORY:
26074 case USER:
26075 case IDENTIFIER:
26076 case QUOTED_LITERAL:
26077 case SQLDATA_CLASS:
26078 case CUSTOMDATUM_CLASS:
26079 case ORADATA_CLASS:
26080 case JAVA_INTERFACE_CLASS:
26081 AttributeDeclaration();
26082 break;
26083 default:
26084 jj_la1[378] = jj_gen;
26085 jj_consume_token(-1);
26086 throw new ParseException();
26087 }
26088 }
26089 }
26090 jj_consume_token(7);
26091 break;
26092 default:
26093 jj_la1[379] = jj_gen;
26094 ;
26095 }
26096 label_91:
26097 while (true) {
26098 switch (jj_nt.kind) {
26099 case FINAL:
26100 case INSTANTIABLE:
26101 case NOT:
26102 case NULL:
26103 ;
26104 break;
26105 default:
26106 jj_la1[380] = jj_gen;
26107 break label_91;
26108 }
26109 switch (jj_nt.kind) {
26110 case NOT:
26111 jj_consume_token(NOT);
26112 break;
26113 default:
26114 jj_la1[381] = jj_gen;
26115 ;
26116 }
26117 switch (jj_nt.kind) {
26118 case FINAL:
26119 jj_consume_token(FINAL);
26120 break;
26121 case INSTANTIABLE:
26122 jj_consume_token(INSTANTIABLE);
26123 break;
26124 case NULL:
26125 jj_consume_token(NULL);
26126 break;
26127 default:
26128 jj_la1[382] = jj_gen;
26129 jj_consume_token(-1);
26130 throw new ParseException();
26131 }
26132 }
26133 switch (jj_nt.kind) {
26134 case CASCADE:
26135 case INVALIDATE:
26136 switch (jj_nt.kind) {
26137 case INVALIDATE:
26138 jj_consume_token(INVALIDATE);
26139 break;
26140 case CASCADE:
26141 jj_consume_token(CASCADE);
26142 label_92:
26143 while (true) {
26144 switch (jj_nt.kind) {
26145 case CONVERT:
26146 case INCLUDING:
26147 case NOT:
26148 ;
26149 break;
26150 default:
26151 jj_la1[383] = jj_gen;
26152 break label_92;
26153 }
26154 switch (jj_nt.kind) {
26155 case INCLUDING:
26156 case NOT:
26157 switch (jj_nt.kind) {
26158 case NOT:
26159 jj_consume_token(NOT);
26160 break;
26161 default:
26162 jj_la1[384] = jj_gen;
26163 ;
26164 }
26165 jj_consume_token(INCLUDING);
26166 jj_consume_token(TABLE);
26167 jj_consume_token(DATA);
26168 break;
26169 case CONVERT:
26170 jj_consume_token(CONVERT);
26171 jj_consume_token(TO);
26172 jj_consume_token(SUBSTITUTABLE);
26173 break;
26174 default:
26175 jj_la1[385] = jj_gen;
26176 jj_consume_token(-1);
26177 throw new ParseException();
26178 }
26179 }
26180 switch (jj_nt.kind) {
26181 case EXCEPTIONS:
26182 case FORCE:
26183 switch (jj_nt.kind) {
26184 case FORCE:
26185 jj_consume_token(FORCE);
26186 break;
26187 default:
26188 jj_la1[386] = jj_gen;
26189 ;
26190 }
26191 jj_consume_token(EXCEPTIONS);
26192 jj_consume_token(INTO);
26193 QualifiedName();
26194 break;
26195 default:
26196 jj_la1[387] = jj_gen;
26197 ;
26198 }
26199 break;
26200 default:
26201 jj_la1[388] = jj_gen;
26202 jj_consume_token(-1);
26203 throw new ParseException();
26204 }
26205 break;
26206 default:
26207 jj_la1[389] = jj_gen;
26208 ;
26209 }
26210 jjtree.closeNodeScope(jjtn000, true);
26211 jjtc000 = false;
26212 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
26213 } catch (Throwable jjte000) {
26214 if (jjtc000) {
26215 jjtree.clearNodeScope(jjtn000);
26216 jjtc000 = false;
26217 } else {
26218 jjtree.popNode();
26219 }
26220 if (jjte000 instanceof RuntimeException) {
26221 {if (true) throw (RuntimeException)jjte000;}
26222 }
26223 if (jjte000 instanceof ParseException) {
26224 {if (true) throw (ParseException)jjte000;}
26225 }
26226 {if (true) throw (Error)jjte000;}
26227 } finally {
26228 if (jjtc000) {
26229 jjtree.closeNodeScope(jjtn000, true);
26230 }
26231 }
26232 throw new Error("Missing return statement in function");
26233 }
26234
26235
26236
26237
26238
26239
26240
26241
26242
26243
26244
26245
26246
26247
26248
26249
26250
26251
26252
26253
26254
26255
26256
26257
26258
26259
26260
26261
26262
26263 final public ASTAttributeDeclaration AttributeDeclaration() throws ParseException {
26264
26265 ASTAttributeDeclaration jjtn000 = new ASTAttributeDeclaration(this, JJTATTRIBUTEDECLARATION);
26266 boolean jjtc000 = true;
26267 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
26268 try {
26269 simpleNode = ID();
26270 Datatype();
26271 jjtree.closeNodeScope(jjtn000, true);
26272 jjtc000 = false;
26273 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
26274 } catch (Throwable jjte000) {
26275 if (jjtc000) {
26276 jjtree.clearNodeScope(jjtn000);
26277 jjtc000 = false;
26278 } else {
26279 jjtree.popNode();
26280 }
26281 if (jjte000 instanceof RuntimeException) {
26282 {if (true) throw (RuntimeException)jjte000;}
26283 }
26284 if (jjte000 instanceof ParseException) {
26285 {if (true) throw (ParseException)jjte000;}
26286 }
26287 {if (true) throw (Error)jjte000;}
26288 } finally {
26289 if (jjtc000) {
26290 jjtree.closeNodeScope(jjtn000, true);
26291 }
26292 }
26293 throw new Error("Missing return statement in function");
26294 }
26295
26296 final public ASTAttribute Attribute() throws ParseException {
26297
26298 ASTAttribute jjtn000 = new ASTAttribute(this, JJTATTRIBUTE);
26299 boolean jjtc000 = true;
26300 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
26301 try {
26302 simpleNode = ID();
26303 jjtree.closeNodeScope(jjtn000, true);
26304 jjtc000 = false;
26305 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
26306 } catch (Throwable jjte000) {
26307 if (jjtc000) {
26308 jjtree.clearNodeScope(jjtn000);
26309 jjtc000 = false;
26310 } else {
26311 jjtree.popNode();
26312 }
26313 if (jjte000 instanceof RuntimeException) {
26314 {if (true) throw (RuntimeException)jjte000;}
26315 }
26316 if (jjte000 instanceof ParseException) {
26317 {if (true) throw (ParseException)jjte000;}
26318 }
26319 {if (true) throw (Error)jjte000;}
26320 } finally {
26321 if (jjtc000) {
26322 jjtree.closeNodeScope(jjtn000, true);
26323 }
26324 }
26325 throw new Error("Missing return statement in function");
26326 }
26327
26328
26329
26330
26331 final public ASTPragmaClause PragmaClause() throws ParseException {
26332
26333 ASTPragmaClause jjtn000 = new ASTPragmaClause(this, JJTPRAGMACLAUSE);
26334 boolean jjtc000 = true;
26335 jjtree.openNodeScope(jjtn000);
26336 try {
26337 jj_consume_token(PRAGMA);
26338 switch (jj_nt.kind) {
26339 case SERIALLY_REUSABLE:
26340 jj_consume_token(SERIALLY_REUSABLE);
26341 break;
26342 case AUTONOMOUS_TRANSACTION:
26343 jj_consume_token(AUTONOMOUS_TRANSACTION);
26344 break;
26345 case RESTRICT_REFERENCES:
26346 jj_consume_token(RESTRICT_REFERENCES);
26347 jj_consume_token(5);
26348 ID();
26349 label_93:
26350 while (true) {
26351 jj_consume_token(6);
26352 switch (jj_nt.kind) {
26353 case REPLACE:
26354 case DEFINER:
26355 case CURRENT_USER:
26356 case SERIALLY_REUSABLE:
26357 case RESTRICT_REFERENCES:
26358 case EXCEPTION_INIT:
26359 case AUTONOMOUS_TRANSACTION:
26360 case LANGUAGE:
26361 case INLINE:
26362 case ADD:
26363 case AGGREGATE:
26364 case ALL:
26365 case ALTER:
26366 case AND:
26367 case ANY:
26368 case ARRAY:
26369 case AS:
26370 case ASC:
26371 case AT:
26372 case ATTRIBUTE:
26373 case AUTHID:
26374 case AVG:
26375 case BETWEEN:
26376 case BINARY_INTEGER:
26377 case BODY:
26378 case BOOLEAN:
26379 case BULK:
26380 case BY:
26381 case BYTE:
26382 case CASCADE:
26383 case CASE:
26384 case CHAR:
26385 case CHAR_BASE:
26386 case CHECK:
26387 case CLOSE:
26388 case CLUSTER:
26389 case COALESCE:
26390 case COLLECT:
26391 case COLUMN:
26392 case COMMENT:
26393 case COMMIT:
26394 case COMPRESS:
26395 case CONNECT:
26396 case CONSTANT:
26397 case CONSTRUCTOR:
26398 case CONTINUE:
26399 case CONVERT:
26400 case CREATE:
26401 case CURRENT:
26402 case CURRVAL:
26403 case CURSOR:
26404 case DATA:
26405 case DATE:
26406 case DAY:
26407 case DECLARE:
26408 case DECIMAL:
26409 case _DEFAULT:
26410 case DELETE:
26411 case DESC:
26412 case DISABLE:
26413 case DISTINCT:
26414 case DO:
26415 case DROP:
26416 case EDITIONABLE:
26417 case ELEMENT:
26418 case ELSE:
26419 case ELSIF:
26420 case ENABLE:
26421 case ESCAPE:
26422 case EXCEPT:
26423 case EXCEPTION:
26424 case EXCEPTIONS:
26425 case EXCLUSIVE:
26426 case EXECUTE:
26427 case EXISTS:
26428 case EXIT:
26429 case EXTERNAL:
26430 case EXTENDS:
26431 case EXTRACT:
26432 case FALSE:
26433 case FETCH:
26434 case FINAL:
26435 case FLOAT:
26436 case FOR:
26437 case FORALL:
26438 case FORCE:
26439 case FROM:
26440 case FUNCTION:
26441 case GLOBAL:
26442 case GOTO:
26443 case GROUP:
26444 case HASH:
26445 case HAVING:
26446 case HEAP:
26447 case HOUR:
26448 case IF:
26449 case IMMEDIATE:
26450 case IN:
26451 case INDEX:
26452 case INDICES:
26453 case INDEXTYPE:
26454 case INDICATOR:
26455 case INSERT:
26456 case INSTANTIABLE:
26457 case INTEGER:
26458 case INTERFACE:
26459 case INTERSECT:
26460 case INTERVAL:
26461 case INTO:
26462 case INVALIDATE:
26463 case IS:
26464 case ISOLATION:
26465 case JAVA:
26466 case LEVEL:
26467 case LIKE:
26468 case LIMIT:
26469 case LIMITED:
26470 case LOCK:
26471 case LONG:
26472 case LOOP:
26473 case MAP:
26474 case MAX:
26475 case MEMBER:
26476 case MERGE:
26477 case MIN:
26478 case MINUS:
26479 case MINUTE:
26480 case MLSLABEL:
26481 case MODIFY:
26482 case MOD:
26483 case MODE:
26484 case MONTH:
26485 case NATURAL:
26486 case NATURALN:
26487 case NEW:
26488 case NEXTVAL:
26489 case NO:
26490 case NOCOPY:
26491 case NONEDITIONABLE:
26492 case NOT:
26493 case NOWAIT:
26494 case NULL:
26495 case NULLIF:
26496 case NUMBER:
26497 case BFILE_BASE:
26498 case BLOB_BASE:
26499 case CLOB_BASE:
26500 case DATE_BASE:
26501 case NUMBER_BASE:
26502 case OBJECT:
26503 case OCIROWID:
26504 case OF:
26505 case OID:
26506 case ON:
26507 case OPAQUE:
26508 case OPEN:
26509 case OPERATOR:
26510 case OPTION:
26511 case OR:
26512 case ORDER:
26513 case ORGANIZATION:
26514 case OTHERS:
26515 case OUT:
26516 case OVERRIDING:
26517 case PACKAGE:
26518 case PARTITION:
26519 case PCTFREE:
26520 case PLS_INTEGER:
26521 case POSITIVE:
26522 case POSITIVEN:
26523 case PRESERVE:
26524 case PRIOR:
26525 case PROMPT:
26526 case PRIVATE:
26527 case PROCEDURE:
26528 case PUBLIC:
26529 case RAISE:
26530 case RANGE:
26531 case RAW:
26532 case REAL:
26533 case RECORD:
26534 case REF:
26535 case RELEASE:
26536 case RELIES_ON:
26537 case RENAME:
26538 case RESULT:
26539 case RETURN:
26540 case RETURNING:
26541 case REVERSE:
26542 case ROLLBACK:
26543 case ROW:
26544 case ROWS:
26545 case ROWID:
26546 case ROWNUM:
26547 case ROWTYPE:
26548 case SAVE:
26549 case SAVEPOINT:
26550 case SECOND:
26551 case SELECT:
26552 case SELF:
26553 case SEPARATE:
26554 case SET:
26555 case SHARE:
26556 case SMALLINT:
26557 case SPACE:
26558 case SQL:
26559 case SQLCODE:
26560 case SQLERRM:
26561 case START:
26562 case STATIC:
26563 case STDDEV:
26564 case SUBTYPE:
26565 case SUBSTITUTABLE:
26566 case SUCCESSFUL:
26567 case SUM:
26568 case SYNONYM:
26569 case SYSDATE:
26570 case SYS_REFCURSOR:
26571 case TABLE:
26572 case TEMPORARY:
26573 case THEN:
26574 case TIME:
26575 case TIMESTAMP:
26576 case TIMEZONE_REGION:
26577 case TIMEZONE_ABBR:
26578 case TIMEZONE_MINUTE:
26579 case TIMEZONE_HOUR:
26580 case TO:
26581 case TRANSACTION:
26582 case TRIGGER:
26583 case TRUE:
26584 case TYPE:
26585 case UI:
26586 case UNDER:
26587 case USING:
26588 case WHILE:
26589 case YES:
26590 case SHOW:
26591 case A:
26592 case UPDATE:
26593 case VARCHAR:
26594 case VARCHAR2:
26595 case DOUBLE:
26596 case DEC:
26597 case PRECISION:
26598 case INT:
26599 case NUMERIC:
26600 case SIGNTYPE:
26601 case NCHAR:
26602 case NVARCHAR2:
26603 case STRING:
26604 case UROWID:
26605 case VARRAY:
26606 case VARYING:
26607 case BFILE:
26608 case BLOB:
26609 case CLOB:
26610 case NCLOB:
26611 case YEAR:
26612 case LOCAL:
26613 case WITH:
26614 case ZONE:
26615 case CHARACTER:
26616 case AFTER:
26617 case BEFORE:
26618 case OLD:
26619 case PARENT:
26620 case ANALYZE:
26621 case ASSOCIATE:
26622 case AUDIT:
26623 case COMPOUND:
26624 case DATABASE:
26625 case CALL:
26626 case DDL:
26627 case DISASSOCIATE:
26628 case EACH:
26629 case FOLLOWS:
26630 case LOGOFF:
26631 case LOGON:
26632 case NESTED:
26633 case NOAUDIT:
26634 case SCHEMA:
26635 case SERVERERROR:
26636 case SHUTDOWN:
26637 case STARTUP:
26638 case STATEMENT:
26639 case STATISTICS:
26640 case SUSPEND:
26641 case TRUNCATE:
26642 case WRAPPED:
26643 case LIBRARY:
26644 case NAME:
26645 case STRUCT:
26646 case CONTEXT:
26647 case PARAMETERS:
26648 case LENGTH:
26649 case TDO:
26650 case MAXLEN:
26651 case CHARSETID:
26652 case CHARSETFORM:
26653 case ACCEPT:
26654 case ACCESSIBLE:
26655 case COPY:
26656 case DEFINE:
26657 case DISCONNECT:
26658 case HOST:
26659 case PRINT:
26660 case QUIT:
26661 case REMARK:
26662 case UNDEFINE:
26663 case VARIABLE:
26664 case WHENEVER:
26665 case ATTACH:
26666 case CAST:
26667 case TREAT:
26668 case TRIM:
26669 case LEFT:
26670 case RIGHT:
26671 case BOTH:
26672 case EMPTY:
26673 case MULTISET:
26674 case SUBMULTISET:
26675 case LEADING:
26676 case TRAILING:
26677 case CHAR_CS:
26678 case NCHAR_CS:
26679 case DBTIMEZONE:
26680 case SESSIONTIMEZONE:
26681 case AUTHENTICATED:
26682 case LINK:
26683 case SHARED:
26684 case DIRECTORY:
26685 case USER:
26686 case IDENTIFIER:
26687 case QUOTED_LITERAL:
26688 case SQLDATA_CLASS:
26689 case CUSTOMDATUM_CLASS:
26690 case ORADATA_CLASS:
26691 case JAVA_INTERFACE_CLASS:
26692 ID();
26693 break;
26694 case STRING_LITERAL:
26695 StringLiteral();
26696 break;
26697 default:
26698 jj_la1[390] = jj_gen;
26699 jj_consume_token(-1);
26700 throw new ParseException();
26701 }
26702 switch (jj_nt.kind) {
26703 case 6:
26704 ;
26705 break;
26706 default:
26707 jj_la1[391] = jj_gen;
26708 break label_93;
26709 }
26710 }
26711 jj_consume_token(7);
26712 break;
26713 case EXCEPTION_INIT:
26714 jj_consume_token(EXCEPTION_INIT);
26715 jj_consume_token(5);
26716 jj_consume_token(IDENTIFIER);
26717 jj_consume_token(6);
26718 switch (jj_nt.kind) {
26719 case 16:
26720 case 17:
26721 switch (jj_nt.kind) {
26722 case 16:
26723 jj_consume_token(16);
26724 break;
26725 case 17:
26726 jj_consume_token(17);
26727 break;
26728 default:
26729 jj_la1[392] = jj_gen;
26730 jj_consume_token(-1);
26731 throw new ParseException();
26732 }
26733 break;
26734 default:
26735 jj_la1[393] = jj_gen;
26736 ;
26737 }
26738 NumericLiteral();
26739 jj_consume_token(7);
26740 break;
26741 case INTERFACE:
26742 jj_consume_token(INTERFACE);
26743 jj_consume_token(5);
26744 jj_consume_token(IDENTIFIER);
26745 jj_consume_token(6);
26746 jj_consume_token(IDENTIFIER);
26747 jj_consume_token(6);
26748 NumericLiteral();
26749 jj_consume_token(7);
26750 break;
26751 default:
26752 jj_la1[394] = jj_gen;
26753 jj_consume_token(-1);
26754 throw new ParseException();
26755 }
26756 jjtree.closeNodeScope(jjtn000, true);
26757 jjtc000 = false;
26758 {if (true) return jjtn000 ;}
26759 } catch (Throwable jjte000) {
26760 if (jjtc000) {
26761 jjtree.clearNodeScope(jjtn000);
26762 jjtc000 = false;
26763 } else {
26764 jjtree.popNode();
26765 }
26766 if (jjte000 instanceof RuntimeException) {
26767 {if (true) throw (RuntimeException)jjte000;}
26768 }
26769 if (jjte000 instanceof ParseException) {
26770 {if (true) throw (ParseException)jjte000;}
26771 }
26772 {if (true) throw (Error)jjte000;}
26773 } finally {
26774 if (jjtc000) {
26775 jjtree.closeNodeScope(jjtn000, true);
26776 }
26777 }
26778 throw new Error("Missing return statement in function");
26779 }
26780
26781
26782
26783
26784
26785
26786
26787
26788
26789
26790
26791
26792
26793
26794
26795
26796
26797
26798
26799
26800
26801
26802
26803
26804
26805
26806
26807
26808
26809
26810
26811
26812
26813
26814
26815
26816
26817
26818
26819
26820
26821
26822
26823
26824
26825
26826
26827
26828
26829
26830
26831
26832
26833
26834
26835
26836
26837
26838
26839
26840
26841
26842
26843
26844
26845
26846
26847
26848
26849
26850
26851
26852
26853
26854
26855 final public ASTTriggerUnit TriggerUnit() throws ParseException {
26856
26857 ASTTriggerUnit jjtn000 = new ASTTriggerUnit(this, JJTTRIGGERUNIT);
26858 boolean jjtc000 = true;
26859 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
26860 try {
26861 switch (jj_nt.kind) {
26862 case CREATE:
26863 jj_consume_token(CREATE);
26864 switch (jj_nt.kind) {
26865 case OR:
26866 jj_consume_token(OR);
26867 jj_consume_token(REPLACE);
26868 break;
26869 default:
26870 jj_la1[395] = jj_gen;
26871 ;
26872 }
26873 switch (jj_nt.kind) {
26874 case EDITIONABLE:
26875 case NONEDITIONABLE:
26876 switch (jj_nt.kind) {
26877 case EDITIONABLE:
26878 jj_consume_token(EDITIONABLE);
26879 break;
26880 case NONEDITIONABLE:
26881 jj_consume_token(NONEDITIONABLE);
26882 break;
26883 default:
26884 jj_la1[396] = jj_gen;
26885 jj_consume_token(-1);
26886 throw new ParseException();
26887 }
26888 break;
26889 default:
26890 jj_la1[397] = jj_gen;
26891 ;
26892 }
26893 break;
26894 default:
26895 jj_la1[398] = jj_gen;
26896 ;
26897 }
26898 jj_consume_token(TRIGGER);
26899 simpleNode = ObjectNameDeclaration();
26900 switch (jj_nt.kind) {
26901 case BEFORE:
26902 jj_consume_token(BEFORE);
26903 break;
26904 case AFTER:
26905 jj_consume_token(AFTER);
26906 break;
26907 case INSTEADOF:
26908 jj_consume_token(INSTEADOF);
26909 break;
26910 case FOR:
26911 jj_consume_token(FOR);
26912 break;
26913 default:
26914 jj_la1[399] = jj_gen;
26915 jj_consume_token(-1);
26916 throw new ParseException();
26917 }
26918 switch (jj_nt.kind) {
26919 case DELETE:
26920 case INSERT:
26921 case UPDATE:
26922 switch (jj_nt.kind) {
26923 case DELETE:
26924 jj_consume_token(DELETE);
26925 break;
26926 case INSERT:
26927 jj_consume_token(INSERT);
26928 break;
26929 case UPDATE:
26930 jj_consume_token(UPDATE);
26931 break;
26932 default:
26933 jj_la1[400] = jj_gen;
26934 jj_consume_token(-1);
26935 throw new ParseException();
26936 }
26937 if (jj_2_72(6)) {
26938 jj_consume_token(OF);
26939 ID();
26940 label_94:
26941 while (true) {
26942 switch (jj_nt.kind) {
26943 case 6:
26944 ;
26945 break;
26946 default:
26947 jj_la1[401] = jj_gen;
26948 break label_94;
26949 }
26950 jj_consume_token(6);
26951 ID();
26952 }
26953 } else {
26954 ;
26955 }
26956 break;
26957 case ALTER:
26958 case COMMENT:
26959 case CREATE:
26960 case DROP:
26961 case GRANT:
26962 case RENAME:
26963 case REVOKE:
26964 case ANALYZE:
26965 case ASSOCIATE:
26966 case AUDIT:
26967 case DDL:
26968 case DISASSOCIATE:
26969 case LOGOFF:
26970 case LOGON:
26971 case NOAUDIT:
26972 case SERVERERROR:
26973 case SHUTDOWN:
26974 case STARTUP:
26975 case SUSPEND:
26976 case TRUNCATE:
26977 NonDMLEvent();
26978 break;
26979 default:
26980 jj_la1[402] = jj_gen;
26981 jj_consume_token(-1);
26982 throw new ParseException();
26983 }
26984 label_95:
26985 while (true) {
26986 switch (jj_nt.kind) {
26987 case OR:
26988 ;
26989 break;
26990 default:
26991 jj_la1[403] = jj_gen;
26992 break label_95;
26993 }
26994 jj_consume_token(OR);
26995 switch (jj_nt.kind) {
26996 case DELETE:
26997 case INSERT:
26998 case UPDATE:
26999 switch (jj_nt.kind) {
27000 case DELETE:
27001 jj_consume_token(DELETE);
27002 break;
27003 case INSERT:
27004 jj_consume_token(INSERT);
27005 break;
27006 case UPDATE:
27007 jj_consume_token(UPDATE);
27008 break;
27009 default:
27010 jj_la1[404] = jj_gen;
27011 jj_consume_token(-1);
27012 throw new ParseException();
27013 }
27014 if (jj_2_73(6)) {
27015 jj_consume_token(OF);
27016 ID();
27017 label_96:
27018 while (true) {
27019 switch (jj_nt.kind) {
27020 case 6:
27021 ;
27022 break;
27023 default:
27024 jj_la1[405] = jj_gen;
27025 break label_96;
27026 }
27027 jj_consume_token(6);
27028 ID();
27029 }
27030 } else {
27031 ;
27032 }
27033 break;
27034 case ALTER:
27035 case COMMENT:
27036 case CREATE:
27037 case DROP:
27038 case GRANT:
27039 case RENAME:
27040 case REVOKE:
27041 case ANALYZE:
27042 case ASSOCIATE:
27043 case AUDIT:
27044 case DDL:
27045 case DISASSOCIATE:
27046 case LOGOFF:
27047 case LOGON:
27048 case NOAUDIT:
27049 case SERVERERROR:
27050 case SHUTDOWN:
27051 case STARTUP:
27052 case SUSPEND:
27053 case TRUNCATE:
27054 NonDMLEvent();
27055 break;
27056 default:
27057 jj_la1[406] = jj_gen;
27058 jj_consume_token(-1);
27059 throw new ParseException();
27060 }
27061 }
27062 jj_consume_token(ON);
27063 switch (jj_nt.kind) {
27064 case DATABASE:
27065 jj_consume_token(DATABASE);
27066 break;
27067 default:
27068 jj_la1[407] = jj_gen;
27069 if (jj_2_76(2)) {
27070 jj_consume_token(NESTED);
27071 jj_consume_token(TABLE);
27072 ID();
27073 jj_consume_token(OF);
27074 if (jj_2_74(2)) {
27075 ID();
27076 jj_consume_token(3);
27077 } else {
27078 ;
27079 }
27080 ID();
27081 } else {
27082 switch (jj_nt.kind) {
27083 case REPLACE:
27084 case DEFINER:
27085 case CURRENT_USER:
27086 case SERIALLY_REUSABLE:
27087 case RESTRICT_REFERENCES:
27088 case EXCEPTION_INIT:
27089 case AUTONOMOUS_TRANSACTION:
27090 case LANGUAGE:
27091 case INLINE:
27092 case ADD:
27093 case AGGREGATE:
27094 case ALL:
27095 case ALTER:
27096 case AND:
27097 case ANY:
27098 case ARRAY:
27099 case AS:
27100 case ASC:
27101 case AT:
27102 case ATTRIBUTE:
27103 case AUTHID:
27104 case AVG:
27105 case BETWEEN:
27106 case BINARY_INTEGER:
27107 case BODY:
27108 case BOOLEAN:
27109 case BULK:
27110 case BY:
27111 case BYTE:
27112 case CASCADE:
27113 case CASE:
27114 case CHAR:
27115 case CHAR_BASE:
27116 case CHECK:
27117 case CLOSE:
27118 case CLUSTER:
27119 case COALESCE:
27120 case COLLECT:
27121 case COLUMN:
27122 case COMMENT:
27123 case COMMIT:
27124 case COMPRESS:
27125 case CONNECT:
27126 case CONSTANT:
27127 case CONSTRUCTOR:
27128 case CONTINUE:
27129 case CONVERT:
27130 case CREATE:
27131 case CURRENT:
27132 case CURRVAL:
27133 case CURSOR:
27134 case DATA:
27135 case DATE:
27136 case DAY:
27137 case DECLARE:
27138 case DECIMAL:
27139 case _DEFAULT:
27140 case DELETE:
27141 case DESC:
27142 case DISABLE:
27143 case DISTINCT:
27144 case DO:
27145 case DROP:
27146 case EDITIONABLE:
27147 case ELEMENT:
27148 case ELSE:
27149 case ELSIF:
27150 case ENABLE:
27151 case ESCAPE:
27152 case EXCEPT:
27153 case EXCEPTION:
27154 case EXCEPTIONS:
27155 case EXCLUSIVE:
27156 case EXECUTE:
27157 case EXISTS:
27158 case EXIT:
27159 case EXTERNAL:
27160 case EXTENDS:
27161 case EXTRACT:
27162 case FALSE:
27163 case FETCH:
27164 case FINAL:
27165 case FLOAT:
27166 case FOR:
27167 case FORALL:
27168 case FORCE:
27169 case FROM:
27170 case FUNCTION:
27171 case GLOBAL:
27172 case GOTO:
27173 case GROUP:
27174 case HASH:
27175 case HAVING:
27176 case HEAP:
27177 case HOUR:
27178 case IF:
27179 case IMMEDIATE:
27180 case IN:
27181 case INDEX:
27182 case INDICES:
27183 case INDEXTYPE:
27184 case INDICATOR:
27185 case INSERT:
27186 case INSTANTIABLE:
27187 case INTEGER:
27188 case INTERFACE:
27189 case INTERSECT:
27190 case INTERVAL:
27191 case INTO:
27192 case INVALIDATE:
27193 case IS:
27194 case ISOLATION:
27195 case JAVA:
27196 case LEVEL:
27197 case LIKE:
27198 case LIMIT:
27199 case LIMITED:
27200 case LOCK:
27201 case LONG:
27202 case LOOP:
27203 case MAP:
27204 case MAX:
27205 case MEMBER:
27206 case MERGE:
27207 case MIN:
27208 case MINUS:
27209 case MINUTE:
27210 case MLSLABEL:
27211 case MODIFY:
27212 case MOD:
27213 case MODE:
27214 case MONTH:
27215 case NATURAL:
27216 case NATURALN:
27217 case NEW:
27218 case NEXTVAL:
27219 case NO:
27220 case NOCOPY:
27221 case NONEDITIONABLE:
27222 case NOT:
27223 case NOWAIT:
27224 case NULL:
27225 case NULLIF:
27226 case NUMBER:
27227 case BFILE_BASE:
27228 case BLOB_BASE:
27229 case CLOB_BASE:
27230 case DATE_BASE:
27231 case NUMBER_BASE:
27232 case OBJECT:
27233 case OCIROWID:
27234 case OF:
27235 case OID:
27236 case ON:
27237 case OPAQUE:
27238 case OPEN:
27239 case OPERATOR:
27240 case OPTION:
27241 case OR:
27242 case ORDER:
27243 case ORGANIZATION:
27244 case OTHERS:
27245 case OUT:
27246 case OVERRIDING:
27247 case PACKAGE:
27248 case PARTITION:
27249 case PCTFREE:
27250 case PLS_INTEGER:
27251 case POSITIVE:
27252 case POSITIVEN:
27253 case PRESERVE:
27254 case PRIOR:
27255 case PROMPT:
27256 case PRIVATE:
27257 case PROCEDURE:
27258 case PUBLIC:
27259 case RAISE:
27260 case RANGE:
27261 case RAW:
27262 case REAL:
27263 case RECORD:
27264 case REF:
27265 case RELEASE:
27266 case RELIES_ON:
27267 case RENAME:
27268 case RESULT:
27269 case RETURN:
27270 case RETURNING:
27271 case REVERSE:
27272 case ROLLBACK:
27273 case ROW:
27274 case ROWS:
27275 case ROWID:
27276 case ROWNUM:
27277 case ROWTYPE:
27278 case SAVE:
27279 case SAVEPOINT:
27280 case SECOND:
27281 case SELECT:
27282 case SELF:
27283 case SEPARATE:
27284 case SET:
27285 case SHARE:
27286 case SMALLINT:
27287 case SPACE:
27288 case SQL:
27289 case SQLCODE:
27290 case SQLERRM:
27291 case START:
27292 case STATIC:
27293 case STDDEV:
27294 case SUBTYPE:
27295 case SUBSTITUTABLE:
27296 case SUCCESSFUL:
27297 case SUM:
27298 case SYNONYM:
27299 case SYSDATE:
27300 case SYS_REFCURSOR:
27301 case TABLE:
27302 case TEMPORARY:
27303 case THEN:
27304 case TIME:
27305 case TIMESTAMP:
27306 case TIMEZONE_REGION:
27307 case TIMEZONE_ABBR:
27308 case TIMEZONE_MINUTE:
27309 case TIMEZONE_HOUR:
27310 case TO:
27311 case TRANSACTION:
27312 case TRIGGER:
27313 case TRUE:
27314 case TYPE:
27315 case UI:
27316 case UNDER:
27317 case USING:
27318 case WHILE:
27319 case YES:
27320 case SHOW:
27321 case A:
27322 case UPDATE:
27323 case VARCHAR:
27324 case VARCHAR2:
27325 case DOUBLE:
27326 case DEC:
27327 case PRECISION:
27328 case INT:
27329 case NUMERIC:
27330 case SIGNTYPE:
27331 case NCHAR:
27332 case NVARCHAR2:
27333 case STRING:
27334 case UROWID:
27335 case VARRAY:
27336 case VARYING:
27337 case BFILE:
27338 case BLOB:
27339 case CLOB:
27340 case NCLOB:
27341 case YEAR:
27342 case LOCAL:
27343 case WITH:
27344 case ZONE:
27345 case CHARACTER:
27346 case AFTER:
27347 case BEFORE:
27348 case OLD:
27349 case PARENT:
27350 case ANALYZE:
27351 case ASSOCIATE:
27352 case AUDIT:
27353 case COMPOUND:
27354 case DATABASE:
27355 case CALL:
27356 case DDL:
27357 case DISASSOCIATE:
27358 case EACH:
27359 case FOLLOWS:
27360 case LOGOFF:
27361 case LOGON:
27362 case NESTED:
27363 case NOAUDIT:
27364 case SCHEMA:
27365 case SERVERERROR:
27366 case SHUTDOWN:
27367 case STARTUP:
27368 case STATEMENT:
27369 case STATISTICS:
27370 case SUSPEND:
27371 case TRUNCATE:
27372 case WRAPPED:
27373 case LIBRARY:
27374 case NAME:
27375 case STRUCT:
27376 case CONTEXT:
27377 case PARAMETERS:
27378 case LENGTH:
27379 case TDO:
27380 case MAXLEN:
27381 case CHARSETID:
27382 case CHARSETFORM:
27383 case ACCEPT:
27384 case ACCESSIBLE:
27385 case COPY:
27386 case DEFINE:
27387 case DISCONNECT:
27388 case HOST:
27389 case PRINT:
27390 case QUIT:
27391 case REMARK:
27392 case UNDEFINE:
27393 case VARIABLE:
27394 case WHENEVER:
27395 case ATTACH:
27396 case CAST:
27397 case TREAT:
27398 case TRIM:
27399 case LEFT:
27400 case RIGHT:
27401 case BOTH:
27402 case EMPTY:
27403 case MULTISET:
27404 case SUBMULTISET:
27405 case LEADING:
27406 case TRAILING:
27407 case CHAR_CS:
27408 case NCHAR_CS:
27409 case DBTIMEZONE:
27410 case SESSIONTIMEZONE:
27411 case AUTHENTICATED:
27412 case LINK:
27413 case SHARED:
27414 case DIRECTORY:
27415 case USER:
27416 case IDENTIFIER:
27417 case QUOTED_LITERAL:
27418 case SQLDATA_CLASS:
27419 case CUSTOMDATUM_CLASS:
27420 case ORADATA_CLASS:
27421 case JAVA_INTERFACE_CLASS:
27422 if (jj_2_75(2)) {
27423 ID();
27424 jj_consume_token(3);
27425 } else {
27426 ;
27427 }
27428 ID();
27429 break;
27430 default:
27431 jj_la1[408] = jj_gen;
27432 jj_consume_token(-1);
27433 throw new ParseException();
27434 }
27435 }
27436 }
27437 switch (jj_nt.kind) {
27438 case REFERENCING:
27439 jj_consume_token(REFERENCING);
27440 label_97:
27441 while (true) {
27442 switch (jj_nt.kind) {
27443 case NEW:
27444 case OLD:
27445 case PARENT:
27446 ;
27447 break;
27448 default:
27449 jj_la1[409] = jj_gen;
27450 break label_97;
27451 }
27452 switch (jj_nt.kind) {
27453 case OLD:
27454 jj_consume_token(OLD);
27455 break;
27456 case NEW:
27457 jj_consume_token(NEW);
27458 break;
27459 case PARENT:
27460 jj_consume_token(PARENT);
27461 break;
27462 default:
27463 jj_la1[410] = jj_gen;
27464 jj_consume_token(-1);
27465 throw new ParseException();
27466 }
27467 jj_consume_token(AS);
27468 ID();
27469 }
27470 break;
27471 default:
27472 jj_la1[411] = jj_gen;
27473 ;
27474 }
27475 switch (jj_nt.kind) {
27476 case FOREACHROW:
27477 jj_consume_token(FOREACHROW);
27478 break;
27479 default:
27480 jj_la1[412] = jj_gen;
27481 ;
27482 }
27483 switch (jj_nt.kind) {
27484 case REVERSE:
27485 case FORWARD:
27486 case CROSSEDITION:
27487 switch (jj_nt.kind) {
27488 case REVERSE:
27489 case FORWARD:
27490 switch (jj_nt.kind) {
27491 case FORWARD:
27492 jj_consume_token(FORWARD);
27493 break;
27494 case REVERSE:
27495 jj_consume_token(REVERSE);
27496 break;
27497 default:
27498 jj_la1[413] = jj_gen;
27499 jj_consume_token(-1);
27500 throw new ParseException();
27501 }
27502 break;
27503 default:
27504 jj_la1[414] = jj_gen;
27505 ;
27506 }
27507 jj_consume_token(CROSSEDITION);
27508 break;
27509 default:
27510 jj_la1[415] = jj_gen;
27511 ;
27512 }
27513 switch (jj_nt.kind) {
27514 case FOLLOWS:
27515 case PRECEDES:
27516 switch (jj_nt.kind) {
27517 case FOLLOWS:
27518 jj_consume_token(FOLLOWS);
27519 break;
27520 case PRECEDES:
27521 jj_consume_token(PRECEDES);
27522 break;
27523 default:
27524 jj_la1[416] = jj_gen;
27525 jj_consume_token(-1);
27526 throw new ParseException();
27527 }
27528 if (jj_2_77(2)) {
27529 ID();
27530 jj_consume_token(3);
27531 } else {
27532 ;
27533 }
27534 ID();
27535 label_98:
27536 while (true) {
27537 switch (jj_nt.kind) {
27538 case 6:
27539 ;
27540 break;
27541 default:
27542 jj_la1[417] = jj_gen;
27543 break label_98;
27544 }
27545 jj_consume_token(6);
27546 if (jj_2_78(2)) {
27547 ID();
27548 jj_consume_token(3);
27549 } else {
27550 ;
27551 }
27552 ID();
27553 }
27554 break;
27555 default:
27556 jj_la1[418] = jj_gen;
27557 ;
27558 }
27559 switch (jj_nt.kind) {
27560 case DISABLE:
27561 case ENABLE:
27562 switch (jj_nt.kind) {
27563 case ENABLE:
27564 jj_consume_token(ENABLE);
27565 break;
27566 case DISABLE:
27567 jj_consume_token(DISABLE);
27568 break;
27569 default:
27570 jj_la1[419] = jj_gen;
27571 jj_consume_token(-1);
27572 throw new ParseException();
27573 }
27574 break;
27575 default:
27576 jj_la1[420] = jj_gen;
27577 ;
27578 }
27579 switch (jj_nt.kind) {
27580 case WHEN:
27581 jj_consume_token(WHEN);
27582 jj_consume_token(5);
27583 ConditionalOrExpression();
27584 jj_consume_token(7);
27585 break;
27586 default:
27587 jj_la1[421] = jj_gen;
27588 ;
27589 }
27590 switch (jj_nt.kind) {
27591 case CALL:
27592 jj_consume_token(CALL);
27593 PrimaryExpression();
27594 jj_consume_token(4);
27595 break;
27596 case COMPOUND:
27597 CompoundTriggerBlock();
27598 break;
27599 case BEGIN:
27600 case DECLARE:
27601 Block();
27602 jj_consume_token(4);
27603 break;
27604 default:
27605 jj_la1[422] = jj_gen;
27606 jj_consume_token(-1);
27607 throw new ParseException();
27608 }
27609 jjtree.closeNodeScope(jjtn000, true);
27610 jjtc000 = false;
27611 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
27612 } catch (Throwable jjte000) {
27613 if (jjtc000) {
27614 jjtree.clearNodeScope(jjtn000);
27615 jjtc000 = false;
27616 } else {
27617 jjtree.popNode();
27618 }
27619 if (jjte000 instanceof RuntimeException) {
27620 {if (true) throw (RuntimeException)jjte000;}
27621 }
27622 if (jjte000 instanceof ParseException) {
27623 {if (true) throw (ParseException)jjte000;}
27624 }
27625 {if (true) throw (Error)jjte000;}
27626 } finally {
27627 if (jjtc000) {
27628 jjtree.closeNodeScope(jjtn000, true);
27629 }
27630 }
27631 throw new Error("Missing return statement in function");
27632 }
27633
27634 final public ASTTriggerTimingPointSection TriggerTimingPointSection() throws ParseException {
27635
27636 ASTTriggerTimingPointSection jjtn000 = new ASTTriggerTimingPointSection(this, JJTTRIGGERTIMINGPOINTSECTION);
27637 boolean jjtc000 = true;
27638 jjtree.openNodeScope(jjtn000);StringBuilder sb = new StringBuilder();
27639 try {
27640 switch (jj_nt.kind) {
27641 case BEFORE:
27642 jj_consume_token(BEFORE);
27643 break;
27644 case AFTER:
27645 jj_consume_token(AFTER);
27646 break;
27647 case INSTEADOF:
27648 jj_consume_token(INSTEADOF);
27649 break;
27650 default:
27651 jj_la1[423] = jj_gen;
27652 jj_consume_token(-1);
27653 throw new ParseException();
27654 }
27655 sb.append(token.image) ;
27656 switch (jj_nt.kind) {
27657 case STATEMENT:
27658 jj_consume_token(STATEMENT);
27659 break;
27660 case EACH:
27661 jj_consume_token(EACH);
27662 jj_consume_token(ROW);
27663 break;
27664 default:
27665 jj_la1[424] = jj_gen;
27666 jj_consume_token(-1);
27667 throw new ParseException();
27668 }
27669 sb.append(" "); sb.append(token.image) ;
27670 jj_consume_token(IS);
27671 jj_consume_token(BEGIN);
27672 label_99:
27673 while (true) {
27674 Statement();
27675 switch (jj_nt.kind) {
27676 case 5:
27677 case 16:
27678 case 17:
27679 case 21:
27680 case REPLACE:
27681 case DEFINER:
27682 case CURRENT_USER:
27683 case LANGUAGE:
27684 case INLINE:
27685 case ADD:
27686 case AGGREGATE:
27687 case ARRAY:
27688 case AT:
27689 case ATTRIBUTE:
27690 case AUTHID:
27691 case BEGIN:
27692 case BODY:
27693 case BULK:
27694 case BYTE:
27695 case CASCADE:
27696 case CASE:
27697 case CLOSE:
27698 case COALESCE:
27699 case COLLECT:
27700 case COLUMN:
27701 case COMMENT:
27702 case COMMIT:
27703 case CONSTRUCTOR:
27704 case CONTINUE:
27705 case CONVERT:
27706 case CURRENT:
27707 case CURSOR:
27708 case DATA:
27709 case DATE:
27710 case DAY:
27711 case DECLARE:
27712 case DELETE:
27713 case DISABLE:
27714 case EDITIONABLE:
27715 case ELEMENT:
27716 case ENABLE:
27717 case ESCAPE:
27718 case EXCEPT:
27719 case EXCEPTIONS:
27720 case EXECUTE:
27721 case EXIT:
27722 case EXTERNAL:
27723 case EXTENDS:
27724 case EXTRACT:
27725 case FALSE:
27726 case FETCH:
27727 case FINAL:
27728 case FOR:
27729 case FORALL:
27730 case FORCE:
27731 case FUNCTION:
27732 case GLOBAL:
27733 case GOTO:
27734 case HASH:
27735 case HEAP:
27736 case HOUR:
27737 case IF:
27738 case IMMEDIATE:
27739 case INDICES:
27740 case INDEXTYPE:
27741 case INDICATOR:
27742 case INSERT:
27743 case INSTANTIABLE:
27744 case INTERVAL:
27745 case INVALIDATE:
27746 case ISOLATION:
27747 case JAVA:
27748 case LEVEL:
27749 case LIMIT:
27750 case LOCK:
27751 case LOOP:
27752 case MAP:
27753 case MAX:
27754 case MEMBER:
27755 case MERGE:
27756 case MIN:
27757 case MINUTE:
27758 case MLSLABEL:
27759 case MODIFY:
27760 case MOD:
27761 case MONTH:
27762 case NATURAL:
27763 case NEW:
27764 case NEW_DOT:
27765 case NO:
27766 case NONEDITIONABLE:
27767 case NOT:
27768 case NULL:
27769 case NULLIF:
27770 case OBJECT:
27771 case OID:
27772 case OPAQUE:
27773 case OPEN:
27774 case OPERATOR:
27775 case ORGANIZATION:
27776 case OTHERS:
27777 case OVERRIDING:
27778 case PACKAGE:
27779 case PARTITION:
27780 case PIPE:
27781 case PRAGMA:
27782 case PRESERVE:
27783 case PRIVATE:
27784 case PROCEDURE:
27785 case RAISE:
27786 case RANGE:
27787 case RAW:
27788 case REAL:
27789 case RECORD:
27790 case REF:
27791 case RELEASE:
27792 case RELIES_ON:
27793 case RENAME:
27794 case RESULT:
27795 case RETURN:
27796 case RETURNING:
27797 case REVERSE:
27798 case ROLLBACK:
27799 case ROW:
27800 case ROWS:
27801 case ROWID:
27802 case ROWNUM:
27803 case SAVE:
27804 case SAVEPOINT:
27805 case SECOND:
27806 case SELECT:
27807 case SELF:
27808 case SET:
27809 case SPACE:
27810 case SQL:
27811 case SQLCODE:
27812 case SQLERRM:
27813 case STATIC:
27814 case SUBTYPE:
27815 case SUBSTITUTABLE:
27816 case SUCCESSFUL:
27817 case SYSDATE:
27818 case SYS_REFCURSOR:
27819 case TEMPORARY:
27820 case TIME:
27821 case TIMESTAMP:
27822 case TIMEZONE_REGION:
27823 case TIMEZONE_ABBR:
27824 case TIMEZONE_MINUTE:
27825 case TIMEZONE_HOUR:
27826 case TRANSACTION:
27827 case TRUE:
27828 case TYPE:
27829 case UNDER:
27830 case USING:
27831 case WHILE:
27832 case YES:
27833 case SHOW:
27834 case A:
27835 case UPDATE:
27836 case DOUBLE:
27837 case DEC:
27838 case PRECISION:
27839 case INT:
27840 case NUMERIC:
27841 case NCHAR:
27842 case NVARCHAR2:
27843 case STRING:
27844 case UROWID:
27845 case VARRAY:
27846 case VARYING:
27847 case BFILE:
27848 case BLOB:
27849 case CLOB:
27850 case NCLOB:
27851 case YEAR:
27852 case LOCAL:
27853 case WITH:
27854 case ZONE:
27855 case CHARACTER:
27856 case AFTER:
27857 case BEFORE:
27858 case OLD:
27859 case PARENT:
27860 case CC_IF:
27861 case CC_ERROR:
27862 case ANALYZE:
27863 case ASSOCIATE:
27864 case AUDIT:
27865 case COMPOUND:
27866 case DATABASE:
27867 case CALL:
27868 case DDL:
27869 case DISASSOCIATE:
27870 case EACH:
27871 case FOLLOWS:
27872 case LOGOFF:
27873 case LOGON:
27874 case NESTED:
27875 case NOAUDIT:
27876 case SCHEMA:
27877 case SERVERERROR:
27878 case SHUTDOWN:
27879 case STARTUP:
27880 case STATEMENT:
27881 case STATISTICS:
27882 case SUSPEND:
27883 case TRUNCATE:
27884 case WRAPPED:
27885 case LIBRARY:
27886 case NAME:
27887 case STRUCT:
27888 case CONTEXT:
27889 case PARAMETERS:
27890 case LENGTH:
27891 case TDO:
27892 case MAXLEN:
27893 case CHARSETID:
27894 case CHARSETFORM:
27895 case ACCEPT:
27896 case ACCESSIBLE:
27897 case COPY:
27898 case DEFINE:
27899 case DISCONNECT:
27900 case HOST:
27901 case PRINT:
27902 case QUIT:
27903 case REMARK:
27904 case UNDEFINE:
27905 case VARIABLE:
27906 case WHENEVER:
27907 case ATTACH:
27908 case CAST:
27909 case TREAT:
27910 case TRIM:
27911 case LEFT:
27912 case RIGHT:
27913 case BOTH:
27914 case EMPTY:
27915 case MULTISET:
27916 case SUBMULTISET:
27917 case LEADING:
27918 case TRAILING:
27919 case CHAR_CS:
27920 case NCHAR_CS:
27921 case DBTIMEZONE:
27922 case SESSIONTIMEZONE:
27923 case AUTHENTICATED:
27924 case LINK:
27925 case SHARED:
27926 case DIRECTORY:
27927 case USER:
27928 case IDENTIFIER:
27929 case UNSIGNED_NUMERIC_LITERAL:
27930 case CHARACTER_LITERAL:
27931 case STRING_LITERAL:
27932 case QUOTED_LITERAL:
27933 ;
27934 break;
27935 default:
27936 jj_la1[425] = jj_gen;
27937 break label_99;
27938 }
27939 }
27940 jj_consume_token(END);
27941 switch (jj_nt.kind) {
27942 case BEFORE:
27943 jj_consume_token(BEFORE);
27944 break;
27945 case AFTER:
27946 jj_consume_token(AFTER);
27947 break;
27948 case INSTEADOF:
27949 jj_consume_token(INSTEADOF);
27950 break;
27951 default:
27952 jj_la1[426] = jj_gen;
27953 jj_consume_token(-1);
27954 throw new ParseException();
27955 }
27956 switch (jj_nt.kind) {
27957 case STATEMENT:
27958 jj_consume_token(STATEMENT);
27959 break;
27960 case EACH:
27961 jj_consume_token(EACH);
27962 jj_consume_token(ROW);
27963 break;
27964 default:
27965 jj_la1[427] = jj_gen;
27966 jj_consume_token(-1);
27967 throw new ParseException();
27968 }
27969 jj_consume_token(4);
27970
27971 jjtree.closeNodeScope(jjtn000, true);
27972 jjtc000 = false;
27973 jjtn000.setImage(sb.toString()) ; {if (true) return jjtn000 ;}
27974 } catch (Throwable jjte000) {
27975 if (jjtc000) {
27976 jjtree.clearNodeScope(jjtn000);
27977 jjtc000 = false;
27978 } else {
27979 jjtree.popNode();
27980 }
27981 if (jjte000 instanceof RuntimeException) {
27982 {if (true) throw (RuntimeException)jjte000;}
27983 }
27984 if (jjte000 instanceof ParseException) {
27985 {if (true) throw (ParseException)jjte000;}
27986 }
27987 {if (true) throw (Error)jjte000;}
27988 } finally {
27989 if (jjtc000) {
27990 jjtree.closeNodeScope(jjtn000, true);
27991 }
27992 }
27993 throw new Error("Missing return statement in function");
27994 }
27995
27996 final public ASTCompoundTriggerBlock CompoundTriggerBlock() throws ParseException {
27997
27998 ASTCompoundTriggerBlock jjtn000 = new ASTCompoundTriggerBlock(this, JJTCOMPOUNDTRIGGERBLOCK);
27999 boolean jjtc000 = true;
28000 jjtree.openNodeScope(jjtn000);
28001 try {
28002 jj_consume_token(COMPOUND);
28003 jj_consume_token(TRIGGER);
28004 label_100:
28005 while (true) {
28006 switch (jj_nt.kind) {
28007 case REPLACE:
28008 case DEFINER:
28009 case CURRENT_USER:
28010 case SERIALLY_REUSABLE:
28011 case RESTRICT_REFERENCES:
28012 case EXCEPTION_INIT:
28013 case AUTONOMOUS_TRANSACTION:
28014 case LANGUAGE:
28015 case INLINE:
28016 case ADD:
28017 case AGGREGATE:
28018 case ALL:
28019 case ALTER:
28020 case AND:
28021 case ANY:
28022 case ARRAY:
28023 case AS:
28024 case ASC:
28025 case AT:
28026 case ATTRIBUTE:
28027 case AUTHID:
28028 case AVG:
28029 case BETWEEN:
28030 case BINARY_INTEGER:
28031 case BODY:
28032 case BOOLEAN:
28033 case BULK:
28034 case BY:
28035 case BYTE:
28036 case CASCADE:
28037 case CASE:
28038 case CHAR:
28039 case CHAR_BASE:
28040 case CHECK:
28041 case CLOSE:
28042 case CLUSTER:
28043 case COALESCE:
28044 case COLLECT:
28045 case COLUMN:
28046 case COMMENT:
28047 case COMMIT:
28048 case COMPRESS:
28049 case CONNECT:
28050 case CONSTANT:
28051 case CONSTRUCTOR:
28052 case CONTINUE:
28053 case CONVERT:
28054 case CREATE:
28055 case CURRENT:
28056 case CURRVAL:
28057 case CURSOR:
28058 case DATA:
28059 case DATE:
28060 case DAY:
28061 case DECLARE:
28062 case DECIMAL:
28063 case _DEFAULT:
28064 case DELETE:
28065 case DESC:
28066 case DISABLE:
28067 case DISTINCT:
28068 case DO:
28069 case DROP:
28070 case EDITIONABLE:
28071 case ELEMENT:
28072 case ELSE:
28073 case ELSIF:
28074 case ENABLE:
28075 case ESCAPE:
28076 case EXCEPT:
28077 case EXCEPTION:
28078 case EXCEPTIONS:
28079 case EXCLUSIVE:
28080 case EXECUTE:
28081 case EXISTS:
28082 case EXIT:
28083 case EXTERNAL:
28084 case EXTENDS:
28085 case EXTRACT:
28086 case FALSE:
28087 case FETCH:
28088 case FINAL:
28089 case FLOAT:
28090 case FOR:
28091 case FORALL:
28092 case FORCE:
28093 case FROM:
28094 case FUNCTION:
28095 case GLOBAL:
28096 case GOTO:
28097 case GROUP:
28098 case HASH:
28099 case HAVING:
28100 case HEAP:
28101 case HOUR:
28102 case IF:
28103 case IMMEDIATE:
28104 case IN:
28105 case INDEX:
28106 case INDICES:
28107 case INDEXTYPE:
28108 case INDICATOR:
28109 case INSERT:
28110 case INSTANTIABLE:
28111 case INTEGER:
28112 case INTERFACE:
28113 case INTERSECT:
28114 case INTERVAL:
28115 case INTO:
28116 case INVALIDATE:
28117 case IS:
28118 case ISOLATION:
28119 case JAVA:
28120 case LEVEL:
28121 case LIKE:
28122 case LIMIT:
28123 case LIMITED:
28124 case LOCK:
28125 case LONG:
28126 case LOOP:
28127 case MAP:
28128 case MAX:
28129 case MEMBER:
28130 case MERGE:
28131 case MIN:
28132 case MINUS:
28133 case MINUTE:
28134 case MLSLABEL:
28135 case MODIFY:
28136 case MOD:
28137 case MODE:
28138 case MONTH:
28139 case NATURAL:
28140 case NATURALN:
28141 case NEW:
28142 case NEXTVAL:
28143 case NO:
28144 case NOCOPY:
28145 case NONEDITIONABLE:
28146 case NOT:
28147 case NOWAIT:
28148 case NULL:
28149 case NULLIF:
28150 case NUMBER:
28151 case BFILE_BASE:
28152 case BLOB_BASE:
28153 case CLOB_BASE:
28154 case DATE_BASE:
28155 case NUMBER_BASE:
28156 case OBJECT:
28157 case OCIROWID:
28158 case OF:
28159 case OID:
28160 case ON:
28161 case OPAQUE:
28162 case OPEN:
28163 case OPERATOR:
28164 case OPTION:
28165 case OR:
28166 case ORDER:
28167 case ORGANIZATION:
28168 case OTHERS:
28169 case OUT:
28170 case OVERRIDING:
28171 case PACKAGE:
28172 case PARTITION:
28173 case PCTFREE:
28174 case PLS_INTEGER:
28175 case POSITIVE:
28176 case POSITIVEN:
28177 case PRAGMA:
28178 case PRESERVE:
28179 case PRIOR:
28180 case PROMPT:
28181 case PRIVATE:
28182 case PROCEDURE:
28183 case PUBLIC:
28184 case RAISE:
28185 case RANGE:
28186 case RAW:
28187 case REAL:
28188 case RECORD:
28189 case REF:
28190 case RELEASE:
28191 case RELIES_ON:
28192 case RENAME:
28193 case RESULT:
28194 case RETURN:
28195 case RETURNING:
28196 case REVERSE:
28197 case ROLLBACK:
28198 case ROW:
28199 case ROWS:
28200 case ROWID:
28201 case ROWNUM:
28202 case ROWTYPE:
28203 case SAVE:
28204 case SAVEPOINT:
28205 case SECOND:
28206 case SELECT:
28207 case SELF:
28208 case SEPARATE:
28209 case SET:
28210 case SHARE:
28211 case SMALLINT:
28212 case SPACE:
28213 case SQL:
28214 case SQLCODE:
28215 case SQLERRM:
28216 case START:
28217 case STATIC:
28218 case STDDEV:
28219 case SUBTYPE:
28220 case SUBSTITUTABLE:
28221 case SUCCESSFUL:
28222 case SUM:
28223 case SYNONYM:
28224 case SYSDATE:
28225 case SYS_REFCURSOR:
28226 case TABLE:
28227 case TEMPORARY:
28228 case THEN:
28229 case TIME:
28230 case TIMESTAMP:
28231 case TIMEZONE_REGION:
28232 case TIMEZONE_ABBR:
28233 case TIMEZONE_MINUTE:
28234 case TIMEZONE_HOUR:
28235 case TO:
28236 case TRANSACTION:
28237 case TRIGGER:
28238 case TRUE:
28239 case TYPE:
28240 case UI:
28241 case UNDER:
28242 case USING:
28243 case WHILE:
28244 case YES:
28245 case SHOW:
28246 case A:
28247 case UPDATE:
28248 case VARCHAR:
28249 case VARCHAR2:
28250 case DOUBLE:
28251 case DEC:
28252 case PRECISION:
28253 case INT:
28254 case NUMERIC:
28255 case SIGNTYPE:
28256 case NCHAR:
28257 case NVARCHAR2:
28258 case STRING:
28259 case UROWID:
28260 case VARRAY:
28261 case VARYING:
28262 case BFILE:
28263 case BLOB:
28264 case CLOB:
28265 case NCLOB:
28266 case YEAR:
28267 case LOCAL:
28268 case WITH:
28269 case ZONE:
28270 case CHARACTER:
28271 case AFTER:
28272 case BEFORE:
28273 case INSTEADOF:
28274 case OLD:
28275 case PARENT:
28276 case ANALYZE:
28277 case ASSOCIATE:
28278 case AUDIT:
28279 case COMPOUND:
28280 case DATABASE:
28281 case CALL:
28282 case DDL:
28283 case DISASSOCIATE:
28284 case EACH:
28285 case FOLLOWS:
28286 case LOGOFF:
28287 case LOGON:
28288 case NESTED:
28289 case NOAUDIT:
28290 case SCHEMA:
28291 case SERVERERROR:
28292 case SHUTDOWN:
28293 case STARTUP:
28294 case STATEMENT:
28295 case STATISTICS:
28296 case SUSPEND:
28297 case TRUNCATE:
28298 case WRAPPED:
28299 case LIBRARY:
28300 case NAME:
28301 case STRUCT:
28302 case CONTEXT:
28303 case PARAMETERS:
28304 case LENGTH:
28305 case TDO:
28306 case MAXLEN:
28307 case CHARSETID:
28308 case CHARSETFORM:
28309 case ACCEPT:
28310 case ACCESSIBLE:
28311 case COPY:
28312 case DEFINE:
28313 case DISCONNECT:
28314 case HOST:
28315 case PRINT:
28316 case QUIT:
28317 case REMARK:
28318 case UNDEFINE:
28319 case VARIABLE:
28320 case WHENEVER:
28321 case ATTACH:
28322 case CAST:
28323 case TREAT:
28324 case TRIM:
28325 case LEFT:
28326 case RIGHT:
28327 case BOTH:
28328 case EMPTY:
28329 case MULTISET:
28330 case SUBMULTISET:
28331 case LEADING:
28332 case TRAILING:
28333 case CHAR_CS:
28334 case NCHAR_CS:
28335 case DBTIMEZONE:
28336 case SESSIONTIMEZONE:
28337 case AUTHENTICATED:
28338 case LINK:
28339 case SHARED:
28340 case DIRECTORY:
28341 case USER:
28342 case IDENTIFIER:
28343 case QUOTED_LITERAL:
28344 case SQLDATA_CLASS:
28345 case CUSTOMDATUM_CLASS:
28346 case ORADATA_CLASS:
28347 case JAVA_INTERFACE_CLASS:
28348 ;
28349 break;
28350 default:
28351 jj_la1[428] = jj_gen;
28352 break label_100;
28353 }
28354 switch (jj_nt.kind) {
28355 case AFTER:
28356 case BEFORE:
28357 case INSTEADOF:
28358 TriggerTimingPointSection();
28359 break;
28360 case PRAGMA:
28361 Pragma();
28362 break;
28363 default:
28364 jj_la1[429] = jj_gen;
28365 if (jj_2_79(2)) {
28366 ExceptionDeclaration();
28367 } else if (jj_2_80(2)) {
28368 SubTypeDefinition();
28369 } else if (jj_2_81(4)) {
28370 VariableOrConstantDeclaration();
28371 } else if (jj_2_82(2)) {
28372 CursorSpecification();
28373 } else {
28374 switch (jj_nt.kind) {
28375 case CURSOR:
28376 CursorBody();
28377 break;
28378 case IDENTIFIER:
28379 CollectionDeclaration();
28380 break;
28381 case CREATE:
28382 case FUNCTION:
28383 case PROCEDURE:
28384 ProgramUnit();
28385 break;
28386 default:
28387 jj_la1[430] = jj_gen;
28388 jj_consume_token(-1);
28389 throw new ParseException();
28390 }
28391 }
28392 }
28393 }
28394 jj_consume_token(END);
28395 switch (jj_nt.kind) {
28396 case REPLACE:
28397 case DEFINER:
28398 case CURRENT_USER:
28399 case SERIALLY_REUSABLE:
28400 case RESTRICT_REFERENCES:
28401 case EXCEPTION_INIT:
28402 case AUTONOMOUS_TRANSACTION:
28403 case LANGUAGE:
28404 case INLINE:
28405 case ADD:
28406 case AGGREGATE:
28407 case ALL:
28408 case ALTER:
28409 case AND:
28410 case ANY:
28411 case ARRAY:
28412 case AS:
28413 case ASC:
28414 case AT:
28415 case ATTRIBUTE:
28416 case AUTHID:
28417 case AVG:
28418 case BETWEEN:
28419 case BINARY_INTEGER:
28420 case BODY:
28421 case BOOLEAN:
28422 case BULK:
28423 case BY:
28424 case BYTE:
28425 case CASCADE:
28426 case CASE:
28427 case CHAR:
28428 case CHAR_BASE:
28429 case CHECK:
28430 case CLOSE:
28431 case CLUSTER:
28432 case COALESCE:
28433 case COLLECT:
28434 case COLUMN:
28435 case COMMENT:
28436 case COMMIT:
28437 case COMPRESS:
28438 case CONNECT:
28439 case CONSTANT:
28440 case CONSTRUCTOR:
28441 case CONTINUE:
28442 case CONVERT:
28443 case CREATE:
28444 case CURRENT:
28445 case CURRVAL:
28446 case CURSOR:
28447 case DATA:
28448 case DATE:
28449 case DAY:
28450 case DECLARE:
28451 case DECIMAL:
28452 case _DEFAULT:
28453 case DELETE:
28454 case DESC:
28455 case DISABLE:
28456 case DISTINCT:
28457 case DO:
28458 case DROP:
28459 case EDITIONABLE:
28460 case ELEMENT:
28461 case ELSE:
28462 case ELSIF:
28463 case ENABLE:
28464 case ESCAPE:
28465 case EXCEPT:
28466 case EXCEPTION:
28467 case EXCEPTIONS:
28468 case EXCLUSIVE:
28469 case EXECUTE:
28470 case EXISTS:
28471 case EXIT:
28472 case EXTERNAL:
28473 case EXTENDS:
28474 case EXTRACT:
28475 case FALSE:
28476 case FETCH:
28477 case FINAL:
28478 case FLOAT:
28479 case FOR:
28480 case FORALL:
28481 case FORCE:
28482 case FROM:
28483 case FUNCTION:
28484 case GLOBAL:
28485 case GOTO:
28486 case GROUP:
28487 case HASH:
28488 case HAVING:
28489 case HEAP:
28490 case HOUR:
28491 case IF:
28492 case IMMEDIATE:
28493 case IN:
28494 case INDEX:
28495 case INDICES:
28496 case INDEXTYPE:
28497 case INDICATOR:
28498 case INSERT:
28499 case INSTANTIABLE:
28500 case INTEGER:
28501 case INTERFACE:
28502 case INTERSECT:
28503 case INTERVAL:
28504 case INTO:
28505 case INVALIDATE:
28506 case IS:
28507 case ISOLATION:
28508 case JAVA:
28509 case LEVEL:
28510 case LIKE:
28511 case LIMIT:
28512 case LIMITED:
28513 case LOCK:
28514 case LONG:
28515 case LOOP:
28516 case MAP:
28517 case MAX:
28518 case MEMBER:
28519 case MERGE:
28520 case MIN:
28521 case MINUS:
28522 case MINUTE:
28523 case MLSLABEL:
28524 case MODIFY:
28525 case MOD:
28526 case MODE:
28527 case MONTH:
28528 case NATURAL:
28529 case NATURALN:
28530 case NEW:
28531 case NEXTVAL:
28532 case NO:
28533 case NOCOPY:
28534 case NONEDITIONABLE:
28535 case NOT:
28536 case NOWAIT:
28537 case NULL:
28538 case NULLIF:
28539 case NUMBER:
28540 case BFILE_BASE:
28541 case BLOB_BASE:
28542 case CLOB_BASE:
28543 case DATE_BASE:
28544 case NUMBER_BASE:
28545 case OBJECT:
28546 case OCIROWID:
28547 case OF:
28548 case OID:
28549 case ON:
28550 case OPAQUE:
28551 case OPEN:
28552 case OPERATOR:
28553 case OPTION:
28554 case OR:
28555 case ORDER:
28556 case ORGANIZATION:
28557 case OTHERS:
28558 case OUT:
28559 case OVERRIDING:
28560 case PACKAGE:
28561 case PARTITION:
28562 case PCTFREE:
28563 case PLS_INTEGER:
28564 case POSITIVE:
28565 case POSITIVEN:
28566 case PRESERVE:
28567 case PRIOR:
28568 case PROMPT:
28569 case PRIVATE:
28570 case PROCEDURE:
28571 case PUBLIC:
28572 case RAISE:
28573 case RANGE:
28574 case RAW:
28575 case REAL:
28576 case RECORD:
28577 case REF:
28578 case RELEASE:
28579 case RELIES_ON:
28580 case RENAME:
28581 case RESULT:
28582 case RETURN:
28583 case RETURNING:
28584 case REVERSE:
28585 case ROLLBACK:
28586 case ROW:
28587 case ROWS:
28588 case ROWID:
28589 case ROWNUM:
28590 case ROWTYPE:
28591 case SAVE:
28592 case SAVEPOINT:
28593 case SECOND:
28594 case SELECT:
28595 case SELF:
28596 case SEPARATE:
28597 case SET:
28598 case SHARE:
28599 case SMALLINT:
28600 case SPACE:
28601 case SQL:
28602 case SQLCODE:
28603 case SQLERRM:
28604 case START:
28605 case STATIC:
28606 case STDDEV:
28607 case SUBTYPE:
28608 case SUBSTITUTABLE:
28609 case SUCCESSFUL:
28610 case SUM:
28611 case SYNONYM:
28612 case SYSDATE:
28613 case SYS_REFCURSOR:
28614 case TABLE:
28615 case TEMPORARY:
28616 case THEN:
28617 case TIME:
28618 case TIMESTAMP:
28619 case TIMEZONE_REGION:
28620 case TIMEZONE_ABBR:
28621 case TIMEZONE_MINUTE:
28622 case TIMEZONE_HOUR:
28623 case TO:
28624 case TRANSACTION:
28625 case TRIGGER:
28626 case TRUE:
28627 case TYPE:
28628 case UI:
28629 case UNDER:
28630 case USING:
28631 case WHILE:
28632 case YES:
28633 case SHOW:
28634 case A:
28635 case UPDATE:
28636 case VARCHAR:
28637 case VARCHAR2:
28638 case DOUBLE:
28639 case DEC:
28640 case PRECISION:
28641 case INT:
28642 case NUMERIC:
28643 case SIGNTYPE:
28644 case NCHAR:
28645 case NVARCHAR2:
28646 case STRING:
28647 case UROWID:
28648 case VARRAY:
28649 case VARYING:
28650 case BFILE:
28651 case BLOB:
28652 case CLOB:
28653 case NCLOB:
28654 case YEAR:
28655 case LOCAL:
28656 case WITH:
28657 case ZONE:
28658 case CHARACTER:
28659 case AFTER:
28660 case BEFORE:
28661 case OLD:
28662 case PARENT:
28663 case ANALYZE:
28664 case ASSOCIATE:
28665 case AUDIT:
28666 case COMPOUND:
28667 case DATABASE:
28668 case CALL:
28669 case DDL:
28670 case DISASSOCIATE:
28671 case EACH:
28672 case FOLLOWS:
28673 case LOGOFF:
28674 case LOGON:
28675 case NESTED:
28676 case NOAUDIT:
28677 case SCHEMA:
28678 case SERVERERROR:
28679 case SHUTDOWN:
28680 case STARTUP:
28681 case STATEMENT:
28682 case STATISTICS:
28683 case SUSPEND:
28684 case TRUNCATE:
28685 case WRAPPED:
28686 case LIBRARY:
28687 case NAME:
28688 case STRUCT:
28689 case CONTEXT:
28690 case PARAMETERS:
28691 case LENGTH:
28692 case TDO:
28693 case MAXLEN:
28694 case CHARSETID:
28695 case CHARSETFORM:
28696 case ACCEPT:
28697 case ACCESSIBLE:
28698 case COPY:
28699 case DEFINE:
28700 case DISCONNECT:
28701 case HOST:
28702 case PRINT:
28703 case QUIT:
28704 case REMARK:
28705 case UNDEFINE:
28706 case VARIABLE:
28707 case WHENEVER:
28708 case ATTACH:
28709 case CAST:
28710 case TREAT:
28711 case TRIM:
28712 case LEFT:
28713 case RIGHT:
28714 case BOTH:
28715 case EMPTY:
28716 case MULTISET:
28717 case SUBMULTISET:
28718 case LEADING:
28719 case TRAILING:
28720 case CHAR_CS:
28721 case NCHAR_CS:
28722 case DBTIMEZONE:
28723 case SESSIONTIMEZONE:
28724 case AUTHENTICATED:
28725 case LINK:
28726 case SHARED:
28727 case DIRECTORY:
28728 case USER:
28729 case IDENTIFIER:
28730 case QUOTED_LITERAL:
28731 case SQLDATA_CLASS:
28732 case CUSTOMDATUM_CLASS:
28733 case ORADATA_CLASS:
28734 case JAVA_INTERFACE_CLASS:
28735 ID();
28736 break;
28737 default:
28738 jj_la1[431] = jj_gen;
28739 ;
28740 }
28741 jj_consume_token(4);
28742 jjtree.closeNodeScope(jjtn000, true);
28743 jjtc000 = false;
28744 {if (true) return jjtn000 ;}
28745 } catch (Throwable jjte000) {
28746 if (jjtc000) {
28747 jjtree.clearNodeScope(jjtn000);
28748 jjtc000 = false;
28749 } else {
28750 jjtree.popNode();
28751 }
28752 if (jjte000 instanceof RuntimeException) {
28753 {if (true) throw (RuntimeException)jjte000;}
28754 }
28755 if (jjte000 instanceof ParseException) {
28756 {if (true) throw (ParseException)jjte000;}
28757 }
28758 {if (true) throw (Error)jjte000;}
28759 } finally {
28760 if (jjtc000) {
28761 jjtree.closeNodeScope(jjtn000, true);
28762 }
28763 }
28764 throw new Error("Missing return statement in function");
28765 }
28766
28767
28768
28769
28770
28771
28772
28773
28774 final public ASTNonDMLTrigger NonDMLTrigger() throws ParseException {
28775
28776 ASTNonDMLTrigger jjtn000 = new ASTNonDMLTrigger(this, JJTNONDMLTRIGGER);
28777 boolean jjtc000 = true;
28778 jjtree.openNodeScope(jjtn000);
28779 try {
28780 switch (jj_nt.kind) {
28781 case BEFORE:
28782 jj_consume_token(BEFORE);
28783 break;
28784 case AFTER:
28785 jj_consume_token(AFTER);
28786 break;
28787 default:
28788 jj_la1[432] = jj_gen;
28789 jj_consume_token(-1);
28790 throw new ParseException();
28791 }
28792 switch (jj_nt.kind) {
28793 case ALTER:
28794 case COMMENT:
28795 case CREATE:
28796 case DROP:
28797 case GRANT:
28798 case RENAME:
28799 case REVOKE:
28800 case ANALYZE:
28801 case ASSOCIATE:
28802 case AUDIT:
28803 case DDL:
28804 case DISASSOCIATE:
28805 case NOAUDIT:
28806 case TRUNCATE:
28807 DDLEvent();
28808 break;
28809 case LOGOFF:
28810 case LOGON:
28811 case SERVERERROR:
28812 case SHUTDOWN:
28813 case STARTUP:
28814 case SUSPEND:
28815 DatabaseEvent();
28816 break;
28817 default:
28818 jj_la1[433] = jj_gen;
28819 jj_consume_token(-1);
28820 throw new ParseException();
28821 }
28822 label_101:
28823 while (true) {
28824 switch (jj_nt.kind) {
28825 case OR:
28826 ;
28827 break;
28828 default:
28829 jj_la1[434] = jj_gen;
28830 break label_101;
28831 }
28832 jj_consume_token(OR);
28833 switch (jj_nt.kind) {
28834 case ALTER:
28835 case COMMENT:
28836 case CREATE:
28837 case DROP:
28838 case GRANT:
28839 case RENAME:
28840 case REVOKE:
28841 case ANALYZE:
28842 case ASSOCIATE:
28843 case AUDIT:
28844 case DDL:
28845 case DISASSOCIATE:
28846 case NOAUDIT:
28847 case TRUNCATE:
28848 DDLEvent();
28849 break;
28850 case LOGOFF:
28851 case LOGON:
28852 case SERVERERROR:
28853 case SHUTDOWN:
28854 case STARTUP:
28855 case SUSPEND:
28856 DatabaseEvent();
28857 break;
28858 default:
28859 jj_la1[435] = jj_gen;
28860 jj_consume_token(-1);
28861 throw new ParseException();
28862 }
28863 }
28864 jj_consume_token(ON);
28865 switch (jj_nt.kind) {
28866 case DATABASE:
28867 jj_consume_token(DATABASE);
28868 break;
28869 case REPLACE:
28870 case DEFINER:
28871 case CURRENT_USER:
28872 case SERIALLY_REUSABLE:
28873 case RESTRICT_REFERENCES:
28874 case EXCEPTION_INIT:
28875 case AUTONOMOUS_TRANSACTION:
28876 case LANGUAGE:
28877 case INLINE:
28878 case ADD:
28879 case AGGREGATE:
28880 case ALL:
28881 case ALTER:
28882 case AND:
28883 case ANY:
28884 case ARRAY:
28885 case AS:
28886 case ASC:
28887 case AT:
28888 case ATTRIBUTE:
28889 case AUTHID:
28890 case AVG:
28891 case BETWEEN:
28892 case BINARY_INTEGER:
28893 case BODY:
28894 case BOOLEAN:
28895 case BULK:
28896 case BY:
28897 case BYTE:
28898 case CASCADE:
28899 case CASE:
28900 case CHAR:
28901 case CHAR_BASE:
28902 case CHECK:
28903 case CLOSE:
28904 case CLUSTER:
28905 case COALESCE:
28906 case COLLECT:
28907 case COLUMN:
28908 case COMMENT:
28909 case COMMIT:
28910 case COMPRESS:
28911 case CONNECT:
28912 case CONSTANT:
28913 case CONSTRUCTOR:
28914 case CONTINUE:
28915 case CONVERT:
28916 case CREATE:
28917 case CURRENT:
28918 case CURRVAL:
28919 case CURSOR:
28920 case DATA:
28921 case DATE:
28922 case DAY:
28923 case DECLARE:
28924 case DECIMAL:
28925 case _DEFAULT:
28926 case DELETE:
28927 case DESC:
28928 case DISABLE:
28929 case DISTINCT:
28930 case DO:
28931 case DROP:
28932 case EDITIONABLE:
28933 case ELEMENT:
28934 case ELSE:
28935 case ELSIF:
28936 case ENABLE:
28937 case ESCAPE:
28938 case EXCEPT:
28939 case EXCEPTION:
28940 case EXCEPTIONS:
28941 case EXCLUSIVE:
28942 case EXECUTE:
28943 case EXISTS:
28944 case EXIT:
28945 case EXTERNAL:
28946 case EXTENDS:
28947 case EXTRACT:
28948 case FALSE:
28949 case FETCH:
28950 case FINAL:
28951 case FLOAT:
28952 case FOR:
28953 case FORALL:
28954 case FORCE:
28955 case FROM:
28956 case FUNCTION:
28957 case GLOBAL:
28958 case GOTO:
28959 case GROUP:
28960 case HASH:
28961 case HAVING:
28962 case HEAP:
28963 case HOUR:
28964 case IF:
28965 case IMMEDIATE:
28966 case IN:
28967 case INDEX:
28968 case INDICES:
28969 case INDEXTYPE:
28970 case INDICATOR:
28971 case INSERT:
28972 case INSTANTIABLE:
28973 case INTEGER:
28974 case INTERFACE:
28975 case INTERSECT:
28976 case INTERVAL:
28977 case INTO:
28978 case INVALIDATE:
28979 case IS:
28980 case ISOLATION:
28981 case JAVA:
28982 case LEVEL:
28983 case LIKE:
28984 case LIMIT:
28985 case LIMITED:
28986 case LOCK:
28987 case LONG:
28988 case LOOP:
28989 case MAP:
28990 case MAX:
28991 case MEMBER:
28992 case MERGE:
28993 case MIN:
28994 case MINUS:
28995 case MINUTE:
28996 case MLSLABEL:
28997 case MODIFY:
28998 case MOD:
28999 case MODE:
29000 case MONTH:
29001 case NATURAL:
29002 case NATURALN:
29003 case NEW:
29004 case NEXTVAL:
29005 case NO:
29006 case NOCOPY:
29007 case NONEDITIONABLE:
29008 case NOT:
29009 case NOWAIT:
29010 case NULL:
29011 case NULLIF:
29012 case NUMBER:
29013 case BFILE_BASE:
29014 case BLOB_BASE:
29015 case CLOB_BASE:
29016 case DATE_BASE:
29017 case NUMBER_BASE:
29018 case OBJECT:
29019 case OCIROWID:
29020 case OF:
29021 case OID:
29022 case ON:
29023 case OPAQUE:
29024 case OPEN:
29025 case OPERATOR:
29026 case OPTION:
29027 case OR:
29028 case ORDER:
29029 case ORGANIZATION:
29030 case OTHERS:
29031 case OUT:
29032 case OVERRIDING:
29033 case PACKAGE:
29034 case PARTITION:
29035 case PCTFREE:
29036 case PLS_INTEGER:
29037 case POSITIVE:
29038 case POSITIVEN:
29039 case PRESERVE:
29040 case PRIOR:
29041 case PROMPT:
29042 case PRIVATE:
29043 case PROCEDURE:
29044 case PUBLIC:
29045 case RAISE:
29046 case RANGE:
29047 case RAW:
29048 case REAL:
29049 case RECORD:
29050 case REF:
29051 case RELEASE:
29052 case RELIES_ON:
29053 case RENAME:
29054 case RESULT:
29055 case RETURN:
29056 case RETURNING:
29057 case REVERSE:
29058 case ROLLBACK:
29059 case ROW:
29060 case ROWS:
29061 case ROWID:
29062 case ROWNUM:
29063 case ROWTYPE:
29064 case SAVE:
29065 case SAVEPOINT:
29066 case SECOND:
29067 case SELECT:
29068 case SELF:
29069 case SEPARATE:
29070 case SET:
29071 case SHARE:
29072 case SMALLINT:
29073 case SPACE:
29074 case SQL:
29075 case SQLCODE:
29076 case SQLERRM:
29077 case START:
29078 case STATIC:
29079 case STDDEV:
29080 case SUBTYPE:
29081 case SUBSTITUTABLE:
29082 case SUCCESSFUL:
29083 case SUM:
29084 case SYNONYM:
29085 case SYSDATE:
29086 case SYS_REFCURSOR:
29087 case TABLE:
29088 case TEMPORARY:
29089 case THEN:
29090 case TIME:
29091 case TIMESTAMP:
29092 case TIMEZONE_REGION:
29093 case TIMEZONE_ABBR:
29094 case TIMEZONE_MINUTE:
29095 case TIMEZONE_HOUR:
29096 case TO:
29097 case TRANSACTION:
29098 case TRIGGER:
29099 case TRUE:
29100 case TYPE:
29101 case UI:
29102 case UNDER:
29103 case USING:
29104 case WHILE:
29105 case YES:
29106 case SHOW:
29107 case A:
29108 case UPDATE:
29109 case VARCHAR:
29110 case VARCHAR2:
29111 case DOUBLE:
29112 case DEC:
29113 case PRECISION:
29114 case INT:
29115 case NUMERIC:
29116 case SIGNTYPE:
29117 case NCHAR:
29118 case NVARCHAR2:
29119 case STRING:
29120 case UROWID:
29121 case VARRAY:
29122 case VARYING:
29123 case BFILE:
29124 case BLOB:
29125 case CLOB:
29126 case NCLOB:
29127 case YEAR:
29128 case LOCAL:
29129 case WITH:
29130 case ZONE:
29131 case CHARACTER:
29132 case AFTER:
29133 case BEFORE:
29134 case OLD:
29135 case PARENT:
29136 case ANALYZE:
29137 case ASSOCIATE:
29138 case AUDIT:
29139 case COMPOUND:
29140 case CALL:
29141 case DDL:
29142 case DISASSOCIATE:
29143 case EACH:
29144 case FOLLOWS:
29145 case LOGOFF:
29146 case LOGON:
29147 case NESTED:
29148 case NOAUDIT:
29149 case SCHEMA:
29150 case SERVERERROR:
29151 case SHUTDOWN:
29152 case STARTUP:
29153 case STATEMENT:
29154 case STATISTICS:
29155 case SUSPEND:
29156 case TRUNCATE:
29157 case WRAPPED:
29158 case LIBRARY:
29159 case NAME:
29160 case STRUCT:
29161 case CONTEXT:
29162 case PARAMETERS:
29163 case LENGTH:
29164 case TDO:
29165 case MAXLEN:
29166 case CHARSETID:
29167 case CHARSETFORM:
29168 case ACCEPT:
29169 case ACCESSIBLE:
29170 case COPY:
29171 case DEFINE:
29172 case DISCONNECT:
29173 case HOST:
29174 case PRINT:
29175 case QUIT:
29176 case REMARK:
29177 case UNDEFINE:
29178 case VARIABLE:
29179 case WHENEVER:
29180 case ATTACH:
29181 case CAST:
29182 case TREAT:
29183 case TRIM:
29184 case LEFT:
29185 case RIGHT:
29186 case BOTH:
29187 case EMPTY:
29188 case MULTISET:
29189 case SUBMULTISET:
29190 case LEADING:
29191 case TRAILING:
29192 case CHAR_CS:
29193 case NCHAR_CS:
29194 case DBTIMEZONE:
29195 case SESSIONTIMEZONE:
29196 case AUTHENTICATED:
29197 case LINK:
29198 case SHARED:
29199 case DIRECTORY:
29200 case USER:
29201 case IDENTIFIER:
29202 case QUOTED_LITERAL:
29203 case SQLDATA_CLASS:
29204 case CUSTOMDATUM_CLASS:
29205 case ORADATA_CLASS:
29206 case JAVA_INTERFACE_CLASS:
29207 if (jj_2_83(2)) {
29208 ID();
29209 jj_consume_token(3);
29210 } else {
29211 ;
29212 }
29213 jj_consume_token(SCHEMA);
29214 break;
29215 default:
29216 jj_la1[436] = jj_gen;
29217 jj_consume_token(-1);
29218 throw new ParseException();
29219 }
29220 jjtree.closeNodeScope(jjtn000, true);
29221 jjtc000 = false;
29222 {if (true) return jjtn000 ;}
29223 } catch (Throwable jjte000) {
29224 if (jjtc000) {
29225 jjtree.clearNodeScope(jjtn000);
29226 jjtc000 = false;
29227 } else {
29228 jjtree.popNode();
29229 }
29230 if (jjte000 instanceof RuntimeException) {
29231 {if (true) throw (RuntimeException)jjte000;}
29232 }
29233 if (jjte000 instanceof ParseException) {
29234 {if (true) throw (ParseException)jjte000;}
29235 }
29236 {if (true) throw (Error)jjte000;}
29237 } finally {
29238 if (jjtc000) {
29239 jjtree.closeNodeScope(jjtn000, true);
29240 }
29241 }
29242 throw new Error("Missing return statement in function");
29243 }
29244
29245 final public ASTDDLEvent DDLEvent() throws ParseException {
29246
29247 ASTDDLEvent jjtn000 = new ASTDDLEvent(this, JJTDDLEVENT);
29248 boolean jjtc000 = true;
29249 jjtree.openNodeScope(jjtn000);
29250 try {
29251 switch (jj_nt.kind) {
29252 case ALTER:
29253 jj_consume_token(ALTER);
29254 break;
29255 case ANALYZE:
29256 jj_consume_token(ANALYZE);
29257 break;
29258 case ASSOCIATE:
29259 jj_consume_token(ASSOCIATE);
29260 jj_consume_token(STATISTICS);
29261 break;
29262 case AUDIT:
29263 jj_consume_token(AUDIT);
29264 break;
29265 case COMMENT:
29266 jj_consume_token(COMMENT);
29267 break;
29268 case CREATE:
29269 jj_consume_token(CREATE);
29270 break;
29271 case DISASSOCIATE:
29272 jj_consume_token(DISASSOCIATE);
29273 jj_consume_token(STATISTICS);
29274 break;
29275 case DROP:
29276 jj_consume_token(DROP);
29277 break;
29278 case GRANT:
29279 jj_consume_token(GRANT);
29280 break;
29281 case NOAUDIT:
29282 jj_consume_token(NOAUDIT);
29283 break;
29284 case RENAME:
29285 jj_consume_token(RENAME);
29286 break;
29287 case REVOKE:
29288 jj_consume_token(REVOKE);
29289 break;
29290 case TRUNCATE:
29291 jj_consume_token(TRUNCATE);
29292 break;
29293 case DDL:
29294 jj_consume_token(DDL);
29295 break;
29296 default:
29297 jj_la1[437] = jj_gen;
29298 jj_consume_token(-1);
29299 throw new ParseException();
29300 }
29301 jjtree.closeNodeScope(jjtn000, true);
29302 jjtc000 = false;
29303 jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
29304 } finally {
29305 if (jjtc000) {
29306 jjtree.closeNodeScope(jjtn000, true);
29307 }
29308 }
29309 throw new Error("Missing return statement in function");
29310 }
29311
29312 final public ASTDatabaseEvent DatabaseEvent() throws ParseException {
29313
29314 ASTDatabaseEvent jjtn000 = new ASTDatabaseEvent(this, JJTDATABASEEVENT);
29315 boolean jjtc000 = true;
29316 jjtree.openNodeScope(jjtn000);
29317 try {
29318 switch (jj_nt.kind) {
29319 case STARTUP:
29320 jj_consume_token(STARTUP);
29321 break;
29322 case SHUTDOWN:
29323 jj_consume_token(SHUTDOWN);
29324 break;
29325 case LOGON:
29326 jj_consume_token(LOGON);
29327 break;
29328 case LOGOFF:
29329 jj_consume_token(LOGOFF);
29330 break;
29331 case SERVERERROR:
29332 jj_consume_token(SERVERERROR);
29333 break;
29334 case SUSPEND:
29335 jj_consume_token(SUSPEND);
29336 break;
29337 default:
29338 jj_la1[438] = jj_gen;
29339 jj_consume_token(-1);
29340 throw new ParseException();
29341 }
29342 jjtree.closeNodeScope(jjtn000, true);
29343 jjtc000 = false;
29344 jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
29345 } finally {
29346 if (jjtc000) {
29347 jjtree.closeNodeScope(jjtn000, true);
29348 }
29349 }
29350 throw new Error("Missing return statement in function");
29351 }
29352
29353 final public ASTNonDMLEvent NonDMLEvent() throws ParseException {
29354
29355 ASTNonDMLEvent jjtn000 = new ASTNonDMLEvent(this, JJTNONDMLEVENT);
29356 boolean jjtc000 = true;
29357 jjtree.openNodeScope(jjtn000);
29358 try {
29359 switch (jj_nt.kind) {
29360 case ALTER:
29361 case COMMENT:
29362 case CREATE:
29363 case DROP:
29364 case GRANT:
29365 case RENAME:
29366 case REVOKE:
29367 case ANALYZE:
29368 case ASSOCIATE:
29369 case AUDIT:
29370 case DDL:
29371 case DISASSOCIATE:
29372 case NOAUDIT:
29373 case TRUNCATE:
29374 DDLEvent();
29375 break;
29376 case LOGOFF:
29377 case LOGON:
29378 case SERVERERROR:
29379 case SHUTDOWN:
29380 case STARTUP:
29381 case SUSPEND:
29382 DatabaseEvent();
29383 break;
29384 default:
29385 jj_la1[439] = jj_gen;
29386 jj_consume_token(-1);
29387 throw new ParseException();
29388 }
29389 jjtree.closeNodeScope(jjtn000, true);
29390 jjtc000 = false;
29391 {if (true) return jjtn000;}
29392 } catch (Throwable jjte000) {
29393 if (jjtc000) {
29394 jjtree.clearNodeScope(jjtn000);
29395 jjtc000 = false;
29396 } else {
29397 jjtree.popNode();
29398 }
29399 if (jjte000 instanceof RuntimeException) {
29400 {if (true) throw (RuntimeException)jjte000;}
29401 }
29402 if (jjte000 instanceof ParseException) {
29403 {if (true) throw (ParseException)jjte000;}
29404 }
29405 {if (true) throw (Error)jjte000;}
29406 } finally {
29407 if (jjtc000) {
29408 jjtree.closeNodeScope(jjtn000, true);
29409 }
29410 }
29411 throw new Error("Missing return statement in function");
29412 }
29413
29414
29415
29416
29417
29418
29419
29420
29421 final public void AlterTrigger() throws ParseException {
29422
29423 ASTAlterTrigger jjtn000 = new ASTAlterTrigger(this, JJTALTERTRIGGER);
29424 boolean jjtc000 = true;
29425 jjtree.openNodeScope(jjtn000);
29426 try {
29427 jj_consume_token(ALTER);
29428 jj_consume_token(TRIGGER);
29429 Skip2NextTerminator(null,";");
29430 jj_consume_token(4);
29431 jjtree.closeNodeScope(jjtn000, true);
29432 jjtc000 = false;
29433 {if (true) return;}
29434 } catch (Throwable jjte000) {
29435 if (jjtc000) {
29436 jjtree.clearNodeScope(jjtn000);
29437 jjtc000 = false;
29438 } else {
29439 jjtree.popNode();
29440 }
29441 if (jjte000 instanceof RuntimeException) {
29442 {if (true) throw (RuntimeException)jjte000;}
29443 }
29444 if (jjte000 instanceof ParseException) {
29445 {if (true) throw (ParseException)jjte000;}
29446 }
29447 {if (true) throw (Error)jjte000;}
29448 } finally {
29449 if (jjtc000) {
29450 jjtree.closeNodeScope(jjtn000, true);
29451 }
29452 }
29453 }
29454
29455
29456 final public ASTKEYWORD_RESERVED KEYWORD_RESERVED() throws ParseException {
29457
29458 ASTKEYWORD_RESERVED jjtn000 = new ASTKEYWORD_RESERVED(this, JJTKEYWORD_RESERVED);
29459 boolean jjtc000 = true;
29460 jjtree.openNodeScope(jjtn000);
29461 try {
29462 switch (jj_nt.kind) {
29463 case ALL:
29464 jj_consume_token(ALL);
29465 break;
29466 case ALTER:
29467 jj_consume_token(ALTER);
29468 break;
29469 case AND:
29470 jj_consume_token(AND);
29471 break;
29472 case ANY:
29473 jj_consume_token(ANY);
29474 break;
29475 case AS:
29476 jj_consume_token(AS);
29477 break;
29478 case ASC:
29479 jj_consume_token(ASC);
29480 break;
29481 case BETWEEN:
29482 jj_consume_token(BETWEEN);
29483 break;
29484 case BY:
29485 jj_consume_token(BY);
29486 break;
29487 case CHAR:
29488 jj_consume_token(CHAR);
29489 break;
29490 case CHECK:
29491 jj_consume_token(CHECK);
29492 break;
29493 case CLUSTER:
29494 jj_consume_token(CLUSTER);
29495 break;
29496 case COMPRESS:
29497 jj_consume_token(COMPRESS);
29498 break;
29499 case CONNECT:
29500 jj_consume_token(CONNECT);
29501 break;
29502 case CREATE:
29503 jj_consume_token(CREATE);
29504 break;
29505 case DATE:
29506 jj_consume_token(DATE);
29507 break;
29508 case DECIMAL:
29509 jj_consume_token(DECIMAL);
29510 break;
29511 case _DEFAULT:
29512 jj_consume_token(_DEFAULT);
29513 break;
29514 case DELETE:
29515 jj_consume_token(DELETE);
29516 break;
29517 case DESC:
29518 jj_consume_token(DESC);
29519 break;
29520 case DISTINCT:
29521 jj_consume_token(DISTINCT);
29522 break;
29523 case DROP:
29524 jj_consume_token(DROP);
29525 break;
29526 case ELSE:
29527 jj_consume_token(ELSE);
29528 break;
29529 case EXCLUSIVE:
29530 jj_consume_token(EXCLUSIVE);
29531 break;
29532 case EXISTS:
29533 jj_consume_token(EXISTS);
29534 break;
29535 case FLOAT:
29536 jj_consume_token(FLOAT);
29537 break;
29538 case FOR:
29539 jj_consume_token(FOR);
29540 break;
29541 case FROM:
29542 jj_consume_token(FROM);
29543 break;
29544 case GRANT:
29545 jj_consume_token(GRANT);
29546 break;
29547 case GROUP:
29548 jj_consume_token(GROUP);
29549 break;
29550 case HAVING:
29551 jj_consume_token(HAVING);
29552 break;
29553 case IDENTIFIED:
29554 jj_consume_token(IDENTIFIED);
29555 break;
29556 case IN:
29557 jj_consume_token(IN);
29558 break;
29559 case INDEX:
29560 jj_consume_token(INDEX);
29561 break;
29562 case INSERT:
29563 jj_consume_token(INSERT);
29564 break;
29565 case INTEGER:
29566 jj_consume_token(INTEGER);
29567 break;
29568 case INTERSECT:
29569 jj_consume_token(INTERSECT);
29570 break;
29571 case INTO:
29572 jj_consume_token(INTO);
29573 break;
29574 case IS:
29575 jj_consume_token(IS);
29576 break;
29577 case LIKE:
29578 jj_consume_token(LIKE);
29579 break;
29580 case LOCK:
29581 jj_consume_token(LOCK);
29582 break;
29583 case LONG:
29584 jj_consume_token(LONG);
29585 break;
29586 case MINUS:
29587 jj_consume_token(MINUS);
29588 break;
29589 case MODE:
29590 jj_consume_token(MODE);
29591 break;
29592 case NOCOMPRESS:
29593 jj_consume_token(NOCOMPRESS);
29594 break;
29595 case NOT:
29596 jj_consume_token(NOT);
29597 break;
29598 case NOWAIT:
29599 jj_consume_token(NOWAIT);
29600 break;
29601 case NULL:
29602 jj_consume_token(NULL);
29603 break;
29604 case NUMBER:
29605 jj_consume_token(NUMBER);
29606 break;
29607 case OF:
29608 jj_consume_token(OF);
29609 break;
29610 case ON:
29611 jj_consume_token(ON);
29612 break;
29613 case OPTION:
29614 jj_consume_token(OPTION);
29615 break;
29616 case OR:
29617 jj_consume_token(OR);
29618 break;
29619 case ORDER:
29620 jj_consume_token(ORDER);
29621 break;
29622 case PCTFREE:
29623 jj_consume_token(PCTFREE);
29624 break;
29625 case PRIOR:
29626 jj_consume_token(PRIOR);
29627 break;
29628 case PUBLIC:
29629 jj_consume_token(PUBLIC);
29630 break;
29631 case RAW:
29632 jj_consume_token(RAW);
29633 break;
29634 case RESOURCE:
29635 jj_consume_token(RESOURCE);
29636 break;
29637 case REVOKE:
29638 jj_consume_token(REVOKE);
29639 break;
29640 case SELECT:
29641 jj_consume_token(SELECT);
29642 break;
29643 case SET:
29644 jj_consume_token(SET);
29645 break;
29646 case SHARE:
29647 jj_consume_token(SHARE);
29648 break;
29649 case SIZE:
29650 jj_consume_token(SIZE);
29651 break;
29652 case SMALLINT:
29653 jj_consume_token(SMALLINT);
29654 break;
29655 case START:
29656 jj_consume_token(START);
29657 break;
29658 case SYNONYM:
29659 jj_consume_token(SYNONYM);
29660 break;
29661 case TABLE:
29662 jj_consume_token(TABLE);
29663 break;
29664 case THEN:
29665 jj_consume_token(THEN);
29666 break;
29667 case TO:
29668 jj_consume_token(TO);
29669 break;
29670 case TRIGGER:
29671 jj_consume_token(TRIGGER);
29672 break;
29673 case UNION:
29674 jj_consume_token(UNION);
29675 break;
29676 case UNIQUE:
29677 jj_consume_token(UNIQUE);
29678 break;
29679 case UPDATE:
29680 jj_consume_token(UPDATE);
29681 break;
29682 case VALUES:
29683 jj_consume_token(VALUES);
29684 break;
29685 case VARCHAR:
29686 jj_consume_token(VARCHAR);
29687 break;
29688 case VARCHAR2:
29689 jj_consume_token(VARCHAR2);
29690 break;
29691 case VIEW:
29692 jj_consume_token(VIEW);
29693 break;
29694 case WHERE:
29695 jj_consume_token(WHERE);
29696 break;
29697 case WITH:
29698 jj_consume_token(WITH);
29699 break;
29700 default:
29701 jj_la1[440] = jj_gen;
29702 jj_consume_token(-1);
29703 throw new ParseException();
29704 }
29705 jjtree.closeNodeScope(jjtn000, true);
29706 jjtc000 = false;
29707 jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
29708 } finally {
29709 if (jjtc000) {
29710 jjtree.closeNodeScope(jjtn000, true);
29711 }
29712 }
29713 throw new Error("Missing return statement in function");
29714 }
29715
29716 final public ASTKEYWORD_UNRESERVED KEYWORD_UNRESERVED() throws ParseException {
29717
29718 ASTKEYWORD_UNRESERVED jjtn000 = new ASTKEYWORD_UNRESERVED(this, JJTKEYWORD_UNRESERVED);
29719 boolean jjtc000 = true;
29720 jjtree.openNodeScope(jjtn000);
29721 try {
29722 switch (jj_nt.kind) {
29723 case FALSE:
29724 jj_consume_token(FALSE);
29725 break;
29726 case TRUE:
29727 jj_consume_token(TRUE);
29728 break;
29729 case A:
29730 jj_consume_token(A);
29731 break;
29732 case ACCEPT:
29733 jj_consume_token(ACCEPT);
29734 break;
29735 case ADD:
29736 jj_consume_token(ADD);
29737 break;
29738 case AFTER:
29739 jj_consume_token(AFTER);
29740 break;
29741 case AGGREGATE:
29742 jj_consume_token(AGGREGATE);
29743 break;
29744 case ANALYZE:
29745 jj_consume_token(ANALYZE);
29746 break;
29747 case ASSOCIATE:
29748 jj_consume_token(ASSOCIATE);
29749 break;
29750 case AT:
29751 jj_consume_token(AT);
29752 break;
29753 case ATTACH:
29754 jj_consume_token(ATTACH);
29755 break;
29756 case ATTRIBUTE:
29757 jj_consume_token(ATTRIBUTE);
29758 break;
29759 case AUDIT:
29760 jj_consume_token(AUDIT);
29761 break;
29762 case AUTHENTICATED:
29763 jj_consume_token(AUTHENTICATED);
29764 break;
29765 case AUTHID:
29766 jj_consume_token(AUTHID);
29767 break;
29768 case BEFORE:
29769 jj_consume_token(BEFORE);
29770 break;
29771 case BFILE:
29772 jj_consume_token(BFILE);
29773 break;
29774 case BLOB:
29775 jj_consume_token(BLOB);
29776 break;
29777 case BOTH:
29778 jj_consume_token(BOTH);
29779 break;
29780 case BULK:
29781 jj_consume_token(BULK);
29782 break;
29783 case BYTE:
29784 jj_consume_token(BYTE);
29785 break;
29786 case CALL:
29787 jj_consume_token(CALL);
29788 break;
29789 case CASCADE:
29790 jj_consume_token(CASCADE);
29791 break;
29792 case CAST:
29793 jj_consume_token(CAST);
29794 break;
29795 case CHAR_CS:
29796 jj_consume_token(CHAR_CS);
29797 break;
29798 case CHARACTER:
29799 jj_consume_token(CHARACTER);
29800 break;
29801 case CHARSETFORM:
29802 jj_consume_token(CHARSETFORM);
29803 break;
29804 case CHARSETID:
29805 jj_consume_token(CHARSETID);
29806 break;
29807 case CLOB:
29808 jj_consume_token(CLOB);
29809 break;
29810 case CLOSE:
29811 jj_consume_token(CLOSE);
29812 break;
29813 case COALESCE:
29814 jj_consume_token(COALESCE);
29815 break;
29816 case COLLECT:
29817 jj_consume_token(COLLECT);
29818 break;
29819 case COLUMN:
29820 jj_consume_token(COLUMN);
29821 break;
29822 case COMMENT:
29823 jj_consume_token(COMMENT);
29824 break;
29825 case COMMIT:
29826 jj_consume_token(COMMIT);
29827 break;
29828 case COMPOUND:
29829 jj_consume_token(COMPOUND);
29830 break;
29831 case CONSTRUCTOR:
29832 jj_consume_token(CONSTRUCTOR);
29833 break;
29834 case CONTEXT:
29835 jj_consume_token(CONTEXT);
29836 break;
29837 case CONTINUE:
29838 jj_consume_token(CONTINUE);
29839 break;
29840 case CONVERT:
29841 jj_consume_token(CONVERT);
29842 break;
29843 case COPY:
29844 jj_consume_token(COPY);
29845 break;
29846 case CURRENT:
29847 jj_consume_token(CURRENT);
29848 break;
29849 case CURRENT_USER:
29850 jj_consume_token(CURRENT_USER);
29851 break;
29852 case CURSOR:
29853 jj_consume_token(CURSOR);
29854 break;
29855 case DATA:
29856 jj_consume_token(DATA);
29857 break;
29858 case DATABASE:
29859 jj_consume_token(DATABASE);
29860 break;
29861 case DAY:
29862 jj_consume_token(DAY);
29863 break;
29864 case DBTIMEZONE:
29865 jj_consume_token(DBTIMEZONE);
29866 break;
29867 case DDL:
29868 jj_consume_token(DDL);
29869 break;
29870 case DEC:
29871 jj_consume_token(DEC);
29872 break;
29873 case DEFINE:
29874 jj_consume_token(DEFINE);
29875 break;
29876 case DEFINER:
29877 jj_consume_token(DEFINER);
29878 break;
29879 case DIRECTORY:
29880 jj_consume_token(DIRECTORY);
29881 break;
29882 case DISABLE:
29883 jj_consume_token(DISABLE);
29884 break;
29885 case DISASSOCIATE:
29886 jj_consume_token(DISASSOCIATE);
29887 break;
29888 case DISCONNECT:
29889 jj_consume_token(DISCONNECT);
29890 break;
29891 case DOUBLE:
29892 jj_consume_token(DOUBLE);
29893 break;
29894 case EACH:
29895 jj_consume_token(EACH);
29896 break;
29897 case ELEMENT:
29898 jj_consume_token(ELEMENT);
29899 break;
29900 case EMPTY:
29901 jj_consume_token(EMPTY);
29902 break;
29903 case ENABLE:
29904 jj_consume_token(ENABLE);
29905 break;
29906 case ESCAPE:
29907 jj_consume_token(ESCAPE);
29908 break;
29909 case EXCEPT:
29910 jj_consume_token(EXCEPT);
29911 break;
29912 case EXCEPTIONS:
29913 jj_consume_token(EXCEPTIONS);
29914 break;
29915 case EXIT:
29916 jj_consume_token(EXIT);
29917 break;
29918 case EXTENDS:
29919 jj_consume_token(EXTENDS);
29920 break;
29921 case EXTERNAL:
29922 jj_consume_token(EXTERNAL);
29923 break;
29924 case EXTRACT:
29925 jj_consume_token(EXTRACT);
29926 break;
29927 case FINAL:
29928 jj_consume_token(FINAL);
29929 break;
29930 case FOLLOWS:
29931 jj_consume_token(FOLLOWS);
29932 break;
29933 case FORCE:
29934 jj_consume_token(FORCE);
29935 break;
29936 case FUNCTION:
29937 jj_consume_token(FUNCTION);
29938 break;
29939 case GLOBAL:
29940 jj_consume_token(GLOBAL);
29941 break;
29942 case HASH:
29943 jj_consume_token(HASH);
29944 break;
29945 case HEAP:
29946 jj_consume_token(HEAP);
29947 break;
29948 case HOST:
29949 jj_consume_token(HOST);
29950 break;
29951 case HOUR:
29952 jj_consume_token(HOUR);
29953 break;
29954 case IMMEDIATE:
29955 jj_consume_token(IMMEDIATE);
29956 break;
29957 case INDEXTYPE:
29958 jj_consume_token(INDEXTYPE);
29959 break;
29960 case INDICATOR:
29961 jj_consume_token(INDICATOR);
29962 break;
29963 case INDICES:
29964 jj_consume_token(INDICES);
29965 break;
29966 case INSTANTIABLE:
29967 jj_consume_token(INSTANTIABLE);
29968 break;
29969 case INTERVAL:
29970 jj_consume_token(INTERVAL);
29971 break;
29972 case INVALIDATE:
29973 jj_consume_token(INVALIDATE);
29974 break;
29975 case ISOLATION:
29976 jj_consume_token(ISOLATION);
29977 break;
29978 case JAVA:
29979 jj_consume_token(JAVA);
29980 break;
29981 case LANGUAGE:
29982 jj_consume_token(LANGUAGE);
29983 break;
29984 case LEADING:
29985 jj_consume_token(LEADING);
29986 break;
29987 case LEFT:
29988 jj_consume_token(LEFT);
29989 break;
29990 case LENGTH:
29991 jj_consume_token(LENGTH);
29992 break;
29993 case LEVEL:
29994 jj_consume_token(LEVEL);
29995 break;
29996 case LIBRARY:
29997 jj_consume_token(LIBRARY);
29998 break;
29999 case LIMIT:
30000 jj_consume_token(LIMIT);
30001 break;
30002 case LINK:
30003 jj_consume_token(LINK);
30004 break;
30005 case LOCAL:
30006 jj_consume_token(LOCAL);
30007 break;
30008 case LOGOFF:
30009 jj_consume_token(LOGOFF);
30010 break;
30011 case LOGON:
30012 jj_consume_token(LOGON);
30013 break;
30014 case MAP:
30015 jj_consume_token(MAP);
30016 break;
30017 case MAX:
30018 jj_consume_token(MAX);
30019 break;
30020 case MAXLEN:
30021 jj_consume_token(MAXLEN);
30022 break;
30023 case MEMBER:
30024 jj_consume_token(MEMBER);
30025 break;
30026 case MERGE:
30027 jj_consume_token(MERGE);
30028 break;
30029 case MIN:
30030 jj_consume_token(MIN);
30031 break;
30032 case MINUTE:
30033 jj_consume_token(MINUTE);
30034 break;
30035 case MLSLABEL:
30036 jj_consume_token(MLSLABEL);
30037 break;
30038 case MODIFY:
30039 jj_consume_token(MODIFY);
30040 break;
30041 case MONTH:
30042 jj_consume_token(MONTH);
30043 break;
30044 case MULTISET:
30045 jj_consume_token(MULTISET);
30046 break;
30047 case NAME:
30048 jj_consume_token(NAME);
30049 break;
30050 case NATURAL:
30051 jj_consume_token(NATURAL);
30052 break;
30053 case NCHAR:
30054 jj_consume_token(NCHAR);
30055 break;
30056 case NCHAR_CS:
30057 jj_consume_token(NCHAR_CS);
30058 break;
30059 case NCLOB:
30060 jj_consume_token(NCLOB);
30061 break;
30062 case NESTED:
30063 jj_consume_token(NESTED);
30064 break;
30065 case NEW:
30066 jj_consume_token(NEW);
30067 break;
30068 case NO:
30069 jj_consume_token(NO);
30070 break;
30071 case NOAUDIT:
30072 jj_consume_token(NOAUDIT);
30073 break;
30074 case NUMERIC:
30075 jj_consume_token(NUMERIC);
30076 break;
30077 case NVARCHAR2:
30078 jj_consume_token(NVARCHAR2);
30079 break;
30080 case OBJECT:
30081 jj_consume_token(OBJECT);
30082 break;
30083 case OID:
30084 jj_consume_token(OID);
30085 break;
30086 case OLD:
30087 jj_consume_token(OLD);
30088 break;
30089 case OPAQUE:
30090 jj_consume_token(OPAQUE);
30091 break;
30092 case OPEN:
30093 jj_consume_token(OPEN);
30094 break;
30095 case ORGANIZATION:
30096 jj_consume_token(ORGANIZATION);
30097 break;
30098 case OTHERS:
30099 jj_consume_token(OTHERS);
30100 break;
30101 case OVERRIDING:
30102 jj_consume_token(OVERRIDING);
30103 break;
30104 case PACKAGE:
30105 jj_consume_token(PACKAGE);
30106 break;
30107 case PARAMETERS:
30108 jj_consume_token(PARAMETERS);
30109 break;
30110 case PARENT:
30111 jj_consume_token(PARENT);
30112 break;
30113 case PARTITION:
30114 jj_consume_token(PARTITION);
30115 break;
30116 case PRECISION:
30117 jj_consume_token(PRECISION);
30118 break;
30119 case PRESERVE:
30120 jj_consume_token(PRESERVE);
30121 break;
30122 case PRINT:
30123 jj_consume_token(PRINT);
30124 break;
30125 case PROCEDURE:
30126 jj_consume_token(PROCEDURE);
30127 break;
30128 case QUIT:
30129 jj_consume_token(QUIT);
30130 break;
30131 case RANGE:
30132 jj_consume_token(RANGE);
30133 break;
30134 case REAL:
30135 jj_consume_token(REAL);
30136 break;
30137 case RECORD:
30138 jj_consume_token(RECORD);
30139 break;
30140 case REF:
30141 jj_consume_token(REF);
30142 break;
30143 case RELIES_ON:
30144 jj_consume_token(RELIES_ON);
30145 break;
30146 case REMARK:
30147 jj_consume_token(REMARK);
30148 break;
30149 case RESULT:
30150 jj_consume_token(RESULT);
30151 break;
30152 case RETURN:
30153 jj_consume_token(RETURN);
30154 break;
30155 case RETURNING:
30156 jj_consume_token(RETURNING);
30157 break;
30158 case REVERSE:
30159 jj_consume_token(REVERSE);
30160 break;
30161 case RIGHT:
30162 jj_consume_token(RIGHT);
30163 break;
30164 case ROLLBACK:
30165 jj_consume_token(ROLLBACK);
30166 break;
30167 case ROW:
30168 jj_consume_token(ROW);
30169 break;
30170 case ROWID:
30171 jj_consume_token(ROWID);
30172 break;
30173 case ROWNUM:
30174 jj_consume_token(ROWNUM);
30175 break;
30176 case ROWS:
30177 jj_consume_token(ROWS);
30178 break;
30179 case SAVE:
30180 jj_consume_token(SAVE);
30181 break;
30182 case SAVEPOINT:
30183 jj_consume_token(SAVEPOINT);
30184 break;
30185 case SCHEMA:
30186 jj_consume_token(SCHEMA);
30187 break;
30188 case SECOND:
30189 jj_consume_token(SECOND);
30190 break;
30191 case SELF:
30192 jj_consume_token(SELF);
30193 break;
30194 case SERVERERROR:
30195 jj_consume_token(SERVERERROR);
30196 break;
30197 case SESSIONTIMEZONE:
30198 jj_consume_token(SESSIONTIMEZONE);
30199 break;
30200 case SET:
30201 jj_consume_token(SET);
30202 break;
30203 case SHARED:
30204 jj_consume_token(SHARED);
30205 break;
30206 case SHUTDOWN:
30207 jj_consume_token(SHUTDOWN);
30208 break;
30209 case SPACE:
30210 jj_consume_token(SPACE);
30211 break;
30212 case STARTUP:
30213 jj_consume_token(STARTUP);
30214 break;
30215 case STATEMENT:
30216 jj_consume_token(STATEMENT);
30217 break;
30218 case STATIC:
30219 jj_consume_token(STATIC);
30220 break;
30221 case STATISTICS:
30222 jj_consume_token(STATISTICS);
30223 break;
30224 case STRUCT:
30225 jj_consume_token(STRUCT);
30226 break;
30227 case SUBMULTISET:
30228 jj_consume_token(SUBMULTISET);
30229 break;
30230 case SUBSTITUTABLE:
30231 jj_consume_token(SUBSTITUTABLE);
30232 break;
30233 case SUBTYPE:
30234 jj_consume_token(SUBTYPE);
30235 break;
30236 case SUCCESSFUL:
30237 jj_consume_token(SUCCESSFUL);
30238 break;
30239 case SUSPEND:
30240 jj_consume_token(SUSPEND);
30241 break;
30242 case TDO:
30243 jj_consume_token(TDO);
30244 break;
30245 case TEMPORARY:
30246 jj_consume_token(TEMPORARY);
30247 break;
30248 case TIME:
30249 jj_consume_token(TIME);
30250 break;
30251 case TIMESTAMP:
30252 jj_consume_token(TIMESTAMP);
30253 break;
30254 case TIMEZONE_ABBR:
30255 jj_consume_token(TIMEZONE_ABBR);
30256 break;
30257 case TIMEZONE_HOUR:
30258 jj_consume_token(TIMEZONE_HOUR);
30259 break;
30260 case TIMEZONE_MINUTE:
30261 jj_consume_token(TIMEZONE_MINUTE);
30262 break;
30263 case TIMEZONE_REGION:
30264 jj_consume_token(TIMEZONE_REGION);
30265 break;
30266 case TRAILING:
30267 jj_consume_token(TRAILING);
30268 break;
30269 case TRANSACTION:
30270 jj_consume_token(TRANSACTION);
30271 break;
30272 case TREAT:
30273 jj_consume_token(TREAT);
30274 break;
30275 case TRIM:
30276 jj_consume_token(TRIM);
30277 break;
30278 case TRUNCATE:
30279 jj_consume_token(TRUNCATE);
30280 break;
30281 case UNDEFINE:
30282 jj_consume_token(UNDEFINE);
30283 break;
30284 case UNDER:
30285 jj_consume_token(UNDER);
30286 break;
30287 case UROWID:
30288 jj_consume_token(UROWID);
30289 break;
30290 case USER:
30291 jj_consume_token(USER);
30292 break;
30293 case USING:
30294 jj_consume_token(USING);
30295 break;
30296 case VARRAY:
30297 jj_consume_token(VARRAY);
30298 break;
30299 case VARIABLE:
30300 jj_consume_token(VARIABLE);
30301 break;
30302 case VARYING:
30303 jj_consume_token(VARYING);
30304 break;
30305 case WHENEVER:
30306 jj_consume_token(WHENEVER);
30307 break;
30308 case YEAR:
30309 jj_consume_token(YEAR);
30310 break;
30311 case YES:
30312 jj_consume_token(YES);
30313 break;
30314 case ZONE:
30315 jj_consume_token(ZONE);
30316 break;
30317 case SHOW:
30318 jj_consume_token(SHOW);
30319 break;
30320 case WRAPPED:
30321 jj_consume_token(WRAPPED);
30322 break;
30323 case SYS_REFCURSOR:
30324 jj_consume_token(SYS_REFCURSOR);
30325 break;
30326 case EDITIONABLE:
30327 jj_consume_token(EDITIONABLE);
30328 break;
30329 case NONEDITIONABLE:
30330 jj_consume_token(NONEDITIONABLE);
30331 break;
30332 case ACCESSIBLE:
30333 jj_consume_token(ACCESSIBLE);
30334 break;
30335 case NULLIF:
30336 jj_consume_token(NULLIF);
30337 break;
30338 case RENAME:
30339 jj_consume_token(RENAME);
30340 break;
30341 case RELEASE:
30342 jj_consume_token(RELEASE);
30343 break;
30344 case INLINE:
30345 jj_consume_token(INLINE);
30346 break;
30347 default:
30348 jj_la1[441] = jj_gen;
30349 jj_consume_token(-1);
30350 throw new ParseException();
30351 }
30352 jjtree.closeNodeScope(jjtn000, true);
30353 jjtc000 = false;
30354 jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
30355 } finally {
30356 if (jjtc000) {
30357 jjtree.closeNodeScope(jjtn000, true);
30358 }
30359 }
30360 throw new Error("Missing return statement in function");
30361 }
30362
30363
30364
30365
30366
30367 final public ASTID ID() throws ParseException {
30368
30369 ASTID jjtn000 = new ASTID(this, JJTID);
30370 boolean jjtc000 = true;
30371 jjtree.openNodeScope(jjtn000);
30372 try {
30373 switch (jj_nt.kind) {
30374 case IDENTIFIER:
30375 jj_consume_token(IDENTIFIER);
30376 break;
30377 case QUOTED_LITERAL:
30378 jj_consume_token(QUOTED_LITERAL);
30379 break;
30380 case DEFINER:
30381 case CURRENT_USER:
30382 case LANGUAGE:
30383 case INLINE:
30384 case ADD:
30385 case AGGREGATE:
30386 case AT:
30387 case ATTRIBUTE:
30388 case AUTHID:
30389 case BULK:
30390 case BYTE:
30391 case CASCADE:
30392 case CLOSE:
30393 case COALESCE:
30394 case COLLECT:
30395 case COLUMN:
30396 case COMMENT:
30397 case COMMIT:
30398 case CONSTRUCTOR:
30399 case CONTINUE:
30400 case CONVERT:
30401 case CURRENT:
30402 case CURSOR:
30403 case DATA:
30404 case DAY:
30405 case DISABLE:
30406 case EDITIONABLE:
30407 case ELEMENT:
30408 case ENABLE:
30409 case ESCAPE:
30410 case EXCEPT:
30411 case EXCEPTIONS:
30412 case EXIT:
30413 case EXTERNAL:
30414 case EXTENDS:
30415 case EXTRACT:
30416 case FALSE:
30417 case FINAL:
30418 case FORCE:
30419 case FUNCTION:
30420 case GLOBAL:
30421 case HASH:
30422 case HEAP:
30423 case HOUR:
30424 case IMMEDIATE:
30425 case INDICES:
30426 case INDEXTYPE:
30427 case INDICATOR:
30428 case INSTANTIABLE:
30429 case INTERVAL:
30430 case INVALIDATE:
30431 case ISOLATION:
30432 case JAVA:
30433 case LEVEL:
30434 case LIMIT:
30435 case MAP:
30436 case MAX:
30437 case MEMBER:
30438 case MERGE:
30439 case MIN:
30440 case MINUTE:
30441 case MLSLABEL:
30442 case MODIFY:
30443 case MONTH:
30444 case NATURAL:
30445 case NEW:
30446 case NO:
30447 case NONEDITIONABLE:
30448 case NULLIF:
30449 case OBJECT:
30450 case OID:
30451 case OPAQUE:
30452 case OPEN:
30453 case ORGANIZATION:
30454 case OTHERS:
30455 case OVERRIDING:
30456 case PACKAGE:
30457 case PARTITION:
30458 case PRESERVE:
30459 case PROCEDURE:
30460 case RANGE:
30461 case REAL:
30462 case RECORD:
30463 case REF:
30464 case RELEASE:
30465 case RELIES_ON:
30466 case RENAME:
30467 case RESULT:
30468 case RETURN:
30469 case RETURNING:
30470 case REVERSE:
30471 case ROLLBACK:
30472 case ROW:
30473 case ROWS:
30474 case ROWID:
30475 case ROWNUM:
30476 case SAVE:
30477 case SAVEPOINT:
30478 case SECOND:
30479 case SELF:
30480 case SET:
30481 case SPACE:
30482 case STATIC:
30483 case SUBTYPE:
30484 case SUBSTITUTABLE:
30485 case SUCCESSFUL:
30486 case SYS_REFCURSOR:
30487 case TEMPORARY:
30488 case TIME:
30489 case TIMESTAMP:
30490 case TIMEZONE_REGION:
30491 case TIMEZONE_ABBR:
30492 case TIMEZONE_MINUTE:
30493 case TIMEZONE_HOUR:
30494 case TRANSACTION:
30495 case TRUE:
30496 case UNDER:
30497 case USING:
30498 case YES:
30499 case SHOW:
30500 case A:
30501 case DOUBLE:
30502 case DEC:
30503 case PRECISION:
30504 case NUMERIC:
30505 case NCHAR:
30506 case NVARCHAR2:
30507 case UROWID:
30508 case VARRAY:
30509 case VARYING:
30510 case BFILE:
30511 case BLOB:
30512 case CLOB:
30513 case NCLOB:
30514 case YEAR:
30515 case LOCAL:
30516 case ZONE:
30517 case CHARACTER:
30518 case AFTER:
30519 case BEFORE:
30520 case OLD:
30521 case PARENT:
30522 case ANALYZE:
30523 case ASSOCIATE:
30524 case AUDIT:
30525 case COMPOUND:
30526 case DATABASE:
30527 case CALL:
30528 case DDL:
30529 case DISASSOCIATE:
30530 case EACH:
30531 case FOLLOWS:
30532 case LOGOFF:
30533 case LOGON:
30534 case NESTED:
30535 case NOAUDIT:
30536 case SCHEMA:
30537 case SERVERERROR:
30538 case SHUTDOWN:
30539 case STARTUP:
30540 case STATEMENT:
30541 case STATISTICS:
30542 case SUSPEND:
30543 case TRUNCATE:
30544 case WRAPPED:
30545 case LIBRARY:
30546 case NAME:
30547 case STRUCT:
30548 case CONTEXT:
30549 case PARAMETERS:
30550 case LENGTH:
30551 case TDO:
30552 case MAXLEN:
30553 case CHARSETID:
30554 case CHARSETFORM:
30555 case ACCEPT:
30556 case ACCESSIBLE:
30557 case COPY:
30558 case DEFINE:
30559 case DISCONNECT:
30560 case HOST:
30561 case PRINT:
30562 case QUIT:
30563 case REMARK:
30564 case UNDEFINE:
30565 case VARIABLE:
30566 case WHENEVER:
30567 case ATTACH:
30568 case CAST:
30569 case TREAT:
30570 case TRIM:
30571 case LEFT:
30572 case RIGHT:
30573 case BOTH:
30574 case EMPTY:
30575 case MULTISET:
30576 case SUBMULTISET:
30577 case LEADING:
30578 case TRAILING:
30579 case CHAR_CS:
30580 case NCHAR_CS:
30581 case DBTIMEZONE:
30582 case SESSIONTIMEZONE:
30583 case AUTHENTICATED:
30584 case LINK:
30585 case SHARED:
30586 case DIRECTORY:
30587 case USER:
30588 KEYWORD_UNRESERVED();
30589 break;
30590 case REPLACE:
30591 jj_consume_token(REPLACE);
30592 break;
30593 case SERIALLY_REUSABLE:
30594 jj_consume_token(SERIALLY_REUSABLE);
30595 break;
30596 case RESTRICT_REFERENCES:
30597 jj_consume_token(RESTRICT_REFERENCES);
30598 break;
30599 case EXCEPTION_INIT:
30600 jj_consume_token(EXCEPTION_INIT);
30601 break;
30602 case AUTONOMOUS_TRANSACTION:
30603 jj_consume_token(AUTONOMOUS_TRANSACTION);
30604 break;
30605 case ALL:
30606 jj_consume_token(ALL);
30607 break;
30608 case ALTER:
30609 jj_consume_token(ALTER);
30610 break;
30611 case AND:
30612 jj_consume_token(AND);
30613 break;
30614 case ANY:
30615 jj_consume_token(ANY);
30616 break;
30617 case ARRAY:
30618 jj_consume_token(ARRAY);
30619 break;
30620 case AS:
30621 jj_consume_token(AS);
30622 break;
30623 case ASC:
30624 jj_consume_token(ASC);
30625 break;
30626 case AVG:
30627 jj_consume_token(AVG);
30628 break;
30629 case BETWEEN:
30630 jj_consume_token(BETWEEN);
30631 break;
30632 case BINARY_INTEGER:
30633 jj_consume_token(BINARY_INTEGER);
30634 break;
30635 case BODY:
30636 jj_consume_token(BODY);
30637 break;
30638 case BOOLEAN:
30639 jj_consume_token(BOOLEAN);
30640 break;
30641 case BY:
30642 jj_consume_token(BY);
30643 break;
30644 case CASE:
30645 jj_consume_token(CASE);
30646 break;
30647 case CHAR:
30648 jj_consume_token(CHAR);
30649 break;
30650 case CHAR_BASE:
30651 jj_consume_token(CHAR_BASE);
30652 break;
30653 case CHECK:
30654 jj_consume_token(CHECK);
30655 break;
30656 case CLUSTER:
30657 jj_consume_token(CLUSTER);
30658 break;
30659 case COMPRESS:
30660 jj_consume_token(COMPRESS);
30661 break;
30662 case CONNECT:
30663 jj_consume_token(CONNECT);
30664 break;
30665 case CONSTANT:
30666 jj_consume_token(CONSTANT);
30667 break;
30668 case CREATE:
30669 jj_consume_token(CREATE);
30670 break;
30671 case CURRVAL:
30672 jj_consume_token(CURRVAL);
30673 break;
30674 case DATE:
30675 jj_consume_token(DATE);
30676 break;
30677 case DECLARE:
30678 jj_consume_token(DECLARE);
30679 break;
30680 case DECIMAL:
30681 jj_consume_token(DECIMAL);
30682 break;
30683 case _DEFAULT:
30684 jj_consume_token(_DEFAULT);
30685 break;
30686 case DELETE:
30687 jj_consume_token(DELETE);
30688 break;
30689 case DESC:
30690 jj_consume_token(DESC);
30691 break;
30692 case DISTINCT:
30693 jj_consume_token(DISTINCT);
30694 break;
30695 case DO:
30696 jj_consume_token(DO);
30697 break;
30698 case DROP:
30699 jj_consume_token(DROP);
30700 break;
30701 case ELSE:
30702 jj_consume_token(ELSE);
30703 break;
30704 case ELSIF:
30705 jj_consume_token(ELSIF);
30706 break;
30707 case EXCEPTION:
30708 jj_consume_token(EXCEPTION);
30709 break;
30710 case EXCLUSIVE:
30711 jj_consume_token(EXCLUSIVE);
30712 break;
30713 case EXECUTE:
30714 jj_consume_token(EXECUTE);
30715 break;
30716 case EXISTS:
30717 jj_consume_token(EXISTS);
30718 break;
30719 case FETCH:
30720 jj_consume_token(FETCH);
30721 break;
30722 case FLOAT:
30723 jj_consume_token(FLOAT);
30724 break;
30725 case FOR:
30726 jj_consume_token(FOR);
30727 break;
30728 case FORALL:
30729 jj_consume_token(FORALL);
30730 break;
30731 case FROM:
30732 jj_consume_token(FROM);
30733 break;
30734 case GOTO:
30735 jj_consume_token(GOTO);
30736 break;
30737 case GROUP:
30738 jj_consume_token(GROUP);
30739 break;
30740 case HAVING:
30741 jj_consume_token(HAVING);
30742 break;
30743 case IF:
30744 jj_consume_token(IF);
30745 break;
30746 case IN:
30747 jj_consume_token(IN);
30748 break;
30749 case INDEX:
30750 jj_consume_token(INDEX);
30751 break;
30752 case INSERT:
30753 jj_consume_token(INSERT);
30754 break;
30755 case INTEGER:
30756 jj_consume_token(INTEGER);
30757 break;
30758 case INTERFACE:
30759 jj_consume_token(INTERFACE);
30760 break;
30761 case INTERSECT:
30762 jj_consume_token(INTERSECT);
30763 break;
30764 case INTO:
30765 jj_consume_token(INTO);
30766 break;
30767 case IS:
30768 jj_consume_token(IS);
30769 break;
30770 case LIKE:
30771 jj_consume_token(LIKE);
30772 break;
30773 case LIMITED:
30774 jj_consume_token(LIMITED);
30775 break;
30776 case LOCK:
30777 jj_consume_token(LOCK);
30778 break;
30779 case LONG:
30780 jj_consume_token(LONG);
30781 break;
30782 case LOOP:
30783 jj_consume_token(LOOP);
30784 break;
30785 case MINUS:
30786 jj_consume_token(MINUS);
30787 break;
30788 case MOD:
30789 jj_consume_token(MOD);
30790 break;
30791 case MODE:
30792 jj_consume_token(MODE);
30793 break;
30794 case NATURALN:
30795 jj_consume_token(NATURALN);
30796 break;
30797 case NEXTVAL:
30798 jj_consume_token(NEXTVAL);
30799 break;
30800 case NOCOPY:
30801 jj_consume_token(NOCOPY);
30802 break;
30803 case NOT:
30804 jj_consume_token(NOT);
30805 break;
30806 case NOWAIT:
30807 jj_consume_token(NOWAIT);
30808 break;
30809 case NULL:
30810 jj_consume_token(NULL);
30811 break;
30812 case NUMBER:
30813 jj_consume_token(NUMBER);
30814 break;
30815 case NUMBER_BASE:
30816 jj_consume_token(NUMBER_BASE);
30817 break;
30818 case OCIROWID:
30819 jj_consume_token(OCIROWID);
30820 break;
30821 case OF:
30822 jj_consume_token(OF);
30823 break;
30824 case ON:
30825 jj_consume_token(ON);
30826 break;
30827 case BFILE_BASE:
30828 jj_consume_token(BFILE_BASE);
30829 break;
30830 case BLOB_BASE:
30831 jj_consume_token(BLOB_BASE);
30832 break;
30833 case CLOB_BASE:
30834 jj_consume_token(CLOB_BASE);
30835 break;
30836 case DATE_BASE:
30837 jj_consume_token(DATE_BASE);
30838 break;
30839 case OPERATOR:
30840 jj_consume_token(OPERATOR);
30841 break;
30842 case OPTION:
30843 jj_consume_token(OPTION);
30844 break;
30845 case OR:
30846 jj_consume_token(OR);
30847 break;
30848 case ORDER:
30849 jj_consume_token(ORDER);
30850 break;
30851 case OUT:
30852 jj_consume_token(OUT);
30853 break;
30854 case PCTFREE:
30855 jj_consume_token(PCTFREE);
30856 break;
30857 case PLS_INTEGER:
30858 jj_consume_token(PLS_INTEGER);
30859 break;
30860 case POSITIVE:
30861 jj_consume_token(POSITIVE);
30862 break;
30863 case POSITIVEN:
30864 jj_consume_token(POSITIVEN);
30865 break;
30866 case PRIOR:
30867 jj_consume_token(PRIOR);
30868 break;
30869 case PRIVATE:
30870 jj_consume_token(PRIVATE);
30871 break;
30872 case PROMPT:
30873 jj_consume_token(PROMPT);
30874 break;
30875 case PUBLIC:
30876 jj_consume_token(PUBLIC);
30877 break;
30878 case RAISE:
30879 jj_consume_token(RAISE);
30880 break;
30881 case RAW:
30882 jj_consume_token(RAW);
30883 break;
30884 case ROWTYPE:
30885 jj_consume_token(ROWTYPE);
30886 break;
30887 case SELECT:
30888 jj_consume_token(SELECT);
30889 break;
30890 case SEPARATE:
30891 jj_consume_token(SEPARATE);
30892 break;
30893 case SHARE:
30894 jj_consume_token(SHARE);
30895 break;
30896 case SMALLINT:
30897 jj_consume_token(SMALLINT);
30898 break;
30899 case SQL:
30900 jj_consume_token(SQL);
30901 break;
30902 case SQLCODE:
30903 jj_consume_token(SQLCODE);
30904 break;
30905 case SQLERRM:
30906 jj_consume_token(SQLERRM);
30907 break;
30908 case START:
30909 jj_consume_token(START);
30910 break;
30911 case STDDEV:
30912 jj_consume_token(STDDEV);
30913 break;
30914 case SUM:
30915 jj_consume_token(SUM);
30916 break;
30917 case SYNONYM:
30918 jj_consume_token(SYNONYM);
30919 break;
30920 case SYSDATE:
30921 jj_consume_token(SYSDATE);
30922 break;
30923 case TABLE:
30924 jj_consume_token(TABLE);
30925 break;
30926 case THEN:
30927 jj_consume_token(THEN);
30928 break;
30929 case TO:
30930 jj_consume_token(TO);
30931 break;
30932 case TRIGGER:
30933 jj_consume_token(TRIGGER);
30934 break;
30935 case TYPE:
30936 jj_consume_token(TYPE);
30937 break;
30938 case UI:
30939 jj_consume_token(UI);
30940 break;
30941 case UPDATE:
30942 jj_consume_token(UPDATE);
30943 break;
30944 case VARCHAR:
30945 jj_consume_token(VARCHAR);
30946 break;
30947 case VARCHAR2:
30948 jj_consume_token(VARCHAR2);
30949 break;
30950 case INT:
30951 jj_consume_token(INT);
30952 break;
30953 case SIGNTYPE:
30954 jj_consume_token(SIGNTYPE);
30955 break;
30956 case STRING:
30957 jj_consume_token(STRING);
30958 break;
30959 case WITH:
30960 jj_consume_token(WITH);
30961 break;
30962 case WHILE:
30963 jj_consume_token(WHILE);
30964 break;
30965 case JAVA_INTERFACE_CLASS:
30966 jj_consume_token(JAVA_INTERFACE_CLASS);
30967 break;
30968 case SQLDATA_CLASS:
30969 jj_consume_token(SQLDATA_CLASS);
30970 break;
30971 case CUSTOMDATUM_CLASS:
30972 jj_consume_token(CUSTOMDATUM_CLASS);
30973 break;
30974 case ORADATA_CLASS:
30975 jj_consume_token(ORADATA_CLASS);
30976 break;
30977 default:
30978 jj_la1[442] = jj_gen;
30979 jj_consume_token(-1);
30980 throw new ParseException();
30981 }
30982 jjtree.closeNodeScope(jjtn000, true);
30983 jjtc000 = false;
30984 jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
30985 } catch (Throwable jjte000) {
30986 if (jjtc000) {
30987 jjtree.clearNodeScope(jjtn000);
30988 jjtc000 = false;
30989 } else {
30990 jjtree.popNode();
30991 }
30992 if (jjte000 instanceof RuntimeException) {
30993 {if (true) throw (RuntimeException)jjte000;}
30994 }
30995 if (jjte000 instanceof ParseException) {
30996 {if (true) throw (ParseException)jjte000;}
30997 }
30998 {if (true) throw (Error)jjte000;}
30999 } finally {
31000 if (jjtc000) {
31001 jjtree.closeNodeScope(jjtn000, true);
31002 }
31003 }
31004 throw new Error("Missing return statement in function");
31005 }
31006
31007
31008
31009
31010 final public ASTUnqualifiedID UnqualifiedID() throws ParseException {
31011
31012 ASTUnqualifiedID jjtn000 = new ASTUnqualifiedID(this, JJTUNQUALIFIEDID);
31013 boolean jjtc000 = true;
31014 jjtree.openNodeScope(jjtn000);
31015 try {
31016 switch (jj_nt.kind) {
31017 case IDENTIFIER:
31018 jj_consume_token(IDENTIFIER);
31019 break;
31020 case QUOTED_LITERAL:
31021 jj_consume_token(QUOTED_LITERAL);
31022 break;
31023 case DEFINER:
31024 case CURRENT_USER:
31025 case LANGUAGE:
31026 case INLINE:
31027 case ADD:
31028 case AGGREGATE:
31029 case AT:
31030 case ATTRIBUTE:
31031 case AUTHID:
31032 case BULK:
31033 case BYTE:
31034 case CASCADE:
31035 case CLOSE:
31036 case COALESCE:
31037 case COLLECT:
31038 case COLUMN:
31039 case COMMENT:
31040 case COMMIT:
31041 case CONSTRUCTOR:
31042 case CONTINUE:
31043 case CONVERT:
31044 case CURRENT:
31045 case CURSOR:
31046 case DATA:
31047 case DAY:
31048 case DISABLE:
31049 case EDITIONABLE:
31050 case ELEMENT:
31051 case ENABLE:
31052 case ESCAPE:
31053 case EXCEPT:
31054 case EXCEPTIONS:
31055 case EXIT:
31056 case EXTERNAL:
31057 case EXTENDS:
31058 case EXTRACT:
31059 case FALSE:
31060 case FINAL:
31061 case FORCE:
31062 case FUNCTION:
31063 case GLOBAL:
31064 case HASH:
31065 case HEAP:
31066 case HOUR:
31067 case IMMEDIATE:
31068 case INDICES:
31069 case INDEXTYPE:
31070 case INDICATOR:
31071 case INSTANTIABLE:
31072 case INTERVAL:
31073 case INVALIDATE:
31074 case ISOLATION:
31075 case JAVA:
31076 case LEVEL:
31077 case LIMIT:
31078 case MAP:
31079 case MAX:
31080 case MEMBER:
31081 case MERGE:
31082 case MIN:
31083 case MINUTE:
31084 case MLSLABEL:
31085 case MODIFY:
31086 case MONTH:
31087 case NATURAL:
31088 case NEW:
31089 case NO:
31090 case NONEDITIONABLE:
31091 case NULLIF:
31092 case OBJECT:
31093 case OID:
31094 case OPAQUE:
31095 case OPEN:
31096 case ORGANIZATION:
31097 case OTHERS:
31098 case OVERRIDING:
31099 case PACKAGE:
31100 case PARTITION:
31101 case PRESERVE:
31102 case PROCEDURE:
31103 case RANGE:
31104 case REAL:
31105 case RECORD:
31106 case REF:
31107 case RELEASE:
31108 case RELIES_ON:
31109 case RENAME:
31110 case RESULT:
31111 case RETURN:
31112 case RETURNING:
31113 case REVERSE:
31114 case ROLLBACK:
31115 case ROW:
31116 case ROWS:
31117 case ROWID:
31118 case ROWNUM:
31119 case SAVE:
31120 case SAVEPOINT:
31121 case SECOND:
31122 case SELF:
31123 case SET:
31124 case SPACE:
31125 case STATIC:
31126 case SUBTYPE:
31127 case SUBSTITUTABLE:
31128 case SUCCESSFUL:
31129 case SYS_REFCURSOR:
31130 case TEMPORARY:
31131 case TIME:
31132 case TIMESTAMP:
31133 case TIMEZONE_REGION:
31134 case TIMEZONE_ABBR:
31135 case TIMEZONE_MINUTE:
31136 case TIMEZONE_HOUR:
31137 case TRANSACTION:
31138 case TRUE:
31139 case UNDER:
31140 case USING:
31141 case YES:
31142 case SHOW:
31143 case A:
31144 case DOUBLE:
31145 case DEC:
31146 case PRECISION:
31147 case NUMERIC:
31148 case NCHAR:
31149 case NVARCHAR2:
31150 case UROWID:
31151 case VARRAY:
31152 case VARYING:
31153 case BFILE:
31154 case BLOB:
31155 case CLOB:
31156 case NCLOB:
31157 case YEAR:
31158 case LOCAL:
31159 case ZONE:
31160 case CHARACTER:
31161 case AFTER:
31162 case BEFORE:
31163 case OLD:
31164 case PARENT:
31165 case ANALYZE:
31166 case ASSOCIATE:
31167 case AUDIT:
31168 case COMPOUND:
31169 case DATABASE:
31170 case CALL:
31171 case DDL:
31172 case DISASSOCIATE:
31173 case EACH:
31174 case FOLLOWS:
31175 case LOGOFF:
31176 case LOGON:
31177 case NESTED:
31178 case NOAUDIT:
31179 case SCHEMA:
31180 case SERVERERROR:
31181 case SHUTDOWN:
31182 case STARTUP:
31183 case STATEMENT:
31184 case STATISTICS:
31185 case SUSPEND:
31186 case TRUNCATE:
31187 case WRAPPED:
31188 case LIBRARY:
31189 case NAME:
31190 case STRUCT:
31191 case CONTEXT:
31192 case PARAMETERS:
31193 case LENGTH:
31194 case TDO:
31195 case MAXLEN:
31196 case CHARSETID:
31197 case CHARSETFORM:
31198 case ACCEPT:
31199 case ACCESSIBLE:
31200 case COPY:
31201 case DEFINE:
31202 case DISCONNECT:
31203 case HOST:
31204 case PRINT:
31205 case QUIT:
31206 case REMARK:
31207 case UNDEFINE:
31208 case VARIABLE:
31209 case WHENEVER:
31210 case ATTACH:
31211 case CAST:
31212 case TREAT:
31213 case TRIM:
31214 case LEFT:
31215 case RIGHT:
31216 case BOTH:
31217 case EMPTY:
31218 case MULTISET:
31219 case SUBMULTISET:
31220 case LEADING:
31221 case TRAILING:
31222 case CHAR_CS:
31223 case NCHAR_CS:
31224 case DBTIMEZONE:
31225 case SESSIONTIMEZONE:
31226 case AUTHENTICATED:
31227 case LINK:
31228 case SHARED:
31229 case DIRECTORY:
31230 case USER:
31231 KEYWORD_UNRESERVED();
31232 break;
31233 case BODY:
31234 jj_consume_token(BODY);
31235 break;
31236 case MOD:
31237 jj_consume_token(MOD);
31238 break;
31239 case OPERATOR:
31240 jj_consume_token(OPERATOR);
31241 break;
31242 case PRIVATE:
31243 jj_consume_token(PRIVATE);
31244 break;
31245 case RAW:
31246 jj_consume_token(RAW);
31247 break;
31248 case REPLACE:
31249 jj_consume_token(REPLACE);
31250 break;
31251 case STRING:
31252 jj_consume_token(STRING);
31253 break;
31254 case SQL:
31255 jj_consume_token(SQL);
31256 break;
31257 case SQLCODE:
31258 jj_consume_token(SQLCODE);
31259 break;
31260 case SQLERRM:
31261 jj_consume_token(SQLERRM);
31262 break;
31263 case SYSDATE:
31264 jj_consume_token(SYSDATE);
31265 break;
31266 case TYPE:
31267 jj_consume_token(TYPE);
31268 break;
31269 case LOOP:
31270 jj_consume_token(LOOP);
31271 break;
31272 case INT:
31273 jj_consume_token(INT);
31274 break;
31275 case ARRAY:
31276 jj_consume_token(ARRAY);
31277 break;
31278 default:
31279 jj_la1[443] = jj_gen;
31280 jj_consume_token(-1);
31281 throw new ParseException();
31282 }
31283 jjtree.closeNodeScope(jjtn000, true);
31284 jjtc000 = false;
31285 jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
31286 } catch (Throwable jjte000) {
31287 if (jjtc000) {
31288 jjtree.clearNodeScope(jjtn000);
31289 jjtc000 = false;
31290 } else {
31291 jjtree.popNode();
31292 }
31293 if (jjte000 instanceof RuntimeException) {
31294 {if (true) throw (RuntimeException)jjte000;}
31295 }
31296 if (jjte000 instanceof ParseException) {
31297 {if (true) throw (ParseException)jjte000;}
31298 }
31299 {if (true) throw (Error)jjte000;}
31300 } finally {
31301 if (jjtc000) {
31302 jjtree.closeNodeScope(jjtn000, true);
31303 }
31304 }
31305 throw new Error("Missing return statement in function");
31306 }
31307
31308
31309
31310
31311 final public ASTQualifiedID QualifiedID() throws ParseException {
31312
31313 ASTQualifiedID jjtn000 = new ASTQualifiedID(this, JJTQUALIFIEDID);
31314 boolean jjtc000 = true;
31315 jjtree.openNodeScope(jjtn000);
31316 try {
31317 switch (jj_nt.kind) {
31318 case IDENTIFIER:
31319 jj_consume_token(IDENTIFIER);
31320 break;
31321 case QUOTED_LITERAL:
31322 jj_consume_token(QUOTED_LITERAL);
31323 break;
31324 case DEFINER:
31325 case CURRENT_USER:
31326 case LANGUAGE:
31327 case INLINE:
31328 case ADD:
31329 case AGGREGATE:
31330 case AT:
31331 case ATTRIBUTE:
31332 case AUTHID:
31333 case BULK:
31334 case BYTE:
31335 case CASCADE:
31336 case CLOSE:
31337 case COALESCE:
31338 case COLLECT:
31339 case COLUMN:
31340 case COMMENT:
31341 case COMMIT:
31342 case CONSTRUCTOR:
31343 case CONTINUE:
31344 case CONVERT:
31345 case CURRENT:
31346 case CURSOR:
31347 case DATA:
31348 case DAY:
31349 case DISABLE:
31350 case EDITIONABLE:
31351 case ELEMENT:
31352 case ENABLE:
31353 case ESCAPE:
31354 case EXCEPT:
31355 case EXCEPTIONS:
31356 case EXIT:
31357 case EXTERNAL:
31358 case EXTENDS:
31359 case EXTRACT:
31360 case FALSE:
31361 case FINAL:
31362 case FORCE:
31363 case FUNCTION:
31364 case GLOBAL:
31365 case HASH:
31366 case HEAP:
31367 case HOUR:
31368 case IMMEDIATE:
31369 case INDICES:
31370 case INDEXTYPE:
31371 case INDICATOR:
31372 case INSTANTIABLE:
31373 case INTERVAL:
31374 case INVALIDATE:
31375 case ISOLATION:
31376 case JAVA:
31377 case LEVEL:
31378 case LIMIT:
31379 case MAP:
31380 case MAX:
31381 case MEMBER:
31382 case MERGE:
31383 case MIN:
31384 case MINUTE:
31385 case MLSLABEL:
31386 case MODIFY:
31387 case MONTH:
31388 case NATURAL:
31389 case NEW:
31390 case NO:
31391 case NONEDITIONABLE:
31392 case NULLIF:
31393 case OBJECT:
31394 case OID:
31395 case OPAQUE:
31396 case OPEN:
31397 case ORGANIZATION:
31398 case OTHERS:
31399 case OVERRIDING:
31400 case PACKAGE:
31401 case PARTITION:
31402 case PRESERVE:
31403 case PROCEDURE:
31404 case RANGE:
31405 case REAL:
31406 case RECORD:
31407 case REF:
31408 case RELEASE:
31409 case RELIES_ON:
31410 case RENAME:
31411 case RESULT:
31412 case RETURN:
31413 case RETURNING:
31414 case REVERSE:
31415 case ROLLBACK:
31416 case ROW:
31417 case ROWS:
31418 case ROWID:
31419 case ROWNUM:
31420 case SAVE:
31421 case SAVEPOINT:
31422 case SECOND:
31423 case SELF:
31424 case SET:
31425 case SPACE:
31426 case STATIC:
31427 case SUBTYPE:
31428 case SUBSTITUTABLE:
31429 case SUCCESSFUL:
31430 case SYS_REFCURSOR:
31431 case TEMPORARY:
31432 case TIME:
31433 case TIMESTAMP:
31434 case TIMEZONE_REGION:
31435 case TIMEZONE_ABBR:
31436 case TIMEZONE_MINUTE:
31437 case TIMEZONE_HOUR:
31438 case TRANSACTION:
31439 case TRUE:
31440 case UNDER:
31441 case USING:
31442 case YES:
31443 case SHOW:
31444 case A:
31445 case DOUBLE:
31446 case DEC:
31447 case PRECISION:
31448 case NUMERIC:
31449 case NCHAR:
31450 case NVARCHAR2:
31451 case UROWID:
31452 case VARRAY:
31453 case VARYING:
31454 case BFILE:
31455 case BLOB:
31456 case CLOB:
31457 case NCLOB:
31458 case YEAR:
31459 case LOCAL:
31460 case ZONE:
31461 case CHARACTER:
31462 case AFTER:
31463 case BEFORE:
31464 case OLD:
31465 case PARENT:
31466 case ANALYZE:
31467 case ASSOCIATE:
31468 case AUDIT:
31469 case COMPOUND:
31470 case DATABASE:
31471 case CALL:
31472 case DDL:
31473 case DISASSOCIATE:
31474 case EACH:
31475 case FOLLOWS:
31476 case LOGOFF:
31477 case LOGON:
31478 case NESTED:
31479 case NOAUDIT:
31480 case SCHEMA:
31481 case SERVERERROR:
31482 case SHUTDOWN:
31483 case STARTUP:
31484 case STATEMENT:
31485 case STATISTICS:
31486 case SUSPEND:
31487 case TRUNCATE:
31488 case WRAPPED:
31489 case LIBRARY:
31490 case NAME:
31491 case STRUCT:
31492 case CONTEXT:
31493 case PARAMETERS:
31494 case LENGTH:
31495 case TDO:
31496 case MAXLEN:
31497 case CHARSETID:
31498 case CHARSETFORM:
31499 case ACCEPT:
31500 case ACCESSIBLE:
31501 case COPY:
31502 case DEFINE:
31503 case DISCONNECT:
31504 case HOST:
31505 case PRINT:
31506 case QUIT:
31507 case REMARK:
31508 case UNDEFINE:
31509 case VARIABLE:
31510 case WHENEVER:
31511 case ATTACH:
31512 case CAST:
31513 case TREAT:
31514 case TRIM:
31515 case LEFT:
31516 case RIGHT:
31517 case BOTH:
31518 case EMPTY:
31519 case MULTISET:
31520 case SUBMULTISET:
31521 case LEADING:
31522 case TRAILING:
31523 case CHAR_CS:
31524 case NCHAR_CS:
31525 case DBTIMEZONE:
31526 case SESSIONTIMEZONE:
31527 case AUTHENTICATED:
31528 case LINK:
31529 case SHARED:
31530 case DIRECTORY:
31531 case USER:
31532 KEYWORD_UNRESERVED();
31533 break;
31534 case REPLACE:
31535 jj_consume_token(REPLACE);
31536 break;
31537 case SERIALLY_REUSABLE:
31538 jj_consume_token(SERIALLY_REUSABLE);
31539 break;
31540 case RESTRICT_REFERENCES:
31541 jj_consume_token(RESTRICT_REFERENCES);
31542 break;
31543 case EXCEPTION_INIT:
31544 jj_consume_token(EXCEPTION_INIT);
31545 break;
31546 case AUTONOMOUS_TRANSACTION:
31547 jj_consume_token(AUTONOMOUS_TRANSACTION);
31548 break;
31549 case ARRAY:
31550 jj_consume_token(ARRAY);
31551 break;
31552 case AVG:
31553 jj_consume_token(AVG);
31554 break;
31555 case BINARY_INTEGER:
31556 jj_consume_token(BINARY_INTEGER);
31557 break;
31558 case BODY:
31559 jj_consume_token(BODY);
31560 break;
31561 case BOOLEAN:
31562 jj_consume_token(BOOLEAN);
31563 break;
31564 case CHAR:
31565 jj_consume_token(CHAR);
31566 break;
31567 case CHAR_BASE:
31568 jj_consume_token(CHAR_BASE);
31569 break;
31570 case CONSTANT:
31571 jj_consume_token(CONSTANT);
31572 break;
31573 case CURRVAL:
31574 jj_consume_token(CURRVAL);
31575 break;
31576 case DATE:
31577 jj_consume_token(DATE);
31578 break;
31579 case DECIMAL:
31580 jj_consume_token(DECIMAL);
31581 break;
31582 case DELETE:
31583 jj_consume_token(DELETE);
31584 break;
31585 case DO:
31586 jj_consume_token(DO);
31587 break;
31588 case ELSIF:
31589 jj_consume_token(ELSIF);
31590 break;
31591 case EXECUTE:
31592 jj_consume_token(EXECUTE);
31593 break;
31594 case EXISTS:
31595 jj_consume_token(EXISTS);
31596 break;
31597 case FLOAT:
31598 jj_consume_token(FLOAT);
31599 break;
31600 case FORALL:
31601 jj_consume_token(FORALL);
31602 break;
31603 case INTEGER:
31604 jj_consume_token(INTEGER);
31605 break;
31606 case INTERFACE:
31607 jj_consume_token(INTERFACE);
31608 break;
31609 case LONG:
31610 jj_consume_token(LONG);
31611 break;
31612 case LOOP:
31613 jj_consume_token(LOOP);
31614 break;
31615 case MOD:
31616 jj_consume_token(MOD);
31617 break;
31618 case NATURALN:
31619 jj_consume_token(NATURALN);
31620 break;
31621 case NEXTVAL:
31622 jj_consume_token(NEXTVAL);
31623 break;
31624 case NOCOPY:
31625 jj_consume_token(NOCOPY);
31626 break;
31627 case NUMBER:
31628 jj_consume_token(NUMBER);
31629 break;
31630 case BFILE_BASE:
31631 jj_consume_token(BFILE_BASE);
31632 break;
31633 case BLOB_BASE:
31634 jj_consume_token(BLOB_BASE);
31635 break;
31636 case CLOB_BASE:
31637 jj_consume_token(CLOB_BASE);
31638 break;
31639 case DATE_BASE:
31640 jj_consume_token(DATE_BASE);
31641 break;
31642 case NUMBER_BASE:
31643 jj_consume_token(NUMBER_BASE);
31644 break;
31645 case OCIROWID:
31646 jj_consume_token(OCIROWID);
31647 break;
31648 case OPERATOR:
31649 jj_consume_token(OPERATOR);
31650 break;
31651 case OUT:
31652 jj_consume_token(OUT);
31653 break;
31654 case PLS_INTEGER:
31655 jj_consume_token(PLS_INTEGER);
31656 break;
31657 case POSITIVE:
31658 jj_consume_token(POSITIVE);
31659 break;
31660 case POSITIVEN:
31661 jj_consume_token(POSITIVEN);
31662 break;
31663 case PRAGMA:
31664 jj_consume_token(PRAGMA);
31665 break;
31666 case PRIOR:
31667 jj_consume_token(PRIOR);
31668 break;
31669 case PRIVATE:
31670 jj_consume_token(PRIVATE);
31671 break;
31672 case PROMPT:
31673 jj_consume_token(PROMPT);
31674 break;
31675 case RAISE:
31676 jj_consume_token(RAISE);
31677 break;
31678 case RAW:
31679 jj_consume_token(RAW);
31680 break;
31681 case ROWTYPE:
31682 jj_consume_token(ROWTYPE);
31683 break;
31684 case SEPARATE:
31685 jj_consume_token(SEPARATE);
31686 break;
31687 case SMALLINT:
31688 jj_consume_token(SMALLINT);
31689 break;
31690 case SQLCODE:
31691 jj_consume_token(SQLCODE);
31692 break;
31693 case SQLERRM:
31694 jj_consume_token(SQLERRM);
31695 break;
31696 case STDDEV:
31697 jj_consume_token(STDDEV);
31698 break;
31699 case SUM:
31700 jj_consume_token(SUM);
31701 break;
31702 case SYNONYM:
31703 jj_consume_token(SYNONYM);
31704 break;
31705 case SYSDATE:
31706 jj_consume_token(SYSDATE);
31707 break;
31708 case TRIGGER:
31709 jj_consume_token(TRIGGER);
31710 break;
31711 case TYPE:
31712 jj_consume_token(TYPE);
31713 break;
31714 case UI:
31715 jj_consume_token(UI);
31716 break;
31717 case VARCHAR:
31718 jj_consume_token(VARCHAR);
31719 break;
31720 case VARCHAR2:
31721 jj_consume_token(VARCHAR2);
31722 break;
31723 case INT:
31724 jj_consume_token(INT);
31725 break;
31726 case SIGNTYPE:
31727 jj_consume_token(SIGNTYPE);
31728 break;
31729 case STRING:
31730 jj_consume_token(STRING);
31731 break;
31732 case WHILE:
31733 jj_consume_token(WHILE);
31734 break;
31735 default:
31736 jj_la1[444] = jj_gen;
31737 jj_consume_token(-1);
31738 throw new ParseException();
31739 }
31740 jjtree.closeNodeScope(jjtn000, true);
31741 jjtc000 = false;
31742 jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
31743 } catch (Throwable jjte000) {
31744 if (jjtc000) {
31745 jjtree.clearNodeScope(jjtn000);
31746 jjtc000 = false;
31747 } else {
31748 jjtree.popNode();
31749 }
31750 if (jjte000 instanceof RuntimeException) {
31751 {if (true) throw (RuntimeException)jjte000;}
31752 }
31753 if (jjte000 instanceof ParseException) {
31754 {if (true) throw (ParseException)jjte000;}
31755 }
31756 {if (true) throw (Error)jjte000;}
31757 } finally {
31758 if (jjtc000) {
31759 jjtree.closeNodeScope(jjtn000, true);
31760 }
31761 }
31762 throw new Error("Missing return statement in function");
31763 }
31764
31765 final public ASTTypeKeyword TypeKeyword() throws ParseException {
31766
31767 ASTTypeKeyword jjtn000 = new ASTTypeKeyword(this, JJTTYPEKEYWORD);
31768 boolean jjtc000 = true;
31769 jjtree.openNodeScope(jjtn000);
31770 try {
31771 switch (jj_nt.kind) {
31772 case BFILE_BASE:
31773 jj_consume_token(BFILE_BASE);
31774 break;
31775 case BLOB_BASE:
31776 jj_consume_token(BLOB_BASE);
31777 break;
31778 case CLOB_BASE:
31779 jj_consume_token(CLOB_BASE);
31780 break;
31781 case DATE_BASE:
31782 jj_consume_token(DATE_BASE);
31783 break;
31784 case NUMBER_BASE:
31785 jj_consume_token(NUMBER_BASE);
31786 break;
31787 case BOOLEAN:
31788 jj_consume_token(BOOLEAN);
31789 break;
31790 case DATE:
31791 jj_consume_token(DATE);
31792 break;
31793 case NUMBER:
31794 jj_consume_token(NUMBER);
31795 break;
31796 case FLOAT:
31797 jj_consume_token(FLOAT);
31798 break;
31799 case REAL:
31800 jj_consume_token(REAL);
31801 break;
31802 case INTEGER:
31803 jj_consume_token(INTEGER);
31804 break;
31805 case INT:
31806 jj_consume_token(INT);
31807 break;
31808 case SMALLINT:
31809 jj_consume_token(SMALLINT);
31810 break;
31811 case DECIMAL:
31812 jj_consume_token(DECIMAL);
31813 break;
31814 case NUMERIC:
31815 jj_consume_token(NUMERIC);
31816 break;
31817 case DEC:
31818 jj_consume_token(DEC);
31819 break;
31820 case BINARY_INTEGER:
31821 jj_consume_token(BINARY_INTEGER);
31822 break;
31823 case NATURAL:
31824 jj_consume_token(NATURAL);
31825 break;
31826 case NATURALN:
31827 jj_consume_token(NATURALN);
31828 break;
31829 case POSITIVE:
31830 jj_consume_token(POSITIVE);
31831 break;
31832 case POSITIVEN:
31833 jj_consume_token(POSITIVEN);
31834 break;
31835 case SIGNTYPE:
31836 jj_consume_token(SIGNTYPE);
31837 break;
31838 case VARCHAR2:
31839 jj_consume_token(VARCHAR2);
31840 break;
31841 case VARCHAR:
31842 jj_consume_token(VARCHAR);
31843 break;
31844 case STRING:
31845 jj_consume_token(STRING);
31846 break;
31847 case LONG:
31848 jj_consume_token(LONG);
31849 break;
31850 case RAW:
31851 jj_consume_token(RAW);
31852 break;
31853 case ROWID:
31854 jj_consume_token(ROWID);
31855 break;
31856 case CHAR:
31857 jj_consume_token(CHAR);
31858 break;
31859 case CHARACTER:
31860 jj_consume_token(CHARACTER);
31861 break;
31862 case MLSLABEL:
31863 jj_consume_token(MLSLABEL);
31864 break;
31865 case BLOB:
31866 jj_consume_token(BLOB);
31867 break;
31868 case CLOB:
31869 jj_consume_token(CLOB);
31870 break;
31871 case BFILE:
31872 jj_consume_token(BFILE);
31873 break;
31874 case NCHAR:
31875 jj_consume_token(NCHAR);
31876 break;
31877 case NVARCHAR2:
31878 jj_consume_token(NVARCHAR2);
31879 break;
31880 case NCLOB:
31881 jj_consume_token(NCLOB);
31882 break;
31883 case PLS_INTEGER:
31884 jj_consume_token(PLS_INTEGER);
31885 break;
31886 case TIME:
31887 jj_consume_token(TIME);
31888 break;
31889 case TIMESTAMP:
31890 jj_consume_token(TIMESTAMP);
31891 break;
31892 case UROWID:
31893 jj_consume_token(UROWID);
31894 break;
31895 case ARRAY:
31896 jj_consume_token(ARRAY);
31897 break;
31898 case AUTHID:
31899 jj_consume_token(AUTHID);
31900 break;
31901 case ACCESSIBLE:
31902 jj_consume_token(ACCESSIBLE);
31903 jj_consume_token(CHAR_BASE);
31904 break;
31905 case CURRVAL:
31906 jj_consume_token(CURRVAL);
31907 break;
31908 case HOUR:
31909 jj_consume_token(HOUR);
31910 break;
31911 case INTERVAL:
31912 jj_consume_token(INTERVAL);
31913 break;
31914 case MONTH:
31915 jj_consume_token(MONTH);
31916 break;
31917 case OCIROWID:
31918 jj_consume_token(OCIROWID);
31919 break;
31920 case RECORD:
31921 jj_consume_token(RECORD);
31922 break;
31923 case REF:
31924 jj_consume_token(REF);
31925 break;
31926 case ROW:
31927 jj_consume_token(ROW);
31928 break;
31929 case ROWNUM:
31930 jj_consume_token(ROWNUM);
31931 break;
31932 case ROWTYPE:
31933 jj_consume_token(ROWTYPE);
31934 break;
31935 case SECOND:
31936 jj_consume_token(SECOND);
31937 break;
31938 case SET:
31939 jj_consume_token(SET);
31940 break;
31941 case TABLE:
31942 jj_consume_token(TABLE);
31943 break;
31944 case TIMEZONE_REGION:
31945 jj_consume_token(TIMEZONE_REGION);
31946 break;
31947 case TIMEZONE_ABBR:
31948 jj_consume_token(TIMEZONE_ABBR);
31949 break;
31950 case TIMEZONE_MINUTE:
31951 jj_consume_token(TIMEZONE_MINUTE);
31952 break;
31953 case TIMEZONE_HOUR:
31954 jj_consume_token(TIMEZONE_HOUR);
31955 break;
31956 case DOUBLE:
31957 jj_consume_token(DOUBLE);
31958 break;
31959 case PRECISION:
31960 jj_consume_token(PRECISION);
31961 break;
31962 case VARRAY:
31963 jj_consume_token(VARRAY);
31964 break;
31965 case YEAR:
31966 jj_consume_token(YEAR);
31967 break;
31968 case LOCAL:
31969 jj_consume_token(LOCAL);
31970 break;
31971 case WITH:
31972 jj_consume_token(WITH);
31973 break;
31974 case ZONE:
31975 jj_consume_token(ZONE);
31976 break;
31977 case JAVA_INTERFACE_CLASS:
31978 jj_consume_token(JAVA_INTERFACE_CLASS);
31979 break;
31980 case SQLDATA_CLASS:
31981 jj_consume_token(SQLDATA_CLASS);
31982 break;
31983 case CUSTOMDATUM_CLASS:
31984 jj_consume_token(CUSTOMDATUM_CLASS);
31985 break;
31986 case ORADATA_CLASS:
31987 jj_consume_token(ORADATA_CLASS);
31988 break;
31989 default:
31990 jj_la1[445] = jj_gen;
31991 jj_consume_token(-1);
31992 throw new ParseException();
31993 }
31994 jjtree.closeNodeScope(jjtn000, true);
31995 jjtc000 = false;
31996 jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
31997 } finally {
31998 if (jjtc000) {
31999 jjtree.closeNodeScope(jjtn000, true);
32000 }
32001 }
32002 throw new Error("Missing return statement in function");
32003 }
32004
32005 final public ASTJavaInterfaceClass JavaInterfaceClass() throws ParseException {
32006
32007 ASTJavaInterfaceClass jjtn000 = new ASTJavaInterfaceClass(this, JJTJAVAINTERFACECLASS);
32008 boolean jjtc000 = true;
32009 jjtree.openNodeScope(jjtn000);
32010 try {
32011 switch (jj_nt.kind) {
32012 case SQLDATA_CLASS:
32013 jj_consume_token(SQLDATA_CLASS);
32014 break;
32015 case CUSTOMDATUM_CLASS:
32016 jj_consume_token(CUSTOMDATUM_CLASS);
32017 break;
32018 case ORADATA_CLASS:
32019 jj_consume_token(ORADATA_CLASS);
32020 break;
32021 default:
32022 jj_la1[446] = jj_gen;
32023 jj_consume_token(-1);
32024 throw new ParseException();
32025 }
32026 jjtree.closeNodeScope(jjtn000, true);
32027 jjtc000 = false;
32028 jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
32029 } finally {
32030 if (jjtc000) {
32031 jjtree.closeNodeScope(jjtn000, true);
32032 }
32033 }
32034 throw new Error("Missing return statement in function");
32035 }
32036
32037
32038
32039
32040
32041
32042
32043 final public PLSQLNode EqualsOldIDNewID(PLSQLNode pOldID) throws ParseException {
32044
32045 ASTEqualsOldIDNewID jjtn000 = new ASTEqualsOldIDNewID(this, JJTEQUALSOLDIDNEWID);
32046 boolean jjtc000 = true;
32047 jjtree.openNodeScope(jjtn000);PLSQLNode newID;
32048 Token oldIDToken;
32049 Token newIDToken;
32050 try {
32051 newID = ID();
32052 jjtree.closeNodeScope(jjtn000, true);
32053 jjtc000 = false;
32054 oldIDToken = (Token) ((AbstractPLSQLNode)pOldID).value ;
32055 newIDToken = (Token) ((AbstractPLSQLNode)newID).value ;
32056 if (oldIDToken.image.equals(newIDToken.image)) {
32057 {if (true) return newID;}
32058 } else {
32059 {if (true) throw new ParseException("PLSQL syntax error on line "+newIDToken.beginLine+" at column "+newIDToken.beginColumn+"!\u005cn"
32060 + "Found \u005c""+newIDToken.image+"\u005c" but expected \u005c""+oldIDToken.image+"\u005c".");}
32061 }
32062 } catch (Throwable jjte000) {
32063 if (jjtc000) {
32064 jjtree.clearNodeScope(jjtn000);
32065 jjtc000 = false;
32066 } else {
32067 jjtree.popNode();
32068 }
32069 if (jjte000 instanceof RuntimeException) {
32070 {if (true) throw (RuntimeException)jjte000;}
32071 }
32072 if (jjte000 instanceof ParseException) {
32073 {if (true) throw (ParseException)jjte000;}
32074 }
32075 {if (true) throw (Error)jjte000;}
32076 } finally {
32077 if (jjtc000) {
32078 jjtree.closeNodeScope(jjtn000, true);
32079 }
32080 }
32081 throw new Error("Missing return statement in function");
32082 }
32083
32084 private boolean jj_2_1(int xla) {
32085 jj_la = xla; jj_lastpos = jj_scanpos = token;
32086 try { return !jj_3_1(); }
32087 catch(LookaheadSuccess ls) { return true; }
32088 finally { jj_save(0, xla); }
32089 }
32090
32091 private boolean jj_2_2(int xla) {
32092 jj_la = xla; jj_lastpos = jj_scanpos = token;
32093 try { return !jj_3_2(); }
32094 catch(LookaheadSuccess ls) { return true; }
32095 finally { jj_save(1, xla); }
32096 }
32097
32098 private boolean jj_2_3(int xla) {
32099 jj_la = xla; jj_lastpos = jj_scanpos = token;
32100 try { return !jj_3_3(); }
32101 catch(LookaheadSuccess ls) { return true; }
32102 finally { jj_save(2, xla); }
32103 }
32104
32105 private boolean jj_2_4(int xla) {
32106 jj_la = xla; jj_lastpos = jj_scanpos = token;
32107 try { return !jj_3_4(); }
32108 catch(LookaheadSuccess ls) { return true; }
32109 finally { jj_save(3, xla); }
32110 }
32111
32112 private boolean jj_2_5(int xla) {
32113 jj_la = xla; jj_lastpos = jj_scanpos = token;
32114 try { return !jj_3_5(); }
32115 catch(LookaheadSuccess ls) { return true; }
32116 finally { jj_save(4, xla); }
32117 }
32118
32119 private boolean jj_2_6(int xla) {
32120 jj_la = xla; jj_lastpos = jj_scanpos = token;
32121 try { return !jj_3_6(); }
32122 catch(LookaheadSuccess ls) { return true; }
32123 finally { jj_save(5, xla); }
32124 }
32125
32126 private boolean jj_2_7(int xla) {
32127 jj_la = xla; jj_lastpos = jj_scanpos = token;
32128 try { return !jj_3_7(); }
32129 catch(LookaheadSuccess ls) { return true; }
32130 finally { jj_save(6, xla); }
32131 }
32132
32133 private boolean jj_2_8(int xla) {
32134 jj_la = xla; jj_lastpos = jj_scanpos = token;
32135 try { return !jj_3_8(); }
32136 catch(LookaheadSuccess ls) { return true; }
32137 finally { jj_save(7, xla); }
32138 }
32139
32140 private boolean jj_2_9(int xla) {
32141 jj_la = xla; jj_lastpos = jj_scanpos = token;
32142 try { return !jj_3_9(); }
32143 catch(LookaheadSuccess ls) { return true; }
32144 finally { jj_save(8, xla); }
32145 }
32146
32147 private boolean jj_2_10(int xla) {
32148 jj_la = xla; jj_lastpos = jj_scanpos = token;
32149 try { return !jj_3_10(); }
32150 catch(LookaheadSuccess ls) { return true; }
32151 finally { jj_save(9, xla); }
32152 }
32153
32154 private boolean jj_2_11(int xla) {
32155 jj_la = xla; jj_lastpos = jj_scanpos = token;
32156 try { return !jj_3_11(); }
32157 catch(LookaheadSuccess ls) { return true; }
32158 finally { jj_save(10, xla); }
32159 }
32160
32161 private boolean jj_2_12(int xla) {
32162 jj_la = xla; jj_lastpos = jj_scanpos = token;
32163 try { return !jj_3_12(); }
32164 catch(LookaheadSuccess ls) { return true; }
32165 finally { jj_save(11, xla); }
32166 }
32167
32168 private boolean jj_2_13(int xla) {
32169 jj_la = xla; jj_lastpos = jj_scanpos = token;
32170 try { return !jj_3_13(); }
32171 catch(LookaheadSuccess ls) { return true; }
32172 finally { jj_save(12, xla); }
32173 }
32174
32175 private boolean jj_2_14(int xla) {
32176 jj_la = xla; jj_lastpos = jj_scanpos = token;
32177 try { return !jj_3_14(); }
32178 catch(LookaheadSuccess ls) { return true; }
32179 finally { jj_save(13, xla); }
32180 }
32181
32182 private boolean jj_2_15(int xla) {
32183 jj_la = xla; jj_lastpos = jj_scanpos = token;
32184 try { return !jj_3_15(); }
32185 catch(LookaheadSuccess ls) { return true; }
32186 finally { jj_save(14, xla); }
32187 }
32188
32189 private boolean jj_2_16(int xla) {
32190 jj_la = xla; jj_lastpos = jj_scanpos = token;
32191 try { return !jj_3_16(); }
32192 catch(LookaheadSuccess ls) { return true; }
32193 finally { jj_save(15, xla); }
32194 }
32195
32196 private boolean jj_2_17(int xla) {
32197 jj_la = xla; jj_lastpos = jj_scanpos = token;
32198 try { return !jj_3_17(); }
32199 catch(LookaheadSuccess ls) { return true; }
32200 finally { jj_save(16, xla); }
32201 }
32202
32203 private boolean jj_2_18(int xla) {
32204 jj_la = xla; jj_lastpos = jj_scanpos = token;
32205 try { return !jj_3_18(); }
32206 catch(LookaheadSuccess ls) { return true; }
32207 finally { jj_save(17, xla); }
32208 }
32209
32210 private boolean jj_2_19(int xla) {
32211 jj_la = xla; jj_lastpos = jj_scanpos = token;
32212 try { return !jj_3_19(); }
32213 catch(LookaheadSuccess ls) { return true; }
32214 finally { jj_save(18, xla); }
32215 }
32216
32217 private boolean jj_2_20(int xla) {
32218 jj_la = xla; jj_lastpos = jj_scanpos = token;
32219 try { return !jj_3_20(); }
32220 catch(LookaheadSuccess ls) { return true; }
32221 finally { jj_save(19, xla); }
32222 }
32223
32224 private boolean jj_2_21(int xla) {
32225 jj_la = xla; jj_lastpos = jj_scanpos = token;
32226 try { return !jj_3_21(); }
32227 catch(LookaheadSuccess ls) { return true; }
32228 finally { jj_save(20, xla); }
32229 }
32230
32231 private boolean jj_2_22(int xla) {
32232 jj_la = xla; jj_lastpos = jj_scanpos = token;
32233 try { return !jj_3_22(); }
32234 catch(LookaheadSuccess ls) { return true; }
32235 finally { jj_save(21, xla); }
32236 }
32237
32238 private boolean jj_2_23(int xla) {
32239 jj_la = xla; jj_lastpos = jj_scanpos = token;
32240 try { return !jj_3_23(); }
32241 catch(LookaheadSuccess ls) { return true; }
32242 finally { jj_save(22, xla); }
32243 }
32244
32245 private boolean jj_2_24(int xla) {
32246 jj_la = xla; jj_lastpos = jj_scanpos = token;
32247 try { return !jj_3_24(); }
32248 catch(LookaheadSuccess ls) { return true; }
32249 finally { jj_save(23, xla); }
32250 }
32251
32252 private boolean jj_2_25(int xla) {
32253 jj_la = xla; jj_lastpos = jj_scanpos = token;
32254 try { return !jj_3_25(); }
32255 catch(LookaheadSuccess ls) { return true; }
32256 finally { jj_save(24, xla); }
32257 }
32258
32259 private boolean jj_2_26(int xla) {
32260 jj_la = xla; jj_lastpos = jj_scanpos = token;
32261 try { return !jj_3_26(); }
32262 catch(LookaheadSuccess ls) { return true; }
32263 finally { jj_save(25, xla); }
32264 }
32265
32266 private boolean jj_2_27(int xla) {
32267 jj_la = xla; jj_lastpos = jj_scanpos = token;
32268 try { return !jj_3_27(); }
32269 catch(LookaheadSuccess ls) { return true; }
32270 finally { jj_save(26, xla); }
32271 }
32272
32273 private boolean jj_2_28(int xla) {
32274 jj_la = xla; jj_lastpos = jj_scanpos = token;
32275 try { return !jj_3_28(); }
32276 catch(LookaheadSuccess ls) { return true; }
32277 finally { jj_save(27, xla); }
32278 }
32279
32280 private boolean jj_2_29(int xla) {
32281 jj_la = xla; jj_lastpos = jj_scanpos = token;
32282 try { return !jj_3_29(); }
32283 catch(LookaheadSuccess ls) { return true; }
32284 finally { jj_save(28, xla); }
32285 }
32286
32287 private boolean jj_2_30(int xla) {
32288 jj_la = xla; jj_lastpos = jj_scanpos = token;
32289 try { return !jj_3_30(); }
32290 catch(LookaheadSuccess ls) { return true; }
32291 finally { jj_save(29, xla); }
32292 }
32293
32294 private boolean jj_2_31(int xla) {
32295 jj_la = xla; jj_lastpos = jj_scanpos = token;
32296 try { return !jj_3_31(); }
32297 catch(LookaheadSuccess ls) { return true; }
32298 finally { jj_save(30, xla); }
32299 }
32300
32301 private boolean jj_2_32(int xla) {
32302 jj_la = xla; jj_lastpos = jj_scanpos = token;
32303 try { return !jj_3_32(); }
32304 catch(LookaheadSuccess ls) { return true; }
32305 finally { jj_save(31, xla); }
32306 }
32307
32308 private boolean jj_2_33(int xla) {
32309 jj_la = xla; jj_lastpos = jj_scanpos = token;
32310 try { return !jj_3_33(); }
32311 catch(LookaheadSuccess ls) { return true; }
32312 finally { jj_save(32, xla); }
32313 }
32314
32315 private boolean jj_2_34(int xla) {
32316 jj_la = xla; jj_lastpos = jj_scanpos = token;
32317 try { return !jj_3_34(); }
32318 catch(LookaheadSuccess ls) { return true; }
32319 finally { jj_save(33, xla); }
32320 }
32321
32322 private boolean jj_2_35(int xla) {
32323 jj_la = xla; jj_lastpos = jj_scanpos = token;
32324 try { return !jj_3_35(); }
32325 catch(LookaheadSuccess ls) { return true; }
32326 finally { jj_save(34, xla); }
32327 }
32328
32329 private boolean jj_2_36(int xla) {
32330 jj_la = xla; jj_lastpos = jj_scanpos = token;
32331 try { return !jj_3_36(); }
32332 catch(LookaheadSuccess ls) { return true; }
32333 finally { jj_save(35, xla); }
32334 }
32335
32336 private boolean jj_2_37(int xla) {
32337 jj_la = xla; jj_lastpos = jj_scanpos = token;
32338 try { return !jj_3_37(); }
32339 catch(LookaheadSuccess ls) { return true; }
32340 finally { jj_save(36, xla); }
32341 }
32342
32343 private boolean jj_2_38(int xla) {
32344 jj_la = xla; jj_lastpos = jj_scanpos = token;
32345 try { return !jj_3_38(); }
32346 catch(LookaheadSuccess ls) { return true; }
32347 finally { jj_save(37, xla); }
32348 }
32349
32350 private boolean jj_2_39(int xla) {
32351 jj_la = xla; jj_lastpos = jj_scanpos = token;
32352 try { return !jj_3_39(); }
32353 catch(LookaheadSuccess ls) { return true; }
32354 finally { jj_save(38, xla); }
32355 }
32356
32357 private boolean jj_2_40(int xla) {
32358 jj_la = xla; jj_lastpos = jj_scanpos = token;
32359 try { return !jj_3_40(); }
32360 catch(LookaheadSuccess ls) { return true; }
32361 finally { jj_save(39, xla); }
32362 }
32363
32364 private boolean jj_2_41(int xla) {
32365 jj_la = xla; jj_lastpos = jj_scanpos = token;
32366 try { return !jj_3_41(); }
32367 catch(LookaheadSuccess ls) { return true; }
32368 finally { jj_save(40, xla); }
32369 }
32370
32371 private boolean jj_2_42(int xla) {
32372 jj_la = xla; jj_lastpos = jj_scanpos = token;
32373 try { return !jj_3_42(); }
32374 catch(LookaheadSuccess ls) { return true; }
32375 finally { jj_save(41, xla); }
32376 }
32377
32378 private boolean jj_2_43(int xla) {
32379 jj_la = xla; jj_lastpos = jj_scanpos = token;
32380 try { return !jj_3_43(); }
32381 catch(LookaheadSuccess ls) { return true; }
32382 finally { jj_save(42, xla); }
32383 }
32384
32385 private boolean jj_2_44(int xla) {
32386 jj_la = xla; jj_lastpos = jj_scanpos = token;
32387 try { return !jj_3_44(); }
32388 catch(LookaheadSuccess ls) { return true; }
32389 finally { jj_save(43, xla); }
32390 }
32391
32392 private boolean jj_2_45(int xla) {
32393 jj_la = xla; jj_lastpos = jj_scanpos = token;
32394 try { return !jj_3_45(); }
32395 catch(LookaheadSuccess ls) { return true; }
32396 finally { jj_save(44, xla); }
32397 }
32398
32399 private boolean jj_2_46(int xla) {
32400 jj_la = xla; jj_lastpos = jj_scanpos = token;
32401 try { return !jj_3_46(); }
32402 catch(LookaheadSuccess ls) { return true; }
32403 finally { jj_save(45, xla); }
32404 }
32405
32406 private boolean jj_2_47(int xla) {
32407 jj_la = xla; jj_lastpos = jj_scanpos = token;
32408 try { return !jj_3_47(); }
32409 catch(LookaheadSuccess ls) { return true; }
32410 finally { jj_save(46, xla); }
32411 }
32412
32413 private boolean jj_2_48(int xla) {
32414 jj_la = xla; jj_lastpos = jj_scanpos = token;
32415 try { return !jj_3_48(); }
32416 catch(LookaheadSuccess ls) { return true; }
32417 finally { jj_save(47, xla); }
32418 }
32419
32420 private boolean jj_2_49(int xla) {
32421 jj_la = xla; jj_lastpos = jj_scanpos = token;
32422 try { return !jj_3_49(); }
32423 catch(LookaheadSuccess ls) { return true; }
32424 finally { jj_save(48, xla); }
32425 }
32426
32427 private boolean jj_2_50(int xla) {
32428 jj_la = xla; jj_lastpos = jj_scanpos = token;
32429 try { return !jj_3_50(); }
32430 catch(LookaheadSuccess ls) { return true; }
32431 finally { jj_save(49, xla); }
32432 }
32433
32434 private boolean jj_2_51(int xla) {
32435 jj_la = xla; jj_lastpos = jj_scanpos = token;
32436 try { return !jj_3_51(); }
32437 catch(LookaheadSuccess ls) { return true; }
32438 finally { jj_save(50, xla); }
32439 }
32440
32441 private boolean jj_2_52(int xla) {
32442 jj_la = xla; jj_lastpos = jj_scanpos = token;
32443 try { return !jj_3_52(); }
32444 catch(LookaheadSuccess ls) { return true; }
32445 finally { jj_save(51, xla); }
32446 }
32447
32448 private boolean jj_2_53(int xla) {
32449 jj_la = xla; jj_lastpos = jj_scanpos = token;
32450 try { return !jj_3_53(); }
32451 catch(LookaheadSuccess ls) { return true; }
32452 finally { jj_save(52, xla); }
32453 }
32454
32455 private boolean jj_2_54(int xla) {
32456 jj_la = xla; jj_lastpos = jj_scanpos = token;
32457 try { return !jj_3_54(); }
32458 catch(LookaheadSuccess ls) { return true; }
32459 finally { jj_save(53, xla); }
32460 }
32461
32462 private boolean jj_2_55(int xla) {
32463 jj_la = xla; jj_lastpos = jj_scanpos = token;
32464 try { return !jj_3_55(); }
32465 catch(LookaheadSuccess ls) { return true; }
32466 finally { jj_save(54, xla); }
32467 }
32468
32469 private boolean jj_2_56(int xla) {
32470 jj_la = xla; jj_lastpos = jj_scanpos = token;
32471 try { return !jj_3_56(); }
32472 catch(LookaheadSuccess ls) { return true; }
32473 finally { jj_save(55, xla); }
32474 }
32475
32476 private boolean jj_2_57(int xla) {
32477 jj_la = xla; jj_lastpos = jj_scanpos = token;
32478 try { return !jj_3_57(); }
32479 catch(LookaheadSuccess ls) { return true; }
32480 finally { jj_save(56, xla); }
32481 }
32482
32483 private boolean jj_2_58(int xla) {
32484 jj_la = xla; jj_lastpos = jj_scanpos = token;
32485 try { return !jj_3_58(); }
32486 catch(LookaheadSuccess ls) { return true; }
32487 finally { jj_save(57, xla); }
32488 }
32489
32490 private boolean jj_2_59(int xla) {
32491 jj_la = xla; jj_lastpos = jj_scanpos = token;
32492 try { return !jj_3_59(); }
32493 catch(LookaheadSuccess ls) { return true; }
32494 finally { jj_save(58, xla); }
32495 }
32496
32497 private boolean jj_2_60(int xla) {
32498 jj_la = xla; jj_lastpos = jj_scanpos = token;
32499 try { return !jj_3_60(); }
32500 catch(LookaheadSuccess ls) { return true; }
32501 finally { jj_save(59, xla); }
32502 }
32503
32504 private boolean jj_2_61(int xla) {
32505 jj_la = xla; jj_lastpos = jj_scanpos = token;
32506 try { return !jj_3_61(); }
32507 catch(LookaheadSuccess ls) { return true; }
32508 finally { jj_save(60, xla); }
32509 }
32510
32511 private boolean jj_2_62(int xla) {
32512 jj_la = xla; jj_lastpos = jj_scanpos = token;
32513 try { return !jj_3_62(); }
32514 catch(LookaheadSuccess ls) { return true; }
32515 finally { jj_save(61, xla); }
32516 }
32517
32518 private boolean jj_2_63(int xla) {
32519 jj_la = xla; jj_lastpos = jj_scanpos = token;
32520 try { return !jj_3_63(); }
32521 catch(LookaheadSuccess ls) { return true; }
32522 finally { jj_save(62, xla); }
32523 }
32524
32525 private boolean jj_2_64(int xla) {
32526 jj_la = xla; jj_lastpos = jj_scanpos = token;
32527 try { return !jj_3_64(); }
32528 catch(LookaheadSuccess ls) { return true; }
32529 finally { jj_save(63, xla); }
32530 }
32531
32532 private boolean jj_2_65(int xla) {
32533 jj_la = xla; jj_lastpos = jj_scanpos = token;
32534 try { return !jj_3_65(); }
32535 catch(LookaheadSuccess ls) { return true; }
32536 finally { jj_save(64, xla); }
32537 }
32538
32539 private boolean jj_2_66(int xla) {
32540 jj_la = xla; jj_lastpos = jj_scanpos = token;
32541 try { return !jj_3_66(); }
32542 catch(LookaheadSuccess ls) { return true; }
32543 finally { jj_save(65, xla); }
32544 }
32545
32546 private boolean jj_2_67(int xla) {
32547 jj_la = xla; jj_lastpos = jj_scanpos = token;
32548 try { return !jj_3_67(); }
32549 catch(LookaheadSuccess ls) { return true; }
32550 finally { jj_save(66, xla); }
32551 }
32552
32553 private boolean jj_2_68(int xla) {
32554 jj_la = xla; jj_lastpos = jj_scanpos = token;
32555 try { return !jj_3_68(); }
32556 catch(LookaheadSuccess ls) { return true; }
32557 finally { jj_save(67, xla); }
32558 }
32559
32560 private boolean jj_2_69(int xla) {
32561 jj_la = xla; jj_lastpos = jj_scanpos = token;
32562 try { return !jj_3_69(); }
32563 catch(LookaheadSuccess ls) { return true; }
32564 finally { jj_save(68, xla); }
32565 }
32566
32567 private boolean jj_2_70(int xla) {
32568 jj_la = xla; jj_lastpos = jj_scanpos = token;
32569 try { return !jj_3_70(); }
32570 catch(LookaheadSuccess ls) { return true; }
32571 finally { jj_save(69, xla); }
32572 }
32573
32574 private boolean jj_2_71(int xla) {
32575 jj_la = xla; jj_lastpos = jj_scanpos = token;
32576 try { return !jj_3_71(); }
32577 catch(LookaheadSuccess ls) { return true; }
32578 finally { jj_save(70, xla); }
32579 }
32580
32581 private boolean jj_2_72(int xla) {
32582 jj_la = xla; jj_lastpos = jj_scanpos = token;
32583 try { return !jj_3_72(); }
32584 catch(LookaheadSuccess ls) { return true; }
32585 finally { jj_save(71, xla); }
32586 }
32587
32588 private boolean jj_2_73(int xla) {
32589 jj_la = xla; jj_lastpos = jj_scanpos = token;
32590 try { return !jj_3_73(); }
32591 catch(LookaheadSuccess ls) { return true; }
32592 finally { jj_save(72, xla); }
32593 }
32594
32595 private boolean jj_2_74(int xla) {
32596 jj_la = xla; jj_lastpos = jj_scanpos = token;
32597 try { return !jj_3_74(); }
32598 catch(LookaheadSuccess ls) { return true; }
32599 finally { jj_save(73, xla); }
32600 }
32601
32602 private boolean jj_2_75(int xla) {
32603 jj_la = xla; jj_lastpos = jj_scanpos = token;
32604 try { return !jj_3_75(); }
32605 catch(LookaheadSuccess ls) { return true; }
32606 finally { jj_save(74, xla); }
32607 }
32608
32609 private boolean jj_2_76(int xla) {
32610 jj_la = xla; jj_lastpos = jj_scanpos = token;
32611 try { return !jj_3_76(); }
32612 catch(LookaheadSuccess ls) { return true; }
32613 finally { jj_save(75, xla); }
32614 }
32615
32616 private boolean jj_2_77(int xla) {
32617 jj_la = xla; jj_lastpos = jj_scanpos = token;
32618 try { return !jj_3_77(); }
32619 catch(LookaheadSuccess ls) { return true; }
32620 finally { jj_save(76, xla); }
32621 }
32622
32623 private boolean jj_2_78(int xla) {
32624 jj_la = xla; jj_lastpos = jj_scanpos = token;
32625 try { return !jj_3_78(); }
32626 catch(LookaheadSuccess ls) { return true; }
32627 finally { jj_save(77, xla); }
32628 }
32629
32630 private boolean jj_2_79(int xla) {
32631 jj_la = xla; jj_lastpos = jj_scanpos = token;
32632 try { return !jj_3_79(); }
32633 catch(LookaheadSuccess ls) { return true; }
32634 finally { jj_save(78, xla); }
32635 }
32636
32637 private boolean jj_2_80(int xla) {
32638 jj_la = xla; jj_lastpos = jj_scanpos = token;
32639 try { return !jj_3_80(); }
32640 catch(LookaheadSuccess ls) { return true; }
32641 finally { jj_save(79, xla); }
32642 }
32643
32644 private boolean jj_2_81(int xla) {
32645 jj_la = xla; jj_lastpos = jj_scanpos = token;
32646 try { return !jj_3_81(); }
32647 catch(LookaheadSuccess ls) { return true; }
32648 finally { jj_save(80, xla); }
32649 }
32650
32651 private boolean jj_2_82(int xla) {
32652 jj_la = xla; jj_lastpos = jj_scanpos = token;
32653 try { return !jj_3_82(); }
32654 catch(LookaheadSuccess ls) { return true; }
32655 finally { jj_save(81, xla); }
32656 }
32657
32658 private boolean jj_2_83(int xla) {
32659 jj_la = xla; jj_lastpos = jj_scanpos = token;
32660 try { return !jj_3_83(); }
32661 catch(LookaheadSuccess ls) { return true; }
32662 finally { jj_save(82, xla); }
32663 }
32664
32665 private boolean jj_3R_150() {
32666 if (jj_scan_token(6)) return true;
32667 if (jj_3R_123()) return true;
32668 return false;
32669 }
32670
32671 private boolean jj_3R_623() {
32672 if (jj_scan_token(3)) return true;
32673 Token xsp;
32674 xsp = jj_scanpos;
32675 if (jj_scan_token(418)) {
32676 jj_scanpos = xsp;
32677 if (jj_scan_token(426)) {
32678 jj_scanpos = xsp;
32679 if (jj_3R_624()) return true;
32680 }
32681 }
32682 return false;
32683 }
32684
32685 private boolean jj_3R_596() {
32686 if (jj_scan_token(9)) return true;
32687 if (jj_scan_token(10)) return true;
32688 return false;
32689 }
32690
32691 private boolean jj_3R_288() {
32692 if (jj_scan_token(PARAMETERS)) return true;
32693 if (jj_3R_561()) return true;
32694 return false;
32695 }
32696
32697 private boolean jj_3R_563() {
32698 Token xsp;
32699 xsp = jj_scanpos;
32700 if (jj_3R_596()) {
32701 jj_scanpos = xsp;
32702 if (jj_scan_token(92)) return true;
32703 }
32704 if (jj_3R_232()) return true;
32705 return false;
32706 }
32707
32708 private boolean jj_3R_523() {
32709 if (jj_scan_token(5)) return true;
32710 if (jj_3R_126()) return true;
32711 if (jj_scan_token(7)) return true;
32712 return false;
32713 }
32714
32715 private boolean jj_3R_287() {
32716 if (jj_scan_token(WITH)) return true;
32717 if (jj_scan_token(CONTEXT)) return true;
32718 return false;
32719 }
32720
32721 private boolean jj_3R_149() {
32722 if (jj_scan_token(6)) return true;
32723 if (jj_3R_123()) return true;
32724 return false;
32725 }
32726
32727 private boolean jj_3R_286() {
32728 if (jj_scan_token(NAME)) return true;
32729 Token xsp;
32730 xsp = jj_scanpos;
32731 if (jj_scan_token(418)) {
32732 jj_scanpos = xsp;
32733 if (jj_scan_token(426)) {
32734 jj_scanpos = xsp;
32735 if (jj_3R_560()) return true;
32736 }
32737 }
32738 return false;
32739 }
32740
32741 private boolean jj_3R_525() {
32742 if (jj_scan_token(INDEX)) return true;
32743 if (jj_scan_token(BY)) return true;
32744 if (jj_3R_234()) return true;
32745 return false;
32746 }
32747
32748 private boolean jj_3R_521() {
32749 if (jj_scan_token(6)) return true;
32750 if (jj_3R_519()) return true;
32751 return false;
32752 }
32753
32754 private boolean jj_3R_199() {
32755 Token xsp;
32756 xsp = jj_scanpos;
32757 if (jj_3R_285()) {
32758 jj_scanpos = xsp;
32759 if (jj_3R_286()) {
32760 jj_scanpos = xsp;
32761 if (jj_3R_287()) {
32762 jj_scanpos = xsp;
32763 if (jj_3R_288()) return true;
32764 }
32765 }
32766 }
32767 return false;
32768 }
32769
32770 private boolean jj_3R_285() {
32771 if (jj_scan_token(LIBRARY)) return true;
32772 Token xsp;
32773 xsp = jj_scanpos;
32774 if (jj_scan_token(418)) {
32775 jj_scanpos = xsp;
32776 if (jj_scan_token(426)) {
32777 jj_scanpos = xsp;
32778 if (jj_3R_559()) return true;
32779 }
32780 }
32781 xsp = jj_scanpos;
32782 if (jj_3R_623()) jj_scanpos = xsp;
32783 return false;
32784 }
32785
32786 private boolean jj_3_74() {
32787 if (jj_3R_123()) return true;
32788 if (jj_scan_token(3)) return true;
32789 return false;
32790 }
32791
32792 private boolean jj_3R_520() {
32793 if (jj_scan_token(6)) return true;
32794 if (jj_3R_519()) return true;
32795 return false;
32796 }
32797
32798 private boolean jj_3_77() {
32799 if (jj_3R_123()) return true;
32800 if (jj_scan_token(3)) return true;
32801 return false;
32802 }
32803
32804 private boolean jj_3R_198() {
32805 if (jj_scan_token(LANGUAGE)) return true;
32806 Token xsp;
32807 xsp = jj_scanpos;
32808 if (jj_scan_token(418)) {
32809 jj_scanpos = xsp;
32810 if (jj_scan_token(153)) return true;
32811 }
32812 return false;
32813 }
32814
32815 private boolean jj_3_73() {
32816 if (jj_scan_token(OF)) return true;
32817 if (jj_3R_123()) return true;
32818 Token xsp;
32819 while (true) {
32820 xsp = jj_scanpos;
32821 if (jj_3R_150()) { jj_scanpos = xsp; break; }
32822 }
32823 return false;
32824 }
32825
32826 private boolean jj_3R_562() {
32827 Token xsp;
32828 xsp = jj_scanpos;
32829 if (jj_scan_token(182)) jj_scanpos = xsp;
32830 if (jj_scan_token(NULL)) return true;
32831 return false;
32832 }
32833
32834 private boolean jj_3R_527() {
32835 if (jj_scan_token(6)) return true;
32836 if (jj_3R_232()) return true;
32837 return false;
32838 }
32839
32840 private boolean jj_3R_522() {
32841 if (jj_scan_token(VARYING)) return true;
32842 if (jj_scan_token(ARRAY)) return true;
32843 return false;
32844 }
32845
32846 private boolean jj_3R_526() {
32847 if (jj_scan_token(RETURN)) return true;
32848 if (jj_3R_234()) return true;
32849 return false;
32850 }
32851
32852 private boolean jj_3R_524() {
32853 if (jj_scan_token(NOT)) return true;
32854 if (jj_scan_token(NULL)) return true;
32855 return false;
32856 }
32857
32858 private boolean jj_3_72() {
32859 if (jj_scan_token(OF)) return true;
32860 if (jj_3R_123()) return true;
32861 Token xsp;
32862 while (true) {
32863 xsp = jj_scanpos;
32864 if (jj_3R_149()) { jj_scanpos = xsp; break; }
32865 }
32866 return false;
32867 }
32868
32869 private boolean jj_3R_122() {
32870 Token xsp;
32871 xsp = jj_scanpos;
32872 if (jj_scan_token(114)) {
32873 jj_scanpos = xsp;
32874 if (jj_3R_198()) return true;
32875 }
32876 while (true) {
32877 xsp = jj_scanpos;
32878 if (jj_3R_199()) { jj_scanpos = xsp; break; }
32879 }
32880 return false;
32881 }
32882
32883 private boolean jj_3R_496() {
32884 if (jj_3R_234()) return true;
32885 return false;
32886 }
32887
32888 private boolean jj_3R_495() {
32889 if (jj_scan_token(5)) return true;
32890 if (jj_3R_232()) return true;
32891 Token xsp;
32892 while (true) {
32893 xsp = jj_scanpos;
32894 if (jj_3R_527()) { jj_scanpos = xsp; break; }
32895 }
32896 if (jj_scan_token(7)) return true;
32897 return false;
32898 }
32899
32900 private boolean jj_3R_494() {
32901 if (jj_scan_token(REF)) return true;
32902 if (jj_scan_token(CURSOR)) return true;
32903 Token xsp;
32904 xsp = jj_scanpos;
32905 if (jj_3R_526()) jj_scanpos = xsp;
32906 return false;
32907 }
32908
32909 private boolean jj_3R_519() {
32910 if (jj_3R_123()) return true;
32911 if (jj_3R_234()) return true;
32912 Token xsp;
32913 xsp = jj_scanpos;
32914 if (jj_3R_562()) jj_scanpos = xsp;
32915 xsp = jj_scanpos;
32916 if (jj_3R_563()) jj_scanpos = xsp;
32917 return false;
32918 }
32919
32920 private boolean jj_3R_493() {
32921 Token xsp;
32922 xsp = jj_scanpos;
32923 if (jj_scan_token(269)) {
32924 jj_scanpos = xsp;
32925 if (jj_scan_token(308)) {
32926 jj_scanpos = xsp;
32927 if (jj_3R_522()) return true;
32928 }
32929 }
32930 xsp = jj_scanpos;
32931 if (jj_3R_523()) jj_scanpos = xsp;
32932 if (jj_scan_token(OF)) return true;
32933 if (jj_3R_234()) return true;
32934 xsp = jj_scanpos;
32935 if (jj_3R_524()) jj_scanpos = xsp;
32936 xsp = jj_scanpos;
32937 if (jj_3R_525()) jj_scanpos = xsp;
32938 return false;
32939 }
32940
32941 private boolean jj_3R_265() {
32942 Token xsp;
32943 xsp = jj_scanpos;
32944 if (jj_scan_token(100)) {
32945 jj_scanpos = xsp;
32946 if (jj_scan_token(181)) return true;
32947 }
32948 return false;
32949 }
32950
32951 private boolean jj_3R_492() {
32952 if (jj_scan_token(RECORD)) return true;
32953 if (jj_scan_token(5)) return true;
32954 if (jj_3R_519()) return true;
32955 Token xsp;
32956 while (true) {
32957 xsp = jj_scanpos;
32958 if (jj_3R_521()) { jj_scanpos = xsp; break; }
32959 }
32960 if (jj_scan_token(7)) return true;
32961 return false;
32962 }
32963
32964 private boolean jj_3R_491() {
32965 if (jj_scan_token(OBJECT)) return true;
32966 if (jj_scan_token(5)) return true;
32967 if (jj_3R_519()) return true;
32968 Token xsp;
32969 while (true) {
32970 xsp = jj_scanpos;
32971 if (jj_3R_520()) { jj_scanpos = xsp; break; }
32972 }
32973 if (jj_scan_token(7)) return true;
32974 return false;
32975 }
32976
32977 private boolean jj_3R_267() {
32978 Token xsp;
32979 xsp = jj_scanpos;
32980 if (jj_scan_token(93)) {
32981 jj_scanpos = xsp;
32982 if (jj_scan_token(143)) {
32983 jj_scanpos = xsp;
32984 if (jj_scan_token(295)) return true;
32985 }
32986 }
32987 return false;
32988 }
32989
32990 private boolean jj_3_75() {
32991 if (jj_3R_123()) return true;
32992 if (jj_scan_token(3)) return true;
32993 return false;
32994 }
32995
32996 private boolean jj_3R_177() {
32997 Token xsp;
32998 xsp = jj_scanpos;
32999 if (jj_3_75()) jj_scanpos = xsp;
33000 if (jj_3R_123()) return true;
33001 return false;
33002 }
33003
33004 private boolean jj_3_76() {
33005 if (jj_scan_token(NESTED)) return true;
33006 if (jj_scan_token(TABLE)) return true;
33007 return false;
33008 }
33009
33010 private boolean jj_3R_632() {
33011 if (jj_3R_172()) return true;
33012 return false;
33013 }
33014
33015 private boolean jj_3_44() {
33016 if (jj_scan_token(NEW)) return true;
33017 Token xsp;
33018 xsp = jj_scanpos;
33019 if (jj_scan_token(68)) {
33020 jj_scanpos = xsp;
33021 if (jj_scan_token(190)) {
33022 jj_scanpos = xsp;
33023 if (jj_scan_token(189)) {
33024 jj_scanpos = xsp;
33025 if (jj_scan_token(188)) {
33026 jj_scanpos = xsp;
33027 if (jj_scan_token(187)) {
33028 jj_scanpos = xsp;
33029 if (jj_scan_token(191)) return true;
33030 }
33031 }
33032 }
33033 }
33034 }
33035 return false;
33036 }
33037
33038 private boolean jj_3R_176() {
33039 if (jj_scan_token(OR)) return true;
33040 Token xsp;
33041 xsp = jj_scanpos;
33042 if (jj_3R_267()) {
33043 jj_scanpos = xsp;
33044 if (jj_3R_268()) return true;
33045 }
33046 return false;
33047 }
33048
33049 private boolean jj_3R_174() {
33050 Token xsp;
33051 xsp = jj_scanpos;
33052 if (jj_scan_token(93)) {
33053 jj_scanpos = xsp;
33054 if (jj_scan_token(143)) {
33055 jj_scanpos = xsp;
33056 if (jj_scan_token(295)) return true;
33057 }
33058 }
33059 xsp = jj_scanpos;
33060 if (jj_3_72()) jj_scanpos = xsp;
33061 return false;
33062 }
33063
33064 private boolean jj_3R_264() {
33065 if (jj_scan_token(OR)) return true;
33066 if (jj_scan_token(REPLACE)) return true;
33067 return false;
33068 }
33069
33070 private boolean jj_3R_592() {
33071 if (jj_3R_172()) return true;
33072 return false;
33073 }
33074
33075 private boolean jj_3R_490() {
33076 if (jj_scan_token(NOT)) return true;
33077 if (jj_scan_token(NULL)) return true;
33078 return false;
33079 }
33080
33081 private boolean jj_3R_173() {
33082 if (jj_scan_token(CREATE)) return true;
33083 Token xsp;
33084 xsp = jj_scanpos;
33085 if (jj_3R_264()) jj_scanpos = xsp;
33086 xsp = jj_scanpos;
33087 if (jj_3R_265()) jj_scanpos = xsp;
33088 return false;
33089 }
33090
33091 private boolean jj_3R_518() {
33092 if (jj_scan_token(RANGE)) return true;
33093 if (jj_3R_481()) return true;
33094 if (jj_scan_token(12)) return true;
33095 if (jj_3R_481()) return true;
33096 return false;
33097 }
33098
33099 private boolean jj_3R_107() {
33100 Token xsp;
33101 xsp = jj_scanpos;
33102 if (jj_3R_173()) jj_scanpos = xsp;
33103 if (jj_scan_token(TRIGGER)) return true;
33104 if (jj_3R_153()) return true;
33105 xsp = jj_scanpos;
33106 if (jj_scan_token(320)) {
33107 jj_scanpos = xsp;
33108 if (jj_scan_token(319)) {
33109 jj_scanpos = xsp;
33110 if (jj_scan_token(321)) {
33111 jj_scanpos = xsp;
33112 if (jj_scan_token(121)) return true;
33113 }
33114 }
33115 }
33116 xsp = jj_scanpos;
33117 if (jj_3R_174()) {
33118 jj_scanpos = xsp;
33119 if (jj_3R_175()) return true;
33120 }
33121 while (true) {
33122 xsp = jj_scanpos;
33123 if (jj_3R_176()) { jj_scanpos = xsp; break; }
33124 }
33125 if (jj_scan_token(ON)) return true;
33126 xsp = jj_scanpos;
33127 if (jj_scan_token(346)) {
33128 jj_scanpos = xsp;
33129 if (jj_3_76()) {
33130 jj_scanpos = xsp;
33131 if (jj_3R_177()) return true;
33132 }
33133 }
33134 return false;
33135 }
33136
33137 private boolean jj_3R_517() {
33138 if (jj_scan_token(5)) return true;
33139 if (jj_scan_token(IDENTIFIER)) return true;
33140 if (jj_scan_token(7)) return true;
33141 return false;
33142 }
33143
33144 private boolean jj_3R_489() {
33145 Token xsp;
33146 xsp = jj_scanpos;
33147 if (jj_3R_517()) {
33148 jj_scanpos = xsp;
33149 if (jj_3R_518()) return true;
33150 }
33151 return false;
33152 }
33153
33154 private boolean jj_3R_633() {
33155 if (jj_scan_token(IN)) return true;
33156 Token xsp;
33157 xsp = jj_scanpos;
33158 if (jj_scan_token(205)) jj_scanpos = xsp;
33159 return false;
33160 }
33161
33162 private boolean jj_3R_631() {
33163 Token xsp;
33164 xsp = jj_scanpos;
33165 if (jj_3R_633()) {
33166 jj_scanpos = xsp;
33167 if (jj_scan_token(205)) return true;
33168 }
33169 return false;
33170 }
33171
33172 private boolean jj_3R_242() {
33173 if (jj_scan_token(TYPE)) return true;
33174 if (jj_3R_119()) return true;
33175 Token xsp;
33176 xsp = jj_scanpos;
33177 if (jj_scan_token(151)) {
33178 jj_scanpos = xsp;
33179 if (jj_scan_token(51)) return true;
33180 }
33181 xsp = jj_scanpos;
33182 if (jj_3_44()) {
33183 jj_scanpos = xsp;
33184 if (jj_3R_491()) {
33185 jj_scanpos = xsp;
33186 if (jj_3R_492()) {
33187 jj_scanpos = xsp;
33188 if (jj_3R_493()) {
33189 jj_scanpos = xsp;
33190 if (jj_3R_494()) {
33191 jj_scanpos = xsp;
33192 if (jj_3R_495()) {
33193 jj_scanpos = xsp;
33194 if (jj_3R_496()) return true;
33195 }
33196 }
33197 }
33198 }
33199 }
33200 }
33201 return false;
33202 }
33203
33204 private boolean jj_3R_628() {
33205 if (jj_scan_token(6)) return true;
33206 if (jj_3R_232()) return true;
33207 return false;
33208 }
33209
33210 private boolean jj_3R_627() {
33211 if (jj_scan_token(6)) return true;
33212 Token xsp;
33213 xsp = jj_scanpos;
33214 if (jj_3R_631()) jj_scanpos = xsp;
33215 if (jj_3R_232()) return true;
33216 return false;
33217 }
33218
33219 private boolean jj_3R_241() {
33220 if (jj_scan_token(SUBTYPE)) return true;
33221 if (jj_3R_119()) return true;
33222 if (jj_scan_token(IS)) return true;
33223 if (jj_3R_234()) return true;
33224 Token xsp;
33225 xsp = jj_scanpos;
33226 if (jj_3R_489()) jj_scanpos = xsp;
33227 xsp = jj_scanpos;
33228 if (jj_3R_490()) jj_scanpos = xsp;
33229 return false;
33230 }
33231
33232 private boolean jj_3R_615() {
33233 if (jj_3R_172()) return true;
33234 return false;
33235 }
33236
33237 private boolean jj_3R_151() {
33238 Token xsp;
33239 xsp = jj_scanpos;
33240 if (jj_3R_241()) {
33241 jj_scanpos = xsp;
33242 if (jj_3R_242()) return true;
33243 }
33244 if (jj_scan_token(4)) return true;
33245 return false;
33246 }
33247
33248 private boolean jj_3R_553() {
33249 if (jj_scan_token(LIMIT)) return true;
33250 if (jj_3R_232()) return true;
33251 return false;
33252 }
33253
33254 private boolean jj_3R_630() {
33255 if (jj_scan_token(6)) return true;
33256 if (jj_3R_232()) return true;
33257 return false;
33258 }
33259
33260 private boolean jj_3R_594() {
33261 if (jj_scan_token(CC_ELSE)) return true;
33262 Token xsp;
33263 if (jj_3R_615()) return true;
33264 while (true) {
33265 xsp = jj_scanpos;
33266 if (jj_3R_615()) { jj_scanpos = xsp; break; }
33267 }
33268 return false;
33269 }
33270
33271 private boolean jj_3R_593() {
33272 if (jj_scan_token(CC_ELSIF)) return true;
33273 if (jj_3R_342()) return true;
33274 if (jj_scan_token(CC_THEN)) return true;
33275 Token xsp;
33276 if (jj_3R_632()) return true;
33277 while (true) {
33278 xsp = jj_scanpos;
33279 if (jj_3R_632()) { jj_scanpos = xsp; break; }
33280 }
33281 return false;
33282 }
33283
33284 private boolean jj_3R_455() {
33285 if (jj_scan_token(CC_ERROR)) return true;
33286 if (jj_3R_232()) return true;
33287 if (jj_scan_token(CC_END)) return true;
33288 return false;
33289 }
33290
33291 private boolean jj_3R_454() {
33292 if (jj_scan_token(CC_IF)) return true;
33293 if (jj_3R_342()) return true;
33294 if (jj_scan_token(CC_THEN)) return true;
33295 Token xsp;
33296 while (true) {
33297 xsp = jj_scanpos;
33298 if (jj_3R_592()) { jj_scanpos = xsp; break; }
33299 }
33300 while (true) {
33301 xsp = jj_scanpos;
33302 if (jj_3R_593()) { jj_scanpos = xsp; break; }
33303 }
33304 while (true) {
33305 xsp = jj_scanpos;
33306 if (jj_3R_594()) { jj_scanpos = xsp; break; }
33307 }
33308 if (jj_scan_token(CC_END)) return true;
33309 return false;
33310 }
33311
33312 private boolean jj_3R_626() {
33313 if (jj_scan_token(6)) return true;
33314 if (jj_3R_293()) return true;
33315 return false;
33316 }
33317
33318 private boolean jj_3R_419() {
33319 Token xsp;
33320 xsp = jj_scanpos;
33321 if (jj_3R_454()) {
33322 jj_scanpos = xsp;
33323 if (jj_3R_455()) return true;
33324 }
33325 return false;
33326 }
33327
33328 private boolean jj_3R_614() {
33329 if (jj_scan_token(IN)) return true;
33330 Token xsp;
33331 xsp = jj_scanpos;
33332 if (jj_scan_token(205)) jj_scanpos = xsp;
33333 return false;
33334 }
33335
33336 private boolean jj_3R_591() {
33337 Token xsp;
33338 xsp = jj_scanpos;
33339 if (jj_3R_614()) {
33340 jj_scanpos = xsp;
33341 if (jj_scan_token(205)) return true;
33342 }
33343 return false;
33344 }
33345
33346 private boolean jj_3R_551() {
33347 if (jj_scan_token(BULK)) return true;
33348 if (jj_scan_token(COLLECT)) return true;
33349 return false;
33350 }
33351
33352 private boolean jj_3R_552() {
33353 if (jj_scan_token(6)) return true;
33354 if (jj_3R_232()) return true;
33355 return false;
33356 }
33357
33358 private boolean jj_3R_418() {
33359 if (jj_scan_token(PIPE)) return true;
33360 if (jj_scan_token(ROW)) return true;
33361 if (jj_3R_232()) return true;
33362 return false;
33363 }
33364
33365 private boolean jj_3R_590() {
33366 if (jj_scan_token(USING)) return true;
33367 if (jj_3R_232()) return true;
33368 Token xsp;
33369 while (true) {
33370 xsp = jj_scanpos;
33371 if (jj_3R_630()) { jj_scanpos = xsp; break; }
33372 }
33373 return false;
33374 }
33375
33376 private boolean jj_3R_556() {
33377 Token xsp;
33378 xsp = jj_scanpos;
33379 if (jj_scan_token(235)) {
33380 jj_scanpos = xsp;
33381 if (jj_scan_token(236)) return true;
33382 }
33383 if (jj_scan_token(INTO)) return true;
33384 if (jj_3R_232()) return true;
33385 while (true) {
33386 xsp = jj_scanpos;
33387 if (jj_3R_628()) { jj_scanpos = xsp; break; }
33388 }
33389 return false;
33390 }
33391
33392 private boolean jj_3R_555() {
33393 if (jj_scan_token(USING)) return true;
33394 Token xsp;
33395 xsp = jj_scanpos;
33396 if (jj_3R_591()) jj_scanpos = xsp;
33397 if (jj_3R_232()) return true;
33398 while (true) {
33399 xsp = jj_scanpos;
33400 if (jj_3R_627()) { jj_scanpos = xsp; break; }
33401 }
33402 return false;
33403 }
33404
33405 private boolean jj_3R_554() {
33406 if (jj_scan_token(INTO)) return true;
33407 if (jj_3R_293()) return true;
33408 Token xsp;
33409 while (true) {
33410 xsp = jj_scanpos;
33411 if (jj_3R_626()) { jj_scanpos = xsp; break; }
33412 }
33413 return false;
33414 }
33415
33416 private boolean jj_3R_450() {
33417 if (jj_scan_token(WHEN)) return true;
33418 if (jj_3R_232()) return true;
33419 return false;
33420 }
33421
33422 private boolean jj_3R_417() {
33423 if (jj_scan_token(EXECUTE)) return true;
33424 if (jj_scan_token(IMMEDIATE)) return true;
33425 if (jj_3R_232()) return true;
33426 Token xsp;
33427 xsp = jj_scanpos;
33428 if (jj_3R_554()) jj_scanpos = xsp;
33429 xsp = jj_scanpos;
33430 if (jj_3R_555()) jj_scanpos = xsp;
33431 xsp = jj_scanpos;
33432 if (jj_3R_556()) jj_scanpos = xsp;
33433 if (jj_scan_token(4)) return true;
33434 return false;
33435 }
33436
33437 private boolean jj_3R_453() {
33438 if (jj_scan_token(FOR)) return true;
33439 if (jj_3R_232()) return true;
33440 Token xsp;
33441 xsp = jj_scanpos;
33442 if (jj_3R_590()) jj_scanpos = xsp;
33443 return false;
33444 }
33445
33446 private boolean jj_3R_416() {
33447 if (jj_scan_token(FETCH)) return true;
33448 if (jj_3R_127()) return true;
33449 Token xsp;
33450 xsp = jj_scanpos;
33451 if (jj_3R_551()) jj_scanpos = xsp;
33452 if (jj_scan_token(INTO)) return true;
33453 if (jj_3R_232()) return true;
33454 while (true) {
33455 xsp = jj_scanpos;
33456 if (jj_3R_552()) { jj_scanpos = xsp; break; }
33457 }
33458 xsp = jj_scanpos;
33459 if (jj_3R_553()) jj_scanpos = xsp;
33460 return false;
33461 }
33462
33463 private boolean jj_3R_207() {
33464 if (jj_scan_token(WHEN)) return true;
33465 if (jj_3R_232()) return true;
33466 return false;
33467 }
33468
33469 private boolean jj_3R_452() {
33470 if (jj_3R_232()) return true;
33471 return false;
33472 }
33473
33474 private boolean jj_3R_402() {
33475 if (jj_scan_token(INTERFACE)) return true;
33476 if (jj_scan_token(5)) return true;
33477 return false;
33478 }
33479
33480 private boolean jj_3R_401() {
33481 if (jj_scan_token(EXCEPTION_INIT)) return true;
33482 if (jj_scan_token(5)) return true;
33483 return false;
33484 }
33485
33486 private boolean jj_3R_400() {
33487 if (jj_scan_token(RESTRICT_REFERENCES)) return true;
33488 if (jj_scan_token(5)) return true;
33489 return false;
33490 }
33491
33492 private boolean jj_3R_415() {
33493 if (jj_scan_token(OPEN)) return true;
33494 Token xsp;
33495 xsp = jj_scanpos;
33496 if (jj_3R_452()) jj_scanpos = xsp;
33497 xsp = jj_scanpos;
33498 if (jj_3R_453()) jj_scanpos = xsp;
33499 return false;
33500 }
33501
33502 private boolean jj_3R_451() {
33503 if (jj_3R_127()) return true;
33504 return false;
33505 }
33506
33507 private boolean jj_3R_414() {
33508 if (jj_scan_token(CLOSE)) return true;
33509 if (jj_3R_127()) return true;
33510 return false;
33511 }
33512
33513 private boolean jj_3R_350() {
33514 if (jj_scan_token(PRAGMA)) return true;
33515 Token xsp;
33516 xsp = jj_scanpos;
33517 if (jj_scan_token(38)) {
33518 jj_scanpos = xsp;
33519 if (jj_scan_token(41)) {
33520 jj_scanpos = xsp;
33521 if (jj_3R_400()) {
33522 jj_scanpos = xsp;
33523 if (jj_3R_401()) {
33524 jj_scanpos = xsp;
33525 if (jj_3R_402()) return true;
33526 }
33527 }
33528 }
33529 }
33530 return false;
33531 }
33532
33533 private boolean jj_3R_449() {
33534 if (jj_3R_141()) return true;
33535 return false;
33536 }
33537
33538 private boolean jj_3R_413() {
33539 if (jj_scan_token(RAISE)) return true;
33540 Token xsp;
33541 xsp = jj_scanpos;
33542 if (jj_3R_451()) jj_scanpos = xsp;
33543 return false;
33544 }
33545
33546 private boolean jj_3R_206() {
33547 if (jj_3R_141()) return true;
33548 return false;
33549 }
33550
33551 private boolean jj_3R_589() {
33552 if (jj_scan_token(12)) return true;
33553 if (jj_3R_232()) return true;
33554 return false;
33555 }
33556
33557 private boolean jj_3R_412() {
33558 if (jj_scan_token(EXIT)) return true;
33559 Token xsp;
33560 xsp = jj_scanpos;
33561 if (jj_3R_449()) jj_scanpos = xsp;
33562 xsp = jj_scanpos;
33563 if (jj_3R_450()) jj_scanpos = xsp;
33564 return false;
33565 }
33566
33567 private boolean jj_3R_448() {
33568 if (jj_3R_232()) return true;
33569 return false;
33570 }
33571
33572 private boolean jj_3R_131() {
33573 if (jj_scan_token(CONTINUE)) return true;
33574 Token xsp;
33575 xsp = jj_scanpos;
33576 if (jj_3R_206()) jj_scanpos = xsp;
33577 xsp = jj_scanpos;
33578 if (jj_3R_207()) jj_scanpos = xsp;
33579 return false;
33580 }
33581
33582 private boolean jj_3R_549() {
33583 if (jj_scan_token(SAVE)) return true;
33584 if (jj_scan_token(EXCEPTIONS)) return true;
33585 return false;
33586 }
33587
33588 private boolean jj_3R_146() {
33589 if (jj_3R_123()) return true;
33590 if (jj_3R_234()) return true;
33591 return false;
33592 }
33593
33594 private boolean jj_3R_548() {
33595 if (jj_3R_232()) return true;
33596 Token xsp;
33597 xsp = jj_scanpos;
33598 if (jj_3R_589()) jj_scanpos = xsp;
33599 return false;
33600 }
33601
33602 private boolean jj_3R_625() {
33603 if (jj_3R_172()) return true;
33604 return false;
33605 }
33606
33607 private boolean jj_3R_547() {
33608 Token xsp;
33609 xsp = jj_scanpos;
33610 if (jj_scan_token(139)) {
33611 jj_scanpos = xsp;
33612 if (jj_scan_token(287)) return true;
33613 }
33614 if (jj_scan_token(OF)) return true;
33615 if (jj_3R_232()) return true;
33616 return false;
33617 }
33618
33619 private boolean jj_3R_411() {
33620 if (jj_scan_token(RETURN)) return true;
33621 Token xsp;
33622 xsp = jj_scanpos;
33623 if (jj_3R_448()) jj_scanpos = xsp;
33624 return false;
33625 }
33626
33627 private boolean jj_3R_410() {
33628 if (jj_scan_token(GOTO)) return true;
33629 if (jj_3R_127()) return true;
33630 return false;
33631 }
33632
33633 private boolean jj_3R_407() {
33634 if (jj_scan_token(FORALL)) return true;
33635 if (jj_3R_446()) return true;
33636 if (jj_scan_token(IN)) return true;
33637 Token xsp;
33638 xsp = jj_scanpos;
33639 if (jj_3R_547()) {
33640 jj_scanpos = xsp;
33641 if (jj_3R_548()) return true;
33642 }
33643 xsp = jj_scanpos;
33644 if (jj_3R_549()) jj_scanpos = xsp;
33645 if (jj_3R_403()) return true;
33646 return false;
33647 }
33648
33649 private boolean jj_3R_546() {
33650 if (jj_scan_token(12)) return true;
33651 if (jj_3R_232()) return true;
33652 return false;
33653 }
33654
33655 private boolean jj_3R_543() {
33656 if (jj_3R_172()) return true;
33657 return false;
33658 }
33659
33660 private boolean jj_3R_550() {
33661 if (jj_3R_172()) return true;
33662 return false;
33663 }
33664
33665 private boolean jj_3R_446() {
33666 if (jj_3R_123()) return true;
33667 return false;
33668 }
33669
33670 private boolean jj_3R_445() {
33671 if (jj_3R_123()) return true;
33672 return false;
33673 }
33674
33675 private boolean jj_3R_354() {
33676 if (jj_scan_token(CASCADE)) return true;
33677 return false;
33678 }
33679
33680 private boolean jj_3R_313() {
33681 Token xsp;
33682 xsp = jj_scanpos;
33683 if (jj_scan_token(150)) {
33684 jj_scanpos = xsp;
33685 if (jj_3R_354()) return true;
33686 }
33687 return false;
33688 }
33689
33690 private boolean jj_3R_545() {
33691 if (jj_3R_483()) return true;
33692 return false;
33693 }
33694
33695 private boolean jj_3R_544() {
33696 if (jj_3R_588()) return true;
33697 return false;
33698 }
33699
33700 private boolean jj_3R_148() {
33701 if (jj_3R_237()) return true;
33702 return false;
33703 }
33704
33705 private boolean jj_3R_405() {
33706 if (jj_scan_token(IF)) return true;
33707 if (jj_3R_232()) return true;
33708 if (jj_scan_token(THEN)) return true;
33709 Token xsp;
33710 if (jj_3R_543()) return true;
33711 while (true) {
33712 xsp = jj_scanpos;
33713 if (jj_3R_543()) { jj_scanpos = xsp; break; }
33714 }
33715 while (true) {
33716 xsp = jj_scanpos;
33717 if (jj_3R_544()) { jj_scanpos = xsp; break; }
33718 }
33719 xsp = jj_scanpos;
33720 if (jj_3R_545()) jj_scanpos = xsp;
33721 if (jj_scan_token(END)) return true;
33722 if (jj_scan_token(IF)) return true;
33723 return false;
33724 }
33725
33726 private boolean jj_3_71() {
33727 if (jj_3R_145()) return true;
33728 return false;
33729 }
33730
33731 private boolean jj_3R_629() {
33732 if (jj_3R_172()) return true;
33733 return false;
33734 }
33735
33736 private boolean jj_3R_147() {
33737 if (jj_scan_token(AUTHID)) return true;
33738 Token xsp;
33739 xsp = jj_scanpos;
33740 if (jj_scan_token(37)) {
33741 jj_scanpos = xsp;
33742 if (jj_scan_token(36)) return true;
33743 }
33744 return false;
33745 }
33746
33747 private boolean jj_3R_409() {
33748 if (jj_scan_token(WHILE)) return true;
33749 if (jj_3R_232()) return true;
33750 if (jj_scan_token(LOOP)) return true;
33751 Token xsp;
33752 if (jj_3R_550()) return true;
33753 while (true) {
33754 xsp = jj_scanpos;
33755 if (jj_3R_550()) { jj_scanpos = xsp; break; }
33756 }
33757 if (jj_scan_token(END)) return true;
33758 if (jj_scan_token(LOOP)) return true;
33759 xsp = jj_scanpos;
33760 if (jj_scan_token(418)) jj_scanpos = xsp;
33761 return false;
33762 }
33763
33764 private boolean jj_3R_130() {
33765 if (jj_scan_token(LOCK)) return true;
33766 if (jj_scan_token(TABLE)) return true;
33767 return false;
33768 }
33769
33770 private boolean jj_3R_312() {
33771 Token xsp;
33772 xsp = jj_scanpos;
33773 if (jj_scan_token(182)) jj_scanpos = xsp;
33774 xsp = jj_scanpos;
33775 if (jj_scan_token(119)) {
33776 jj_scanpos = xsp;
33777 if (jj_scan_token(144)) {
33778 jj_scanpos = xsp;
33779 if (jj_scan_token(184)) return true;
33780 }
33781 }
33782 return false;
33783 }
33784
33785 private boolean jj_3_70() {
33786 if (jj_3R_145()) return true;
33787 return false;
33788 }
33789
33790 private boolean jj_3R_406() {
33791 if (jj_scan_token(FOR)) return true;
33792 if (jj_3R_445()) return true;
33793 if (jj_scan_token(IN)) return true;
33794 Token xsp;
33795 xsp = jj_scanpos;
33796 if (jj_scan_token(237)) jj_scanpos = xsp;
33797 if (jj_3R_232()) return true;
33798 xsp = jj_scanpos;
33799 if (jj_3R_546()) jj_scanpos = xsp;
33800 if (jj_scan_token(LOOP)) return true;
33801 if (jj_3R_625()) return true;
33802 while (true) {
33803 xsp = jj_scanpos;
33804 if (jj_3R_625()) { jj_scanpos = xsp; break; }
33805 }
33806 if (jj_scan_token(END)) return true;
33807 if (jj_scan_token(LOOP)) return true;
33808 xsp = jj_scanpos;
33809 if (jj_scan_token(418)) jj_scanpos = xsp;
33810 return false;
33811 }
33812
33813 private boolean jj_3R_612() {
33814 if (jj_3R_172()) return true;
33815 return false;
33816 }
33817
33818 private boolean jj_3R_447() {
33819 if (jj_3R_172()) return true;
33820 return false;
33821 }
33822
33823 private boolean jj_3_69() {
33824 Token xsp;
33825 xsp = jj_scanpos;
33826 if (jj_3R_147()) {
33827 jj_scanpos = xsp;
33828 if (jj_3R_148()) return true;
33829 }
33830 return false;
33831 }
33832
33833 private boolean jj_3R_408() {
33834 if (jj_scan_token(LOOP)) return true;
33835 Token xsp;
33836 if (jj_3R_447()) return true;
33837 while (true) {
33838 xsp = jj_scanpos;
33839 if (jj_3R_447()) { jj_scanpos = xsp; break; }
33840 }
33841 if (jj_scan_token(END)) return true;
33842 if (jj_scan_token(LOOP)) return true;
33843 xsp = jj_scanpos;
33844 if (jj_scan_token(418)) jj_scanpos = xsp;
33845 return false;
33846 }
33847
33848 private boolean jj_3R_311() {
33849 if (jj_scan_token(REPLACE)) return true;
33850 return false;
33851 }
33852
33853 private boolean jj_3R_129() {
33854 if (jj_scan_token(SET)) return true;
33855 if (jj_scan_token(TRANSACTION)) return true;
33856 return false;
33857 }
33858
33859 private boolean jj_3R_613() {
33860 if (jj_3R_172()) return true;
33861 return false;
33862 }
33863
33864 private boolean jj_3R_588() {
33865 if (jj_scan_token(ELSIF)) return true;
33866 if (jj_3R_232()) return true;
33867 if (jj_scan_token(THEN)) return true;
33868 Token xsp;
33869 if (jj_3R_629()) return true;
33870 while (true) {
33871 xsp = jj_scanpos;
33872 if (jj_3R_629()) { jj_scanpos = xsp; break; }
33873 }
33874 return false;
33875 }
33876
33877 private boolean jj_3R_483() {
33878 if (jj_scan_token(ELSE)) return true;
33879 Token xsp;
33880 if (jj_3R_613()) return true;
33881 while (true) {
33882 xsp = jj_scanpos;
33883 if (jj_3R_613()) { jj_scanpos = xsp; break; }
33884 }
33885 return false;
33886 }
33887
33888 private boolean jj_3R_482() {
33889 if (jj_scan_token(WHEN)) return true;
33890 if (jj_3R_232()) return true;
33891 if (jj_scan_token(THEN)) return true;
33892 Token xsp;
33893 if (jj_3R_612()) return true;
33894 while (true) {
33895 xsp = jj_scanpos;
33896 if (jj_3R_612()) { jj_scanpos = xsp; break; }
33897 }
33898 return false;
33899 }
33900
33901 private boolean jj_3R_442() {
33902 if (jj_3R_232()) return true;
33903 return false;
33904 }
33905
33906 private boolean jj_3R_444() {
33907 if (jj_3R_483()) return true;
33908 return false;
33909 }
33910
33911 private boolean jj_3R_443() {
33912 if (jj_3R_482()) return true;
33913 return false;
33914 }
33915
33916 private boolean jj_3R_404() {
33917 if (jj_scan_token(CASE)) return true;
33918 Token xsp;
33919 xsp = jj_scanpos;
33920 if (jj_3R_442()) jj_scanpos = xsp;
33921 while (true) {
33922 xsp = jj_scanpos;
33923 if (jj_3R_443()) { jj_scanpos = xsp; break; }
33924 }
33925 xsp = jj_scanpos;
33926 if (jj_3R_444()) jj_scanpos = xsp;
33927 if (jj_scan_token(END)) return true;
33928 if (jj_scan_token(CASE)) return true;
33929 xsp = jj_scanpos;
33930 if (jj_scan_token(418)) jj_scanpos = xsp;
33931 return false;
33932 }
33933
33934 private boolean jj_3R_355() {
33935 if (jj_3R_189()) return true;
33936 return false;
33937 }
33938
33939 private boolean jj_3R_314() {
33940 Token xsp;
33941 if (jj_3R_355()) return true;
33942 while (true) {
33943 xsp = jj_scanpos;
33944 if (jj_3R_355()) { jj_scanpos = xsp; break; }
33945 }
33946 if (jj_3R_315()) return true;
33947 return false;
33948 }
33949
33950 private boolean jj_3R_353() {
33951 if (jj_scan_token(DROP)) return true;
33952 return false;
33953 }
33954
33955 private boolean jj_3R_263() {
33956 if (jj_3R_315()) return true;
33957 return false;
33958 }
33959
33960 private boolean jj_3R_262() {
33961 if (jj_3R_314()) return true;
33962 return false;
33963 }
33964
33965 private boolean jj_3R_172() {
33966 Token xsp;
33967 xsp = jj_scanpos;
33968 if (jj_3R_262()) {
33969 jj_scanpos = xsp;
33970 if (jj_3R_263()) return true;
33971 }
33972 return false;
33973 }
33974
33975 private boolean jj_3R_375() {
33976 if (jj_3R_232()) return true;
33977 if (jj_scan_token(4)) return true;
33978 return false;
33979 }
33980
33981 private boolean jj_3R_374() {
33982 if (jj_3R_420()) return true;
33983 if (jj_scan_token(4)) return true;
33984 return false;
33985 }
33986
33987 private boolean jj_3R_373() {
33988 if (jj_3R_419()) return true;
33989 return false;
33990 }
33991
33992 private boolean jj_3R_372() {
33993 if (jj_3R_418()) return true;
33994 if (jj_scan_token(4)) return true;
33995 return false;
33996 }
33997
33998 private boolean jj_3R_441() {
33999 if (jj_scan_token(LOCK)) return true;
34000 if (jj_scan_token(TABLE)) return true;
34001 return false;
34002 }
34003
34004 private boolean jj_3R_371() {
34005 if (jj_3R_417()) return true;
34006 if (jj_scan_token(4)) return true;
34007 return false;
34008 }
34009
34010 private boolean jj_3R_370() {
34011 if (jj_3R_270()) return true;
34012 if (jj_scan_token(4)) return true;
34013 return false;
34014 }
34015
34016 private boolean jj_3R_369() {
34017 if (jj_3R_416()) return true;
34018 if (jj_scan_token(4)) return true;
34019 return false;
34020 }
34021
34022 private boolean jj_3R_368() {
34023 if (jj_3R_415()) return true;
34024 if (jj_scan_token(4)) return true;
34025 return false;
34026 }
34027
34028 private boolean jj_3R_367() {
34029 if (jj_3R_414()) return true;
34030 if (jj_scan_token(4)) return true;
34031 return false;
34032 }
34033
34034 private boolean jj_3R_352() {
34035 Token xsp;
34036 xsp = jj_scanpos;
34037 if (jj_scan_token(6)) jj_scanpos = xsp;
34038 xsp = jj_scanpos;
34039 if (jj_scan_token(44)) {
34040 jj_scanpos = xsp;
34041 if (jj_scan_token(169)) return true;
34042 }
34043 return false;
34044 }
34045
34046 private boolean jj_3R_310() {
34047 Token xsp;
34048 xsp = jj_scanpos;
34049 if (jj_3R_352()) {
34050 jj_scanpos = xsp;
34051 if (jj_3R_353()) return true;
34052 }
34053 return false;
34054 }
34055
34056 private boolean jj_3R_366() {
34057 if (jj_3R_413()) return true;
34058 if (jj_scan_token(4)) return true;
34059 return false;
34060 }
34061
34062 private boolean jj_3R_365() {
34063 if (jj_3R_412()) return true;
34064 if (jj_scan_token(4)) return true;
34065 return false;
34066 }
34067
34068 private boolean jj_3R_364() {
34069 if (jj_3R_411()) return true;
34070 if (jj_scan_token(4)) return true;
34071 return false;
34072 }
34073
34074 private boolean jj_3R_363() {
34075 if (jj_3R_410()) return true;
34076 if (jj_scan_token(4)) return true;
34077 return false;
34078 }
34079
34080 private boolean jj_3_42() {
34081 Token xsp;
34082 xsp = jj_scanpos;
34083 if (jj_3R_128()) {
34084 jj_scanpos = xsp;
34085 if (jj_scan_token(295)) {
34086 jj_scanpos = xsp;
34087 if (jj_scan_token(143)) {
34088 jj_scanpos = xsp;
34089 if (jj_scan_token(93)) {
34090 jj_scanpos = xsp;
34091 if (jj_scan_token(76)) {
34092 jj_scanpos = xsp;
34093 if (jj_scan_token(239)) {
34094 jj_scanpos = xsp;
34095 if (jj_scan_token(246)) {
34096 jj_scanpos = xsp;
34097 if (jj_scan_token(111)) {
34098 jj_scanpos = xsp;
34099 if (jj_3R_129()) {
34100 jj_scanpos = xsp;
34101 if (jj_3R_130()) {
34102 jj_scanpos = xsp;
34103 if (jj_scan_token(164)) {
34104 jj_scanpos = xsp;
34105 if (jj_scan_token(316)) return true;
34106 }
34107 }
34108 }
34109 }
34110 }
34111 }
34112 }
34113 }
34114 }
34115 }
34116 }
34117 return false;
34118 }
34119
34120 private boolean jj_3R_128() {
34121 Token xsp;
34122 xsp = jj_scanpos;
34123 if (jj_scan_token(5)) jj_scanpos = xsp;
34124 if (jj_scan_token(SELECT)) return true;
34125 return false;
34126 }
34127
34128 private boolean jj_3R_362() {
34129 if (jj_3R_409()) return true;
34130 if (jj_scan_token(4)) return true;
34131 return false;
34132 }
34133
34134 private boolean jj_3R_361() {
34135 if (jj_3R_408()) return true;
34136 if (jj_scan_token(4)) return true;
34137 return false;
34138 }
34139
34140 private boolean jj_3R_360() {
34141 if (jj_3R_407()) return true;
34142 if (jj_scan_token(4)) return true;
34143 return false;
34144 }
34145
34146 private boolean jj_3R_359() {
34147 if (jj_3R_406()) return true;
34148 if (jj_scan_token(4)) return true;
34149 return false;
34150 }
34151
34152 private boolean jj_3R_358() {
34153 if (jj_3R_405()) return true;
34154 if (jj_scan_token(4)) return true;
34155 return false;
34156 }
34157
34158 private boolean jj_3R_357() {
34159 if (jj_3R_404()) return true;
34160 if (jj_scan_token(4)) return true;
34161 return false;
34162 }
34163
34164 private boolean jj_3R_306() {
34165 if (jj_3R_146()) return true;
34166 return false;
34167 }
34168
34169 private boolean jj_3_43() {
34170 if (jj_3R_131()) return true;
34171 if (jj_scan_token(4)) return true;
34172 return false;
34173 }
34174
34175 private boolean jj_3R_258() {
34176 if (jj_scan_token(ALTER)) return true;
34177 if (jj_scan_token(TYPE)) return true;
34178 if (jj_3R_127()) return true;
34179 Token xsp;
34180 while (true) {
34181 xsp = jj_scanpos;
34182 if (jj_3R_310()) { jj_scanpos = xsp; break; }
34183 }
34184 xsp = jj_scanpos;
34185 if (jj_3R_311()) jj_scanpos = xsp;
34186 while (true) {
34187 xsp = jj_scanpos;
34188 if (jj_3R_312()) { jj_scanpos = xsp; break; }
34189 }
34190 xsp = jj_scanpos;
34191 if (jj_3R_313()) jj_scanpos = xsp;
34192 return false;
34193 }
34194
34195 private boolean jj_3_68() {
34196 if (jj_3R_146()) return true;
34197 return false;
34198 }
34199
34200 private boolean jj_3R_356() {
34201 if (jj_3R_403()) return true;
34202 Token xsp;
34203 xsp = jj_scanpos;
34204 if (jj_scan_token(4)) jj_scanpos = xsp;
34205 return false;
34206 }
34207
34208 private boolean jj_3R_440() {
34209 if (jj_scan_token(SET)) return true;
34210 if (jj_scan_token(TRANSACTION)) return true;
34211 return false;
34212 }
34213
34214 private boolean jj_3R_315() {
34215 Token xsp;
34216 xsp = jj_scanpos;
34217 if (jj_3R_356()) {
34218 jj_scanpos = xsp;
34219 if (jj_3_43()) {
34220 jj_scanpos = xsp;
34221 if (jj_3R_357()) {
34222 jj_scanpos = xsp;
34223 if (jj_3R_358()) {
34224 jj_scanpos = xsp;
34225 if (jj_3R_359()) {
34226 jj_scanpos = xsp;
34227 if (jj_3R_360()) {
34228 jj_scanpos = xsp;
34229 if (jj_3R_361()) {
34230 jj_scanpos = xsp;
34231 if (jj_3R_362()) {
34232 jj_scanpos = xsp;
34233 if (jj_3R_363()) {
34234 jj_scanpos = xsp;
34235 if (jj_3R_364()) {
34236 jj_scanpos = xsp;
34237 if (jj_3R_365()) {
34238 jj_scanpos = xsp;
34239 if (jj_3R_366()) {
34240 jj_scanpos = xsp;
34241 if (jj_3R_367()) {
34242 jj_scanpos = xsp;
34243 if (jj_3R_368()) {
34244 jj_scanpos = xsp;
34245 if (jj_3R_369()) {
34246 jj_scanpos = xsp;
34247 if (jj_3R_370()) {
34248 jj_scanpos = xsp;
34249 if (jj_3R_371()) {
34250 jj_scanpos = xsp;
34251 if (jj_3R_372()) {
34252 jj_scanpos = xsp;
34253 if (jj_3R_373()) {
34254 jj_scanpos = xsp;
34255 if (jj_3R_374()) {
34256 jj_scanpos = xsp;
34257 if (jj_3R_375()) return true;
34258 }
34259 }
34260 }
34261 }
34262 }
34263 }
34264 }
34265 }
34266 }
34267 }
34268 }
34269 }
34270 }
34271 }
34272 }
34273 }
34274 }
34275 }
34276 }
34277 }
34278 return false;
34279 }
34280
34281 private boolean jj_3R_259() {
34282 if (jj_3R_258()) return true;
34283 return false;
34284 }
34285
34286 private boolean jj_3R_166() {
34287 Token xsp;
34288 xsp = jj_scanpos;
34289 if (jj_scan_token(4)) {
34290 jj_scanpos = xsp;
34291 if (jj_scan_token(1)) return true;
34292 }
34293 while (true) {
34294 xsp = jj_scanpos;
34295 if (jj_3R_259()) { jj_scanpos = xsp; break; }
34296 }
34297 return false;
34298 }
34299
34300 private boolean jj_3R_165() {
34301 if (jj_3R_258()) return true;
34302 return false;
34303 }
34304
34305 private boolean jj_3R_308() {
34306 if (jj_3R_145()) return true;
34307 return false;
34308 }
34309
34310 private boolean jj_3R_309() {
34311 if (jj_3R_350()) return true;
34312 return false;
34313 }
34314
34315 private boolean jj_3R_164() {
34316 Token xsp;
34317 xsp = jj_scanpos;
34318 if (jj_scan_token(182)) jj_scanpos = xsp;
34319 xsp = jj_scanpos;
34320 if (jj_scan_token(119)) {
34321 jj_scanpos = xsp;
34322 if (jj_scan_token(144)) {
34323 jj_scanpos = xsp;
34324 if (jj_scan_token(184)) return true;
34325 }
34326 }
34327 return false;
34328 }
34329
34330 private boolean jj_3R_257() {
34331 if (jj_scan_token(6)) return true;
34332 Token xsp;
34333 xsp = jj_scanpos;
34334 if (jj_3R_308()) {
34335 jj_scanpos = xsp;
34336 if (jj_3_68()) {
34337 jj_scanpos = xsp;
34338 if (jj_3R_309()) return true;
34339 }
34340 }
34341 return false;
34342 }
34343
34344 private boolean jj_3R_307() {
34345 if (jj_3R_350()) return true;
34346 return false;
34347 }
34348
34349 private boolean jj_3_67() {
34350 if (jj_3R_145()) return true;
34351 return false;
34352 }
34353
34354 private boolean jj_3R_256() {
34355 Token xsp;
34356 xsp = jj_scanpos;
34357 if (jj_3_67()) {
34358 jj_scanpos = xsp;
34359 if (jj_3R_306()) {
34360 jj_scanpos = xsp;
34361 if (jj_3R_307()) return true;
34362 }
34363 }
34364 return false;
34365 }
34366
34367 private boolean jj_3R_163() {
34368 if (jj_scan_token(5)) return true;
34369 Token xsp;
34370 while (true) {
34371 xsp = jj_scanpos;
34372 if (jj_3R_256()) { jj_scanpos = xsp; break; }
34373 }
34374 while (true) {
34375 xsp = jj_scanpos;
34376 if (jj_3R_257()) { jj_scanpos = xsp; break; }
34377 }
34378 if (jj_scan_token(7)) return true;
34379 return false;
34380 }
34381
34382 private boolean jj_3R_247() {
34383 if (jj_scan_token(WRAPPED)) return true;
34384 return false;
34385 }
34386
34387 private boolean jj_3R_601() {
34388 if (jj_3R_123()) return true;
34389 return false;
34390 }
34391
34392 private boolean jj_3R_162() {
34393 if (jj_3R_247()) return true;
34394 return false;
34395 }
34396
34397 private boolean jj_3_65() {
34398 Token xsp;
34399 xsp = jj_scanpos;
34400 if (jj_scan_token(151)) {
34401 jj_scanpos = xsp;
34402 if (jj_scan_token(51)) return true;
34403 }
34404 if (jj_3R_144()) return true;
34405 if (jj_scan_token(OF)) return true;
34406 if (jj_3R_234()) return true;
34407 return false;
34408 }
34409
34410 private boolean jj_3R_143() {
34411 if (jj_3R_237()) return true;
34412 return false;
34413 }
34414
34415 private boolean jj_3_64() {
34416 Token xsp;
34417 xsp = jj_scanpos;
34418 if (jj_scan_token(151)) {
34419 jj_scanpos = xsp;
34420 if (jj_scan_token(51)) return true;
34421 }
34422 if (jj_scan_token(OPAQUE)) return true;
34423 if (jj_scan_token(VARYING)) return true;
34424 if (jj_scan_token(24)) return true;
34425 return false;
34426 }
34427
34428 private boolean jj_3_66() {
34429 if (jj_scan_token(EXTERNAL)) return true;
34430 if (jj_scan_token(IDENTIFIER)) return true;
34431 if (jj_scan_token(IDENTIFIER)) return true;
34432 if (jj_scan_token(LANGUAGE)) return true;
34433 if (jj_scan_token(JAVA)) return true;
34434 if (jj_scan_token(USING)) return true;
34435 if (jj_scan_token(IDENTIFIER)) return true;
34436 return false;
34437 }
34438
34439 private boolean jj_3_63() {
34440 Token xsp;
34441 xsp = jj_scanpos;
34442 if (jj_scan_token(151)) {
34443 jj_scanpos = xsp;
34444 if (jj_scan_token(51)) return true;
34445 }
34446 if (jj_scan_token(OBJECT)) return true;
34447 return false;
34448 }
34449
34450 private boolean jj_3R_142() {
34451 if (jj_scan_token(AUTHID)) return true;
34452 Token xsp;
34453 xsp = jj_scanpos;
34454 if (jj_scan_token(37)) {
34455 jj_scanpos = xsp;
34456 if (jj_scan_token(36)) return true;
34457 }
34458 return false;
34459 }
34460
34461 private boolean jj_3R_255() {
34462 if (jj_scan_token(UNDER)) return true;
34463 if (jj_3R_153()) return true;
34464 return false;
34465 }
34466
34467 private boolean jj_3R_161() {
34468 Token xsp;
34469 xsp = jj_scanpos;
34470 if (jj_3R_255()) {
34471 jj_scanpos = xsp;
34472 if (jj_3_63()) {
34473 jj_scanpos = xsp;
34474 if (jj_3_64()) {
34475 jj_scanpos = xsp;
34476 if (jj_3_65()) return true;
34477 }
34478 }
34479 }
34480 return false;
34481 }
34482
34483 private boolean jj_3R_254() {
34484 Token xsp;
34485 xsp = jj_scanpos;
34486 if (jj_scan_token(100)) {
34487 jj_scanpos = xsp;
34488 if (jj_scan_token(181)) return true;
34489 }
34490 return false;
34491 }
34492
34493 private boolean jj_3R_600() {
34494 if (jj_3R_349()) return true;
34495 return false;
34496 }
34497
34498 private boolean jj_3_62() {
34499 Token xsp;
34500 xsp = jj_scanpos;
34501 if (jj_3R_142()) {
34502 jj_scanpos = xsp;
34503 if (jj_3R_143()) return true;
34504 }
34505 return false;
34506 }
34507
34508 private boolean jj_3_61() {
34509 if (jj_scan_token(OID)) return true;
34510 if (jj_scan_token(STRING_LITERAL)) return true;
34511 return false;
34512 }
34513
34514 private boolean jj_3R_403() {
34515 Token xsp;
34516 xsp = jj_scanpos;
34517 if (jj_scan_token(248)) {
34518 jj_scanpos = xsp;
34519 if (jj_scan_token(295)) {
34520 jj_scanpos = xsp;
34521 if (jj_scan_token(143)) {
34522 jj_scanpos = xsp;
34523 if (jj_scan_token(93)) {
34524 jj_scanpos = xsp;
34525 if (jj_scan_token(76)) {
34526 jj_scanpos = xsp;
34527 if (jj_scan_token(239)) {
34528 jj_scanpos = xsp;
34529 if (jj_scan_token(246)) {
34530 jj_scanpos = xsp;
34531 if (jj_scan_token(111)) {
34532 jj_scanpos = xsp;
34533 if (jj_3R_440()) {
34534 jj_scanpos = xsp;
34535 if (jj_3R_441()) {
34536 jj_scanpos = xsp;
34537 if (jj_scan_token(164)) {
34538 jj_scanpos = xsp;
34539 if (jj_scan_token(316)) return true;
34540 }
34541 }
34542 }
34543 }
34544 }
34545 }
34546 }
34547 }
34548 }
34549 }
34550 }
34551 if (jj_3R_178()) return true;
34552 return false;
34553 }
34554
34555 private boolean jj_3R_253() {
34556 if (jj_scan_token(OR)) return true;
34557 if (jj_scan_token(REPLACE)) return true;
34558 return false;
34559 }
34560
34561 private boolean jj_3R_599() {
34562 if (jj_3R_172()) return true;
34563 return false;
34564 }
34565
34566 private boolean jj_3R_488() {
34567 return false;
34568 }
34569
34570 private boolean jj_3R_160() {
34571 if (jj_scan_token(CREATE)) return true;
34572 Token xsp;
34573 xsp = jj_scanpos;
34574 if (jj_3R_253()) jj_scanpos = xsp;
34575 xsp = jj_scanpos;
34576 if (jj_3R_254()) jj_scanpos = xsp;
34577 return false;
34578 }
34579
34580 private boolean jj_3R_104() {
34581 Token xsp;
34582 xsp = jj_scanpos;
34583 if (jj_3R_160()) jj_scanpos = xsp;
34584 if (jj_scan_token(TYPE)) return true;
34585 if (jj_3R_153()) return true;
34586 xsp = jj_scanpos;
34587 if (jj_scan_token(123)) jj_scanpos = xsp;
34588 xsp = jj_scanpos;
34589 if (jj_3_61()) jj_scanpos = xsp;
34590 while (true) {
34591 xsp = jj_scanpos;
34592 if (jj_3_62()) { jj_scanpos = xsp; break; }
34593 }
34594 xsp = jj_scanpos;
34595 if (jj_3R_161()) jj_scanpos = xsp;
34596 xsp = jj_scanpos;
34597 if (jj_3_66()) jj_scanpos = xsp;
34598 xsp = jj_scanpos;
34599 if (jj_3R_162()) jj_scanpos = xsp;
34600 xsp = jj_scanpos;
34601 if (jj_3R_163()) jj_scanpos = xsp;
34602 while (true) {
34603 xsp = jj_scanpos;
34604 if (jj_3R_164()) { jj_scanpos = xsp; break; }
34605 }
34606 while (true) {
34607 xsp = jj_scanpos;
34608 if (jj_3R_165()) { jj_scanpos = xsp; break; }
34609 }
34610 xsp = jj_scanpos;
34611 if (jj_3R_166()) jj_scanpos = xsp;
34612 return false;
34613 }
34614
34615 private boolean jj_3R_565() {
34616 if (jj_3R_190()) return true;
34617 if (jj_scan_token(BEGIN)) return true;
34618 Token xsp;
34619 while (true) {
34620 xsp = jj_scanpos;
34621 if (jj_3R_599()) { jj_scanpos = xsp; break; }
34622 }
34623 xsp = jj_scanpos;
34624 if (jj_3R_600()) jj_scanpos = xsp;
34625 if (jj_scan_token(END)) return true;
34626 xsp = jj_scanpos;
34627 if (jj_3R_601()) jj_scanpos = xsp;
34628 if (jj_scan_token(4)) return true;
34629 return false;
34630 }
34631
34632 private boolean jj_3R_564() {
34633 if (jj_3R_122()) return true;
34634 Token xsp;
34635 xsp = jj_scanpos;
34636 if (jj_scan_token(4)) jj_scanpos = xsp;
34637 return false;
34638 }
34639
34640 private boolean jj_3R_528() {
34641 Token xsp;
34642 xsp = jj_scanpos;
34643 if (jj_scan_token(151)) {
34644 jj_scanpos = xsp;
34645 if (jj_scan_token(51)) return true;
34646 }
34647 xsp = jj_scanpos;
34648 if (jj_3R_564()) {
34649 jj_scanpos = xsp;
34650 if (jj_3R_565()) return true;
34651 }
34652 return false;
34653 }
34654
34655 private boolean jj_3_59() {
34656 if (jj_3R_123()) return true;
34657 if (jj_scan_token(3)) return true;
34658 return false;
34659 }
34660
34661 private boolean jj_3R_186() {
34662 return false;
34663 }
34664
34665 private boolean jj_3R_240() {
34666 Token xsp;
34667 xsp = jj_scanpos;
34668 if (jj_scan_token(161)) {
34669 jj_scanpos = xsp;
34670 if (jj_scan_token(202)) return true;
34671 }
34672 return false;
34673 }
34674
34675 private boolean jj_3R_239() {
34676 Token xsp;
34677 xsp = jj_scanpos;
34678 if (jj_scan_token(182)) jj_scanpos = xsp;
34679 xsp = jj_scanpos;
34680 if (jj_scan_token(206)) {
34681 jj_scanpos = xsp;
34682 if (jj_scan_token(144)) {
34683 jj_scanpos = xsp;
34684 if (jj_scan_token(119)) return true;
34685 }
34686 }
34687 return false;
34688 }
34689
34690 private boolean jj_3R_188() {
34691 return false;
34692 }
34693
34694 private boolean jj_3_60() {
34695 if (jj_3R_123()) return true;
34696 if (jj_scan_token(3)) return true;
34697 if (jj_3R_123()) return true;
34698 if (jj_scan_token(3)) return true;
34699 if (jj_3R_123()) return true;
34700 return false;
34701 }
34702
34703 private boolean jj_3R_145() {
34704 Token xsp;
34705 while (true) {
34706 xsp = jj_scanpos;
34707 if (jj_3R_239()) { jj_scanpos = xsp; break; }
34708 }
34709 xsp = jj_scanpos;
34710 if (jj_3R_240()) jj_scanpos = xsp;
34711 xsp = jj_scanpos;
34712 if (jj_scan_token(80)) {
34713 jj_scanpos = xsp;
34714 if (jj_scan_token(163)) {
34715 jj_scanpos = xsp;
34716 if (jj_scan_token(260)) return true;
34717 }
34718 }
34719 if (jj_3R_192()) return true;
34720 xsp = jj_scanpos;
34721 if (jj_scan_token(95)) jj_scanpos = xsp;
34722 xsp = jj_scanpos;
34723 if (jj_scan_token(208)) jj_scanpos = xsp;
34724 xsp = jj_scanpos;
34725 if (jj_scan_token(212)) jj_scanpos = xsp;
34726 xsp = jj_scanpos;
34727 if (jj_scan_token(234)) jj_scanpos = xsp;
34728 xsp = jj_scanpos;
34729 if (jj_3R_528()) jj_scanpos = xsp;
34730 return false;
34731 }
34732
34733 private boolean jj_3R_457() {
34734 if (jj_3R_172()) return true;
34735 return false;
34736 }
34737
34738 private boolean jj_3R_260() {
34739 if (jj_3R_123()) return true;
34740 return false;
34741 }
34742
34743 private boolean jj_3R_183() {
34744 if (jj_3R_141()) return true;
34745 if (jj_scan_token(IDENTIFIED)) return true;
34746 return false;
34747 }
34748
34749 private boolean jj_3R_561() {
34750 return false;
34751 }
34752
34753 private boolean jj_3R_456() {
34754 if (jj_scan_token(OR)) return true;
34755 if (jj_3R_127()) return true;
34756 return false;
34757 }
34758
34759 private boolean jj_3R_182() {
34760 if (jj_scan_token(CONNECT)) return true;
34761 if (jj_scan_token(TO)) return true;
34762 return false;
34763 }
34764
34765 private boolean jj_3R_111() {
34766 if (jj_scan_token(CREATE)) return true;
34767 Token xsp;
34768 xsp = jj_scanpos;
34769 if (jj_scan_token(408)) jj_scanpos = xsp;
34770 xsp = jj_scanpos;
34771 if (jj_scan_token(222)) jj_scanpos = xsp;
34772 if (jj_scan_token(DATABASE)) return true;
34773 if (jj_scan_token(LINK)) return true;
34774 if (jj_3R_153()) return true;
34775 xsp = jj_scanpos;
34776 if (jj_3R_182()) {
34777 jj_scanpos = xsp;
34778 if (jj_3R_183()) return true;
34779 }
34780 return false;
34781 }
34782
34783 private boolean jj_3R_458() {
34784 if (jj_3R_172()) return true;
34785 return false;
34786 }
34787
34788 private boolean jj_3R_180() {
34789 if (jj_scan_token(OR)) return true;
34790 if (jj_scan_token(REPLACE)) return true;
34791 return false;
34792 }
34793
34794 private boolean jj_3R_110() {
34795 if (jj_scan_token(CREATE)) return true;
34796 Token xsp;
34797 xsp = jj_scanpos;
34798 if (jj_3R_180()) jj_scanpos = xsp;
34799 if (jj_scan_token(DIRECTORY)) return true;
34800 if (jj_3R_153()) return true;
34801 if (jj_scan_token(AS)) return true;
34802 if (jj_3R_181()) return true;
34803 xsp = jj_scanpos;
34804 if (jj_scan_token(4)) {
34805 jj_scanpos = xsp;
34806 if (jj_scan_token(1)) return true;
34807 }
34808 return false;
34809 }
34810
34811 private boolean jj_3R_178() {
34812 return false;
34813 }
34814
34815 private boolean jj_3R_179() {
34816 if (jj_scan_token(OR)) return true;
34817 if (jj_scan_token(REPLACE)) return true;
34818 return false;
34819 }
34820
34821 private boolean jj_3R_261() {
34822 if (jj_scan_token(6)) return true;
34823 return false;
34824 }
34825
34826 private boolean jj_3R_399() {
34827 if (jj_scan_token(WHEN)) return true;
34828 if (jj_scan_token(OTHERS)) return true;
34829 if (jj_scan_token(THEN)) return true;
34830 Token xsp;
34831 if (jj_3R_458()) return true;
34832 while (true) {
34833 xsp = jj_scanpos;
34834 if (jj_3R_458()) { jj_scanpos = xsp; break; }
34835 }
34836 return false;
34837 }
34838
34839 private boolean jj_3_41() {
34840 if (jj_scan_token(WHEN)) return true;
34841 if (jj_3R_127()) return true;
34842 Token xsp;
34843 while (true) {
34844 xsp = jj_scanpos;
34845 if (jj_3R_456()) { jj_scanpos = xsp; break; }
34846 }
34847 if (jj_scan_token(THEN)) return true;
34848 if (jj_3R_457()) return true;
34849 while (true) {
34850 xsp = jj_scanpos;
34851 if (jj_3R_457()) { jj_scanpos = xsp; break; }
34852 }
34853 return false;
34854 }
34855
34856 private boolean jj_3R_109() {
34857 if (jj_scan_token(CREATE)) return true;
34858 Token xsp;
34859 xsp = jj_scanpos;
34860 if (jj_3R_179()) jj_scanpos = xsp;
34861 xsp = jj_scanpos;
34862 if (jj_scan_token(222)) jj_scanpos = xsp;
34863 if (jj_scan_token(SYNONYM)) return true;
34864 if (jj_3R_153()) return true;
34865 if (jj_scan_token(FOR)) return true;
34866 if (jj_3R_153()) return true;
34867 xsp = jj_scanpos;
34868 if (jj_scan_token(4)) {
34869 jj_scanpos = xsp;
34870 if (jj_scan_token(1)) return true;
34871 }
34872 return false;
34873 }
34874
34875 private boolean jj_3R_169() {
34876 if (jj_scan_token(OR)) return true;
34877 if (jj_scan_token(REPLACE)) return true;
34878 return false;
34879 }
34880
34881 private boolean jj_3R_349() {
34882 if (jj_scan_token(EXCEPTION)) return true;
34883 Token xsp;
34884 while (true) {
34885 xsp = jj_scanpos;
34886 if (jj_3_41()) { jj_scanpos = xsp; break; }
34887 }
34888 xsp = jj_scanpos;
34889 if (jj_3R_399()) jj_scanpos = xsp;
34890 return false;
34891 }
34892
34893 private boolean jj_3R_171() {
34894 if (jj_scan_token(5)) return true;
34895 if (jj_3R_260()) return true;
34896 Token xsp;
34897 while (true) {
34898 xsp = jj_scanpos;
34899 if (jj_3R_261()) { jj_scanpos = xsp; break; }
34900 }
34901 if (jj_scan_token(7)) return true;
34902 return false;
34903 }
34904
34905 private boolean jj_3R_170() {
34906 Token xsp;
34907 xsp = jj_scanpos;
34908 if (jj_scan_token(178)) jj_scanpos = xsp;
34909 if (jj_scan_token(FORCE)) return true;
34910 return false;
34911 }
34912
34913 private boolean jj_3R_106() {
34914 if (jj_scan_token(CREATE)) return true;
34915 Token xsp;
34916 xsp = jj_scanpos;
34917 if (jj_3R_169()) jj_scanpos = xsp;
34918 xsp = jj_scanpos;
34919 if (jj_3R_170()) jj_scanpos = xsp;
34920 if (jj_scan_token(VIEW)) return true;
34921 if (jj_3R_153()) return true;
34922 xsp = jj_scanpos;
34923 if (jj_3R_171()) jj_scanpos = xsp;
34924 if (jj_scan_token(AS)) return true;
34925 if (jj_3R_172()) return true;
34926 xsp = jj_scanpos;
34927 if (jj_scan_token(4)) {
34928 jj_scanpos = xsp;
34929 if (jj_scan_token(1)) return true;
34930 }
34931 return false;
34932 }
34933
34934 private boolean jj_3_40() {
34935 if (jj_scan_token(5)) return true;
34936 if (jj_3R_126()) return true;
34937 if (jj_scan_token(7)) return true;
34938 return false;
34939 }
34940
34941 private boolean jj_3R_168() {
34942 if (jj_3R_123()) return true;
34943 if (jj_3R_234()) return true;
34944 return false;
34945 }
34946
34947 private boolean jj_3R_622() {
34948 if (jj_scan_token(6)) return true;
34949 if (jj_3R_123()) return true;
34950 return false;
34951 }
34952
34953 private boolean jj_3R_621() {
34954 if (jj_scan_token(6)) return true;
34955 if (jj_3R_123()) return true;
34956 return false;
34957 }
34958
34959 private boolean jj_3R_167() {
34960 if (jj_scan_token(GLOBAL)) return true;
34961 if (jj_scan_token(TEMPORARY)) return true;
34962 return false;
34963 }
34964
34965 private boolean jj_3R_478() {
34966 if (jj_scan_token(TO)) return true;
34967 Token xsp;
34968 xsp = jj_scanpos;
34969 if (jj_scan_token(314)) {
34970 jj_scanpos = xsp;
34971 if (jj_scan_token(172)) {
34972 jj_scanpos = xsp;
34973 if (jj_scan_token(89)) {
34974 jj_scanpos = xsp;
34975 if (jj_scan_token(133)) {
34976 jj_scanpos = xsp;
34977 if (jj_scan_token(167)) {
34978 jj_scanpos = xsp;
34979 if (jj_scan_token(247)) return true;
34980 }
34981 }
34982 }
34983 }
34984 }
34985 xsp = jj_scanpos;
34986 if (jj_3_40()) jj_scanpos = xsp;
34987 return false;
34988 }
34989
34990 private boolean jj_3R_504() {
34991 if (jj_scan_token(LOCAL)) return true;
34992 return false;
34993 }
34994
34995 private boolean jj_3_58() {
34996 if (jj_scan_token(ON)) return true;
34997 if (jj_scan_token(COMMIT)) return true;
34998 return false;
34999 }
35000
35001 private boolean jj_3R_477() {
35002 if (jj_scan_token(WITH)) return true;
35003 Token xsp;
35004 xsp = jj_scanpos;
35005 if (jj_3R_504()) jj_scanpos = xsp;
35006 if (jj_scan_token(TIME)) return true;
35007 if (jj_scan_token(ZONE)) return true;
35008 return false;
35009 }
35010
35011 private boolean jj_3R_433() {
35012 Token xsp;
35013 xsp = jj_scanpos;
35014 if (jj_3R_477()) {
35015 jj_scanpos = xsp;
35016 if (jj_3R_478()) return true;
35017 }
35018 return false;
35019 }
35020
35021 private boolean jj_3_39() {
35022 if (jj_scan_token(5)) return true;
35023 if (jj_3R_126()) return true;
35024 if (jj_scan_token(7)) return true;
35025 return false;
35026 }
35027
35028 private boolean jj_3R_105() {
35029 if (jj_scan_token(CREATE)) return true;
35030 Token xsp;
35031 xsp = jj_scanpos;
35032 if (jj_3R_167()) jj_scanpos = xsp;
35033 if (jj_scan_token(TABLE)) return true;
35034 if (jj_3R_153()) return true;
35035 if (jj_scan_token(5)) return true;
35036 if (jj_3R_168()) return true;
35037 return false;
35038 }
35039
35040 private boolean jj_3R_616() {
35041 Token xsp;
35042 xsp = jj_scanpos;
35043 if (jj_scan_token(125)) {
35044 jj_scanpos = xsp;
35045 if (jj_scan_token(221)) {
35046 jj_scanpos = xsp;
35047 if (jj_scan_token(207)) {
35048 jj_scanpos = xsp;
35049 if (jj_scan_token(280)) {
35050 jj_scanpos = xsp;
35051 if (jj_scan_token(282)) return true;
35052 }
35053 }
35054 }
35055 }
35056 return false;
35057 }
35058
35059 private boolean jj_3R_347() {
35060 Token xsp;
35061 xsp = jj_scanpos;
35062 if (jj_scan_token(125)) {
35063 jj_scanpos = xsp;
35064 if (jj_scan_token(221)) {
35065 jj_scanpos = xsp;
35066 if (jj_scan_token(207)) {
35067 jj_scanpos = xsp;
35068 if (jj_scan_token(280)) {
35069 jj_scanpos = xsp;
35070 if (jj_scan_token(282)) return true;
35071 }
35072 }
35073 }
35074 }
35075 return false;
35076 }
35077
35078 private boolean jj_3R_432() {
35079 Token xsp;
35080 xsp = jj_scanpos;
35081 if (jj_scan_token(314)) {
35082 jj_scanpos = xsp;
35083 if (jj_scan_token(172)) {
35084 jj_scanpos = xsp;
35085 if (jj_scan_token(89)) {
35086 jj_scanpos = xsp;
35087 if (jj_scan_token(133)) {
35088 jj_scanpos = xsp;
35089 if (jj_scan_token(167)) {
35090 jj_scanpos = xsp;
35091 if (jj_scan_token(247)) return true;
35092 }
35093 }
35094 }
35095 }
35096 }
35097 return false;
35098 }
35099
35100 private boolean jj_3R_348() {
35101 if (jj_scan_token(6)) return true;
35102 Token xsp;
35103 xsp = jj_scanpos;
35104 if (jj_3R_616()) jj_scanpos = xsp;
35105 if (jj_3R_127()) return true;
35106 return false;
35107 }
35108
35109 private boolean jj_3R_487() {
35110 if (jj_scan_token(6)) return true;
35111 if (jj_3R_126()) return true;
35112 return false;
35113 }
35114
35115 private boolean jj_3R_431() {
35116 if (jj_3R_181()) return true;
35117 return false;
35118 }
35119
35120 private boolean jj_3R_430() {
35121 if (jj_scan_token(CHARACTER_LITERAL)) return true;
35122 return false;
35123 }
35124
35125 private boolean jj_3R_486() {
35126 Token xsp;
35127 xsp = jj_scanpos;
35128 if (jj_scan_token(16)) {
35129 jj_scanpos = xsp;
35130 if (jj_scan_token(17)) return true;
35131 }
35132 return false;
35133 }
35134
35135 private boolean jj_3R_237() {
35136 if (jj_scan_token(ACCESSIBLE)) return true;
35137 if (jj_scan_token(BY)) return true;
35138 if (jj_scan_token(5)) return true;
35139 Token xsp;
35140 xsp = jj_scanpos;
35141 if (jj_3R_347()) jj_scanpos = xsp;
35142 if (jj_3R_127()) return true;
35143 while (true) {
35144 xsp = jj_scanpos;
35145 if (jj_3R_348()) { jj_scanpos = xsp; break; }
35146 }
35147 if (jj_scan_token(7)) return true;
35148 return false;
35149 }
35150
35151 private boolean jj_3R_617() {
35152 Token xsp;
35153 xsp = jj_scanpos;
35154 if (jj_scan_token(130)) {
35155 jj_scanpos = xsp;
35156 if (jj_scan_token(224)) return true;
35157 }
35158 if (jj_scan_token(5)) return true;
35159 if (jj_3R_123()) return true;
35160 while (true) {
35161 xsp = jj_scanpos;
35162 if (jj_3R_621()) { jj_scanpos = xsp; break; }
35163 }
35164 if (jj_scan_token(7)) return true;
35165 return false;
35166 }
35167
35168 private boolean jj_3R_618() {
35169 Token xsp;
35170 xsp = jj_scanpos;
35171 if (jj_scan_token(202)) {
35172 jj_scanpos = xsp;
35173 if (jj_scan_token(71)) return true;
35174 }
35175 if (jj_scan_token(BY)) return true;
35176 if (jj_scan_token(5)) return true;
35177 if (jj_3R_123()) return true;
35178 while (true) {
35179 xsp = jj_scanpos;
35180 if (jj_3R_622()) { jj_scanpos = xsp; break; }
35181 }
35182 if (jj_scan_token(7)) return true;
35183 return false;
35184 }
35185
35186 private boolean jj_3R_427() {
35187 if (jj_scan_token(5)) return true;
35188 if (jj_scan_token(PARTITION)) return true;
35189 if (jj_3R_123()) return true;
35190 if (jj_scan_token(BY)) return true;
35191 Token xsp;
35192 xsp = jj_scanpos;
35193 if (jj_scan_token(49)) {
35194 jj_scanpos = xsp;
35195 if (jj_3R_617()) return true;
35196 }
35197 if (jj_scan_token(7)) return true;
35198 xsp = jj_scanpos;
35199 if (jj_3R_618()) jj_scanpos = xsp;
35200 return false;
35201 }
35202
35203 private boolean jj_3_34() {
35204 if (jj_scan_token(5)) return true;
35205 if (jj_3R_126()) return true;
35206 if (jj_scan_token(7)) return true;
35207 return false;
35208 }
35209
35210 private boolean jj_3R_118() {
35211 if (jj_3R_123()) return true;
35212 if (jj_scan_token(EXCEPTION)) return true;
35213 if (jj_scan_token(4)) return true;
35214 return false;
35215 }
35216
35217 private boolean jj_3R_391() {
35218 Token xsp;
35219 xsp = jj_scanpos;
35220 if (jj_scan_token(148)) {
35221 jj_scanpos = xsp;
35222 if (jj_scan_token(273)) {
35223 jj_scanpos = xsp;
35224 if (jj_scan_token(88)) return true;
35225 }
35226 }
35227 xsp = jj_scanpos;
35228 if (jj_3R_430()) {
35229 jj_scanpos = xsp;
35230 if (jj_3R_431()) return true;
35231 }
35232 xsp = jj_scanpos;
35233 if (jj_3R_432()) jj_scanpos = xsp;
35234 xsp = jj_scanpos;
35235 if (jj_3_39()) jj_scanpos = xsp;
35236 xsp = jj_scanpos;
35237 if (jj_3R_433()) jj_scanpos = xsp;
35238 return false;
35239 }
35240
35241 private boolean jj_3R_516() {
35242 if (jj_3R_181()) return true;
35243 return false;
35244 }
35245
35246 private boolean jj_3R_420() {
35247 if (jj_scan_token(PRAGMA)) return true;
35248 if (jj_scan_token(INLINE)) return true;
35249 if (jj_scan_token(5)) return true;
35250 if (jj_3R_127()) return true;
35251 if (jj_scan_token(6)) return true;
35252 if (jj_3R_181()) return true;
35253 if (jj_scan_token(7)) return true;
35254 return false;
35255 }
35256
35257 private boolean jj_3R_515() {
35258 if (jj_3R_123()) return true;
35259 return false;
35260 }
35261
35262 private boolean jj_3R_466() {
35263 if (jj_3R_127()) return true;
35264 if (jj_scan_token(5)) return true;
35265 if (jj_3R_488()) return true;
35266 return false;
35267 }
35268
35269 private boolean jj_3R_465() {
35270 if (jj_scan_token(INTERFACE)) return true;
35271 if (jj_scan_token(5)) return true;
35272 if (jj_scan_token(IDENTIFIER)) return true;
35273 if (jj_scan_token(6)) return true;
35274 if (jj_3R_123()) return true;
35275 Token xsp;
35276 xsp = jj_scanpos;
35277 if (jj_3R_487()) jj_scanpos = xsp;
35278 if (jj_scan_token(7)) return true;
35279 return false;
35280 }
35281
35282 private boolean jj_3R_464() {
35283 if (jj_scan_token(EXCEPTION_INIT)) return true;
35284 if (jj_scan_token(5)) return true;
35285 if (jj_scan_token(IDENTIFIER)) return true;
35286 if (jj_scan_token(6)) return true;
35287 Token xsp;
35288 xsp = jj_scanpos;
35289 if (jj_3R_486()) jj_scanpos = xsp;
35290 if (jj_3R_126()) return true;
35291 if (jj_scan_token(7)) return true;
35292 return false;
35293 }
35294
35295 private boolean jj_3R_485() {
35296 if (jj_scan_token(6)) return true;
35297 Token xsp;
35298 xsp = jj_scanpos;
35299 if (jj_3R_515()) {
35300 jj_scanpos = xsp;
35301 if (jj_3R_516()) return true;
35302 }
35303 return false;
35304 }
35305
35306 private boolean jj_3R_463() {
35307 if (jj_scan_token(RESTRICT_REFERENCES)) return true;
35308 if (jj_scan_token(5)) return true;
35309 if (jj_3R_123()) return true;
35310 Token xsp;
35311 if (jj_3R_485()) return true;
35312 while (true) {
35313 xsp = jj_scanpos;
35314 if (jj_3R_485()) { jj_scanpos = xsp; break; }
35315 }
35316 if (jj_scan_token(7)) return true;
35317 return false;
35318 }
35319
35320 private boolean jj_3R_462() {
35321 if (jj_scan_token(TIMESTAMP)) return true;
35322 if (jj_scan_token(5)) return true;
35323 if (jj_3R_181()) return true;
35324 if (jj_scan_token(7)) return true;
35325 return false;
35326 }
35327
35328 private boolean jj_3_38() {
35329 if (jj_scan_token(TO)) return true;
35330 if (jj_scan_token(SECOND)) return true;
35331 Token xsp;
35332 xsp = jj_scanpos;
35333 if (jj_3_34()) jj_scanpos = xsp;
35334 return false;
35335 }
35336
35337 private boolean jj_3_37() {
35338 if (jj_scan_token(TO)) return true;
35339 if (jj_scan_token(MONTH)) return true;
35340 return false;
35341 }
35342
35343 private boolean jj_3_36() {
35344 if (jj_scan_token(WITH)) return true;
35345 if (jj_scan_token(TIME)) return true;
35346 if (jj_scan_token(ZONE)) return true;
35347 return false;
35348 }
35349
35350 private boolean jj_3_35() {
35351 if (jj_scan_token(WITH)) return true;
35352 if (jj_scan_token(LOCAL)) return true;
35353 if (jj_scan_token(TIME)) return true;
35354 if (jj_scan_token(ZONE)) return true;
35355 return false;
35356 }
35357
35358 private boolean jj_3R_205() {
35359 Token xsp;
35360 xsp = jj_scanpos;
35361 if (jj_3R_289()) {
35362 jj_scanpos = xsp;
35363 if (jj_3_35()) {
35364 jj_scanpos = xsp;
35365 if (jj_3_36()) {
35366 jj_scanpos = xsp;
35367 if (jj_3_37()) {
35368 jj_scanpos = xsp;
35369 if (jj_3_38()) return true;
35370 }
35371 }
35372 }
35373 }
35374 return false;
35375 }
35376
35377 private boolean jj_3R_289() {
35378 if (jj_scan_token(CHARACTER)) return true;
35379 if (jj_scan_token(SET)) return true;
35380 if (jj_3R_293()) return true;
35381 return false;
35382 }
35383
35384 private boolean jj_3R_421() {
35385 if (jj_scan_token(PRAGMA)) return true;
35386 Token xsp;
35387 xsp = jj_scanpos;
35388 if (jj_scan_token(38)) {
35389 jj_scanpos = xsp;
35390 if (jj_scan_token(41)) {
35391 jj_scanpos = xsp;
35392 if (jj_3R_462()) {
35393 jj_scanpos = xsp;
35394 if (jj_3R_463()) {
35395 jj_scanpos = xsp;
35396 if (jj_3R_464()) {
35397 jj_scanpos = xsp;
35398 if (jj_3R_465()) {
35399 jj_scanpos = xsp;
35400 if (jj_3R_466()) return true;
35401 }
35402 }
35403 }
35404 }
35405 }
35406 }
35407 if (jj_scan_token(4)) return true;
35408 return false;
35409 }
35410
35411 private boolean jj_3R_439() {
35412 if (jj_scan_token(BYTE)) return true;
35413 return false;
35414 }
35415
35416 private boolean jj_3R_438() {
35417 if (jj_scan_token(CHAR)) return true;
35418 return false;
35419 }
35420
35421 private boolean jj_3R_437() {
35422 if (jj_scan_token(6)) return true;
35423 if (jj_3R_481()) return true;
35424 return false;
35425 }
35426
35427 private boolean jj_3_33() {
35428 if (jj_scan_token(5)) return true;
35429 if (jj_3R_126()) return true;
35430 Token xsp;
35431 xsp = jj_scanpos;
35432 if (jj_3R_437()) jj_scanpos = xsp;
35433 xsp = jj_scanpos;
35434 if (jj_3R_438()) jj_scanpos = xsp;
35435 xsp = jj_scanpos;
35436 if (jj_3R_439()) jj_scanpos = xsp;
35437 if (jj_scan_token(7)) return true;
35438 return false;
35439 }
35440
35441 private boolean jj_3R_120() {
35442 if (jj_3R_196()) return true;
35443 if (jj_scan_token(4)) return true;
35444 return false;
35445 }
35446
35447 private boolean jj_3R_204() {
35448 if (jj_scan_token(SELF)) return true;
35449 if (jj_scan_token(AS)) return true;
35450 if (jj_scan_token(RESULT)) return true;
35451 return false;
35452 }
35453
35454 private boolean jj_3R_201() {
35455 if (jj_scan_token(DOUBLE)) return true;
35456 if (jj_scan_token(PRECISION)) return true;
35457 return false;
35458 }
35459
35460 private boolean jj_3_32() {
35461 if (jj_scan_token(INTERVAL)) return true;
35462 if (jj_scan_token(DAY)) return true;
35463 return false;
35464 }
35465
35466 private boolean jj_3_31() {
35467 if (jj_scan_token(INTERVAL)) return true;
35468 if (jj_scan_token(YEAR)) return true;
35469 return false;
35470 }
35471
35472 private boolean jj_3R_566() {
35473 if (jj_scan_token(USING)) return true;
35474 Token xsp;
35475 xsp = jj_scanpos;
35476 if (jj_scan_token(399)) {
35477 jj_scanpos = xsp;
35478 if (jj_scan_token(400)) return true;
35479 }
35480 return false;
35481 }
35482
35483 private boolean jj_3R_203() {
35484 if (jj_scan_token(REF)) return true;
35485 if (jj_scan_token(CURSOR)) return true;
35486 return false;
35487 }
35488
35489 private boolean jj_3_57() {
35490 if (jj_3R_141()) return true;
35491 Token xsp;
35492 xsp = jj_scanpos;
35493 if (jj_scan_token(23)) {
35494 jj_scanpos = xsp;
35495 if (jj_scan_token(51)) return true;
35496 }
35497 return false;
35498 }
35499
35500 private boolean jj_3R_434() {
35501 Token xsp;
35502 xsp = jj_scanpos;
35503 if (jj_3_57()) jj_scanpos = xsp;
35504 if (jj_3R_232()) return true;
35505 xsp = jj_scanpos;
35506 if (jj_3R_566()) jj_scanpos = xsp;
35507 return false;
35508 }
35509
35510 private boolean jj_3_30() {
35511 if (jj_scan_token(LONG)) return true;
35512 if (jj_scan_token(RAW)) return true;
35513 return false;
35514 }
35515
35516 private boolean jj_3R_533() {
35517 if (jj_scan_token(6)) return true;
35518 if (jj_3R_434()) return true;
35519 return false;
35520 }
35521
35522 private boolean jj_3R_392() {
35523 if (jj_3R_434()) return true;
35524 Token xsp;
35525 while (true) {
35526 xsp = jj_scanpos;
35527 if (jj_3R_533()) { jj_scanpos = xsp; break; }
35528 }
35529 return false;
35530 }
35531
35532 private boolean jj_3R_202() {
35533 Token xsp;
35534 xsp = jj_scanpos;
35535 if (jj_scan_token(67)) {
35536 jj_scanpos = xsp;
35537 if (jj_scan_token(318)) {
35538 jj_scanpos = xsp;
35539 if (jj_3_30()) {
35540 jj_scanpos = xsp;
35541 if (jj_scan_token(159)) {
35542 jj_scanpos = xsp;
35543 if (jj_scan_token(304)) {
35544 jj_scanpos = xsp;
35545 if (jj_scan_token(305)) {
35546 jj_scanpos = xsp;
35547 if (jj_scan_token(225)) {
35548 jj_scanpos = xsp;
35549 if (jj_scan_token(242)) {
35550 jj_scanpos = xsp;
35551 if (jj_scan_token(306)) {
35552 jj_scanpos = xsp;
35553 if (jj_scan_token(307)) {
35554 jj_scanpos = xsp;
35555 if (jj_scan_token(296)) {
35556 jj_scanpos = xsp;
35557 if (jj_scan_token(297)) {
35558 jj_scanpos = xsp;
35559 if (jj_scan_token(312)) {
35560 jj_scanpos = xsp;
35561 if (jj_scan_token(313)) return true;
35562 }
35563 }
35564 }
35565 }
35566 }
35567 }
35568 }
35569 }
35570 }
35571 }
35572 }
35573 }
35574 }
35575 return false;
35576 }
35577
35578 private boolean jj_3R_340() {
35579 if (jj_3R_392()) return true;
35580 return false;
35581 }
35582
35583 private boolean jj_3R_140() {
35584 if (jj_scan_token(11)) return true;
35585 return false;
35586 }
35587
35588 private boolean jj_3R_297() {
35589 if (jj_scan_token(5)) return true;
35590 Token xsp;
35591 xsp = jj_scanpos;
35592 if (jj_3R_340()) jj_scanpos = xsp;
35593 if (jj_scan_token(7)) return true;
35594 return false;
35595 }
35596
35597 private boolean jj_3R_281() {
35598 Token xsp;
35599 xsp = jj_scanpos;
35600 if (jj_scan_token(117)) {
35601 jj_scanpos = xsp;
35602 if (jj_scan_token(281)) {
35603 jj_scanpos = xsp;
35604 if (jj_scan_token(294)) {
35605 jj_scanpos = xsp;
35606 if (jj_scan_token(375)) {
35607 jj_scanpos = xsp;
35608 if (jj_scan_token(44)) {
35609 jj_scanpos = xsp;
35610 if (jj_scan_token(319)) {
35611 jj_scanpos = xsp;
35612 if (jj_scan_token(45)) {
35613 jj_scanpos = xsp;
35614 if (jj_scan_token(342)) {
35615 jj_scanpos = xsp;
35616 if (jj_scan_token(343)) {
35617 jj_scanpos = xsp;
35618 if (jj_scan_token(53)) {
35619 jj_scanpos = xsp;
35620 if (jj_scan_token(387)) {
35621 jj_scanpos = xsp;
35622 if (jj_scan_token(54)) {
35623 jj_scanpos = xsp;
35624 if (jj_scan_token(344)) {
35625 jj_scanpos = xsp;
35626 if (jj_scan_token(406)) {
35627 jj_scanpos = xsp;
35628 if (jj_scan_token(55)) {
35629 jj_scanpos = xsp;
35630 if (jj_scan_token(320)) {
35631 jj_scanpos = xsp;
35632 if (jj_scan_token(310)) {
35633 jj_scanpos = xsp;
35634 if (jj_scan_token(311)) {
35635 jj_scanpos = xsp;
35636 if (jj_scan_token(393)) {
35637 jj_scanpos = xsp;
35638 if (jj_scan_token(62)) {
35639 jj_scanpos = xsp;
35640 if (jj_scan_token(64)) {
35641 jj_scanpos = xsp;
35642 if (jj_scan_token(347)) {
35643 jj_scanpos = xsp;
35644 if (jj_scan_token(65)) {
35645 jj_scanpos = xsp;
35646 if (jj_scan_token(388)) {
35647 jj_scanpos = xsp;
35648 if (jj_scan_token(399)) {
35649 jj_scanpos = xsp;
35650 if (jj_scan_token(318)) {
35651 jj_scanpos = xsp;
35652 if (jj_scan_token(374)) {
35653 jj_scanpos = xsp;
35654 if (jj_scan_token(373)) {
35655 jj_scanpos = xsp;
35656 if (jj_scan_token(312)) {
35657 jj_scanpos = xsp;
35658 if (jj_scan_token(70)) {
35659 jj_scanpos = xsp;
35660 if (jj_scan_token(72)) {
35661 jj_scanpos = xsp;
35662 if (jj_scan_token(73)) {
35663 jj_scanpos = xsp;
35664 if (jj_scan_token(74)) {
35665 jj_scanpos = xsp;
35666 if (jj_scan_token(75)) {
35667 jj_scanpos = xsp;
35668 if (jj_scan_token(76)) {
35669 jj_scanpos = xsp;
35670 if (jj_scan_token(345)) {
35671 jj_scanpos = xsp;
35672 if (jj_scan_token(80)) {
35673 jj_scanpos = xsp;
35674 if (jj_scan_token(368)) {
35675 jj_scanpos = xsp;
35676 if (jj_scan_token(81)) {
35677 jj_scanpos = xsp;
35678 if (jj_scan_token(82)) {
35679 jj_scanpos = xsp;
35680 if (jj_scan_token(377)) {
35681 jj_scanpos = xsp;
35682 if (jj_scan_token(84)) {
35683 jj_scanpos = xsp;
35684 if (jj_scan_token(37)) {
35685 jj_scanpos = xsp;
35686 if (jj_scan_token(86)) {
35687 jj_scanpos = xsp;
35688 if (jj_scan_token(87)) {
35689 jj_scanpos = xsp;
35690 if (jj_scan_token(346)) {
35691 jj_scanpos = xsp;
35692 if (jj_scan_token(89)) {
35693 jj_scanpos = xsp;
35694 if (jj_scan_token(404)) {
35695 jj_scanpos = xsp;
35696 if (jj_scan_token(348)) {
35697 jj_scanpos = xsp;
35698 if (jj_scan_token(299)) {
35699 jj_scanpos = xsp;
35700 if (jj_scan_token(378)) {
35701 jj_scanpos = xsp;
35702 if (jj_scan_token(36)) {
35703 jj_scanpos = xsp;
35704 if (jj_scan_token(409)) {
35705 jj_scanpos = xsp;
35706 if (jj_scan_token(96)) {
35707 jj_scanpos = xsp;
35708 if (jj_scan_token(349)) {
35709 jj_scanpos = xsp;
35710 if (jj_scan_token(379)) {
35711 jj_scanpos = xsp;
35712 if (jj_scan_token(298)) {
35713 jj_scanpos = xsp;
35714 if (jj_scan_token(350)) {
35715 jj_scanpos = xsp;
35716 if (jj_scan_token(101)) {
35717 jj_scanpos = xsp;
35718 if (jj_scan_token(394)) {
35719 jj_scanpos = xsp;
35720 if (jj_scan_token(104)) {
35721 jj_scanpos = xsp;
35722 if (jj_scan_token(106)) {
35723 jj_scanpos = xsp;
35724 if (jj_scan_token(107)) {
35725 jj_scanpos = xsp;
35726 if (jj_scan_token(109)) {
35727 jj_scanpos = xsp;
35728 if (jj_scan_token(113)) {
35729 jj_scanpos = xsp;
35730 if (jj_scan_token(115)) {
35731 jj_scanpos = xsp;
35732 if (jj_scan_token(114)) {
35733 jj_scanpos = xsp;
35734 if (jj_scan_token(116)) {
35735 jj_scanpos = xsp;
35736 if (jj_scan_token(119)) {
35737 jj_scanpos = xsp;
35738 if (jj_scan_token(351)) {
35739 jj_scanpos = xsp;
35740 if (jj_scan_token(123)) {
35741 jj_scanpos = xsp;
35742 if (jj_scan_token(125)) {
35743 jj_scanpos = xsp;
35744 if (jj_scan_token(126)) {
35745 jj_scanpos = xsp;
35746 if (jj_scan_token(130)) {
35747 jj_scanpos = xsp;
35748 if (jj_scan_token(132)) {
35749 jj_scanpos = xsp;
35750 if (jj_scan_token(380)) {
35751 jj_scanpos = xsp;
35752 if (jj_scan_token(133)) {
35753 jj_scanpos = xsp;
35754 if (jj_scan_token(136)) {
35755 jj_scanpos = xsp;
35756 if (jj_scan_token(141)) {
35757 jj_scanpos = xsp;
35758 if (jj_scan_token(142)) {
35759 jj_scanpos = xsp;
35760 if (jj_scan_token(139)) {
35761 jj_scanpos = xsp;
35762 if (jj_scan_token(144)) {
35763 jj_scanpos = xsp;
35764 if (jj_scan_token(148)) {
35765 jj_scanpos = xsp;
35766 if (jj_scan_token(150)) {
35767 jj_scanpos = xsp;
35768 if (jj_scan_token(152)) {
35769 jj_scanpos = xsp;
35770 if (jj_scan_token(153)) {
35771 jj_scanpos = xsp;
35772 if (jj_scan_token(42)) {
35773 jj_scanpos = xsp;
35774 if (jj_scan_token(397)) {
35775 jj_scanpos = xsp;
35776 if (jj_scan_token(391)) {
35777 jj_scanpos = xsp;
35778 if (jj_scan_token(370)) {
35779 jj_scanpos = xsp;
35780 if (jj_scan_token(154)) {
35781 jj_scanpos = xsp;
35782 if (jj_scan_token(365)) {
35783 jj_scanpos = xsp;
35784 if (jj_scan_token(156)) {
35785 jj_scanpos = xsp;
35786 if (jj_scan_token(407)) {
35787 jj_scanpos = xsp;
35788 if (jj_scan_token(315)) {
35789 jj_scanpos = xsp;
35790 if (jj_scan_token(352)) {
35791 jj_scanpos = xsp;
35792 if (jj_scan_token(353)) {
35793 jj_scanpos = xsp;
35794 if (jj_scan_token(161)) {
35795 jj_scanpos = xsp;
35796 if (jj_scan_token(162)) {
35797 jj_scanpos = xsp;
35798 if (jj_scan_token(372)) {
35799 jj_scanpos = xsp;
35800 if (jj_scan_token(163)) {
35801 jj_scanpos = xsp;
35802 if (jj_scan_token(164)) {
35803 jj_scanpos = xsp;
35804 if (jj_scan_token(165)) {
35805 jj_scanpos = xsp;
35806 if (jj_scan_token(167)) {
35807 jj_scanpos = xsp;
35808 if (jj_scan_token(168)) {
35809 jj_scanpos = xsp;
35810 if (jj_scan_token(169)) {
35811 jj_scanpos = xsp;
35812 if (jj_scan_token(172)) {
35813 jj_scanpos = xsp;
35814 if (jj_scan_token(395)) {
35815 jj_scanpos = xsp;
35816 if (jj_scan_token(366)) {
35817 jj_scanpos = xsp;
35818 if (jj_scan_token(173)) {
35819 jj_scanpos = xsp;
35820 if (jj_scan_token(304)) {
35821 jj_scanpos = xsp;
35822 if (jj_scan_token(400)) {
35823 jj_scanpos = xsp;
35824 if (jj_scan_token(313)) {
35825 jj_scanpos = xsp;
35826 if (jj_scan_token(354)) {
35827 jj_scanpos = xsp;
35828 if (jj_scan_token(175)) {
35829 jj_scanpos = xsp;
35830 if (jj_scan_token(178)) {
35831 jj_scanpos = xsp;
35832 if (jj_scan_token(355)) {
35833 jj_scanpos = xsp;
35834 if (jj_scan_token(302)) {
35835 jj_scanpos = xsp;
35836 if (jj_scan_token(305)) {
35837 jj_scanpos = xsp;
35838 if (jj_scan_token(192)) {
35839 jj_scanpos = xsp;
35840 if (jj_scan_token(195)) {
35841 jj_scanpos = xsp;
35842 if (jj_scan_token(324)) {
35843 jj_scanpos = xsp;
35844 if (jj_scan_token(197)) {
35845 jj_scanpos = xsp;
35846 if (jj_scan_token(198)) {
35847 jj_scanpos = xsp;
35848 if (jj_scan_token(203)) {
35849 jj_scanpos = xsp;
35850 if (jj_scan_token(204)) {
35851 jj_scanpos = xsp;
35852 if (jj_scan_token(206)) {
35853 jj_scanpos = xsp;
35854 if (jj_scan_token(207)) {
35855 jj_scanpos = xsp;
35856 if (jj_scan_token(369)) {
35857 jj_scanpos = xsp;
35858 if (jj_scan_token(325)) {
35859 jj_scanpos = xsp;
35860 if (jj_scan_token(209)) {
35861 jj_scanpos = xsp;
35862 if (jj_scan_token(300)) {
35863 jj_scanpos = xsp;
35864 if (jj_scan_token(217)) {
35865 jj_scanpos = xsp;
35866 if (jj_scan_token(381)) {
35867 jj_scanpos = xsp;
35868 if (jj_scan_token(221)) {
35869 jj_scanpos = xsp;
35870 if (jj_scan_token(382)) {
35871 jj_scanpos = xsp;
35872 if (jj_scan_token(224)) {
35873 jj_scanpos = xsp;
35874 if (jj_scan_token(226)) {
35875 jj_scanpos = xsp;
35876 if (jj_scan_token(227)) {
35877 jj_scanpos = xsp;
35878 if (jj_scan_token(228)) {
35879 jj_scanpos = xsp;
35880 if (jj_scan_token(230)) {
35881 jj_scanpos = xsp;
35882 if (jj_scan_token(383)) {
35883 jj_scanpos = xsp;
35884 if (jj_scan_token(233)) {
35885 jj_scanpos = xsp;
35886 if (jj_scan_token(235)) {
35887 jj_scanpos = xsp;
35888 if (jj_scan_token(236)) {
35889 jj_scanpos = xsp;
35890 if (jj_scan_token(237)) {
35891 jj_scanpos = xsp;
35892 if (jj_scan_token(392)) {
35893 jj_scanpos = xsp;
35894 if (jj_scan_token(239)) {
35895 jj_scanpos = xsp;
35896 if (jj_scan_token(240)) {
35897 jj_scanpos = xsp;
35898 if (jj_scan_token(242)) {
35899 jj_scanpos = xsp;
35900 if (jj_scan_token(243)) {
35901 jj_scanpos = xsp;
35902 if (jj_scan_token(241)) {
35903 jj_scanpos = xsp;
35904 if (jj_scan_token(245)) {
35905 jj_scanpos = xsp;
35906 if (jj_scan_token(246)) {
35907 jj_scanpos = xsp;
35908 if (jj_scan_token(356)) {
35909 jj_scanpos = xsp;
35910 if (jj_scan_token(247)) {
35911 jj_scanpos = xsp;
35912 if (jj_scan_token(249)) {
35913 jj_scanpos = xsp;
35914 if (jj_scan_token(357)) {
35915 jj_scanpos = xsp;
35916 if (jj_scan_token(405)) {
35917 jj_scanpos = xsp;
35918 if (jj_scan_token(251)) {
35919 jj_scanpos = xsp;
35920 if (jj_scan_token(408)) {
35921 jj_scanpos = xsp;
35922 if (jj_scan_token(358)) {
35923 jj_scanpos = xsp;
35924 if (jj_scan_token(255)) {
35925 jj_scanpos = xsp;
35926 if (jj_scan_token(359)) {
35927 jj_scanpos = xsp;
35928 if (jj_scan_token(360)) {
35929 jj_scanpos = xsp;
35930 if (jj_scan_token(260)) {
35931 jj_scanpos = xsp;
35932 if (jj_scan_token(361)) {
35933 jj_scanpos = xsp;
35934 if (jj_scan_token(367)) {
35935 jj_scanpos = xsp;
35936 if (jj_scan_token(396)) {
35937 jj_scanpos = xsp;
35938 if (jj_scan_token(263)) {
35939 jj_scanpos = xsp;
35940 if (jj_scan_token(262)) {
35941 jj_scanpos = xsp;
35942 if (jj_scan_token(264)) {
35943 jj_scanpos = xsp;
35944 if (jj_scan_token(362)) {
35945 jj_scanpos = xsp;
35946 if (jj_scan_token(371)) {
35947 jj_scanpos = xsp;
35948 if (jj_scan_token(270)) {
35949 jj_scanpos = xsp;
35950 if (jj_scan_token(272)) {
35951 jj_scanpos = xsp;
35952 if (jj_scan_token(273)) {
35953 jj_scanpos = xsp;
35954 if (jj_scan_token(275)) {
35955 jj_scanpos = xsp;
35956 if (jj_scan_token(277)) {
35957 jj_scanpos = xsp;
35958 if (jj_scan_token(276)) {
35959 jj_scanpos = xsp;
35960 if (jj_scan_token(274)) {
35961 jj_scanpos = xsp;
35962 if (jj_scan_token(398)) {
35963 jj_scanpos = xsp;
35964 if (jj_scan_token(279)) {
35965 jj_scanpos = xsp;
35966 if (jj_scan_token(389)) {
35967 jj_scanpos = xsp;
35968 if (jj_scan_token(390)) {
35969 jj_scanpos = xsp;
35970 if (jj_scan_token(363)) {
35971 jj_scanpos = xsp;
35972 if (jj_scan_token(384)) {
35973 jj_scanpos = xsp;
35974 if (jj_scan_token(284)) {
35975 jj_scanpos = xsp;
35976 if (jj_scan_token(307)) {
35977 jj_scanpos = xsp;
35978 if (jj_scan_token(410)) {
35979 jj_scanpos = xsp;
35980 if (jj_scan_token(286)) {
35981 jj_scanpos = xsp;
35982 if (jj_scan_token(308)) {
35983 jj_scanpos = xsp;
35984 if (jj_scan_token(385)) {
35985 jj_scanpos = xsp;
35986 if (jj_scan_token(309)) {
35987 jj_scanpos = xsp;
35988 if (jj_scan_token(386)) {
35989 jj_scanpos = xsp;
35990 if (jj_scan_token(314)) {
35991 jj_scanpos = xsp;
35992 if (jj_scan_token(291)) {
35993 jj_scanpos = xsp;
35994 if (jj_scan_token(317)) {
35995 jj_scanpos = xsp;
35996 if (jj_scan_token(292)) {
35997 jj_scanpos = xsp;
35998 if (jj_scan_token(364)) {
35999 jj_scanpos = xsp;
36000 if (jj_scan_token(268)) {
36001 jj_scanpos = xsp;
36002 if (jj_scan_token(100)) {
36003 jj_scanpos = xsp;
36004 if (jj_scan_token(181)) {
36005 jj_scanpos = xsp;
36006 if (jj_scan_token(376)) {
36007 jj_scanpos = xsp;
36008 if (jj_scan_token(185)) {
36009 jj_scanpos = xsp;
36010 if (jj_scan_token(231)) {
36011 jj_scanpos = xsp;
36012 if (jj_scan_token(229)) {
36013 jj_scanpos = xsp;
36014 if (jj_scan_token(43)) return true;
36015 }
36016 }
36017 }
36018 }
36019 }
36020 }
36021 }
36022 }
36023 }
36024 }
36025 }
36026 }
36027 }
36028 }
36029 }
36030 }
36031 }
36032 }
36033 }
36034 }
36035 }
36036 }
36037 }
36038 }
36039 }
36040 }
36041 }
36042 }
36043 }
36044 }
36045 }
36046 }
36047 }
36048 }
36049 }
36050 }
36051 }
36052 }
36053 }
36054 }
36055 }
36056 }
36057 }
36058 }
36059 }
36060 }
36061 }
36062 }
36063 }
36064 }
36065 }
36066 }
36067 }
36068 }
36069 }
36070 }
36071 }
36072 }
36073 }
36074 }
36075 }
36076 }
36077 }
36078 }
36079 }
36080 }
36081 }
36082 }
36083 }
36084 }
36085 }
36086 }
36087 }
36088 }
36089 }
36090 }
36091 }
36092 }
36093 }
36094 }
36095 }
36096 }
36097 }
36098 }
36099 }
36100 }
36101 }
36102 }
36103 }
36104 }
36105 }
36106 }
36107 }
36108 }
36109 }
36110 }
36111 }
36112 }
36113 }
36114 }
36115 }
36116 }
36117 }
36118 }
36119 }
36120 }
36121 }
36122 }
36123 }
36124 }
36125 }
36126 }
36127 }
36128 }
36129 }
36130 }
36131 }
36132 }
36133 }
36134 }
36135 }
36136 }
36137 }
36138 }
36139 }
36140 }
36141 }
36142 }
36143 }
36144 }
36145 }
36146 }
36147 }
36148 }
36149 }
36150 }
36151 }
36152 }
36153 }
36154 }
36155 }
36156 }
36157 }
36158 }
36159 }
36160 }
36161 }
36162 }
36163 }
36164 }
36165 }
36166 }
36167 }
36168 }
36169 }
36170 }
36171 }
36172 }
36173 }
36174 }
36175 }
36176 }
36177 }
36178 }
36179 }
36180 }
36181 }
36182 }
36183 }
36184 }
36185 }
36186 }
36187 }
36188 }
36189 }
36190 }
36191 }
36192 }
36193 }
36194 }
36195 }
36196 }
36197 }
36198 }
36199 }
36200 }
36201 }
36202 }
36203 }
36204 }
36205 }
36206 }
36207 }
36208 }
36209 }
36210 }
36211 }
36212 }
36213 }
36214 }
36215 }
36216 }
36217 }
36218 }
36219 }
36220 }
36221 }
36222 return false;
36223 }
36224
36225 private boolean jj_3R_351() {
36226 if (jj_scan_token(3)) return true;
36227 if (jj_3R_119()) return true;
36228 return false;
36229 }
36230
36231 private boolean jj_3R_125() {
36232 Token xsp;
36233 xsp = jj_scanpos;
36234 if (jj_scan_token(187)) {
36235 jj_scanpos = xsp;
36236 if (jj_scan_token(188)) {
36237 jj_scanpos = xsp;
36238 if (jj_scan_token(68)) {
36239 jj_scanpos = xsp;
36240 if (jj_scan_token(189)) {
36241 jj_scanpos = xsp;
36242 if (jj_scan_token(190)) {
36243 jj_scanpos = xsp;
36244 if (jj_scan_token(191)) {
36245 jj_scanpos = xsp;
36246 if (jj_scan_token(59)) {
36247 jj_scanpos = xsp;
36248 if (jj_scan_token(299)) {
36249 jj_scanpos = xsp;
36250 if (jj_scan_token(91)) {
36251 jj_scanpos = xsp;
36252 if (jj_3R_201()) {
36253 jj_scanpos = xsp;
36254 if (jj_scan_token(120)) {
36255 jj_scanpos = xsp;
36256 if (jj_scan_token(301)) {
36257 jj_scanpos = xsp;
36258 if (jj_scan_token(145)) {
36259 jj_scanpos = xsp;
36260 if (jj_scan_token(173)) {
36261 jj_scanpos = xsp;
36262 if (jj_scan_token(174)) {
36263 jj_scanpos = xsp;
36264 if (jj_scan_token(186)) {
36265 jj_scanpos = xsp;
36266 if (jj_scan_token(302)) {
36267 jj_scanpos = xsp;
36268 if (jj_scan_token(213)) {
36269 jj_scanpos = xsp;
36270 if (jj_scan_token(214)) {
36271 jj_scanpos = xsp;
36272 if (jj_scan_token(215)) {
36273 jj_scanpos = xsp;
36274 if (jj_scan_token(226)) {
36275 jj_scanpos = xsp;
36276 if (jj_scan_token(303)) {
36277 jj_scanpos = xsp;
36278 if (jj_scan_token(254)) {
36279 jj_scanpos = xsp;
36280 if (jj_3R_202()) {
36281 jj_scanpos = xsp;
36282 if (jj_scan_token(61)) {
36283 jj_scanpos = xsp;
36284 if (jj_scan_token(310)) {
36285 jj_scanpos = xsp;
36286 if (jj_scan_token(311)) {
36287 jj_scanpos = xsp;
36288 if (jj_scan_token(268)) {
36289 jj_scanpos = xsp;
36290 if (jj_3R_203()) {
36291 jj_scanpos = xsp;
36292 if (jj_scan_token(88)) {
36293 jj_scanpos = xsp;
36294 if (jj_3_31()) {
36295 jj_scanpos = xsp;
36296 if (jj_3_32()) {
36297 jj_scanpos = xsp;
36298 if (jj_scan_token(272)) {
36299 jj_scanpos = xsp;
36300 if (jj_scan_token(273)) {
36301 jj_scanpos = xsp;
36302 if (jj_3R_204()) return true;
36303 }
36304 }
36305 }
36306 }
36307 }
36308 }
36309 }
36310 }
36311 }
36312 }
36313 }
36314 }
36315 }
36316 }
36317 }
36318 }
36319 }
36320 }
36321 }
36322 }
36323 }
36324 }
36325 }
36326 }
36327 }
36328 }
36329 }
36330 }
36331 }
36332 }
36333 }
36334 }
36335 }
36336 }
36337 xsp = jj_scanpos;
36338 if (jj_3_33()) jj_scanpos = xsp;
36339 xsp = jj_scanpos;
36340 if (jj_3R_205()) jj_scanpos = xsp;
36341 return false;
36342 }
36343
36344 private boolean jj_3R_238() {
36345 if (jj_scan_token(VARYING)) return true;
36346 if (jj_scan_token(ARRAY)) return true;
36347 return false;
36348 }
36349
36350 private boolean jj_3R_127() {
36351 if (jj_3R_141()) return true;
36352 Token xsp;
36353 while (true) {
36354 xsp = jj_scanpos;
36355 if (jj_3R_351()) { jj_scanpos = xsp; break; }
36356 }
36357 return false;
36358 }
36359
36360 private boolean jj_3_29() {
36361 if (jj_scan_token(5)) return true;
36362 if (jj_3R_126()) return true;
36363 return false;
36364 }
36365
36366 private boolean jj_3R_139() {
36367 if (jj_scan_token(3)) return true;
36368 return false;
36369 }
36370
36371 private boolean jj_3_56() {
36372 Token xsp;
36373 xsp = jj_scanpos;
36374 if (jj_3R_139()) {
36375 jj_scanpos = xsp;
36376 if (jj_3R_140()) return true;
36377 }
36378 if (jj_3R_119()) return true;
36379 return false;
36380 }
36381
36382 private boolean jj_3R_144() {
36383 Token xsp;
36384 xsp = jj_scanpos;
36385 if (jj_scan_token(269)) {
36386 jj_scanpos = xsp;
36387 if (jj_scan_token(308)) {
36388 jj_scanpos = xsp;
36389 if (jj_3R_238()) return true;
36390 }
36391 }
36392 xsp = jj_scanpos;
36393 if (jj_3_29()) jj_scanpos = xsp;
36394 return false;
36395 }
36396
36397 private boolean jj_3R_293() {
36398 if (jj_3R_141()) return true;
36399 Token xsp;
36400 while (true) {
36401 xsp = jj_scanpos;
36402 if (jj_3_56()) { jj_scanpos = xsp; break; }
36403 }
36404 return false;
36405 }
36406
36407 private boolean jj_3R_398() {
36408 if (jj_scan_token(CC_ELSE)) return true;
36409 if (jj_3R_234()) return true;
36410 return false;
36411 }
36412
36413 private boolean jj_3R_189() {
36414 if (jj_scan_token(21)) return true;
36415 if (jj_3R_141()) return true;
36416 if (jj_scan_token(22)) return true;
36417 return false;
36418 }
36419
36420 private boolean jj_3R_397() {
36421 if (jj_scan_token(CC_ELSIF)) return true;
36422 if (jj_3R_342()) return true;
36423 if (jj_scan_token(CC_THEN)) return true;
36424 if (jj_3R_234()) return true;
36425 return false;
36426 }
36427
36428 private boolean jj_3R_344() {
36429 if (jj_scan_token(CC_IF)) return true;
36430 if (jj_3R_342()) return true;
36431 if (jj_scan_token(CC_THEN)) return true;
36432 if (jj_3R_234()) return true;
36433 Token xsp;
36434 while (true) {
36435 xsp = jj_scanpos;
36436 if (jj_3R_397()) { jj_scanpos = xsp; break; }
36437 }
36438 while (true) {
36439 xsp = jj_scanpos;
36440 if (jj_3R_398()) { jj_scanpos = xsp; break; }
36441 }
36442 if (jj_scan_token(CC_END)) return true;
36443 return false;
36444 }
36445
36446 private boolean jj_3R_346() {
36447 if (jj_scan_token(11)) return true;
36448 Token xsp;
36449 xsp = jj_scanpos;
36450 if (jj_scan_token(282)) {
36451 jj_scanpos = xsp;
36452 if (jj_scan_token(244)) return true;
36453 }
36454 return false;
36455 }
36456
36457 private boolean jj_3R_126() {
36458 if (jj_scan_token(UNSIGNED_NUMERIC_LITERAL)) return true;
36459 return false;
36460 }
36461
36462 private boolean jj_3R_345() {
36463 if (jj_scan_token(2)) return true;
36464 if (jj_3R_127()) return true;
36465 return false;
36466 }
36467
36468 private boolean jj_3_27() {
36469 if (jj_scan_token(REF)) return true;
36470 return false;
36471 }
36472
36473 private boolean jj_3R_303() {
36474 Token xsp;
36475 xsp = jj_scanpos;
36476 if (jj_3_27()) jj_scanpos = xsp;
36477 if (jj_3R_127()) return true;
36478 xsp = jj_scanpos;
36479 if (jj_3R_345()) jj_scanpos = xsp;
36480 xsp = jj_scanpos;
36481 if (jj_3R_346()) jj_scanpos = xsp;
36482 return false;
36483 }
36484
36485 private boolean jj_3_28() {
36486 if (jj_3R_125()) return true;
36487 return false;
36488 }
36489
36490 private boolean jj_3R_302() {
36491 if (jj_3R_344()) return true;
36492 return false;
36493 }
36494
36495 private boolean jj_3R_234() {
36496 Token xsp;
36497 xsp = jj_scanpos;
36498 if (jj_3R_302()) {
36499 jj_scanpos = xsp;
36500 if (jj_3_28()) {
36501 jj_scanpos = xsp;
36502 if (jj_3R_303()) return true;
36503 }
36504 }
36505 return false;
36506 }
36507
36508 private boolean jj_3R_225() {
36509 if (jj_scan_token(A)) return true;
36510 if (jj_scan_token(SET)) return true;
36511 return false;
36512 }
36513
36514 private boolean jj_3R_135() {
36515 Token xsp;
36516 xsp = jj_scanpos;
36517 if (jj_3R_225()) {
36518 jj_scanpos = xsp;
36519 if (jj_scan_token(394)) return true;
36520 }
36521 return false;
36522 }
36523
36524 private boolean jj_3R_333() {
36525 if (jj_scan_token(_DEFAULT)) return true;
36526 return false;
36527 }
36528
36529 private boolean jj_3R_390() {
36530 if (jj_scan_token(NULL)) return true;
36531 return false;
36532 }
36533
36534 private boolean jj_3R_334() {
36535 if (jj_3R_232()) return true;
36536 return false;
36537 }
36538
36539 private boolean jj_3R_282() {
36540 if (jj_3R_123()) return true;
36541 return false;
36542 }
36543
36544 private boolean jj_3R_389() {
36545 Token xsp;
36546 xsp = jj_scanpos;
36547 if (jj_scan_token(281)) {
36548 jj_scanpos = xsp;
36549 if (jj_scan_token(117)) return true;
36550 }
36551 return false;
36552 }
36553
36554 private boolean jj_3R_332() {
36555 if (jj_scan_token(9)) return true;
36556 if (jj_scan_token(10)) return true;
36557 return false;
36558 }
36559
36560 private boolean jj_3R_284() {
36561 Token xsp;
36562 xsp = jj_scanpos;
36563 if (jj_3R_332()) {
36564 jj_scanpos = xsp;
36565 if (jj_3R_333()) return true;
36566 }
36567 if (jj_3R_334()) return true;
36568 return false;
36569 }
36570
36571 private boolean jj_3R_331() {
36572 if (jj_scan_token(NOT)) return true;
36573 return false;
36574 }
36575
36576 private boolean jj_3R_283() {
36577 Token xsp;
36578 xsp = jj_scanpos;
36579 if (jj_3R_331()) jj_scanpos = xsp;
36580 if (jj_scan_token(NULL)) return true;
36581 return false;
36582 }
36583
36584 private boolean jj_3_26() {
36585 if (jj_scan_token(CONSTANT)) return true;
36586 return false;
36587 }
36588
36589 private boolean jj_3R_196() {
36590 if (jj_3R_282()) return true;
36591 Token xsp;
36592 xsp = jj_scanpos;
36593 if (jj_3_26()) jj_scanpos = xsp;
36594 if (jj_3R_234()) return true;
36595 xsp = jj_scanpos;
36596 if (jj_3R_283()) jj_scanpos = xsp;
36597 xsp = jj_scanpos;
36598 if (jj_3R_284()) jj_scanpos = xsp;
36599 return false;
36600 }
36601
36602 private boolean jj_3R_512() {
36603 if (jj_scan_token(6)) return true;
36604 if (jj_3R_472()) return true;
36605 return false;
36606 }
36607
36608 private boolean jj_3R_426() {
36609 if (jj_3R_472()) return true;
36610 Token xsp;
36611 while (true) {
36612 xsp = jj_scanpos;
36613 if (jj_3R_512()) { jj_scanpos = xsp; break; }
36614 }
36615 return false;
36616 }
36617
36618 private boolean jj_3R_384() {
36619 if (jj_scan_token(5)) return true;
36620 Token xsp;
36621 xsp = jj_scanpos;
36622 if (jj_3R_426()) jj_scanpos = xsp;
36623 if (jj_scan_token(7)) return true;
36624 return false;
36625 }
36626
36627 private boolean jj_3_23() {
36628 if (jj_scan_token(NOCOPY)) return true;
36629 return false;
36630 }
36631
36632 private boolean jj_3R_324() {
36633 if (jj_3R_384()) return true;
36634 return false;
36635 }
36636
36637 private boolean jj_3R_461() {
36638 if (jj_3R_123()) return true;
36639 return false;
36640 }
36641
36642 private boolean jj_3R_323() {
36643 if (jj_scan_token(RETURN)) return true;
36644 if (jj_3R_234()) return true;
36645 return false;
36646 }
36647
36648 private boolean jj_3R_277() {
36649 if (jj_scan_token(PROCEDURE)) return true;
36650 if (jj_3R_153()) return true;
36651 Token xsp;
36652 xsp = jj_scanpos;
36653 if (jj_3R_324()) jj_scanpos = xsp;
36654 return false;
36655 }
36656
36657 private boolean jj_3R_181() {
36658 if (jj_scan_token(STRING_LITERAL)) return true;
36659 return false;
36660 }
36661
36662 private boolean jj_3R_124() {
36663 if (jj_scan_token(IN)) return true;
36664 if (jj_scan_token(OUT)) return true;
36665 return false;
36666 }
36667
36668 private boolean jj_3R_322() {
36669 if (jj_3R_384()) return true;
36670 return false;
36671 }
36672
36673 private boolean jj_3R_620() {
36674 if (jj_scan_token(3)) return true;
36675 if (jj_3R_123()) return true;
36676 return false;
36677 }
36678
36679 private boolean jj_3R_276() {
36680 if (jj_scan_token(FUNCTION)) return true;
36681 if (jj_3R_153()) return true;
36682 Token xsp;
36683 xsp = jj_scanpos;
36684 if (jj_3R_322()) jj_scanpos = xsp;
36685 xsp = jj_scanpos;
36686 if (jj_3R_323()) jj_scanpos = xsp;
36687 return false;
36688 }
36689
36690 private boolean jj_3R_619() {
36691 if (jj_scan_token(6)) return true;
36692 if (jj_3R_123()) return true;
36693 return false;
36694 }
36695
36696 private boolean jj_3R_195() {
36697 if (jj_3R_281()) return true;
36698 return false;
36699 }
36700
36701 private boolean jj_3R_460() {
36702 if (jj_3R_349()) return true;
36703 return false;
36704 }
36705
36706 private boolean jj_3R_192() {
36707 Token xsp;
36708 xsp = jj_scanpos;
36709 if (jj_3R_276()) {
36710 jj_scanpos = xsp;
36711 if (jj_3R_277()) return true;
36712 }
36713 return false;
36714 }
36715
36716 private boolean jj_3R_339() {
36717 if (jj_3R_391()) return true;
36718 return false;
36719 }
36720
36721 private boolean jj_3_24() {
36722 Token xsp;
36723 xsp = jj_scanpos;
36724 if (jj_scan_token(205)) {
36725 jj_scanpos = xsp;
36726 if (jj_3R_124()) return true;
36727 }
36728 xsp = jj_scanpos;
36729 if (jj_3_23()) jj_scanpos = xsp;
36730 return false;
36731 }
36732
36733 private boolean jj_3R_338() {
36734 if (jj_3R_390()) return true;
36735 return false;
36736 }
36737
36738 private boolean jj_3R_337() {
36739 if (jj_3R_389()) return true;
36740 return false;
36741 }
36742
36743 private boolean jj_3R_557() {
36744 if (jj_3R_234()) return true;
36745 return false;
36746 }
36747
36748 private boolean jj_3R_336() {
36749 if (jj_3R_181()) return true;
36750 return false;
36751 }
36752
36753 private boolean jj_3R_598() {
36754 if (jj_scan_token(6)) return true;
36755 if (jj_3R_123()) return true;
36756 Token xsp;
36757 xsp = jj_scanpos;
36758 if (jj_3R_620()) jj_scanpos = xsp;
36759 return false;
36760 }
36761
36762 private boolean jj_3R_484() {
36763 if (jj_scan_token(3)) return true;
36764 if (jj_3R_123()) return true;
36765 return false;
36766 }
36767
36768 private boolean jj_3R_468() {
36769 if (jj_3R_145()) return true;
36770 return false;
36771 }
36772
36773 private boolean jj_3R_467() {
36774 if (jj_3R_117()) return true;
36775 return false;
36776 }
36777
36778 private boolean jj_3R_335() {
36779 if (jj_3R_126()) return true;
36780 return false;
36781 }
36782
36783 private boolean jj_3R_119() {
36784 Token xsp;
36785 xsp = jj_scanpos;
36786 if (jj_scan_token(418)) {
36787 jj_scanpos = xsp;
36788 if (jj_scan_token(426)) {
36789 jj_scanpos = xsp;
36790 if (jj_3R_195()) {
36791 jj_scanpos = xsp;
36792 if (jj_scan_token(35)) {
36793 jj_scanpos = xsp;
36794 if (jj_scan_token(38)) {
36795 jj_scanpos = xsp;
36796 if (jj_scan_token(39)) {
36797 jj_scanpos = xsp;
36798 if (jj_scan_token(40)) {
36799 jj_scanpos = xsp;
36800 if (jj_scan_token(41)) {
36801 jj_scanpos = xsp;
36802 if (jj_scan_token(50)) {
36803 jj_scanpos = xsp;
36804 if (jj_scan_token(56)) {
36805 jj_scanpos = xsp;
36806 if (jj_scan_token(59)) {
36807 jj_scanpos = xsp;
36808 if (jj_scan_token(60)) {
36809 jj_scanpos = xsp;
36810 if (jj_scan_token(61)) {
36811 jj_scanpos = xsp;
36812 if (jj_scan_token(67)) {
36813 jj_scanpos = xsp;
36814 if (jj_scan_token(68)) {
36815 jj_scanpos = xsp;
36816 if (jj_scan_token(79)) {
36817 jj_scanpos = xsp;
36818 if (jj_scan_token(85)) {
36819 jj_scanpos = xsp;
36820 if (jj_scan_token(88)) {
36821 jj_scanpos = xsp;
36822 if (jj_scan_token(91)) {
36823 jj_scanpos = xsp;
36824 if (jj_scan_token(93)) {
36825 jj_scanpos = xsp;
36826 if (jj_scan_token(98)) {
36827 jj_scanpos = xsp;
36828 if (jj_scan_token(103)) {
36829 jj_scanpos = xsp;
36830 if (jj_scan_token(111)) {
36831 jj_scanpos = xsp;
36832 if (jj_scan_token(112)) {
36833 jj_scanpos = xsp;
36834 if (jj_scan_token(120)) {
36835 jj_scanpos = xsp;
36836 if (jj_scan_token(122)) {
36837 jj_scanpos = xsp;
36838 if (jj_scan_token(145)) {
36839 jj_scanpos = xsp;
36840 if (jj_scan_token(146)) {
36841 jj_scanpos = xsp;
36842 if (jj_scan_token(159)) {
36843 jj_scanpos = xsp;
36844 if (jj_scan_token(160)) {
36845 jj_scanpos = xsp;
36846 if (jj_scan_token(170)) {
36847 jj_scanpos = xsp;
36848 if (jj_scan_token(174)) {
36849 jj_scanpos = xsp;
36850 if (jj_scan_token(177)) {
36851 jj_scanpos = xsp;
36852 if (jj_scan_token(180)) {
36853 jj_scanpos = xsp;
36854 if (jj_scan_token(186)) {
36855 jj_scanpos = xsp;
36856 if (jj_scan_token(187)) {
36857 jj_scanpos = xsp;
36858 if (jj_scan_token(188)) {
36859 jj_scanpos = xsp;
36860 if (jj_scan_token(189)) {
36861 jj_scanpos = xsp;
36862 if (jj_scan_token(190)) {
36863 jj_scanpos = xsp;
36864 if (jj_scan_token(191)) {
36865 jj_scanpos = xsp;
36866 if (jj_scan_token(193)) {
36867 jj_scanpos = xsp;
36868 if (jj_scan_token(199)) {
36869 jj_scanpos = xsp;
36870 if (jj_scan_token(205)) {
36871 jj_scanpos = xsp;
36872 if (jj_scan_token(213)) {
36873 jj_scanpos = xsp;
36874 if (jj_scan_token(214)) {
36875 jj_scanpos = xsp;
36876 if (jj_scan_token(215)) {
36877 jj_scanpos = xsp;
36878 if (jj_scan_token(216)) {
36879 jj_scanpos = xsp;
36880 if (jj_scan_token(218)) {
36881 jj_scanpos = xsp;
36882 if (jj_scan_token(220)) {
36883 jj_scanpos = xsp;
36884 if (jj_scan_token(219)) {
36885 jj_scanpos = xsp;
36886 if (jj_scan_token(223)) {
36887 jj_scanpos = xsp;
36888 if (jj_scan_token(225)) {
36889 jj_scanpos = xsp;
36890 if (jj_scan_token(244)) {
36891 jj_scanpos = xsp;
36892 if (jj_scan_token(250)) {
36893 jj_scanpos = xsp;
36894 if (jj_scan_token(254)) {
36895 jj_scanpos = xsp;
36896 if (jj_scan_token(257)) {
36897 jj_scanpos = xsp;
36898 if (jj_scan_token(258)) {
36899 jj_scanpos = xsp;
36900 if (jj_scan_token(261)) {
36901 jj_scanpos = xsp;
36902 if (jj_scan_token(265)) {
36903 jj_scanpos = xsp;
36904 if (jj_scan_token(266)) {
36905 jj_scanpos = xsp;
36906 if (jj_scan_token(267)) {
36907 jj_scanpos = xsp;
36908 if (jj_scan_token(280)) {
36909 jj_scanpos = xsp;
36910 if (jj_scan_token(282)) {
36911 jj_scanpos = xsp;
36912 if (jj_scan_token(283)) {
36913 jj_scanpos = xsp;
36914 if (jj_scan_token(296)) {
36915 jj_scanpos = xsp;
36916 if (jj_scan_token(297)) {
36917 jj_scanpos = xsp;
36918 if (jj_scan_token(301)) {
36919 jj_scanpos = xsp;
36920 if (jj_scan_token(303)) {
36921 jj_scanpos = xsp;
36922 if (jj_scan_token(306)) {
36923 jj_scanpos = xsp;
36924 if (jj_scan_token(290)) return true;
36925 }
36926 }
36927 }
36928 }
36929 }
36930 }
36931 }
36932 }
36933 }
36934 }
36935 }
36936 }
36937 }
36938 }
36939 }
36940 }
36941 }
36942 }
36943 }
36944 }
36945 }
36946 }
36947 }
36948 }
36949 }
36950 }
36951 }
36952 }
36953 }
36954 }
36955 }
36956 }
36957 }
36958 }
36959 }
36960 }
36961 }
36962 }
36963 }
36964 }
36965 }
36966 }
36967 }
36968 }
36969 }
36970 }
36971 }
36972 }
36973 }
36974 }
36975 }
36976 }
36977 }
36978 }
36979 }
36980 }
36981 }
36982 }
36983 }
36984 }
36985 }
36986 }
36987 }
36988 }
36989 }
36990 }
36991 }
36992 }
36993 }
36994 return false;
36995 }
36996
36997 private boolean jj_3R_292() {
36998 Token xsp;
36999 xsp = jj_scanpos;
37000 if (jj_3R_335()) {
37001 jj_scanpos = xsp;
37002 if (jj_scan_token(423)) {
37003 jj_scanpos = xsp;
37004 if (jj_3R_336()) {
37005 jj_scanpos = xsp;
37006 if (jj_3R_337()) {
37007 jj_scanpos = xsp;
37008 if (jj_3R_338()) {
37009 jj_scanpos = xsp;
37010 if (jj_3R_339()) return true;
37011 }
37012 }
37013 }
37014 }
37015 }
37016 return false;
37017 }
37018
37019 private boolean jj_3R_424() {
37020 Token xsp;
37021 xsp = jj_scanpos;
37022 if (jj_3R_467()) {
37023 jj_scanpos = xsp;
37024 if (jj_3R_468()) return true;
37025 }
37026 return false;
37027 }
37028
37029 private boolean jj_3R_595() {
37030 if (jj_scan_token(9)) return true;
37031 if (jj_scan_token(10)) return true;
37032 return false;
37033 }
37034
37035 private boolean jj_3R_476() {
37036 if (jj_3R_232()) return true;
37037 return false;
37038 }
37039
37040 private boolean jj_3R_459() {
37041 if (jj_3R_172()) return true;
37042 return false;
37043 }
37044
37045 private boolean jj_3R_558() {
37046 Token xsp;
37047 xsp = jj_scanpos;
37048 if (jj_3R_595()) {
37049 jj_scanpos = xsp;
37050 if (jj_scan_token(92)) return true;
37051 }
37052 if (jj_3R_232()) return true;
37053 return false;
37054 }
37055
37056 private boolean jj_3R_475() {
37057 if (jj_3R_181()) return true;
37058 return false;
37059 }
37060
37061 private boolean jj_3R_474() {
37062 if (jj_scan_token(SESSIONTIMEZONE)) return true;
37063 return false;
37064 }
37065
37066 private boolean jj_3R_473() {
37067 if (jj_scan_token(DBTIMEZONE)) return true;
37068 return false;
37069 }
37070
37071 private boolean jj_3_25() {
37072 Token xsp;
37073 xsp = jj_scanpos;
37074 if (jj_3_24()) {
37075 jj_scanpos = xsp;
37076 if (jj_scan_token(137)) return true;
37077 }
37078 return false;
37079 }
37080
37081 private boolean jj_3R_597() {
37082 if (jj_scan_token(3)) return true;
37083 if (jj_3R_123()) return true;
37084 return false;
37085 }
37086
37087 private boolean jj_3R_514() {
37088 if (jj_3R_123()) return true;
37089 return false;
37090 }
37091
37092 private boolean jj_3R_386() {
37093 if (jj_scan_token(USING)) return true;
37094 if (jj_3R_123()) return true;
37095 Token xsp;
37096 xsp = jj_scanpos;
37097 if (jj_3R_484()) jj_scanpos = xsp;
37098 return false;
37099 }
37100
37101 private boolean jj_3R_296() {
37102 if (jj_scan_token(TIME)) return true;
37103 if (jj_scan_token(ZONE)) return true;
37104 Token xsp;
37105 xsp = jj_scanpos;
37106 if (jj_3R_473()) {
37107 jj_scanpos = xsp;
37108 if (jj_3R_474()) {
37109 jj_scanpos = xsp;
37110 if (jj_3R_475()) {
37111 jj_scanpos = xsp;
37112 if (jj_3R_476()) return true;
37113 }
37114 }
37115 }
37116 return false;
37117 }
37118
37119 private boolean jj_3R_224() {
37120 if (jj_3R_297()) return true;
37121 return false;
37122 }
37123
37124 private boolean jj_3R_295() {
37125 if (jj_scan_token(LOCAL)) return true;
37126 return false;
37127 }
37128
37129 private boolean jj_3R_472() {
37130 if (jj_3R_123()) return true;
37131 Token xsp;
37132 xsp = jj_scanpos;
37133 if (jj_3_25()) jj_scanpos = xsp;
37134 xsp = jj_scanpos;
37135 if (jj_scan_token(8)) {
37136 jj_scanpos = xsp;
37137 if (jj_3R_557()) return true;
37138 }
37139 xsp = jj_scanpos;
37140 if (jj_3R_558()) jj_scanpos = xsp;
37141 return false;
37142 }
37143
37144 private boolean jj_3R_236() {
37145 if (jj_3R_281()) return true;
37146 return false;
37147 }
37148
37149 private boolean jj_3R_513() {
37150 if (jj_scan_token(3)) return true;
37151 if (jj_3R_123()) return true;
37152 return false;
37153 }
37154
37155 private boolean jj_3R_330() {
37156 if (jj_3R_190()) return true;
37157 if (jj_scan_token(BEGIN)) return true;
37158 Token xsp;
37159 while (true) {
37160 xsp = jj_scanpos;
37161 if (jj_3R_459()) { jj_scanpos = xsp; break; }
37162 }
37163 xsp = jj_scanpos;
37164 if (jj_3R_460()) jj_scanpos = xsp;
37165 if (jj_scan_token(END)) return true;
37166 xsp = jj_scanpos;
37167 if (jj_3R_461()) jj_scanpos = xsp;
37168 return false;
37169 }
37170
37171 private boolean jj_3_21() {
37172 if (jj_3R_122()) return true;
37173 return false;
37174 }
37175
37176 private boolean jj_3_22() {
37177 if (jj_3R_123()) return true;
37178 if (jj_scan_token(3)) return true;
37179 return false;
37180 }
37181
37182 private boolean jj_3R_223() {
37183 if (jj_scan_token(AT)) return true;
37184 Token xsp;
37185 xsp = jj_scanpos;
37186 if (jj_3R_295()) {
37187 jj_scanpos = xsp;
37188 if (jj_3R_296()) return true;
37189 }
37190 return false;
37191 }
37192
37193 private boolean jj_3R_153() {
37194 Token xsp;
37195 xsp = jj_scanpos;
37196 if (jj_3_22()) jj_scanpos = xsp;
37197 if (jj_3R_123()) return true;
37198 return false;
37199 }
37200
37201 private boolean jj_3R_222() {
37202 if (jj_scan_token(2)) return true;
37203 if (jj_3R_119()) return true;
37204 return false;
37205 }
37206
37207 private boolean jj_3R_388() {
37208 if (jj_scan_token(RELIES_ON)) return true;
37209 if (jj_scan_token(5)) return true;
37210 if (jj_3R_123()) return true;
37211 Token xsp;
37212 xsp = jj_scanpos;
37213 if (jj_3R_597()) jj_scanpos = xsp;
37214 while (true) {
37215 xsp = jj_scanpos;
37216 if (jj_3R_598()) { jj_scanpos = xsp; break; }
37217 }
37218 if (jj_scan_token(7)) return true;
37219 return false;
37220 }
37221
37222 private boolean jj_3R_385() {
37223 if (jj_3R_427()) return true;
37224 return false;
37225 }
37226
37227 private boolean jj_3R_141() {
37228 Token xsp;
37229 xsp = jj_scanpos;
37230 if (jj_scan_token(418)) {
37231 jj_scanpos = xsp;
37232 if (jj_scan_token(426)) {
37233 jj_scanpos = xsp;
37234 if (jj_3R_236()) {
37235 jj_scanpos = xsp;
37236 if (jj_scan_token(60)) {
37237 jj_scanpos = xsp;
37238 if (jj_scan_token(170)) {
37239 jj_scanpos = xsp;
37240 if (jj_scan_token(199)) {
37241 jj_scanpos = xsp;
37242 if (jj_scan_token(220)) {
37243 jj_scanpos = xsp;
37244 if (jj_scan_token(225)) {
37245 jj_scanpos = xsp;
37246 if (jj_scan_token(35)) {
37247 jj_scanpos = xsp;
37248 if (jj_scan_token(306)) {
37249 jj_scanpos = xsp;
37250 if (jj_scan_token(256)) {
37251 jj_scanpos = xsp;
37252 if (jj_scan_token(257)) {
37253 jj_scanpos = xsp;
37254 if (jj_scan_token(258)) {
37255 jj_scanpos = xsp;
37256 if (jj_scan_token(267)) {
37257 jj_scanpos = xsp;
37258 if (jj_scan_token(282)) {
37259 jj_scanpos = xsp;
37260 if (jj_scan_token(160)) {
37261 jj_scanpos = xsp;
37262 if (jj_scan_token(301)) {
37263 jj_scanpos = xsp;
37264 if (jj_scan_token(50)) return true;
37265 }
37266 }
37267 }
37268 }
37269 }
37270 }
37271 }
37272 }
37273 }
37274 }
37275 }
37276 }
37277 }
37278 }
37279 }
37280 }
37281 }
37282 return false;
37283 }
37284
37285 private boolean jj_3R_221() {
37286 if (jj_scan_token(3)) return true;
37287 if (jj_3R_119()) return true;
37288 return false;
37289 }
37290
37291 private boolean jj_3R_429() {
37292 Token xsp;
37293 xsp = jj_scanpos;
37294 if (jj_scan_token(202)) {
37295 jj_scanpos = xsp;
37296 if (jj_scan_token(71)) return true;
37297 }
37298 xsp = jj_scanpos;
37299 if (jj_3R_514()) jj_scanpos = xsp;
37300 if (jj_scan_token(BY)) return true;
37301 if (jj_scan_token(5)) return true;
37302 if (jj_3R_123()) return true;
37303 while (true) {
37304 xsp = jj_scanpos;
37305 if (jj_3R_619()) { jj_scanpos = xsp; break; }
37306 }
37307 if (jj_scan_token(7)) return true;
37308 return false;
37309 }
37310
37311 private boolean jj_3R_134() {
37312 Token xsp;
37313 xsp = jj_scanpos;
37314 if (jj_3R_221()) {
37315 jj_scanpos = xsp;
37316 if (jj_3R_222()) {
37317 jj_scanpos = xsp;
37318 if (jj_3R_223()) {
37319 jj_scanpos = xsp;
37320 if (jj_3R_224()) return true;
37321 }
37322 }
37323 }
37324 return false;
37325 }
37326
37327 private boolean jj_3R_280() {
37328 Token xsp;
37329 xsp = jj_scanpos;
37330 if (jj_scan_token(151)) {
37331 jj_scanpos = xsp;
37332 if (jj_scan_token(51)) return true;
37333 }
37334 xsp = jj_scanpos;
37335 if (jj_3_21()) {
37336 jj_scanpos = xsp;
37337 if (jj_3R_330()) return true;
37338 }
37339 return false;
37340 }
37341
37342 private boolean jj_3R_428() {
37343 if (jj_scan_token(USING)) return true;
37344 if (jj_3R_123()) return true;
37345 Token xsp;
37346 xsp = jj_scanpos;
37347 if (jj_3R_513()) jj_scanpos = xsp;
37348 return false;
37349 }
37350
37351 private boolean jj_3R_387() {
37352 Token xsp;
37353 xsp = jj_scanpos;
37354 if (jj_3R_428()) {
37355 jj_scanpos = xsp;
37356 if (jj_3R_429()) return true;
37357 }
37358 return false;
37359 }
37360
37361 private boolean jj_3R_275() {
37362 Token xsp;
37363 xsp = jj_scanpos;
37364 if (jj_scan_token(100)) {
37365 jj_scanpos = xsp;
37366 if (jj_scan_token(181)) return true;
37367 }
37368 return false;
37369 }
37370
37371 private boolean jj_3_55() {
37372 Token xsp;
37373 if (jj_scan_token(5)) return true;
37374 while (true) {
37375 xsp = jj_scanpos;
37376 if (jj_scan_token(5)) { jj_scanpos = xsp; break; }
37377 }
37378 if (jj_scan_token(WITH)) return true;
37379 return false;
37380 }
37381
37382 private boolean jj_3_54() {
37383 if (jj_scan_token(WITH)) return true;
37384 return false;
37385 }
37386
37387 private boolean jj_3_53() {
37388 Token xsp;
37389 if (jj_scan_token(5)) return true;
37390 while (true) {
37391 xsp = jj_scanpos;
37392 if (jj_scan_token(5)) { jj_scanpos = xsp; break; }
37393 }
37394 if (jj_scan_token(SELECT)) return true;
37395 return false;
37396 }
37397
37398 private boolean jj_3R_279() {
37399 if (jj_scan_token(AGGREGATE)) return true;
37400 if (jj_scan_token(USING)) return true;
37401 if (jj_3R_123()) return true;
37402 return false;
37403 }
37404
37405 private boolean jj_3R_329() {
37406 if (jj_scan_token(RESULT_CACHE)) return true;
37407 Token xsp;
37408 xsp = jj_scanpos;
37409 if (jj_3R_388()) jj_scanpos = xsp;
37410 return false;
37411 }
37412
37413 private boolean jj_3_52() {
37414 if (jj_scan_token(SELECT)) return true;
37415 return false;
37416 }
37417
37418 private boolean jj_3R_294() {
37419 if (jj_scan_token(6)) return true;
37420 if (jj_3R_232()) return true;
37421 return false;
37422 }
37423
37424 private boolean jj_3_51() {
37425 if (jj_3R_138()) return true;
37426 return false;
37427 }
37428
37429 private boolean jj_3R_328() {
37430 if (jj_scan_token(PIPELINED)) return true;
37431 Token xsp;
37432 xsp = jj_scanpos;
37433 if (jj_3R_387()) jj_scanpos = xsp;
37434 return false;
37435 }
37436
37437 private boolean jj_3_50() {
37438 if (jj_3R_137()) return true;
37439 return false;
37440 }
37441
37442 private boolean jj_3R_327() {
37443 if (jj_scan_token(PARALLEL_ENABLE)) return true;
37444 Token xsp;
37445 xsp = jj_scanpos;
37446 if (jj_3R_385()) jj_scanpos = xsp;
37447 xsp = jj_scanpos;
37448 if (jj_3R_386()) jj_scanpos = xsp;
37449 return false;
37450 }
37451
37452 private boolean jj_3R_220() {
37453 if (jj_scan_token(5)) return true;
37454 if (jj_3R_232()) return true;
37455 Token xsp;
37456 while (true) {
37457 xsp = jj_scanpos;
37458 if (jj_3R_294()) { jj_scanpos = xsp; break; }
37459 }
37460 if (jj_scan_token(7)) return true;
37461 return false;
37462 }
37463
37464 private boolean jj_3_49() {
37465 if (jj_3R_136()) return true;
37466 return false;
37467 }
37468
37469 private boolean jj_3R_326() {
37470 if (jj_3R_237()) return true;
37471 return false;
37472 }
37473
37474 private boolean jj_3_48() {
37475 if (jj_3R_135()) return true;
37476 return false;
37477 }
37478
37479 private boolean jj_3R_219() {
37480 if (jj_scan_token(5)) return true;
37481 if (jj_3R_178()) return true;
37482 if (jj_scan_token(7)) return true;
37483 return false;
37484 }
37485
37486 private boolean jj_3R_218() {
37487 if (jj_scan_token(WITH)) return true;
37488 if (jj_3R_178()) return true;
37489 return false;
37490 }
37491
37492 private boolean jj_3R_217() {
37493 if (jj_scan_token(5)) return true;
37494 if (jj_3R_178()) return true;
37495 if (jj_scan_token(7)) return true;
37496 return false;
37497 }
37498
37499 private boolean jj_3R_278() {
37500 Token xsp;
37501 xsp = jj_scanpos;
37502 if (jj_3R_325()) {
37503 jj_scanpos = xsp;
37504 if (jj_scan_token(95)) {
37505 jj_scanpos = xsp;
37506 if (jj_3R_326()) {
37507 jj_scanpos = xsp;
37508 if (jj_3R_327()) {
37509 jj_scanpos = xsp;
37510 if (jj_3R_328()) {
37511 jj_scanpos = xsp;
37512 if (jj_3R_329()) return true;
37513 }
37514 }
37515 }
37516 }
37517 }
37518 return false;
37519 }
37520
37521 private boolean jj_3R_325() {
37522 if (jj_scan_token(AUTHID)) return true;
37523 Token xsp;
37524 xsp = jj_scanpos;
37525 if (jj_scan_token(37)) {
37526 jj_scanpos = xsp;
37527 if (jj_scan_token(36)) return true;
37528 }
37529 return false;
37530 }
37531
37532 private boolean jj_3R_216() {
37533 if (jj_scan_token(SELECT)) return true;
37534 if (jj_3R_178()) return true;
37535 return false;
37536 }
37537
37538 private boolean jj_3R_215() {
37539 if (jj_3R_293()) return true;
37540 return false;
37541 }
37542
37543 private boolean jj_3R_194() {
37544 Token xsp;
37545 while (true) {
37546 xsp = jj_scanpos;
37547 if (jj_3R_278()) { jj_scanpos = xsp; break; }
37548 }
37549 xsp = jj_scanpos;
37550 if (jj_3R_279()) jj_scanpos = xsp;
37551 xsp = jj_scanpos;
37552 if (jj_3R_280()) jj_scanpos = xsp;
37553 if (jj_scan_token(4)) return true;
37554 return false;
37555 }
37556
37557 private boolean jj_3R_274() {
37558 if (jj_scan_token(OR)) return true;
37559 if (jj_scan_token(REPLACE)) return true;
37560 return false;
37561 }
37562
37563 private boolean jj_3R_214() {
37564 if (jj_3R_138()) return true;
37565 return false;
37566 }
37567
37568 private boolean jj_3R_213() {
37569 if (jj_3R_137()) return true;
37570 return false;
37571 }
37572
37573 private boolean jj_3R_212() {
37574 if (jj_3R_136()) return true;
37575 return false;
37576 }
37577
37578 private boolean jj_3R_211() {
37579 if (jj_3R_135()) return true;
37580 return false;
37581 }
37582
37583 private boolean jj_3R_210() {
37584 if (jj_3R_292()) return true;
37585 return false;
37586 }
37587
37588 private boolean jj_3R_193() {
37589 if (jj_3R_247()) return true;
37590 return false;
37591 }
37592
37593 private boolean jj_3R_133() {
37594 Token xsp;
37595 xsp = jj_scanpos;
37596 if (jj_3R_210()) {
37597 jj_scanpos = xsp;
37598 if (jj_3R_211()) {
37599 jj_scanpos = xsp;
37600 if (jj_3R_212()) {
37601 jj_scanpos = xsp;
37602 if (jj_3R_213()) {
37603 jj_scanpos = xsp;
37604 if (jj_3R_214()) {
37605 jj_scanpos = xsp;
37606 if (jj_3R_215()) {
37607 jj_scanpos = xsp;
37608 if (jj_3R_216()) {
37609 jj_scanpos = xsp;
37610 if (jj_3R_217()) {
37611 jj_scanpos = xsp;
37612 if (jj_3R_218()) {
37613 jj_scanpos = xsp;
37614 if (jj_3R_219()) {
37615 jj_scanpos = xsp;
37616 if (jj_3R_220()) return true;
37617 }
37618 }
37619 }
37620 }
37621 }
37622 }
37623 }
37624 }
37625 }
37626 }
37627 return false;
37628 }
37629
37630 private boolean jj_3_47() {
37631 if (jj_3R_134()) return true;
37632 return false;
37633 }
37634
37635 private boolean jj_3_46() {
37636 if (jj_scan_token(NEW)) return true;
37637 if (jj_3R_133()) return true;
37638 return false;
37639 }
37640
37641 private boolean jj_3R_291() {
37642 if (jj_3R_133()) return true;
37643 return false;
37644 }
37645
37646 private boolean jj_3R_191() {
37647 if (jj_scan_token(CREATE)) return true;
37648 Token xsp;
37649 xsp = jj_scanpos;
37650 if (jj_3R_274()) jj_scanpos = xsp;
37651 xsp = jj_scanpos;
37652 if (jj_3R_275()) jj_scanpos = xsp;
37653 return false;
37654 }
37655
37656 private boolean jj_3R_117() {
37657 Token xsp;
37658 xsp = jj_scanpos;
37659 if (jj_3R_191()) jj_scanpos = xsp;
37660 if (jj_3R_192()) return true;
37661 xsp = jj_scanpos;
37662 if (jj_3R_193()) {
37663 jj_scanpos = xsp;
37664 if (jj_3R_194()) return true;
37665 }
37666 return false;
37667 }
37668
37669 private boolean jj_3R_290() {
37670 if (jj_scan_token(NEW)) return true;
37671 if (jj_3R_133()) return true;
37672 return false;
37673 }
37674
37675 private boolean jj_3R_209() {
37676 Token xsp;
37677 xsp = jj_scanpos;
37678 if (jj_3R_290()) {
37679 jj_scanpos = xsp;
37680 if (jj_3R_291()) return true;
37681 }
37682 while (true) {
37683 xsp = jj_scanpos;
37684 if (jj_3_47()) { jj_scanpos = xsp; break; }
37685 }
37686 return false;
37687 }
37688
37689 private boolean jj_3R_532() {
37690 if (jj_scan_token(CC_ERROR)) return true;
37691 if (jj_3R_232()) return true;
37692 if (jj_scan_token(CC_END)) return true;
37693 return false;
37694 }
37695
37696 private boolean jj_3R_208() {
37697 if (jj_scan_token(NEW_DOT)) return true;
37698 if (jj_3R_119()) return true;
37699 return false;
37700 }
37701
37702 private boolean jj_3R_531() {
37703 if (jj_3R_321()) return true;
37704 return false;
37705 }
37706
37707 private boolean jj_3R_503() {
37708 Token xsp;
37709 xsp = jj_scanpos;
37710 if (jj_3R_531()) {
37711 jj_scanpos = xsp;
37712 if (jj_3R_532()) return true;
37713 }
37714 return false;
37715 }
37716
37717 private boolean jj_3R_132() {
37718 Token xsp;
37719 xsp = jj_scanpos;
37720 if (jj_3R_208()) {
37721 jj_scanpos = xsp;
37722 if (jj_3R_209()) return true;
37723 }
37724 return false;
37725 }
37726
37727 private boolean jj_3R_471() {
37728 if (jj_scan_token(CC_ELSE)) return true;
37729 Token xsp;
37730 while (true) {
37731 xsp = jj_scanpos;
37732 if (jj_3R_503()) { jj_scanpos = xsp; break; }
37733 }
37734 return false;
37735 }
37736
37737 private boolean jj_3R_530() {
37738 if (jj_scan_token(CC_ERROR)) return true;
37739 if (jj_3R_232()) return true;
37740 if (jj_scan_token(CC_END)) return true;
37741 return false;
37742 }
37743
37744 private boolean jj_3R_529() {
37745 if (jj_3R_321()) return true;
37746 return false;
37747 }
37748
37749 private boolean jj_3R_502() {
37750 Token xsp;
37751 xsp = jj_scanpos;
37752 if (jj_3R_529()) {
37753 jj_scanpos = xsp;
37754 if (jj_3R_530()) return true;
37755 }
37756 return false;
37757 }
37758
37759 private boolean jj_3R_470() {
37760 if (jj_scan_token(CC_ELSIF)) return true;
37761 if (jj_3R_342()) return true;
37762 if (jj_scan_token(CC_THEN)) return true;
37763 Token xsp;
37764 while (true) {
37765 xsp = jj_scanpos;
37766 if (jj_3R_502()) { jj_scanpos = xsp; break; }
37767 }
37768 return false;
37769 }
37770
37771 private boolean jj_3R_501() {
37772 if (jj_scan_token(CC_ERROR)) return true;
37773 if (jj_3R_232()) return true;
37774 if (jj_scan_token(CC_END)) return true;
37775 return false;
37776 }
37777
37778 private boolean jj_3R_252() {
37779 if (jj_3R_123()) return true;
37780 return false;
37781 }
37782
37783 private boolean jj_3R_587() {
37784 if (jj_3R_132()) return true;
37785 return false;
37786 }
37787
37788 private boolean jj_3R_500() {
37789 if (jj_3R_321()) return true;
37790 return false;
37791 }
37792
37793 private boolean jj_3R_469() {
37794 Token xsp;
37795 xsp = jj_scanpos;
37796 if (jj_3R_500()) {
37797 jj_scanpos = xsp;
37798 if (jj_3R_501()) return true;
37799 }
37800 return false;
37801 }
37802
37803 private boolean jj_3R_586() {
37804 if (jj_scan_token(NOT)) return true;
37805 if (jj_3R_481()) return true;
37806 return false;
37807 }
37808
37809 private boolean jj_3R_542() {
37810 Token xsp;
37811 xsp = jj_scanpos;
37812 if (jj_3R_586()) {
37813 jj_scanpos = xsp;
37814 if (jj_3R_587()) return true;
37815 }
37816 return false;
37817 }
37818
37819 private boolean jj_3R_425() {
37820 if (jj_scan_token(CC_IF)) return true;
37821 if (jj_3R_342()) return true;
37822 if (jj_scan_token(CC_THEN)) return true;
37823 Token xsp;
37824 while (true) {
37825 xsp = jj_scanpos;
37826 if (jj_3R_469()) { jj_scanpos = xsp; break; }
37827 }
37828 while (true) {
37829 xsp = jj_scanpos;
37830 if (jj_3R_470()) { jj_scanpos = xsp; break; }
37831 }
37832 while (true) {
37833 xsp = jj_scanpos;
37834 if (jj_3R_471()) { jj_scanpos = xsp; break; }
37835 }
37836 if (jj_scan_token(CC_END)) return true;
37837 return false;
37838 }
37839
37840 private boolean jj_3R_273() {
37841 if (jj_3R_321()) return true;
37842 return false;
37843 }
37844
37845 private boolean jj_3R_511() {
37846 if (jj_3R_542()) return true;
37847 return false;
37848 }
37849
37850 private boolean jj_3R_541() {
37851 if (jj_scan_token(17)) return true;
37852 return false;
37853 }
37854
37855 private boolean jj_3R_540() {
37856 if (jj_scan_token(16)) return true;
37857 return false;
37858 }
37859
37860 private boolean jj_3R_383() {
37861 if (jj_3R_425()) return true;
37862 return false;
37863 }
37864
37865 private boolean jj_3R_510() {
37866 Token xsp;
37867 xsp = jj_scanpos;
37868 if (jj_3R_540()) {
37869 jj_scanpos = xsp;
37870 if (jj_3R_541()) return true;
37871 }
37872 if (jj_3R_481()) return true;
37873 return false;
37874 }
37875
37876 private boolean jj_3R_190() {
37877 Token xsp;
37878 while (true) {
37879 xsp = jj_scanpos;
37880 if (jj_3R_273()) { jj_scanpos = xsp; break; }
37881 }
37882 return false;
37883 }
37884
37885 private boolean jj_3R_382() {
37886 if (jj_3R_424()) return true;
37887 return false;
37888 }
37889
37890 private boolean jj_3_18() {
37891 Token xsp;
37892 xsp = jj_scanpos;
37893 if (jj_scan_token(125)) {
37894 jj_scanpos = xsp;
37895 if (jj_scan_token(221)) return true;
37896 }
37897 if (jj_3R_119()) return true;
37898 return false;
37899 }
37900
37901 private boolean jj_3R_481() {
37902 Token xsp;
37903 xsp = jj_scanpos;
37904 if (jj_3R_510()) {
37905 jj_scanpos = xsp;
37906 if (jj_3R_511()) return true;
37907 }
37908 return false;
37909 }
37910
37911 private boolean jj_3_17() {
37912 Token xsp;
37913 xsp = jj_scanpos;
37914 if (jj_scan_token(282)) {
37915 jj_scanpos = xsp;
37916 if (jj_scan_token(262)) return true;
37917 }
37918 if (jj_3R_119()) return true;
37919 xsp = jj_scanpos;
37920 if (jj_scan_token(151)) {
37921 jj_scanpos = xsp;
37922 if (jj_scan_token(51)) return true;
37923 }
37924 return false;
37925 }
37926
37927 private boolean jj_3R_381() {
37928 if (jj_3R_423()) return true;
37929 return false;
37930 }
37931
37932 private boolean jj_3R_380() {
37933 if (jj_3R_422()) return true;
37934 return false;
37935 }
37936
37937 private boolean jj_3_20() {
37938 if (jj_3R_121()) return true;
37939 return false;
37940 }
37941
37942 private boolean jj_3R_305() {
37943 if (jj_3R_349()) return true;
37944 return false;
37945 }
37946
37947 private boolean jj_3_19() {
37948 if (jj_3R_120()) return true;
37949 return false;
37950 }
37951
37952 private boolean jj_3R_605() {
37953 if (jj_scan_token(MOD)) return true;
37954 return false;
37955 }
37956
37957 private boolean jj_3R_379() {
37958 if (jj_3R_117()) return true;
37959 return false;
37960 }
37961
37962 private boolean jj_3R_604() {
37963 if (jj_scan_token(1)) return true;
37964 return false;
37965 }
37966
37967 private boolean jj_3R_603() {
37968 if (jj_scan_token(20)) return true;
37969 return false;
37970 }
37971
37972 private boolean jj_3R_378() {
37973 if (jj_3R_151()) return true;
37974 return false;
37975 }
37976
37977 private boolean jj_3R_602() {
37978 if (jj_scan_token(19)) return true;
37979 return false;
37980 }
37981
37982 private boolean jj_3_16() {
37983 if (jj_3R_118()) return true;
37984 return false;
37985 }
37986
37987 private boolean jj_3R_567() {
37988 Token xsp;
37989 xsp = jj_scanpos;
37990 if (jj_3R_602()) {
37991 jj_scanpos = xsp;
37992 if (jj_3R_603()) {
37993 jj_scanpos = xsp;
37994 if (jj_3R_604()) {
37995 jj_scanpos = xsp;
37996 if (jj_3R_605()) return true;
37997 }
37998 }
37999 }
38000 if (jj_3R_481()) return true;
38001 return false;
38002 }
38003
38004 private boolean jj_3R_377() {
38005 if (jj_3R_421()) return true;
38006 return false;
38007 }
38008
38009 private boolean jj_3_15() {
38010 if (jj_3R_117()) return true;
38011 return false;
38012 }
38013
38014 private boolean jj_3R_250() {
38015 Token xsp;
38016 xsp = jj_scanpos;
38017 if (jj_scan_token(100)) {
38018 jj_scanpos = xsp;
38019 if (jj_scan_token(181)) return true;
38020 }
38021 return false;
38022 }
38023
38024 private boolean jj_3R_304() {
38025 if (jj_3R_172()) return true;
38026 return false;
38027 }
38028
38029 private boolean jj_3R_534() {
38030 if (jj_3R_481()) return true;
38031 Token xsp;
38032 while (true) {
38033 xsp = jj_scanpos;
38034 if (jj_3R_567()) { jj_scanpos = xsp; break; }
38035 }
38036 return false;
38037 }
38038
38039 private boolean jj_3R_321() {
38040 Token xsp;
38041 xsp = jj_scanpos;
38042 if (jj_3R_377()) {
38043 jj_scanpos = xsp;
38044 if (jj_3_16()) {
38045 jj_scanpos = xsp;
38046 if (jj_3R_378()) {
38047 jj_scanpos = xsp;
38048 if (jj_3R_379()) {
38049 jj_scanpos = xsp;
38050 if (jj_3_19()) {
38051 jj_scanpos = xsp;
38052 if (jj_3_20()) {
38053 jj_scanpos = xsp;
38054 if (jj_3R_380()) {
38055 jj_scanpos = xsp;
38056 if (jj_3R_381()) {
38057 jj_scanpos = xsp;
38058 if (jj_3R_382()) {
38059 jj_scanpos = xsp;
38060 if (jj_3R_383()) return true;
38061 }
38062 }
38063 }
38064 }
38065 }
38066 }
38067 }
38068 }
38069 }
38070 return false;
38071 }
38072
38073 private boolean jj_3R_251() {
38074 if (jj_scan_token(BEGIN)) return true;
38075 Token xsp;
38076 while (true) {
38077 xsp = jj_scanpos;
38078 if (jj_3R_304()) { jj_scanpos = xsp; break; }
38079 }
38080 xsp = jj_scanpos;
38081 if (jj_3R_305()) jj_scanpos = xsp;
38082 return false;
38083 }
38084
38085 private boolean jj_3R_298() {
38086 if (jj_scan_token(18)) return true;
38087 if (jj_3R_132()) return true;
38088 return false;
38089 }
38090
38091 private boolean jj_3R_249() {
38092 if (jj_scan_token(OR)) return true;
38093 if (jj_scan_token(REPLACE)) return true;
38094 return false;
38095 }
38096
38097 private boolean jj_3R_228() {
38098 if (jj_3R_132()) return true;
38099 Token xsp;
38100 while (true) {
38101 xsp = jj_scanpos;
38102 if (jj_3R_298()) { jj_scanpos = xsp; break; }
38103 }
38104 return false;
38105 }
38106
38107 private boolean jj_3R_159() {
38108 Token xsp;
38109 xsp = jj_scanpos;
38110 if (jj_scan_token(151)) {
38111 jj_scanpos = xsp;
38112 if (jj_scan_token(51)) return true;
38113 }
38114 if (jj_3R_190()) return true;
38115 xsp = jj_scanpos;
38116 if (jj_3R_251()) jj_scanpos = xsp;
38117 if (jj_scan_token(END)) return true;
38118 xsp = jj_scanpos;
38119 if (jj_3R_252()) jj_scanpos = xsp;
38120 if (jj_scan_token(4)) return true;
38121 return false;
38122 }
38123
38124 private boolean jj_3R_158() {
38125 if (jj_3R_247()) return true;
38126 return false;
38127 }
38128
38129 private boolean jj_3R_269() {
38130 if (jj_3R_189()) return true;
38131 return false;
38132 }
38133
38134 private boolean jj_3R_570() {
38135 if (jj_scan_token(18)) return true;
38136 return false;
38137 }
38138
38139 private boolean jj_3R_569() {
38140 if (jj_scan_token(17)) return true;
38141 return false;
38142 }
38143
38144 private boolean jj_3R_568() {
38145 if (jj_scan_token(16)) return true;
38146 return false;
38147 }
38148
38149 private boolean jj_3R_157() {
38150 if (jj_scan_token(CREATE)) return true;
38151 Token xsp;
38152 xsp = jj_scanpos;
38153 if (jj_3R_249()) jj_scanpos = xsp;
38154 xsp = jj_scanpos;
38155 if (jj_3R_250()) jj_scanpos = xsp;
38156 return false;
38157 }
38158
38159 private boolean jj_3R_535() {
38160 Token xsp;
38161 xsp = jj_scanpos;
38162 if (jj_3R_568()) {
38163 jj_scanpos = xsp;
38164 if (jj_3R_569()) {
38165 jj_scanpos = xsp;
38166 if (jj_3R_570()) return true;
38167 }
38168 }
38169 if (jj_3R_534()) return true;
38170 return false;
38171 }
38172
38173 private boolean jj_3R_244() {
38174 Token xsp;
38175 xsp = jj_scanpos;
38176 if (jj_scan_token(100)) {
38177 jj_scanpos = xsp;
38178 if (jj_scan_token(181)) return true;
38179 }
38180 return false;
38181 }
38182
38183 private boolean jj_3R_248() {
38184 if (jj_3R_123()) return true;
38185 return false;
38186 }
38187
38188 private boolean jj_3R_103() {
38189 Token xsp;
38190 xsp = jj_scanpos;
38191 if (jj_3R_157()) jj_scanpos = xsp;
38192 xsp = jj_scanpos;
38193 if (jj_scan_token(207)) {
38194 jj_scanpos = xsp;
38195 if (jj_scan_token(282)) return true;
38196 }
38197 if (jj_scan_token(BODY)) return true;
38198 if (jj_3R_153()) return true;
38199 xsp = jj_scanpos;
38200 if (jj_3R_158()) {
38201 jj_scanpos = xsp;
38202 if (jj_3R_159()) return true;
38203 }
38204 return false;
38205 }
38206
38207 private boolean jj_3R_505() {
38208 if (jj_3R_534()) return true;
38209 Token xsp;
38210 while (true) {
38211 xsp = jj_scanpos;
38212 if (jj_3R_535()) { jj_scanpos = xsp; break; }
38213 }
38214 return false;
38215 }
38216
38217 private boolean jj_3R_585() {
38218 if (jj_3R_181()) return true;
38219 return false;
38220 }
38221
38222 private boolean jj_3R_584() {
38223 if (jj_scan_token(CHARACTER_LITERAL)) return true;
38224 return false;
38225 }
38226
38227 private boolean jj_3R_539() {
38228 if (jj_scan_token(ESCAPE)) return true;
38229 Token xsp;
38230 xsp = jj_scanpos;
38231 if (jj_3R_584()) {
38232 jj_scanpos = xsp;
38233 if (jj_3R_585()) return true;
38234 }
38235 return false;
38236 }
38237
38238 private boolean jj_3R_156() {
38239 Token xsp;
38240 xsp = jj_scanpos;
38241 if (jj_scan_token(151)) {
38242 jj_scanpos = xsp;
38243 if (jj_scan_token(51)) return true;
38244 }
38245 if (jj_3R_190()) return true;
38246 if (jj_scan_token(END)) return true;
38247 xsp = jj_scanpos;
38248 if (jj_3R_248()) jj_scanpos = xsp;
38249 if (jj_scan_token(4)) return true;
38250 return false;
38251 }
38252
38253 private boolean jj_3R_611() {
38254 if (jj_scan_token(ALL)) return true;
38255 return false;
38256 }
38257
38258 private boolean jj_3R_610() {
38259 if (jj_scan_token(DISTINCT)) return true;
38260 return false;
38261 }
38262
38263 private boolean jj_3R_583() {
38264 Token xsp;
38265 xsp = jj_scanpos;
38266 if (jj_3R_610()) {
38267 jj_scanpos = xsp;
38268 if (jj_3R_611()) return true;
38269 }
38270 return false;
38271 }
38272
38273 private boolean jj_3R_155() {
38274 if (jj_3R_247()) return true;
38275 return false;
38276 }
38277
38278 private boolean jj_3R_243() {
38279 if (jj_scan_token(OR)) return true;
38280 if (jj_scan_token(REPLACE)) return true;
38281 return false;
38282 }
38283
38284 private boolean jj_3R_582() {
38285 if (jj_scan_token(UNION)) return true;
38286 return false;
38287 }
38288
38289 private boolean jj_3R_581() {
38290 if (jj_scan_token(INTERSECT)) return true;
38291 return false;
38292 }
38293
38294 private boolean jj_3R_246() {
38295 if (jj_3R_237()) return true;
38296 return false;
38297 }
38298
38299 private boolean jj_3R_580() {
38300 if (jj_scan_token(EXCEPT)) return true;
38301 return false;
38302 }
38303
38304 private boolean jj_3R_154() {
38305 Token xsp;
38306 xsp = jj_scanpos;
38307 if (jj_3R_245()) {
38308 jj_scanpos = xsp;
38309 if (jj_3R_246()) return true;
38310 }
38311 return false;
38312 }
38313
38314 private boolean jj_3R_245() {
38315 if (jj_scan_token(AUTHID)) return true;
38316 Token xsp;
38317 xsp = jj_scanpos;
38318 if (jj_scan_token(37)) {
38319 jj_scanpos = xsp;
38320 if (jj_scan_token(36)) return true;
38321 }
38322 return false;
38323 }
38324
38325 private boolean jj_3R_609() {
38326 if (jj_scan_token(OF)) return true;
38327 return false;
38328 }
38329
38330 private boolean jj_3R_538() {
38331 if (jj_scan_token(MULTISET)) return true;
38332 Token xsp;
38333 xsp = jj_scanpos;
38334 if (jj_3R_580()) {
38335 jj_scanpos = xsp;
38336 if (jj_3R_581()) {
38337 jj_scanpos = xsp;
38338 if (jj_3R_582()) return true;
38339 }
38340 }
38341 xsp = jj_scanpos;
38342 if (jj_3R_583()) jj_scanpos = xsp;
38343 return false;
38344 }
38345
38346 private boolean jj_3R_152() {
38347 if (jj_scan_token(CREATE)) return true;
38348 Token xsp;
38349 xsp = jj_scanpos;
38350 if (jj_3R_243()) jj_scanpos = xsp;
38351 xsp = jj_scanpos;
38352 if (jj_3R_244()) jj_scanpos = xsp;
38353 return false;
38354 }
38355
38356 private boolean jj_3R_608() {
38357 if (jj_scan_token(SUBMULTISET)) return true;
38358 return false;
38359 }
38360
38361 private boolean jj_3R_607() {
38362 if (jj_scan_token(MEMBER)) return true;
38363 return false;
38364 }
38365
38366 private boolean jj_3R_102() {
38367 Token xsp;
38368 xsp = jj_scanpos;
38369 if (jj_3R_152()) jj_scanpos = xsp;
38370 if (jj_scan_token(PACKAGE)) return true;
38371 if (jj_3R_153()) return true;
38372 while (true) {
38373 xsp = jj_scanpos;
38374 if (jj_3R_154()) { jj_scanpos = xsp; break; }
38375 }
38376 xsp = jj_scanpos;
38377 if (jj_3R_155()) {
38378 jj_scanpos = xsp;
38379 if (jj_3R_156()) return true;
38380 }
38381 return false;
38382 }
38383
38384 private boolean jj_3R_116() {
38385 if (jj_scan_token(DECLARE)) return true;
38386 if (jj_3R_190()) return true;
38387 return false;
38388 }
38389
38390 private boolean jj_3R_579() {
38391 Token xsp;
38392 xsp = jj_scanpos;
38393 if (jj_3R_607()) {
38394 jj_scanpos = xsp;
38395 if (jj_3R_608()) return true;
38396 }
38397 xsp = jj_scanpos;
38398 if (jj_3R_609()) jj_scanpos = xsp;
38399 return false;
38400 }
38401
38402 private boolean jj_3R_578() {
38403 if (jj_scan_token(FROM)) return true;
38404 return false;
38405 }
38406
38407 private boolean jj_3R_577() {
38408 if (jj_scan_token(LIKE)) return true;
38409 return false;
38410 }
38411
38412 private boolean jj_3R_576() {
38413 if (jj_scan_token(BETWEEN)) return true;
38414 return false;
38415 }
38416
38417 private boolean jj_3R_575() {
38418 if (jj_scan_token(IN)) return true;
38419 return false;
38420 }
38421
38422 private boolean jj_3R_606() {
38423 if (jj_scan_token(15)) return true;
38424 return false;
38425 }
38426
38427 private boolean jj_3R_574() {
38428 if (jj_scan_token(NOT)) return true;
38429 return false;
38430 }
38431
38432 private boolean jj_3R_573() {
38433 if (jj_scan_token(10)) return true;
38434 return false;
38435 }
38436
38437 private boolean jj_3R_572() {
38438 if (jj_scan_token(15)) return true;
38439 return false;
38440 }
38441
38442 private boolean jj_3R_537() {
38443 Token xsp;
38444 xsp = jj_scanpos;
38445 if (jj_3R_574()) jj_scanpos = xsp;
38446 xsp = jj_scanpos;
38447 if (jj_3R_575()) {
38448 jj_scanpos = xsp;
38449 if (jj_3R_576()) {
38450 jj_scanpos = xsp;
38451 if (jj_3R_577()) {
38452 jj_scanpos = xsp;
38453 if (jj_3R_578()) {
38454 jj_scanpos = xsp;
38455 if (jj_3R_579()) return true;
38456 }
38457 }
38458 }
38459 }
38460 return false;
38461 }
38462
38463 private boolean jj_3R_320() {
38464 if (jj_3R_349()) return true;
38465 return false;
38466 }
38467
38468 private boolean jj_3R_571() {
38469 if (jj_scan_token(14)) return true;
38470 Token xsp;
38471 xsp = jj_scanpos;
38472 if (jj_3R_606()) jj_scanpos = xsp;
38473 return false;
38474 }
38475
38476 private boolean jj_3R_319() {
38477 if (jj_3R_172()) return true;
38478 return false;
38479 }
38480
38481 private boolean jj_3R_200() {
38482 if (jj_3R_281()) return true;
38483 return false;
38484 }
38485
38486 private boolean jj_3R_115() {
38487 if (jj_3R_189()) return true;
38488 return false;
38489 }
38490
38491 private boolean jj_3_14() {
38492 Token xsp;
38493 while (true) {
38494 xsp = jj_scanpos;
38495 if (jj_3R_115()) { jj_scanpos = xsp; break; }
38496 }
38497 xsp = jj_scanpos;
38498 if (jj_3R_116()) jj_scanpos = xsp;
38499 if (jj_scan_token(BEGIN)) return true;
38500 return false;
38501 }
38502
38503 private boolean jj_3R_318() {
38504 if (jj_scan_token(DECLARE)) return true;
38505 if (jj_3R_190()) return true;
38506 return false;
38507 }
38508
38509 private boolean jj_3R_536() {
38510 Token xsp;
38511 xsp = jj_scanpos;
38512 if (jj_3R_571()) {
38513 jj_scanpos = xsp;
38514 if (jj_3R_572()) return true;
38515 }
38516 xsp = jj_scanpos;
38517 if (jj_3R_573()) jj_scanpos = xsp;
38518 return false;
38519 }
38520
38521 private boolean jj_3R_270() {
38522 Token xsp;
38523 xsp = jj_scanpos;
38524 if (jj_3R_318()) jj_scanpos = xsp;
38525 if (jj_scan_token(BEGIN)) return true;
38526 while (true) {
38527 xsp = jj_scanpos;
38528 if (jj_3R_319()) { jj_scanpos = xsp; break; }
38529 }
38530 xsp = jj_scanpos;
38531 if (jj_3R_320()) jj_scanpos = xsp;
38532 if (jj_scan_token(END)) return true;
38533 xsp = jj_scanpos;
38534 if (jj_scan_token(418)) jj_scanpos = xsp;
38535 return false;
38536 }
38537
38538 private boolean jj_3R_506() {
38539 Token xsp;
38540 xsp = jj_scanpos;
38541 if (jj_3R_536()) {
38542 jj_scanpos = xsp;
38543 if (jj_3R_537()) {
38544 jj_scanpos = xsp;
38545 if (jj_3R_538()) return true;
38546 }
38547 }
38548 if (jj_3R_505()) return true;
38549 xsp = jj_scanpos;
38550 if (jj_3R_539()) jj_scanpos = xsp;
38551 return false;
38552 }
38553
38554 private boolean jj_3R_123() {
38555 Token xsp;
38556 xsp = jj_scanpos;
38557 if (jj_scan_token(418)) {
38558 jj_scanpos = xsp;
38559 if (jj_scan_token(426)) {
38560 jj_scanpos = xsp;
38561 if (jj_3R_200()) {
38562 jj_scanpos = xsp;
38563 if (jj_scan_token(35)) {
38564 jj_scanpos = xsp;
38565 if (jj_scan_token(38)) {
38566 jj_scanpos = xsp;
38567 if (jj_scan_token(39)) {
38568 jj_scanpos = xsp;
38569 if (jj_scan_token(40)) {
38570 jj_scanpos = xsp;
38571 if (jj_scan_token(41)) {
38572 jj_scanpos = xsp;
38573 if (jj_scan_token(46)) {
38574 jj_scanpos = xsp;
38575 if (jj_scan_token(47)) {
38576 jj_scanpos = xsp;
38577 if (jj_scan_token(48)) {
38578 jj_scanpos = xsp;
38579 if (jj_scan_token(49)) {
38580 jj_scanpos = xsp;
38581 if (jj_scan_token(50)) {
38582 jj_scanpos = xsp;
38583 if (jj_scan_token(51)) {
38584 jj_scanpos = xsp;
38585 if (jj_scan_token(52)) {
38586 jj_scanpos = xsp;
38587 if (jj_scan_token(56)) {
38588 jj_scanpos = xsp;
38589 if (jj_scan_token(58)) {
38590 jj_scanpos = xsp;
38591 if (jj_scan_token(59)) {
38592 jj_scanpos = xsp;
38593 if (jj_scan_token(60)) {
38594 jj_scanpos = xsp;
38595 if (jj_scan_token(61)) {
38596 jj_scanpos = xsp;
38597 if (jj_scan_token(63)) {
38598 jj_scanpos = xsp;
38599 if (jj_scan_token(66)) {
38600 jj_scanpos = xsp;
38601 if (jj_scan_token(67)) {
38602 jj_scanpos = xsp;
38603 if (jj_scan_token(68)) {
38604 jj_scanpos = xsp;
38605 if (jj_scan_token(69)) {
38606 jj_scanpos = xsp;
38607 if (jj_scan_token(71)) {
38608 jj_scanpos = xsp;
38609 if (jj_scan_token(77)) {
38610 jj_scanpos = xsp;
38611 if (jj_scan_token(78)) {
38612 jj_scanpos = xsp;
38613 if (jj_scan_token(79)) {
38614 jj_scanpos = xsp;
38615 if (jj_scan_token(83)) {
38616 jj_scanpos = xsp;
38617 if (jj_scan_token(85)) {
38618 jj_scanpos = xsp;
38619 if (jj_scan_token(88)) {
38620 jj_scanpos = xsp;
38621 if (jj_scan_token(90)) {
38622 jj_scanpos = xsp;
38623 if (jj_scan_token(91)) {
38624 jj_scanpos = xsp;
38625 if (jj_scan_token(92)) {
38626 jj_scanpos = xsp;
38627 if (jj_scan_token(93)) {
38628 jj_scanpos = xsp;
38629 if (jj_scan_token(94)) {
38630 jj_scanpos = xsp;
38631 if (jj_scan_token(97)) {
38632 jj_scanpos = xsp;
38633 if (jj_scan_token(98)) {
38634 jj_scanpos = xsp;
38635 if (jj_scan_token(99)) {
38636 jj_scanpos = xsp;
38637 if (jj_scan_token(102)) {
38638 jj_scanpos = xsp;
38639 if (jj_scan_token(103)) {
38640 jj_scanpos = xsp;
38641 if (jj_scan_token(108)) {
38642 jj_scanpos = xsp;
38643 if (jj_scan_token(110)) {
38644 jj_scanpos = xsp;
38645 if (jj_scan_token(111)) {
38646 jj_scanpos = xsp;
38647 if (jj_scan_token(112)) {
38648 jj_scanpos = xsp;
38649 if (jj_scan_token(118)) {
38650 jj_scanpos = xsp;
38651 if (jj_scan_token(120)) {
38652 jj_scanpos = xsp;
38653 if (jj_scan_token(121)) {
38654 jj_scanpos = xsp;
38655 if (jj_scan_token(122)) {
38656 jj_scanpos = xsp;
38657 if (jj_scan_token(124)) {
38658 jj_scanpos = xsp;
38659 if (jj_scan_token(127)) {
38660 jj_scanpos = xsp;
38661 if (jj_scan_token(128)) {
38662 jj_scanpos = xsp;
38663 if (jj_scan_token(131)) {
38664 jj_scanpos = xsp;
38665 if (jj_scan_token(135)) {
38666 jj_scanpos = xsp;
38667 if (jj_scan_token(137)) {
38668 jj_scanpos = xsp;
38669 if (jj_scan_token(138)) {
38670 jj_scanpos = xsp;
38671 if (jj_scan_token(143)) {
38672 jj_scanpos = xsp;
38673 if (jj_scan_token(145)) {
38674 jj_scanpos = xsp;
38675 if (jj_scan_token(146)) {
38676 jj_scanpos = xsp;
38677 if (jj_scan_token(147)) {
38678 jj_scanpos = xsp;
38679 if (jj_scan_token(149)) {
38680 jj_scanpos = xsp;
38681 if (jj_scan_token(151)) {
38682 jj_scanpos = xsp;
38683 if (jj_scan_token(155)) {
38684 jj_scanpos = xsp;
38685 if (jj_scan_token(157)) {
38686 jj_scanpos = xsp;
38687 if (jj_scan_token(158)) {
38688 jj_scanpos = xsp;
38689 if (jj_scan_token(159)) {
38690 jj_scanpos = xsp;
38691 if (jj_scan_token(160)) {
38692 jj_scanpos = xsp;
38693 if (jj_scan_token(166)) {
38694 jj_scanpos = xsp;
38695 if (jj_scan_token(170)) {
38696 jj_scanpos = xsp;
38697 if (jj_scan_token(171)) {
38698 jj_scanpos = xsp;
38699 if (jj_scan_token(174)) {
38700 jj_scanpos = xsp;
38701 if (jj_scan_token(177)) {
38702 jj_scanpos = xsp;
38703 if (jj_scan_token(180)) {
38704 jj_scanpos = xsp;
38705 if (jj_scan_token(182)) {
38706 jj_scanpos = xsp;
38707 if (jj_scan_token(183)) {
38708 jj_scanpos = xsp;
38709 if (jj_scan_token(184)) {
38710 jj_scanpos = xsp;
38711 if (jj_scan_token(186)) {
38712 jj_scanpos = xsp;
38713 if (jj_scan_token(191)) {
38714 jj_scanpos = xsp;
38715 if (jj_scan_token(193)) {
38716 jj_scanpos = xsp;
38717 if (jj_scan_token(194)) {
38718 jj_scanpos = xsp;
38719 if (jj_scan_token(196)) {
38720 jj_scanpos = xsp;
38721 if (jj_scan_token(187)) {
38722 jj_scanpos = xsp;
38723 if (jj_scan_token(188)) {
38724 jj_scanpos = xsp;
38725 if (jj_scan_token(189)) {
38726 jj_scanpos = xsp;
38727 if (jj_scan_token(190)) {
38728 jj_scanpos = xsp;
38729 if (jj_scan_token(199)) {
38730 jj_scanpos = xsp;
38731 if (jj_scan_token(200)) {
38732 jj_scanpos = xsp;
38733 if (jj_scan_token(201)) {
38734 jj_scanpos = xsp;
38735 if (jj_scan_token(202)) {
38736 jj_scanpos = xsp;
38737 if (jj_scan_token(205)) {
38738 jj_scanpos = xsp;
38739 if (jj_scan_token(210)) {
38740 jj_scanpos = xsp;
38741 if (jj_scan_token(213)) {
38742 jj_scanpos = xsp;
38743 if (jj_scan_token(214)) {
38744 jj_scanpos = xsp;
38745 if (jj_scan_token(215)) {
38746 jj_scanpos = xsp;
38747 if (jj_scan_token(218)) {
38748 jj_scanpos = xsp;
38749 if (jj_scan_token(220)) {
38750 jj_scanpos = xsp;
38751 if (jj_scan_token(219)) {
38752 jj_scanpos = xsp;
38753 if (jj_scan_token(222)) {
38754 jj_scanpos = xsp;
38755 if (jj_scan_token(223)) {
38756 jj_scanpos = xsp;
38757 if (jj_scan_token(225)) {
38758 jj_scanpos = xsp;
38759 if (jj_scan_token(244)) {
38760 jj_scanpos = xsp;
38761 if (jj_scan_token(248)) {
38762 jj_scanpos = xsp;
38763 if (jj_scan_token(250)) {
38764 jj_scanpos = xsp;
38765 if (jj_scan_token(253)) {
38766 jj_scanpos = xsp;
38767 if (jj_scan_token(254)) {
38768 jj_scanpos = xsp;
38769 if (jj_scan_token(256)) {
38770 jj_scanpos = xsp;
38771 if (jj_scan_token(257)) {
38772 jj_scanpos = xsp;
38773 if (jj_scan_token(258)) {
38774 jj_scanpos = xsp;
38775 if (jj_scan_token(259)) {
38776 jj_scanpos = xsp;
38777 if (jj_scan_token(261)) {
38778 jj_scanpos = xsp;
38779 if (jj_scan_token(265)) {
38780 jj_scanpos = xsp;
38781 if (jj_scan_token(266)) {
38782 jj_scanpos = xsp;
38783 if (jj_scan_token(267)) {
38784 jj_scanpos = xsp;
38785 if (jj_scan_token(269)) {
38786 jj_scanpos = xsp;
38787 if (jj_scan_token(271)) {
38788 jj_scanpos = xsp;
38789 if (jj_scan_token(278)) {
38790 jj_scanpos = xsp;
38791 if (jj_scan_token(280)) {
38792 jj_scanpos = xsp;
38793 if (jj_scan_token(282)) {
38794 jj_scanpos = xsp;
38795 if (jj_scan_token(283)) {
38796 jj_scanpos = xsp;
38797 if (jj_scan_token(295)) {
38798 jj_scanpos = xsp;
38799 if (jj_scan_token(296)) {
38800 jj_scanpos = xsp;
38801 if (jj_scan_token(297)) {
38802 jj_scanpos = xsp;
38803 if (jj_scan_token(301)) {
38804 jj_scanpos = xsp;
38805 if (jj_scan_token(303)) {
38806 jj_scanpos = xsp;
38807 if (jj_scan_token(306)) {
38808 jj_scanpos = xsp;
38809 if (jj_scan_token(316)) {
38810 jj_scanpos = xsp;
38811 if (jj_scan_token(290)) {
38812 jj_scanpos = xsp;
38813 if (jj_scan_token(430)) {
38814 jj_scanpos = xsp;
38815 if (jj_scan_token(427)) {
38816 jj_scanpos = xsp;
38817 if (jj_scan_token(428)) {
38818 jj_scanpos = xsp;
38819 if (jj_scan_token(429)) return true;
38820 }
38821 }
38822 }
38823 }
38824 }
38825 }
38826 }
38827 }
38828 }
38829 }
38830 }
38831 }
38832 }
38833 }
38834 }
38835 }
38836 }
38837 }
38838 }
38839 }
38840 }
38841 }
38842 }
38843 }
38844 }
38845 }
38846 }
38847 }
38848 }
38849 }
38850 }
38851 }
38852 }
38853 }
38854 }
38855 }
38856 }
38857 }
38858 }
38859 }
38860 }
38861 }
38862 }
38863 }
38864 }
38865 }
38866 }
38867 }
38868 }
38869 }
38870 }
38871 }
38872 }
38873 }
38874 }
38875 }
38876 }
38877 }
38878 }
38879 }
38880 }
38881 }
38882 }
38883 }
38884 }
38885 }
38886 }
38887 }
38888 }
38889 }
38890 }
38891 }
38892 }
38893 }
38894 }
38895 }
38896 }
38897 }
38898 }
38899 }
38900 }
38901 }
38902 }
38903 }
38904 }
38905 }
38906 }
38907 }
38908 }
38909 }
38910 }
38911 }
38912 }
38913 }
38914 }
38915 }
38916 }
38917 }
38918 }
38919 }
38920 }
38921 }
38922 }
38923 }
38924 }
38925 }
38926 }
38927 }
38928 }
38929 }
38930 }
38931 }
38932 }
38933 }
38934 }
38935 }
38936 }
38937 }
38938 }
38939 }
38940 }
38941 }
38942 }
38943 }
38944 }
38945 }
38946 }
38947 }
38948 }
38949 }
38950 }
38951 return false;
38952 }
38953
38954 private boolean jj_3R_184() {
38955 Token xsp;
38956 while (true) {
38957 xsp = jj_scanpos;
38958 if (jj_3R_269()) { jj_scanpos = xsp; break; }
38959 }
38960 if (jj_3R_270()) return true;
38961 if (jj_scan_token(4)) return true;
38962 return false;
38963 }
38964
38965 private boolean jj_3R_479() {
38966 if (jj_3R_505()) return true;
38967 Token xsp;
38968 while (true) {
38969 xsp = jj_scanpos;
38970 if (jj_3R_506()) { jj_scanpos = xsp; break; }
38971 }
38972 return false;
38973 }
38974
38975 private boolean jj_3R_112() {
38976 Token xsp;
38977 xsp = jj_scanpos;
38978 if (jj_3R_184()) {
38979 jj_scanpos = xsp;
38980 if (jj_3_15()) return true;
38981 }
38982 return false;
38983 }
38984
38985 private boolean jj_3R_509() {
38986 if (jj_scan_token(IS)) return true;
38987 return false;
38988 }
38989
38990 private boolean jj_3R_508() {
38991 if (jj_scan_token(13)) return true;
38992 if (jj_scan_token(10)) return true;
38993 return false;
38994 }
38995
38996 private boolean jj_3R_507() {
38997 if (jj_scan_token(10)) return true;
38998 return false;
38999 }
39000
39001 private boolean jj_3R_480() {
39002 Token xsp;
39003 xsp = jj_scanpos;
39004 if (jj_3R_507()) {
39005 jj_scanpos = xsp;
39006 if (jj_3R_508()) {
39007 jj_scanpos = xsp;
39008 if (jj_3R_509()) return true;
39009 }
39010 }
39011 if (jj_3R_479()) return true;
39012 return false;
39013 }
39014
39015 private boolean jj_3R_435() {
39016 if (jj_3R_479()) return true;
39017 Token xsp;
39018 while (true) {
39019 xsp = jj_scanpos;
39020 if (jj_3R_480()) { jj_scanpos = xsp; break; }
39021 }
39022 return false;
39023 }
39024
39025 private boolean jj_3R_436() {
39026 if (jj_scan_token(AND)) return true;
39027 if (jj_3R_435()) return true;
39028 return false;
39029 }
39030
39031 private boolean jj_3R_393() {
39032 if (jj_3R_435()) return true;
39033 Token xsp;
39034 while (true) {
39035 xsp = jj_scanpos;
39036 if (jj_3R_436()) { jj_scanpos = xsp; break; }
39037 }
39038 return false;
39039 }
39040
39041 private boolean jj_3R_187() {
39042 if (jj_scan_token(3)) return true;
39043 if (jj_scan_token(ATTACH)) return true;
39044 return false;
39045 }
39046
39047 private boolean jj_3R_394() {
39048 if (jj_scan_token(OR)) return true;
39049 if (jj_3R_393()) return true;
39050 return false;
39051 }
39052
39053 private boolean jj_3R_342() {
39054 if (jj_3R_393()) return true;
39055 Token xsp;
39056 while (true) {
39057 xsp = jj_scanpos;
39058 if (jj_3R_394()) { jj_scanpos = xsp; break; }
39059 }
39060 return false;
39061 }
39062
39063 private boolean jj_3R_235() {
39064 if (jj_scan_token(3)) return true;
39065 if (jj_3R_232()) return true;
39066 return false;
39067 }
39068
39069 private boolean jj_3R_233() {
39070 if (jj_scan_token(AT)) return true;
39071 if (jj_scan_token(TIME)) return true;
39072 if (jj_scan_token(ZONE)) return true;
39073 if (jj_3R_132()) return true;
39074 return false;
39075 }
39076
39077 private boolean jj_3R_138() {
39078 Token xsp;
39079 xsp = jj_scanpos;
39080 if (jj_scan_token(388)) {
39081 jj_scanpos = xsp;
39082 if (jj_scan_token(389)) return true;
39083 }
39084 if (jj_scan_token(5)) return true;
39085 if (jj_3R_232()) return true;
39086 xsp = jj_scanpos;
39087 if (jj_3R_233()) jj_scanpos = xsp;
39088 if (jj_scan_token(AS)) return true;
39089 if (jj_3R_234()) return true;
39090 if (jj_scan_token(7)) return true;
39091 while (true) {
39092 xsp = jj_scanpos;
39093 if (jj_3R_235()) { jj_scanpos = xsp; break; }
39094 }
39095 return false;
39096 }
39097
39098 private boolean jj_3R_114() {
39099 Token xsp;
39100 xsp = jj_scanpos;
39101 if (jj_scan_token(2)) {
39102 jj_scanpos = xsp;
39103 if (jj_scan_token(375)) {
39104 jj_scanpos = xsp;
39105 if (jj_scan_token(74)) {
39106 jj_scanpos = xsp;
39107 if (jj_scan_token(78)) {
39108 jj_scanpos = xsp;
39109 if (jj_scan_token(377)) {
39110 jj_scanpos = xsp;
39111 if (jj_scan_token(378)) {
39112 jj_scanpos = xsp;
39113 if (jj_scan_token(379)) {
39114 jj_scanpos = xsp;
39115 if (jj_scan_token(111)) {
39116 jj_scanpos = xsp;
39117 if (jj_scan_token(113)) {
39118 jj_scanpos = xsp;
39119 if (jj_scan_token(380)) {
39120 jj_scanpos = xsp;
39121 if (jj_scan_token(381)) {
39122 jj_scanpos = xsp;
39123 if (jj_scan_token(219)) {
39124 jj_scanpos = xsp;
39125 if (jj_scan_token(382)) {
39126 jj_scanpos = xsp;
39127 if (jj_scan_token(383)) {
39128 jj_scanpos = xsp;
39129 if (jj_scan_token(251)) {
39130 jj_scanpos = xsp;
39131 if (jj_scan_token(292)) {
39132 jj_scanpos = xsp;
39133 if (jj_scan_token(293)) {
39134 jj_scanpos = xsp;
39135 if (jj_scan_token(259)) {
39136 jj_scanpos = xsp;
39137 if (jj_scan_token(384)) {
39138 jj_scanpos = xsp;
39139 if (jj_scan_token(385)) {
39140 jj_scanpos = xsp;
39141 if (jj_scan_token(386)) {
39142 jj_scanpos = xsp;
39143 if (jj_scan_token(75)) {
39144 jj_scanpos = xsp;
39145 if (jj_scan_token(129)) {
39146 jj_scanpos = xsp;
39147 if (jj_scan_token(238)) {
39148 jj_scanpos = xsp;
39149 if (jj_scan_token(99)) {
39150 jj_scanpos = xsp;
39151 if (jj_scan_token(418)) {
39152 jj_scanpos = xsp;
39153 if (jj_3R_187()) return true;
39154 }
39155 }
39156 }
39157 }
39158 }
39159 }
39160 }
39161 }
39162 }
39163 }
39164 }
39165 }
39166 }
39167 }
39168 }
39169 }
39170 }
39171 }
39172 }
39173 }
39174 }
39175 }
39176 }
39177 }
39178 }
39179 }
39180 if (jj_3R_188()) return true;
39181 return false;
39182 }
39183
39184 private boolean jj_3R_227() {
39185 if (jj_3R_228()) return true;
39186 return false;
39187 }
39188
39189 private boolean jj_3R_226() {
39190 Token xsp;
39191 xsp = jj_scanpos;
39192 if (jj_scan_token(397)) {
39193 jj_scanpos = xsp;
39194 if (jj_scan_token(398)) {
39195 jj_scanpos = xsp;
39196 if (jj_scan_token(393)) return true;
39197 }
39198 }
39199 return false;
39200 }
39201
39202 private boolean jj_3R_113() {
39203 if (jj_3R_185()) return true;
39204 if (jj_3R_186()) return true;
39205 return false;
39206 }
39207
39208 private boolean jj_3R_136() {
39209 if (jj_scan_token(TRIM)) return true;
39210 if (jj_scan_token(5)) return true;
39211 Token xsp;
39212 xsp = jj_scanpos;
39213 if (jj_3R_226()) jj_scanpos = xsp;
39214 xsp = jj_scanpos;
39215 if (jj_3R_227()) jj_scanpos = xsp;
39216 if (jj_scan_token(FROM)) return true;
39217 if (jj_3R_228()) return true;
39218 if (jj_scan_token(7)) return true;
39219 return false;
39220 }
39221
39222 private boolean jj_3_13() {
39223 if (jj_3R_114()) return true;
39224 return false;
39225 }
39226
39227 private boolean jj_3_12() {
39228 if (jj_3R_113()) return true;
39229 return false;
39230 }
39231
39232 private boolean jj_3_11() {
39233 if (jj_3R_112()) return true;
39234 return false;
39235 }
39236
39237 private boolean jj_3_10() {
39238 if (jj_3R_111()) return true;
39239 return false;
39240 }
39241
39242 private boolean jj_3_9() {
39243 if (jj_3R_110()) return true;
39244 return false;
39245 }
39246
39247 private boolean jj_3_8() {
39248 if (jj_3R_109()) return true;
39249 return false;
39250 }
39251
39252 private boolean jj_3_7() {
39253 if (jj_3R_108()) return true;
39254 return false;
39255 }
39256
39257 private boolean jj_3_6() {
39258 if (jj_3R_107()) return true;
39259 return false;
39260 }
39261
39262 private boolean jj_3_5() {
39263 if (jj_3R_106()) return true;
39264 return false;
39265 }
39266
39267 private boolean jj_3_4() {
39268 if (jj_3R_105()) return true;
39269 return false;
39270 }
39271
39272 private boolean jj_3_3() {
39273 if (jj_3R_104()) return true;
39274 return false;
39275 }
39276
39277 private boolean jj_3_2() {
39278 if (jj_3R_103()) return true;
39279 return false;
39280 }
39281
39282 private boolean jj_3_1() {
39283 if (jj_3R_102()) return true;
39284 return false;
39285 }
39286
39287 private boolean jj_3R_231() {
39288 if (jj_scan_token(ELSE)) return true;
39289 if (jj_3R_232()) return true;
39290 return false;
39291 }
39292
39293 private boolean jj_3R_230() {
39294 if (jj_scan_token(WHEN)) return true;
39295 if (jj_3R_232()) return true;
39296 if (jj_scan_token(THEN)) return true;
39297 if (jj_3R_232()) return true;
39298 return false;
39299 }
39300
39301 private boolean jj_3R_229() {
39302 if (jj_3R_232()) return true;
39303 return false;
39304 }
39305
39306 private boolean jj_3R_137() {
39307 if (jj_scan_token(CASE)) return true;
39308 Token xsp;
39309 xsp = jj_scanpos;
39310 if (jj_3R_229()) jj_scanpos = xsp;
39311 if (jj_3R_230()) return true;
39312 while (true) {
39313 xsp = jj_scanpos;
39314 if (jj_3R_230()) { jj_scanpos = xsp; break; }
39315 }
39316 xsp = jj_scanpos;
39317 if (jj_3R_231()) jj_scanpos = xsp;
39318 if (jj_scan_token(END)) return true;
39319 return false;
39320 }
39321
39322 private boolean jj_3R_341() {
39323 if (jj_3R_132()) return true;
39324 if (jj_scan_token(9)) return true;
39325 if (jj_scan_token(10)) return true;
39326 if (jj_3R_232()) return true;
39327 return false;
39328 }
39329
39330 private boolean jj_3R_396() {
39331 if (jj_scan_token(CC_ELSE)) return true;
39332 if (jj_3R_232()) return true;
39333 return false;
39334 }
39335
39336 private boolean jj_3R_395() {
39337 if (jj_scan_token(CC_ELSIF)) return true;
39338 if (jj_3R_342()) return true;
39339 if (jj_scan_token(CC_THEN)) return true;
39340 if (jj_3R_232()) return true;
39341 return false;
39342 }
39343
39344 private boolean jj_3R_343() {
39345 if (jj_scan_token(CC_IF)) return true;
39346 if (jj_3R_342()) return true;
39347 if (jj_scan_token(CC_THEN)) return true;
39348 if (jj_3R_232()) return true;
39349 Token xsp;
39350 while (true) {
39351 xsp = jj_scanpos;
39352 if (jj_3R_395()) { jj_scanpos = xsp; break; }
39353 }
39354 while (true) {
39355 xsp = jj_scanpos;
39356 if (jj_3R_396()) { jj_scanpos = xsp; break; }
39357 }
39358 if (jj_scan_token(CC_END)) return true;
39359 return false;
39360 }
39361
39362 private boolean jj_3_45() {
39363 if (jj_3R_132()) return true;
39364 if (jj_scan_token(9)) return true;
39365 if (jj_scan_token(10)) return true;
39366 return false;
39367 }
39368
39369 private boolean jj_3R_301() {
39370 if (jj_3R_343()) return true;
39371 return false;
39372 }
39373
39374 private boolean jj_3R_300() {
39375 if (jj_3R_342()) return true;
39376 return false;
39377 }
39378
39379 private boolean jj_3R_299() {
39380 if (jj_3R_341()) return true;
39381 return false;
39382 }
39383
39384 private boolean jj_3R_232() {
39385 Token xsp;
39386 xsp = jj_scanpos;
39387 if (jj_3R_299()) {
39388 jj_scanpos = xsp;
39389 if (jj_3R_300()) {
39390 jj_scanpos = xsp;
39391 if (jj_3R_301()) return true;
39392 }
39393 }
39394 return false;
39395 }
39396
39397 private boolean jj_3R_108() {
39398 if (jj_scan_token(ALTER)) return true;
39399 if (jj_scan_token(TRIGGER)) return true;
39400 if (jj_3R_178()) return true;
39401 if (jj_scan_token(4)) return true;
39402 return false;
39403 }
39404
39405 private boolean jj_3R_317() {
39406 if (jj_3R_376()) return true;
39407 return false;
39408 }
39409
39410 private boolean jj_3R_316() {
39411 if (jj_3R_185()) return true;
39412 return false;
39413 }
39414
39415 private boolean jj_3R_266() {
39416 Token xsp;
39417 xsp = jj_scanpos;
39418 if (jj_3R_316()) {
39419 jj_scanpos = xsp;
39420 if (jj_3R_317()) return true;
39421 }
39422 return false;
39423 }
39424
39425 private boolean jj_3R_422() {
39426 if (jj_3R_197()) return true;
39427 return false;
39428 }
39429
39430 private boolean jj_3R_121() {
39431 if (jj_3R_197()) return true;
39432 return false;
39433 }
39434
39435 private boolean jj_3R_499() {
39436 if (jj_scan_token(IS)) return true;
39437 Token xsp;
39438 while (true) {
39439 xsp = jj_scanpos;
39440 if (jj_scan_token(5)) { jj_scanpos = xsp; break; }
39441 }
39442 if (jj_3R_403()) return true;
39443 return false;
39444 }
39445
39446 private boolean jj_3R_376() {
39447 Token xsp;
39448 xsp = jj_scanpos;
39449 if (jj_scan_token(359)) {
39450 jj_scanpos = xsp;
39451 if (jj_scan_token(358)) {
39452 jj_scanpos = xsp;
39453 if (jj_scan_token(353)) {
39454 jj_scanpos = xsp;
39455 if (jj_scan_token(352)) {
39456 jj_scanpos = xsp;
39457 if (jj_scan_token(357)) {
39458 jj_scanpos = xsp;
39459 if (jj_scan_token(362)) return true;
39460 }
39461 }
39462 }
39463 }
39464 }
39465 return false;
39466 }
39467
39468 private boolean jj_3R_498() {
39469 if (jj_scan_token(RETURN)) return true;
39470 if (jj_3R_234()) return true;
39471 return false;
39472 }
39473
39474 private boolean jj_3R_497() {
39475 if (jj_3R_384()) return true;
39476 return false;
39477 }
39478
39479 private boolean jj_3R_197() {
39480 if (jj_scan_token(CURSOR)) return true;
39481 if (jj_3R_123()) return true;
39482 Token xsp;
39483 xsp = jj_scanpos;
39484 if (jj_3R_497()) jj_scanpos = xsp;
39485 xsp = jj_scanpos;
39486 if (jj_3R_498()) jj_scanpos = xsp;
39487 xsp = jj_scanpos;
39488 if (jj_3R_499()) jj_scanpos = xsp;
39489 if (jj_scan_token(4)) return true;
39490 return false;
39491 }
39492
39493 private boolean jj_3R_272() {
39494 if (jj_scan_token(DISASSOCIATE)) return true;
39495 if (jj_scan_token(STATISTICS)) return true;
39496 return false;
39497 }
39498
39499 private boolean jj_3_83() {
39500 if (jj_3R_123()) return true;
39501 if (jj_scan_token(3)) return true;
39502 return false;
39503 }
39504
39505 private boolean jj_3R_271() {
39506 if (jj_scan_token(ASSOCIATE)) return true;
39507 if (jj_scan_token(STATISTICS)) return true;
39508 return false;
39509 }
39510
39511 private boolean jj_3R_185() {
39512 Token xsp;
39513 xsp = jj_scanpos;
39514 if (jj_scan_token(47)) {
39515 jj_scanpos = xsp;
39516 if (jj_scan_token(342)) {
39517 jj_scanpos = xsp;
39518 if (jj_3R_271()) {
39519 jj_scanpos = xsp;
39520 if (jj_scan_token(344)) {
39521 jj_scanpos = xsp;
39522 if (jj_scan_token(75)) {
39523 jj_scanpos = xsp;
39524 if (jj_scan_token(83)) {
39525 jj_scanpos = xsp;
39526 if (jj_3R_272()) {
39527 jj_scanpos = xsp;
39528 if (jj_scan_token(99)) {
39529 jj_scanpos = xsp;
39530 if (jj_scan_token(129)) {
39531 jj_scanpos = xsp;
39532 if (jj_scan_token(355)) {
39533 jj_scanpos = xsp;
39534 if (jj_scan_token(231)) {
39535 jj_scanpos = xsp;
39536 if (jj_scan_token(238)) {
39537 jj_scanpos = xsp;
39538 if (jj_scan_token(363)) {
39539 jj_scanpos = xsp;
39540 if (jj_scan_token(348)) return true;
39541 }
39542 }
39543 }
39544 }
39545 }
39546 }
39547 }
39548 }
39549 }
39550 }
39551 }
39552 }
39553 }
39554 return false;
39555 }
39556
39557 private boolean jj_3R_560() {
39558 if (jj_3R_181()) return true;
39559 return false;
39560 }
39561
39562 private boolean jj_3R_624() {
39563 if (jj_3R_181()) return true;
39564 return false;
39565 }
39566
39567 private boolean jj_3R_559() {
39568 if (jj_3R_181()) return true;
39569 return false;
39570 }
39571
39572 private boolean jj_3R_423() {
39573 if (jj_scan_token(IDENTIFIER)) return true;
39574 return false;
39575 }
39576
39577 private boolean jj_3_78() {
39578 if (jj_3R_123()) return true;
39579 if (jj_scan_token(3)) return true;
39580 return false;
39581 }
39582
39583 private boolean jj_3_82() {
39584 if (jj_3R_121()) return true;
39585 return false;
39586 }
39587
39588 private boolean jj_3R_268() {
39589 if (jj_3R_266()) return true;
39590 return false;
39591 }
39592
39593 private boolean jj_3_81() {
39594 if (jj_3R_120()) return true;
39595 return false;
39596 }
39597
39598 private boolean jj_3_80() {
39599 if (jj_3R_151()) return true;
39600 return false;
39601 }
39602
39603 private boolean jj_3_79() {
39604 if (jj_3R_118()) return true;
39605 return false;
39606 }
39607
39608 private boolean jj_3R_175() {
39609 if (jj_3R_266()) return true;
39610 return false;
39611 }
39612
39613
39614 public PLSQLParserTokenManager token_source;
39615 SimpleCharStream jj_input_stream;
39616
39617 public Token token;
39618
39619 public Token jj_nt;
39620 private Token jj_scanpos, jj_lastpos;
39621 private int jj_la;
39622 private int jj_gen;
39623 final private int[] jj_la1 = new int[447];
39624 static private int[] jj_la1_0;
39625 static private int[] jj_la1_1;
39626 static private int[] jj_la1_2;
39627 static private int[] jj_la1_3;
39628 static private int[] jj_la1_4;
39629 static private int[] jj_la1_5;
39630 static private int[] jj_la1_6;
39631 static private int[] jj_la1_7;
39632 static private int[] jj_la1_8;
39633 static private int[] jj_la1_9;
39634 static private int[] jj_la1_10;
39635 static private int[] jj_la1_11;
39636 static private int[] jj_la1_12;
39637 static private int[] jj_la1_13;
39638 static {
39639 jj_la1_init_0();
39640 jj_la1_init_1();
39641 jj_la1_init_2();
39642 jj_la1_init_3();
39643 jj_la1_init_4();
39644 jj_la1_init_5();
39645 jj_la1_init_6();
39646 jj_la1_init_7();
39647 jj_la1_init_8();
39648 jj_la1_init_9();
39649 jj_la1_init_10();
39650 jj_la1_init_11();
39651 jj_la1_init_12();
39652 jj_la1_init_13();
39653 }
39654 private static void jj_la1_init_0() {
39655 jj_la1_0 = new int[] {0x20000c,0x0,0x0,0x2,0xc,0x200000,0x0,0x230020,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x230020,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20,0x8,0x0,0x8,0x0,0x0,0x40,0x0,0x0,0x8,0x40,0x8,0x0,0x0,0x0,0x0,0x230020,0x0,0x0,0x0,0x0,0x10,0x0,0x0,0x100,0x200,0x200,0x0,0x20,0x0,0x20,0x0,0x40,0x0,0x0,0x0,0x200,0x200,0x4,0x0,0x800,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x230020,0x230020,0x0,0x0,0x10,0x30020,0x230020,0x200000,0x30020,0x0,0x0,0x0,0x230020,0x230020,0x230020,0x230020,0x0,0x0,0x1000,0x230020,0x0,0x230020,0x0,0x230020,0x0,0x0,0x0,0x1000,0x30020,0x0,0x30020,0x0,0x0,0x0,0x0,0x0,0x30020,0x40,0x0,0x0,0x0,0x40,0x0,0x40,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x230020,0x0,0x230020,0x0,0x230020,0x0,0x20,0x20,0x0,0x0,0x0,0x40,0x40,0x0,0x20,0x0,0x0,0x0,0x40,0x20,0x0,0x0,0x0,0x200,0x200,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x20,0x0,0x20,0x0,0x30020,0x0,0x0,0x30020,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x20,0x0,0x0,0x8,0x0,0x0,0x2400,0x2400,0xc000,0x8000,0xc000,0x400,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc000,0x0,0x0,0x70000,0x70000,0x40000,0x180002,0x180002,0x30000,0x30020,0x20,0x20,0x20,0x40,0x0,0x0,0x20,0x30020,0x0,0x2c,0x0,0x0,0x0,0x808,0x8,0x30020,0x40,0x800000,0x0,0x0,0x0,0x40,0x30000,0x30000,0x40,0x0,0x0,0x40,0x0,0x0,0x40,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x40,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x20,0x12,0x0,0x0,0x12,0x0,0x12,0x0,0x0,0x0,0x0,0x0,0x12,0x0,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x230020,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x20,0x0,0x0,0x0,0x0,0x12,0x0,0x12,0x12,0x40,0x40,0x0,0x20,0x40,0x80,0x0,0x0,0x20,0x40,0x80,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x30000,0x30000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x230020,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,};
39656 }
39657 private static void jj_la1_init_1() {
39658 jj_la1_1 = new int[] {0x2008000,0x0,0x0,0x0,0x0,0x0,0x0,0x52e43c38,0x0,0x0,0x0,0x0,0x0,0x0,0x800000,0x30,0x800000,0x80000,0xfdfffff8,0x80000,0x0,0x0,0x0,0x0,0x0,0x80000,0x52e43c38,0x0,0x2000000,0xfdfffff8,0x80000,0x0,0x0,0xfdfffff8,0xfdfffff8,0xfdfffff8,0x0,0xfdfffff8,0xfdfffff8,0x0,0xfdfffff8,0xfdfffff8,0x0,0x0,0x0,0x0,0x800000,0x30,0x0,0x0,0x0,0x0,0x0,0xfdfffff8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x800000,0x2000,0x80000,0x52e43c38,0x0,0xfdfffff8,0xfffffff8,0x80000,0x882000,0x0,0x0,0x78e43c38,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfdfffff8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x50e43c38,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x28000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x52e43c38,0x52e43c38,0x0,0x0,0x0,0x52e43c38,0x52e43c38,0x0,0x50e43c38,0x0,0x0,0x0,0x52e43c38,0x52e43c38,0x52e43c38,0x52e43c38,0x0,0x0,0x0,0x52e43c38,0x0,0x52e43c38,0x0,0x52e43c38,0x0,0x0,0x0,0x0,0x50e43c38,0x0,0x50e43c38,0x50e43c38,0x0,0x50e43c38,0x0,0x50e43c38,0x50e43c38,0x0,0x0,0x0,0x40000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x52e43c38,0x0,0x52e43c38,0x0,0x52e43c38,0x0,0x0,0x0,0x0,0x80000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x78e43c38,0x0,0x0,0x0,0x0,0x0,0x0,0x400,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x50e43c38,0x0,0x0,0x50e43c38,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x50e43c38,0x0,0x200000,0x0,0x0,0x10000,0x0,0x0,0x4000000,0x0,0x0,0x0,0x0,0x0,0x0,0x4000000,0x0,0x4000,0x4000,0x4000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x50e43c38,0x50e43c38,0x50e43c38,0x50e43c38,0x0,0x0,0x50e43c38,0x0,0x50e43c38,0x0,0x200000,0x0,0x0,0x0,0x0,0x0,0x50e43c38,0x0,0x80000,0x0,0x0,0xfdfffff8,0x0,0x0,0x0,0x0,0x50e43ff8,0x0,0x0,0x20000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x50e43c38,0x50e43c38,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80000,0x0,0x52e43c38,0x0,0xfdfffff8,0xfffffff8,0x80000,0x0,0x0,0x0,0x0,0x0,0x30,0x800000,0x80000,0x80000,0x0,0x0,0x0,0x80000,0x0,0x80000,0x0,0xfdfffff8,0xfdfffff8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8000,0x0,0x8000,0x0,0x0,0x1000,0x0,0x1000,0x0,0x0,0x0,0x400000,0x400000,0x0,0x0,0x0,0x400000,0x400000,0x1000,0x30,0x800000,0x80000,0xfdfffff8,0x0,0xfdfffff8,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfdfffff8,0x0,0x0,0x0,0x3c0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8000,0x0,0x0,0x0,0x8000,0x0,0xfdfffff8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2000000,0x0,0x0,0x52e43c38,0x0,0x0,0xfdfffff8,0x0,0x0,0xfdfffff8,0x0,0x8000,0x0,0x8000,0xfdfffff8,0x8000,0x0,0x8000,0x841bc000,0x40e03c30,0xfdfffff8,0x50e43c38,0x79e43ff8,0x28840000,0x0,};
39659 }
39660 private static void jj_la1_init_2() {
39661 jj_la1_2 = new int[] {0x24085c00,0x20001000,0x20001000,0x0,0x4c00,0x0,0x4000000,0x27d71f47,0x0,0x0,0x0,0x0,0x0,0x80000,0x0,0x0,0x0,0x0,0x7fffffff,0x0,0x0,0x0,0x0,0x80000,0x0,0x0,0x27d71f47,0x0,0x0,0x7fffffff,0x0,0x0,0x490000,0x7fffffff,0x7fffffff,0x7fffffff,0x0,0x7fffffff,0x7fffffff,0x0,0x7fffffff,0x7fffffff,0x0,0x0,0x0,0x80000,0x80000000,0x0,0x0,0x0,0x0,0x0,0x80,0x7fffffff,0x0,0x80,0x80,0x0,0x0,0x0,0x0,0x80000000,0x0,0x0,0x27d71f47,0x0,0x7fffffff,0x7fffffff,0x0,0x80000000,0x0,0x0,0xbd71f5b,0x10000000,0x10000000,0x90000,0x0,0x0,0x0,0x0,0x0,0x7fffffff,0x0,0x0,0x10000000,0x10000000,0x0,0x0,0x0,0x0,0x2d71f43,0x0,0x0,0x0,0x0,0x8,0x1,0x8,0x0,0x9000018,0x0,0x0,0x8,0x1,0x0,0x0,0x1000000,0x0,0x2000000,0x2000000,0x0,0x2000000,0x0,0x0,0x0,0x27d71f47,0x27d71f47,0x0,0x20001000,0x0,0x7d71f47,0x27d71f47,0x0,0x3d71f47,0x0,0x0,0x0,0x27d71f47,0x27d71f47,0x27d71f47,0x27d71f47,0x0,0x0,0x0,0x27d71f47,0x0,0x27d71f47,0x0,0x27d71f47,0x0,0x0,0x0,0x0,0x3d71f47,0x0,0x3d71f47,0x2d71f43,0x0,0x2d71f43,0x0,0x2d71f43,0x3d71f47,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x27d71f47,0x0,0x27d71f47,0x0,0x27d71f47,0x0,0x0,0x0,0x0,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xbd71f5b,0x0,0x0,0x0,0x10000000,0x10000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3d71f47,0x0,0x0,0x3d71f47,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3d71f47,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3d71f47,0x3d71f47,0x3d71f47,0x3d71f47,0x0,0x1000000,0x2d71f43,0x0,0x3d71f47,0x0,0x0,0x1000000,0x0,0x0,0x0,0x0,0x3d71f47,0x0,0x0,0x0,0x0,0x7fffffff,0x0,0x0,0x0,0x0,0x2d71f43,0x0,0x0,0x0,0x80,0x0,0x80,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20000000,0x0,0x10000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2d71f43,0x2d75f43,0x0,0x0,0x0,0x400,0x0,0x0,0x0,0x0,0x0,0x0,0x10000,0x80000000,0x0,0x0,0x0,0x0,0x0,0x27d71f47,0x0,0x7fffffff,0x7fffffff,0x0,0x0,0x0,0x0,0x80000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7fffffff,0x7fffffff,0x0,0x10000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10000,0x10000,0x0,0x0,0x0,0x10000,0x10000,0x0,0x0,0x0,0x0,0x7fffffff,0x0,0x7fffffff,0x0,0x0,0x0,0x0,0x40000,0x0,0x40000,0x0,0x0,0x2,0x2,0x7fffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80000,0x0,0x20000000,0x0,0x20080800,0x0,0x20000000,0x0,0x20080800,0x0,0x7fffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4000000,0x0,0x0,0x27d71f47,0x0,0x0,0x7fffffff,0x0,0x480000,0x7fffffff,0x0,0x80800,0x0,0x80800,0x7fffffff,0x80800,0x0,0x80800,0x790860a8,0x2d71f43,0x7fffffff,0x2d71f43,0x2bf79f5b,0x9200008,0x0,};
39662 }
39663 private static void jj_la1_init_3() {
39664 jj_la1_3 = new int[] {0x20028008,0x0,0x0,0x0,0x28008,0x0,0x0,0xeefead31,0x1000,0x0,0x0,0x10,0x10,0x0,0x0,0x0,0x0,0x0,0xfffffdff,0x0,0x0,0x10,0x10,0x0,0x0,0x0,0xeefead31,0x1000,0x0,0xfffffdff,0x0,0x0,0x20800000,0xfffffdff,0xfffffdff,0xfffffdff,0x0,0xfffffdff,0xfffffdff,0x0,0xfffffdff,0xfffffdff,0x0,0x10,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfffffdff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xeefead31,0x1000,0xfffffdff,0xfffffdff,0x0,0x0,0x0,0x0,0x69be2d31,0x0,0x0,0x20800000,0x0,0x0,0x0,0x20000000,0x0,0xfffffdff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x68be2d31,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xeefead31,0xeefead31,0x0,0x8000,0x0,0xeefead31,0xeefead31,0x0,0x68be2d31,0x0,0x40,0x0,0xeefead31,0xeefead31,0xeefead31,0xeefead31,0x0,0x0,0x0,0xeefead31,0x0,0xeefead31,0x0,0xeefead31,0x80,0x40,0x0,0x0,0x68be2d31,0x0,0x68be2d31,0x68be2d31,0x0,0x68be2d31,0x0,0x68be2d31,0x68be2d31,0x0,0x0,0x2000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xeefead31,0x0,0xeefead31,0x0,0xeefead31,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x69be2d31,0x0,0x0,0x0,0x0,0x0,0x0,0x40000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x68be2d31,0x0,0x0,0x68be2d31,0x0,0x40,0x0,0x400,0x0,0x0,0x0,0x68be2d31,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10000000,0x0,0x0,0x0,0x0,0x0,0x0,0x10000000,0x800,0x2,0x2,0x10000000,0x0,0x400,0x0,0x0,0x0,0x0,0x0,0x0,0x68be2d31,0x68be2d31,0x68be2d31,0x68be2d31,0x0,0x200000,0x68be2d31,0x0,0x68be2d31,0x0,0x0,0x200000,0x200000,0x0,0x0,0x0,0x68be2d31,0x0,0x0,0x0,0x0,0xfffffdff,0x0,0x0,0x0,0x0,0x68be2d31,0x0,0x0,0x0,0x0,0x0,0x0,0x20000000,0x20000000,0x0,0x20000000,0x20000000,0x40000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x68be2d31,0x68be2d31,0x0,0x0,0x0,0x0,0x0,0x800000,0x0,0x800000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xeefead31,0x1000,0xfffffdff,0xfffffdff,0x0,0x0,0x10,0x10,0x0,0x8000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfffffdff,0xfffffdff,0x0,0x800000,0x0,0x0,0x800000,0x0,0x800000,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x800020,0x800020,0x0,0x0,0x0,0x800000,0x800000,0x8,0x0,0x0,0x0,0xfffffdff,0x0,0xfffffdff,0x0,0x800000,0x0,0x800000,0x0,0x0,0x0,0x8000000,0x8002000,0x0,0x0,0xfffffdff,0x0,0x0,0x0,0x0,0x0,0x10,0x10,0x0,0x2000000,0x0,0x0,0x8,0x0,0x0,0x0,0x8,0x0,0xfffffdff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x101,0x101,0x0,0x0,0x0,0x0,0xeefead31,0x0,0x0,0xfffffdff,0x0,0x20000000,0xfffffdff,0x0,0x8,0x0,0x8,0xfffffdff,0x8,0x0,0x8,0x1301404a,0x68be2d31,0xfffffdff,0x68be2d31,0x6dbfadb5,0x1000000,0x0,};
39665 }
39666 private static void jj_la1_init_4() {
39667 jj_la1_4 = new int[] {0x40008002,0x40008000,0x40008000,0x0,0x2,0x0,0x0,0x5751e9b4,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x800000,0xffffefbd,0x800000,0x0,0x0,0x0,0x0,0x0,0x800000,0x5751e9b4,0x0,0x0,0xffffefbd,0x800000,0x0,0x10000,0xffffefbd,0xffffefbd,0xffffefbd,0x0,0xffffefbd,0xffffefbd,0x0,0xffffefbd,0xffffefbd,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffefbd,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x800000,0x5751e9b4,0x0,0xffffefbd,0xffffefbd,0x800000,0x800000,0x200,0x200,0x97536934,0x0,0x0,0x10000,0x0,0x0,0x0,0x0,0x0,0xffffefbd,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x17516934,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80000000,0x80020000,0x0,0x0,0x0,0x0,0x0,0x0,0x100000,0x0,0x20,0x20,0x0,0x20,0x0,0x0,0x0,0x5751e9b4,0x5751e9b4,0x0,0x40008000,0x0,0x175169b4,0x5751e9b4,0x0,0x17516934,0x0,0x0,0x0,0x5751e9b4,0x5751e9b4,0x5751e9b4,0x5751e9b4,0x0,0x0,0x0,0x5751e9b4,0x0,0x5751e9b4,0x0,0x5751e9b4,0x0,0x0,0x800,0x0,0x17516934,0x0,0x17516934,0x17516934,0x0,0x17516934,0x0,0x17516934,0x17516934,0x0,0x0,0x0,0x0,0x0,0x10000000,0x0,0x200000,0x0,0x200,0x200,0x0,0x0,0x200,0x200,0x0,0x0,0x0,0x0,0x5751e9b4,0x0,0x5751e9b4,0x0,0x5751e9b4,0x0,0x0,0x0,0x0,0x800000,0x0,0x0,0x0,0x0,0x0,0x0,0x400,0x0,0x0,0x97536934,0x0,0x0,0x0,0x0,0x0,0x2000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x800000,0x17516934,0x0,0x0,0x17516934,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x17516934,0x0,0x0,0x0,0x0,0x0,0x800000,0x800000,0x8000200,0x0,0x0,0x0,0x0,0x0,0x0,0x8000200,0x80000,0x0,0x0,0x8000200,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x17516934,0x17516934,0x17516934,0x17516934,0x0,0x100000,0x17516934,0x0,0x17516934,0x0,0x0,0x100000,0x0,0x0,0x0,0x0,0x17516934,0x0,0x0,0x0,0x0,0xffffefbd,0x0,0x0,0x0,0x0,0x17556934,0x4,0x0,0x4,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x17516934,0x17516934,0x0,0x0,0x2000,0x2000,0x0,0x10000,0x0,0x10000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x800000,0x0,0x5751e9b4,0x0,0xffffefbd,0xffffefbd,0x800000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x800000,0x800000,0x0,0x0,0x0,0x800000,0x0,0x800000,0x0,0xffffefbd,0xffffefbd,0x0,0x10000,0x0,0x0,0x10000,0x0,0x10000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10010000,0x10010000,0x0,0x0,0x0,0x10000,0x10000,0x0,0x0,0x0,0x800000,0xffffefbd,0x0,0xffffefbd,0x0,0x10000,0x0,0x10000,0x1000,0x0,0x1000,0x0,0x0,0x400000,0x400000,0xffffefbd,0x0,0x0,0x0,0x40000,0x0,0x0,0x0,0x0,0x0,0x8000,0x0,0x8002,0x0,0x8000,0x0,0x8002,0x0,0xffffefbd,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x5751e9b4,0x0,0x0,0xffffefbd,0x0,0x0,0xffffefbd,0x0,0x2,0x0,0x2,0xffffefbd,0x2,0x0,0x2,0xc8aa864b,0x17516934,0xffffefbd,0x17516934,0x97576934,0x80120020,0x0,};
39668 }
39669 private static void jj_la1_init_5() {
39670 jj_la1_5 = new int[] {0x10,0x10,0x10,0x0,0x0,0x0,0x0,0x365b7bf,0x0,0x0,0x0,0x200000,0x200000,0x0,0x0,0x0,0x0,0x0,0xfff6ffff,0x0,0x0,0x200000,0x200000,0x0,0x0,0x0,0x365b7bf,0x0,0x0,0xfff6ffff,0x0,0x0,0x40000a,0xfff6ffff,0xfff6ffff,0xfff6ffff,0x0,0xfff6ffff,0xfff6ffff,0x0,0xfff6ffff,0xfff6ffff,0x0,0x200000,0x200000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfff6ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x365b7bf,0x0,0xfff6ffff,0xfff6ffff,0x0,0x0,0x0,0x0,0xfe24f7bf,0x0,0x0,0x40000a,0x0,0x0,0x0,0x0,0x0,0xfff6ffff,0x400000,0x1400000,0x0,0x0,0x0,0x0,0x0,0x0,0x224b7bf,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfc006000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1080,0x1080,0x0,0x1080,0x0,0x0,0x0,0x365b7bf,0x365b7bf,0x0,0x10,0x0,0x365b7bf,0x365b7bf,0x0,0x365b7bf,0x0,0x0,0x0,0x365b7bf,0x365b7bf,0x365b7bf,0x365b7bf,0x0,0x0,0x0,0x365b7bf,0x0,0x365b7bf,0x0,0x365b7bf,0x0,0x0,0x0,0x0,0x365b7bf,0x0,0x365b7bf,0x224b7bf,0x0,0x224b7bf,0x0,0x224b7bf,0x365b7bf,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x365b7bf,0x0,0x365b7bf,0x0,0x365b7bf,0x0,0x0,0x0,0x400000,0x0,0xf8000000,0x0,0x0,0x0,0x0,0x400000,0x0,0x0,0x0,0xfe24f7bf,0x0,0x400000,0x1400000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x365b7bf,0x0,0x0,0x365b7bf,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x325b7bf,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x400008,0x0,0x0,0x0,0x400000,0x8,0x0,0x8,0x0,0x0,0x0,0x400008,0x0,0x0,0x0,0x0,0x0,0x400,0x400,0x0,0x365b7bf,0x365b7bf,0x324b7bf,0x325b7bf,0x0,0x1000000,0x224b7bf,0x0,0x365b7bf,0x0,0x0,0x1000000,0x0,0x0,0x0,0x0,0x365b7bf,0x0,0x0,0x0,0x0,0xfff6ffff,0x0,0x0,0x0,0x0,0x224b7bf,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x400000,0x1400000,0x0,0x40000,0x40000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x224b7bf,0x224b7bf,0x0,0x0,0x0,0x0,0x0,0x400000,0x400000,0x0,0x2,0x2,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x365b7bf,0x0,0xfff6ffff,0xfff6ffff,0x0,0x0,0x200000,0x200000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfff6ffff,0xfff6ffff,0x0,0x40000a,0x0,0x0,0x1400000,0x400000,0x1000000,0x0,0x0,0x0,0x0,0x0,0x200,0x0,0x200,0x0,0x0,0x0,0x40000a,0x40000a,0x0,0x0,0x0,0x40000a,0x40000a,0x200,0x0,0x0,0x0,0xfff6ffff,0x0,0xfff6ffff,0x0,0x1400000,0x400000,0x1000000,0x400000,0x400000,0x400000,0x0,0x0,0x0,0x0,0xfff6ffff,0x0,0x0,0x0,0x0,0x0,0x200000,0x200000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfff6ffff,0x8000,0x8000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x365b7bf,0x0,0x0,0xfff6ffff,0x0,0x0,0xfff6ffff,0x0,0x0,0x0,0x0,0xfff6ffff,0x0,0x0,0x0,0x5c80840,0x224b3be,0xfff6ffff,0x224b7bf,0xfe36f7bf,0xfc007100,0x0,};
39671 }
39672 private static void jj_la1_init_6() {
39673 jj_la1_6 = new int[] {0x28008000,0x0,0x0,0x0,0x8000000,0x0,0x0,0xb30ad8e9,0x0,0x0,0x200,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfee6ffff,0x0,0x200,0x0,0x0,0x0,0x8000,0x0,0xb30ad8e9,0x0,0x0,0xfee6ffff,0x0,0x1000000,0x20004400,0xffe6ffff,0xffe6ffff,0xffe6ffff,0x0,0xffe6ffff,0xffe6ffff,0x0,0xffe6ffff,0xffe6ffff,0x200,0x0,0x0,0x0,0x110000,0x0,0x0,0x0,0x0,0x0,0x400,0xfee6ffff,0x0,0x400,0x400,0x0,0x0,0x0,0x0,0x110000,0x0,0x0,0xb30ad8e9,0x0,0xfee6ffff,0xffe6ffff,0x0,0x110000,0x2000,0x0,0x32e2d8e9,0x0,0x0,0x20004400,0x0,0x0,0x0,0x20000000,0x0,0xfee6ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3202d8e9,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xe00000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x200,0xb30ad8e9,0xb30ad8e9,0x0,0x0,0x0,0xb30ad8e9,0xb30ad8e9,0x0,0x3202d8e9,0x0,0x0,0x0,0xb30ad8e9,0xb30ad8e9,0xb30ad8e9,0xb30ad8e9,0x0,0x0,0x0,0xb30ad8e9,0x0,0xb30ad8e9,0x0,0xb30ad8e9,0x0,0x0,0x0,0x0,0x3202d8e9,0x0,0x3202d8e9,0x3202d8e9,0x0,0x3202d8e9,0x0,0x3202d8e9,0x3202d8e9,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2000,0x2000,0x2000,0x0,0x2000,0x2000,0x2000,0x0,0x0,0x0,0x0,0xb30ad8e9,0x0,0xb30ad8e9,0x0,0xb30ad8e9,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x32e2d8e9,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3202d8e9,0x0,0x0,0x3202d8e9,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3202d8e9,0x0,0x0,0x0,0x200,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3202d8e9,0x3202d8e9,0x3202d8e9,0x3202d8e9,0x0,0x0,0x3202d8e9,0x0,0x3202d8e9,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3202d8e9,0x0,0x0,0x0,0x0,0xfee6ffff,0x0,0x0,0x0,0x0,0x3202d8e9,0x0,0x0,0x0,0x400,0x0,0x400,0x20008000,0x20008000,0x0,0x20008000,0x20008000,0x0,0x0,0x2000000,0x0,0x0,0x0,0x0,0x200,0x0,0x0,0x0,0x0,0x0,0x200,0x40000000,0x0,0x200,0x0,0x0,0x40000000,0x3202d8e9,0x3202d8e9,0x0,0x0,0x80,0x80,0x0,0x4000,0x0,0x4000,0x400,0x400,0x0,0x0,0x10000,0x100000,0x0,0x0,0x0,0xb30ad8e9,0x0,0xfee6ffff,0xffe6ffff,0x0,0x200,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffe6ffff,0xffe6ffff,0x0,0x4400,0x1000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4400,0x4400,0x0,0x0,0x0,0x4400,0x4400,0x0,0x0,0x0,0x0,0xfee6ffff,0x0,0xfee6ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfee6ffff,0x0,0x0,0x0,0x0,0x200,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x200,0x0,0x0,0x0,0x0,0xfee6ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xb30ad8e9,0x0,0x0,0xffe6ffff,0x1000000,0x20000000,0xfee6ffff,0x0,0x0,0x200,0x0,0xfee6ffff,0x0,0x0,0x0,0x44040714,0x2202d869,0xfee6ffff,0x3202d8e9,0xbfe2f8eb,0xe00002,0x0,};
39674 }
39675 private static void jj_la1_init_7() {
39676 jj_la1_7 = new int[] {0x940c080,0x1408000,0x1408000,0x0,0x8004000,0x0,0x0,0x8befbaff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xefffbaff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8befbaff,0x0,0x0,0xefffbaff,0x0,0x0,0x0,0xefffbaff,0xefffbaff,0xefffbaff,0x0,0xefffbaff,0xefffbaff,0x0,0xefffbaff,0xefffbaff,0x0,0x0,0x0,0x0,0x400,0x0,0x0,0x0,0x0,0x0,0x0,0xefffbaff,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x400,0x0,0x0,0x8befbaff,0x0,0xefffbaff,0xefffbaff,0x0,0x400,0x0,0x0,0xcaefbaff,0x0,0x0,0x0,0x0,0x800,0x0,0x0,0x0,0xefffbaff,0x0,0x0,0x0,0x0,0x0,0x100000,0x0,0x0,0x8aefbaff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40002,0x40040016,0x2000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x800000,0x800000,0x0,0x800000,0x0,0x0,0x0,0x8befbaff,0x8befbaff,0x0,0x9408000,0x0,0x8befbaff,0x8befbaff,0x0,0x8befbaff,0x0,0x0,0x0,0x8befbaff,0x8befbaff,0x8befbaff,0x8befbaff,0x0,0x2000,0x0,0x8befbaff,0x0,0x8befbaff,0x0,0x8befbaff,0x0,0x0,0x0,0x0,0x8befbaff,0x200000,0x8befbaff,0x8aefbaff,0x0,0x8aefbaff,0x0,0x8aefbaff,0x8befbaff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1800,0x0,0x1800,0x8befbaff,0x0,0x8befbaff,0x0,0x8befbaff,0x0,0x1,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x800,0x0,0xcaefbaff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x800,0x0,0x0,0x8befbaff,0x0,0x0,0x8befbaff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8befbaff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8befbaff,0x8befbaff,0x8befbaff,0x8befbaff,0x0,0x0,0x8aefbaff,0x0,0x8befbaff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8befbaff,0x0,0x0,0x0,0x0,0xefffbaff,0x0,0x0,0x0,0x0,0x8aefbaff,0x1,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8aefbaff,0x8aefbaff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x400,0x0,0x0,0x8befbaff,0x0,0xefffbaff,0xefffbaff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xefffbaff,0xefffbaff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xefffbaff,0x0,0xefffbaff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xefffbaff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4080,0x0,0x0,0x0,0x4080,0x0,0xefffbaff,0x0,0x0,0x0,0x0,0x2000,0x2000,0x2000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8befbaff,0x0,0x0,0xefffbaff,0x0,0x0,0xefffbaff,0x0,0x4080,0x0,0x4080,0xefffbaff,0x4080,0x0,0x4080,0x79004102,0x8aefbafd,0xefffbaff,0x8aefbaff,0xceffbaff,0x489d001e,0x0,};
39677 }
39678 private static void jj_la1_init_8() {
39679 jj_la1_8 = new int[] {0x5000008,0x0,0x0,0x0,0x8,0x0,0x0,0x56bf59d7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x5fffffff,0x0,0x0,0x0,0x0,0x0,0x4000000,0x0,0x56bf59d7,0x0,0x0,0x5fffffff,0x0,0x0,0x10,0x5fffffff,0x5fffffff,0x5fffffff,0x0,0x5fffffff,0x5fffffff,0x0,0x5fffffff,0x5fffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40000000,0x0,0x0,0x5fffffff,0x0,0x40000000,0x40000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x56bf59d7,0x0,0x5fffffff,0x5fffffff,0x0,0x0,0x0,0x0,0x56bf59d7,0x0,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x5fffffff,0x0,0x0,0x0,0x0,0x0,0x4000000,0x0,0x0,0x56bf59d7,0x0,0x0,0x2000,0x0,0x0,0x0,0x0,0x0,0x1000,0x30000,0x0,0x0,0x0,0x0,0x400000,0x20000,0x0,0x0,0x0,0x0,0x0,0x400000,0x400000,0x0,0x56bf59d7,0x56bf59d7,0x0,0x0,0x0,0x56bf59d7,0x56bf59d7,0x0,0x56bf59d7,0x0,0x0,0x0,0x56bf59d7,0x56bf59d7,0x56bf59d7,0x56bf59d7,0x0,0x0,0x0,0x56bf59d7,0x0,0x56bf59d7,0x0,0x56bf59d7,0x0,0x0,0x80000000,0x0,0xd6bf59d7,0x0,0x56bf59d7,0x56bf59d7,0x0,0x56bf59d7,0x0,0x56bf59d7,0x56bf59d7,0x0,0x40000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40000000,0x0,0x0,0x0,0x56bf59d7,0x0,0x56bf59d7,0x0,0x56bf59d7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2000,0x0,0x0,0x0,0x0,0x0,0x56bf79d7,0x4000040,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x56bf59d7,0x0,0x0,0x56bf59d7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x56bf59d7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x56bf59d7,0x56bf59d7,0x56bf59d7,0x56bf59d7,0x0,0x2020000,0x56bf59d7,0x0,0x56bf59d7,0x10000,0x0,0x2020000,0x2000000,0x0,0x0,0x0,0x56bf59d7,0x0,0x0,0x0,0x40000000,0x5fffffff,0x0,0x0,0x0,0x0,0x56bf59d7,0x0,0x0,0x0,0x0,0x0,0x0,0x5000000,0x5000000,0x0,0x5000000,0x5000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x56bf59d7,0x56bf59d7,0x40000000,0x0,0x2000,0x2000,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x56bf59d7,0x0,0x5fffffff,0x5fffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10000000,0x10000000,0x0,0x5fffffff,0x5fffffff,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x10,0x0,0x0,0x0,0x10,0x10,0x0,0x0,0x0,0x0,0x5fffffff,0x0,0x5fffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x5fffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x5fffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x56bf59d7,0x0,0x0,0x5fffffff,0x0,0x0,0x5fffffff,0x0,0x0,0x0,0x0,0x5fffffff,0x0,0x0,0x0,0xa140a408,0x52bf51d0,0x5fffffff,0x56bf59d7,0x5fbf5ff6,0x3f2000,0x0,};
39680 }
39681 private static void jj_la1_init_9() {
39682 jj_la1_9 = new int[] {0x100000b0,0x10000080,0x10000080,0x0,0x30,0x0,0x0,0xffff7cdc,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffdc,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffff7cdc,0x0,0x0,0xffffffdc,0x0,0x0,0x0,0xffffffdc,0xffffffdc,0xffffffdc,0x0,0xffffffdc,0xffffffdc,0x0,0xffffffdc,0xffffffdc,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffdc,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffff7cdc,0x0,0xffffffdc,0xffffffdc,0x0,0x0,0x0,0x0,0xefffff58,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffdc,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xefff7c58,0x0,0x0,0x300000,0x0,0x0,0x0,0x40000000,0x30f0300,0x43cfef00,0x0,0x0,0x0,0x0,0x40000000,0x50000000,0x0,0x0,0x4000000,0x4000000,0x8000000,0x4000000,0x10000000,0x10000000,0x0,0xffff7cdc,0xffff7cdc,0x1,0x10000080,0x0,0xffff7c5c,0xffff7cdc,0x0,0xffff7c58,0x1,0x0,0x0,0xffff7cdc,0xffff7cdc,0xffff7cdc,0xffff7cdc,0x0,0x0,0x0,0xffff7cdc,0x0,0xffff7cdc,0x0,0xffff7cdc,0x0,0x0,0x0,0x0,0xffff7c58,0x0,0xffff7c58,0xefff7c58,0x1,0xefff7c58,0x1,0xefff7c58,0xffff7c58,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffff7cdc,0x0,0xffff7cdc,0x0,0xffff7cdc,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x300000,0x0,0x0,0x0,0x0,0x0,0xefffff58,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10000000,0x0,0x0,0x0,0x0,0x10000000,0x0,0x0,0x0,0x0,0xffff7c58,0x0,0x0,0xffff7c58,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0xffff7c58,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffff7c58,0xffff7c58,0xffff7c58,0xffff7c58,0x0,0x0,0xefff7c58,0x0,0xffff7c58,0x8000000,0x0,0x0,0x0,0x40,0x0,0x0,0xffff7c58,0x0,0x0,0x0,0x0,0xffffffdc,0x0,0x0,0x0,0x0,0xefff7c58,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xefff7c58,0xefff7c58,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffff7cdc,0x0,0xffffffdc,0xffffffdc,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffdc,0xffffffdc,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffdc,0x0,0xffffffdc,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffdc,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80000000,0x80,0x0,0x80,0x0,0x80,0x0,0x80,0x0,0xffffffdc,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x80000000,0x0,0xffff7cdc,0x80000000,0x0,0xffffffdc,0x80000000,0x0,0xffffffdc,0x80000000,0x0,0x0,0x0,0xffffffdc,0x0,0x0,0x0,0x10000382,0xeffb5c58,0xffffffdc,0xefff7c58,0xefffff5c,0x7fdfff00,0x0,};
39683 }
39684 private static void jj_la1_init_10() {
39685 jj_la1_10 = new int[] {0x31c00000,0x0,0x0,0x0,0x0,0x0,0x0,0xffc02131,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffc00031,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffc02131,0x0,0x0,0xffc00031,0x0,0x0,0x100,0xffc00131,0xffc02131,0xffc02131,0x800,0xffc02131,0xffc02131,0x400,0xffc02131,0xffc02131,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffc00031,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffc02131,0x0,0xffc00031,0xffc00131,0x0,0x0,0x0,0x0,0xffc00131,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffc00031,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x100,0xffc00031,0x800,0x400,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffc02131,0xffc02131,0x0,0x0,0x0,0xffc02131,0xffc02131,0x0,0xffc00131,0x0,0x0,0x0,0xffc02131,0xffc02131,0xffc02131,0xffc02131,0x0,0x0,0x0,0xffc02131,0x0,0xffc02131,0x0,0xffc02131,0x0,0x0,0x0,0x0,0xffc00131,0x0,0xffc00131,0xffc00031,0x0,0xffc00031,0x0,0xffc00031,0xffc00131,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffc02131,0x800,0xffc02131,0x400,0xffc02131,0x2100,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffc00131,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffc00131,0x800,0x400,0xffc00131,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffc00031,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffc00031,0xffc00031,0xffc00031,0xffc00031,0x0,0x0,0xffc00031,0x0,0xffc00131,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffc00131,0x0,0x0,0x0,0x0,0xffc00031,0x0,0x0,0x0,0x0,0xffc00031,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffc00031,0xffc00031,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffc02131,0x0,0xffc00031,0xffc00131,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffc00031,0xffc00031,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffc00031,0x0,0xffc00031,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffc00031,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3,0x0,0x0,0x31c00000,0x0,0x0,0x0,0x31c00000,0x4000000,0xffc00031,0x30,0x30,0x8,0x4,0x0,0x0,0x0,0x80000000,0x0,0x80000000,0x0,0x0,0x0,0xa000000,0x3,0x40000000,0xffc02131,0x3,0x40000000,0xffc00033,0x3,0x0,0xffc00031,0x1,0x31c00000,0x0,0x31c00000,0xffc00031,0x31c00000,0x0,0x31c00000,0xc0,0xffc00031,0xffc00031,0xffc00031,0xffc00031,0x0,0x0,};
39686 }
39687 private static void jj_la1_init_11() {
39688 jj_la1_11 = new int[] {0xfe800808,0x0,0x0,0x0,0xfe800000,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x1000000,0x0,0x1000000,0x0,0xffffffff,0x1000,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0xffffffff,0x1000,0x0,0x0,0xffffffff,0xffffffff,0xffffffff,0x0,0xffffffff,0xffffffff,0x0,0xffffffff,0xffffffff,0x0,0x0,0x0,0x0,0x1000000,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1000000,0x0,0x0,0xffffffff,0x0,0xffffffff,0xffffffff,0x0,0x1001000,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0xffffffff,0x0,0x0,0x0,0xffffffff,0xffffffff,0x0,0xffffffff,0x0,0x0,0x0,0xffffffff,0xffffffff,0xffffffff,0xffffffff,0x0,0x0,0x0,0xffffffff,0x0,0xffffffff,0x0,0xffffffff,0x0,0x0,0x0,0x0,0xffffffff,0x0,0xffffffff,0xffffffff,0x0,0xffffffff,0x0,0xffffffff,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0xffffffff,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x26000,0x0,0x0,0x0,0x0,0x26000,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0xffffffff,0xffffffff,0xffffffff,0x0,0x0,0xffffffff,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0xffffffff,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1000,0xffffffff,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1000000,0x0,0xffffffff,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xceb,0x0,0x0,0x0,0xceb,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x100,0xffffffff,0x0,0x100,0xffffffff,0x0,0x0,0xffffffff,0x0,0xceb,0x0,0xceb,0xffffffff,0x808,0x4e3,0xceb,0x0,0xffffffff,0xffffffff,0xffffffff,0xffffffff,0x1000000,0x0,};
39689 }
39690 private static void jj_la1_init_12() {
39691 jj_la1_12 = new int[] {0x7,0x0,0x0,0x0,0x7,0x0,0x0,0x7f1ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7f1ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7f1ffff,0x0,0x0,0x7f1ffff,0x0,0x0,0x0,0x7f1ffff,0x7f1ffff,0x7f1ffff,0x0,0x7f1ffff,0x7f1ffff,0x0,0x7f1ffff,0x7f1ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7f1ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7f1ffff,0x0,0x7f1ffff,0x7f1ffff,0x0,0x0,0x0,0x0,0x7f1ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7f1ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7f1ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7f1ffff,0x7f1ffff,0x0,0x0,0x0,0x7f1ffff,0x7f1ffff,0x0,0x7f1ffff,0x0,0x0,0x0,0x7f1ffff,0x7f1ffff,0x7f1ffff,0x7f1ffff,0x0,0x0,0x0,0x7f1ffff,0x0,0x7f1ffff,0x0,0x7f1ffff,0x0,0x0,0x0,0x0,0x7f1ffff,0x0,0x7f1ffff,0x7f1ffff,0x0,0x7f1ffff,0x0,0x7f1ffff,0x7f1ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7f1ffff,0x0,0x7f1ffff,0x0,0x7f1ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7f1ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7f1ffff,0x0,0x0,0x7f1ffff,0x0,0x0,0x0,0x0,0x0,0x6200,0x6200,0x7f1ffff,0x30,0x0,0x0,0x0,0x0,0x0,0x0,0x1800,0x0,0x0,0x0,0x0,0x1000,0x0,0x1000,0x0,0x0,0x0,0x1800,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7f1ffff,0x7f1ffff,0x7f1ffff,0x7f1ffff,0x0,0x0,0x7f1ffff,0x0,0x7f1ffff,0x0,0x0,0x0,0x0,0x400,0x0,0x0,0x7f1ffff,0x0,0x0,0x18000,0x0,0x7f1ffff,0x0,0x0,0x0,0x0,0x7f1ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1000000,0x0,0x7f1ffff,0x7f1ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7f1ffff,0x0,0x7f1ffff,0x7f1ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7f1ffff,0x7f1ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7f1ffff,0x0,0x7f1ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7f1ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7f1ffff,0x0,0x0,0x0,0x0,0x40000,0x40000,0xc0000,0x20000,0x0,0x20000,0x0,0x0,0x0,0x0,0x0,0x0,0x7f1ffff,0x0,0x0,0x7f1ffff,0x0,0x0,0x7f1ffff,0x0,0x0,0x0,0x0,0x7f1ffff,0x0,0x0,0x0,0x0,0x7f1ffff,0x7f1ffff,0x7f1ffff,0x7f1ffff,0x0,0x0,};
39692 }
39693 private static void jj_la1_init_13() {
39694 jj_la1_13 = new int[] {0x4,0x0,0x0,0x0,0x4,0x0,0x0,0x58c,0x0,0x4,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7c04,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x58c,0x0,0x0,0x7c04,0x0,0x0,0x4,0x7c04,0x7c04,0x7c04,0x0,0x7c04,0x7c04,0x0,0x7c04,0x7c04,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7c04,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x58c,0x0,0x7c04,0x7c04,0x0,0x0,0x0,0x0,0x404,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7c04,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x404,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x180,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x58c,0x58c,0x0,0x0,0x0,0x58c,0x58c,0x0,0x58c,0x0,0x0,0x4,0x58c,0x58c,0x58c,0x58c,0x4,0x0,0x0,0x58c,0x4,0x58c,0x4,0x58c,0x0,0x0,0x0,0x0,0x58c,0x0,0x58c,0x404,0x0,0x404,0x0,0x404,0x58c,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x58c,0x0,0x58c,0x0,0x58c,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x404,0x0,0x0,0x0,0x0,0x0,0x4,0x0,0x0,0x504,0x504,0x0,0x504,0x0,0x0,0x0,0x0,0x0,0x58c,0x0,0x0,0x58c,0x0,0x0,0x180,0x0,0x0,0x0,0x0,0x58c,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x180,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x58c,0x58c,0x58c,0x58c,0x0,0x188,0x404,0x0,0x58c,0x0,0x0,0x188,0x0,0x0,0x0,0x0,0x58c,0x0,0x0,0x0,0x0,0x7d04,0x0,0x0,0x0,0x0,0x404,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x404,0x404,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x58c,0x0,0x7c04,0x7c04,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x504,0x504,0x0,0x0,0x0,0x0,0x0,0x7c04,0x7c04,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7c04,0x0,0x7c04,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7d04,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7c04,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x58c,0x0,0x0,0x7c04,0x0,0x4,0x7c04,0x0,0x0,0x0,0x0,0x7c04,0x0,0x0,0x0,0x0,0x0,0x7c04,0x404,0x404,0x7800,0x3800,};
39695 }
39696 final private JJCalls[] jj_2_rtns = new JJCalls[83];
39697 private boolean jj_rescan = false;
39698 private int jj_gc = 0;
39699
39700
39701 public PLSQLParser(java.io.InputStream stream) {
39702 this(stream, null);
39703 }
39704
39705 public PLSQLParser(java.io.InputStream stream, String encoding) {
39706 try { jj_input_stream = new SimpleCharStream(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
39707 token_source = new PLSQLParserTokenManager(jj_input_stream);
39708 token = new Token();
39709 token.next = jj_nt = token_source.getNextToken();
39710 jj_gen = 0;
39711 for (int i = 0; i < 447; i++) jj_la1[i] = -1;
39712 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
39713 }
39714
39715
39716 public void ReInit(java.io.InputStream stream) {
39717 ReInit(stream, null);
39718 }
39719
39720 public void ReInit(java.io.InputStream stream, String encoding) {
39721 try { jj_input_stream.ReInit(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
39722 token_source.ReInit(jj_input_stream);
39723 token = new Token();
39724 token.next = jj_nt = token_source.getNextToken();
39725 jjtree.reset();
39726 jj_gen = 0;
39727 for (int i = 0; i < 447; i++) jj_la1[i] = -1;
39728 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
39729 }
39730
39731
39732 public PLSQLParser(java.io.Reader stream) {
39733 jj_input_stream = new SimpleCharStream(stream, 1, 1);
39734 token_source = new PLSQLParserTokenManager(jj_input_stream);
39735 token = new Token();
39736 token.next = jj_nt = token_source.getNextToken();
39737 jj_gen = 0;
39738 for (int i = 0; i < 447; i++) jj_la1[i] = -1;
39739 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
39740 }
39741
39742
39743 public void ReInit(java.io.Reader stream) {
39744 jj_input_stream.ReInit(stream, 1, 1);
39745 token_source.ReInit(jj_input_stream);
39746 token = new Token();
39747 token.next = jj_nt = token_source.getNextToken();
39748 jjtree.reset();
39749 jj_gen = 0;
39750 for (int i = 0; i < 447; i++) jj_la1[i] = -1;
39751 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
39752 }
39753
39754
39755 public PLSQLParser(PLSQLParserTokenManager tm) {
39756 token_source = tm;
39757 token = new Token();
39758 token.next = jj_nt = token_source.getNextToken();
39759 jj_gen = 0;
39760 for (int i = 0; i < 447; i++) jj_la1[i] = -1;
39761 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
39762 }
39763
39764
39765 public void ReInit(PLSQLParserTokenManager tm) {
39766 token_source = tm;
39767 token = new Token();
39768 token.next = jj_nt = token_source.getNextToken();
39769 jjtree.reset();
39770 jj_gen = 0;
39771 for (int i = 0; i < 447; i++) jj_la1[i] = -1;
39772 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
39773 }
39774
39775 private Token jj_consume_token(int kind) throws ParseException {
39776 Token oldToken = token;
39777 if ((token = jj_nt).next != null) jj_nt = jj_nt.next;
39778 else jj_nt = jj_nt.next = token_source.getNextToken();
39779 if (token.kind == kind) {
39780 jj_gen++;
39781 if (++jj_gc > 100) {
39782 jj_gc = 0;
39783 for (int i = 0; i < jj_2_rtns.length; i++) {
39784 JJCalls c = jj_2_rtns[i];
39785 while (c != null) {
39786 if (c.gen < jj_gen) c.first = null;
39787 c = c.next;
39788 }
39789 }
39790 }
39791 return token;
39792 }
39793 jj_nt = token;
39794 token = oldToken;
39795 jj_kind = kind;
39796 throw generateParseException();
39797 }
39798
39799 static private final class LookaheadSuccess extends java.lang.Error { }
39800 final private LookaheadSuccess jj_ls = new LookaheadSuccess();
39801 private boolean jj_scan_token(int kind) {
39802 if (jj_scanpos == jj_lastpos) {
39803 jj_la--;
39804 if (jj_scanpos.next == null) {
39805 jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
39806 } else {
39807 jj_lastpos = jj_scanpos = jj_scanpos.next;
39808 }
39809 } else {
39810 jj_scanpos = jj_scanpos.next;
39811 }
39812 if (jj_rescan) {
39813 int i = 0; Token tok = token;
39814 while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
39815 if (tok != null) jj_add_error_token(kind, i);
39816 }
39817 if (jj_scanpos.kind != kind) return true;
39818 if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
39819 return false;
39820 }
39821
39822
39823
39824 final public Token getNextToken() {
39825 if ((token = jj_nt).next != null) jj_nt = jj_nt.next;
39826 else jj_nt = jj_nt.next = token_source.getNextToken();
39827 jj_gen++;
39828 return token;
39829 }
39830
39831
39832 final public Token getToken(int index) {
39833 Token t = token;
39834 for (int i = 0; i < index; i++) {
39835 if (t.next != null) t = t.next;
39836 else t = t.next = token_source.getNextToken();
39837 }
39838 return t;
39839 }
39840
39841 private java.util.List<int[]> jj_expentries = new java.util.ArrayList<int[]>();
39842 private int[] jj_expentry;
39843 private int jj_kind = -1;
39844 private int[] jj_lasttokens = new int[100];
39845 private int jj_endpos;
39846
39847 private void jj_add_error_token(int kind, int pos) {
39848 if (pos >= 100) return;
39849 if (pos == jj_endpos + 1) {
39850 jj_lasttokens[jj_endpos++] = kind;
39851 } else if (jj_endpos != 0) {
39852 jj_expentry = new int[jj_endpos];
39853 for (int i = 0; i < jj_endpos; i++) {
39854 jj_expentry[i] = jj_lasttokens[i];
39855 }
39856 jj_entries_loop: for (java.util.Iterator<?> it = jj_expentries.iterator(); it.hasNext();) {
39857 int[] oldentry = (int[])(it.next());
39858 if (oldentry.length == jj_expentry.length) {
39859 for (int i = 0; i < jj_expentry.length; i++) {
39860 if (oldentry[i] != jj_expentry[i]) {
39861 continue jj_entries_loop;
39862 }
39863 }
39864 jj_expentries.add(jj_expentry);
39865 break jj_entries_loop;
39866 }
39867 }
39868 if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
39869 }
39870 }
39871
39872
39873 public ParseException generateParseException() {
39874 jj_expentries.clear();
39875 boolean[] la1tokens = new boolean[432];
39876 if (jj_kind >= 0) {
39877 la1tokens[jj_kind] = true;
39878 jj_kind = -1;
39879 }
39880 for (int i = 0; i < 447; i++) {
39881 if (jj_la1[i] == jj_gen) {
39882 for (int j = 0; j < 32; j++) {
39883 if ((jj_la1_0[i] & (1<<j)) != 0) {
39884 la1tokens[j] = true;
39885 }
39886 if ((jj_la1_1[i] & (1<<j)) != 0) {
39887 la1tokens[32+j] = true;
39888 }
39889 if ((jj_la1_2[i] & (1<<j)) != 0) {
39890 la1tokens[64+j] = true;
39891 }
39892 if ((jj_la1_3[i] & (1<<j)) != 0) {
39893 la1tokens[96+j] = true;
39894 }
39895 if ((jj_la1_4[i] & (1<<j)) != 0) {
39896 la1tokens[128+j] = true;
39897 }
39898 if ((jj_la1_5[i] & (1<<j)) != 0) {
39899 la1tokens[160+j] = true;
39900 }
39901 if ((jj_la1_6[i] & (1<<j)) != 0) {
39902 la1tokens[192+j] = true;
39903 }
39904 if ((jj_la1_7[i] & (1<<j)) != 0) {
39905 la1tokens[224+j] = true;
39906 }
39907 if ((jj_la1_8[i] & (1<<j)) != 0) {
39908 la1tokens[256+j] = true;
39909 }
39910 if ((jj_la1_9[i] & (1<<j)) != 0) {
39911 la1tokens[288+j] = true;
39912 }
39913 if ((jj_la1_10[i] & (1<<j)) != 0) {
39914 la1tokens[320+j] = true;
39915 }
39916 if ((jj_la1_11[i] & (1<<j)) != 0) {
39917 la1tokens[352+j] = true;
39918 }
39919 if ((jj_la1_12[i] & (1<<j)) != 0) {
39920 la1tokens[384+j] = true;
39921 }
39922 if ((jj_la1_13[i] & (1<<j)) != 0) {
39923 la1tokens[416+j] = true;
39924 }
39925 }
39926 }
39927 }
39928 for (int i = 0; i < 432; i++) {
39929 if (la1tokens[i]) {
39930 jj_expentry = new int[1];
39931 jj_expentry[0] = i;
39932 jj_expentries.add(jj_expentry);
39933 }
39934 }
39935 jj_endpos = 0;
39936 jj_rescan_token();
39937 jj_add_error_token(0, 0);
39938 int[][] exptokseq = new int[jj_expentries.size()][];
39939 for (int i = 0; i < jj_expentries.size(); i++) {
39940 exptokseq[i] = jj_expentries.get(i);
39941 }
39942 return new ParseException(token, exptokseq, tokenImage);
39943 }
39944
39945
39946 final public void enable_tracing() {
39947 }
39948
39949
39950 final public void disable_tracing() {
39951 }
39952
39953 private void jj_rescan_token() {
39954 jj_rescan = true;
39955 for (int i = 0; i < 83; i++) {
39956 try {
39957 JJCalls p = jj_2_rtns[i];
39958 do {
39959 if (p.gen > jj_gen) {
39960 jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
39961 switch (i) {
39962 case 0: jj_3_1(); break;
39963 case 1: jj_3_2(); break;
39964 case 2: jj_3_3(); break;
39965 case 3: jj_3_4(); break;
39966 case 4: jj_3_5(); break;
39967 case 5: jj_3_6(); break;
39968 case 6: jj_3_7(); break;
39969 case 7: jj_3_8(); break;
39970 case 8: jj_3_9(); break;
39971 case 9: jj_3_10(); break;
39972 case 10: jj_3_11(); break;
39973 case 11: jj_3_12(); break;
39974 case 12: jj_3_13(); break;
39975 case 13: jj_3_14(); break;
39976 case 14: jj_3_15(); break;
39977 case 15: jj_3_16(); break;
39978 case 16: jj_3_17(); break;
39979 case 17: jj_3_18(); break;
39980 case 18: jj_3_19(); break;
39981 case 19: jj_3_20(); break;
39982 case 20: jj_3_21(); break;
39983 case 21: jj_3_22(); break;
39984 case 22: jj_3_23(); break;
39985 case 23: jj_3_24(); break;
39986 case 24: jj_3_25(); break;
39987 case 25: jj_3_26(); break;
39988 case 26: jj_3_27(); break;
39989 case 27: jj_3_28(); break;
39990 case 28: jj_3_29(); break;
39991 case 29: jj_3_30(); break;
39992 case 30: jj_3_31(); break;
39993 case 31: jj_3_32(); break;
39994 case 32: jj_3_33(); break;
39995 case 33: jj_3_34(); break;
39996 case 34: jj_3_35(); break;
39997 case 35: jj_3_36(); break;
39998 case 36: jj_3_37(); break;
39999 case 37: jj_3_38(); break;
40000 case 38: jj_3_39(); break;
40001 case 39: jj_3_40(); break;
40002 case 40: jj_3_41(); break;
40003 case 41: jj_3_42(); break;
40004 case 42: jj_3_43(); break;
40005 case 43: jj_3_44(); break;
40006 case 44: jj_3_45(); break;
40007 case 45: jj_3_46(); break;
40008 case 46: jj_3_47(); break;
40009 case 47: jj_3_48(); break;
40010 case 48: jj_3_49(); break;
40011 case 49: jj_3_50(); break;
40012 case 50: jj_3_51(); break;
40013 case 51: jj_3_52(); break;
40014 case 52: jj_3_53(); break;
40015 case 53: jj_3_54(); break;
40016 case 54: jj_3_55(); break;
40017 case 55: jj_3_56(); break;
40018 case 56: jj_3_57(); break;
40019 case 57: jj_3_58(); break;
40020 case 58: jj_3_59(); break;
40021 case 59: jj_3_60(); break;
40022 case 60: jj_3_61(); break;
40023 case 61: jj_3_62(); break;
40024 case 62: jj_3_63(); break;
40025 case 63: jj_3_64(); break;
40026 case 64: jj_3_65(); break;
40027 case 65: jj_3_66(); break;
40028 case 66: jj_3_67(); break;
40029 case 67: jj_3_68(); break;
40030 case 68: jj_3_69(); break;
40031 case 69: jj_3_70(); break;
40032 case 70: jj_3_71(); break;
40033 case 71: jj_3_72(); break;
40034 case 72: jj_3_73(); break;
40035 case 73: jj_3_74(); break;
40036 case 74: jj_3_75(); break;
40037 case 75: jj_3_76(); break;
40038 case 76: jj_3_77(); break;
40039 case 77: jj_3_78(); break;
40040 case 78: jj_3_79(); break;
40041 case 79: jj_3_80(); break;
40042 case 80: jj_3_81(); break;
40043 case 81: jj_3_82(); break;
40044 case 82: jj_3_83(); break;
40045 }
40046 }
40047 p = p.next;
40048 } while (p != null);
40049 } catch(LookaheadSuccess ls) { }
40050 }
40051 jj_rescan = false;
40052 }
40053
40054 private void jj_save(int index, int xla) {
40055 JJCalls p = jj_2_rtns[index];
40056 while (p.gen > jj_gen) {
40057 if (p.next == null) { p = p.next = new JJCalls(); break; }
40058 p = p.next;
40059 }
40060 p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
40061 }
40062
40063 static final class JJCalls {
40064 int gen;
40065 Token first;
40066 int arg;
40067 JJCalls next;
40068 }
40069
40070 }