View Javadoc
1   /* Generated By:JJTree&JavaCC: Do not edit this line. PLSQLParser.java */
2   /* Copyright (C) 2002 Albert Tumanov
3   
4   This library is free software; you can redistribute it and/or
5   modify it under the terms of the GNU Lesser General Public
6   License as published by the Free Software Foundation; either
7   version 2.1 of the License, or (at your option) any later version.
8   
9   This library is distributed in the hope that it will be useful,
10  but WITHOUT ANY WARRANTY; without even the implied warranty of
11  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12  Lesser General Public License for more details.
13  
14  You should have received a copy of the GNU Lesser General Public
15  License along with this library; if not, write to the Free Software
16  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
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 PLSQLParser/*@bgen(jjtree)*/implements PLSQLParserTreeConstants, PLSQLParserConstants {/*@bgen(jjtree)*/
28    protected JJTPLSQLParserState jjtree = new JJTPLSQLParserState();
29    /**
30     * main method, for testing only.
31     * @param args
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  //    System.err.println(s + " -> " + parser.purifyIdentifier(s));
42      s = "\u005c"qwerty\u005c"";
43  //    System.err.println(s + " -> " + parser.purifyIdentifier(s));
44      s = "\u005c"qwerty\u005c".uiop";
45  //    System.err.println(s + " -> " + parser.purifyIdentifier(s));
46      s = "\u005c"qwerty\u005c".\u005c"uiop\u005c"";
47  //    System.err.println(s + " -> " + parser.purifyIdentifier(s));
48    }
49  
50    /**
51     Return canonical version of the Oracle
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            //Toggle whether following characters are quoted or not
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   * 2006-05-22 - Matthias Hendler - Added parsing of triggers and global functions/procedures
95   *                                 Refactored printing of custom tags into the XML/DOM.
96   *                                 Custom tags are language independent. Reserved tags are linked
97   *                                 to the documented language like RETURN, PARAM and THROWS.
98   */
99  
100 /**
101  * 2006-05-22 - Matthias Hendler - added globalBody()
102  */
103   final public ASTInput Input() throws ParseException {
104                     /*@bgen(jjtree) Input */
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  /*@bgen(jjtree) DDLCommand */
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  /*@bgen(jjtree) SqlPlusCommand */
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 SRT 2011-04-17 This syntax breaks the parser when fields of record.attach* are referenced  in PL/SQL 
451 void attachLibrary() :
452 {}
453 {
454 	<".attach"> <IDENTIFIER> <IDENTIFIER> <END> <IDENTIFIER>
455 }
456 */
457 
458 /**
459  * All global definitions of triggers, functions and procedures are evaluated here.
460  * Every occurence goes under a new PACKAGE-Node in the XML document.
461  * This happens, cause a global "block" does not have a definied start and end token 
462  * like a package specification or a package body.
463  * Thats why every construct is handled like a new part of the global package.
464  * To overcome this problem, I could use an infinity lookahead - which should solve the problem 
465  * and slow down the whole parsing.
466  * Another idea would be to lookahead the next tokens and decide wether they belong to a package definition or not.
467  * Then I could decide to stay in this global parsing state. By now lookahead gives the parser a hint to
468  * choose the correct way on a given base. So we can't negate it easily.
469  * On the other hand I could also hold the global state in a global variable. 
470  * But this does not seems the correct way to solve the problem, I think.
471  *
472  * 2006-05-17 - Matthias Hendler - added
473  */
474   final public ASTGlobal Global() throws ParseException {
475  /*@bgen(jjtree) Global */
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  /*@bgen(jjtree) Block */
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  /*@bgen(jjtree) PackageSpecification */
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  /*@bgen(jjtree) PackageBody */
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  /*@bgen(jjtree) DeclarativeUnit */
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  /*@bgen(jjtree) DeclarativeSection */
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  /*@bgen(jjtree) CompilationDeclarationFragment */
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  * 2006-05-22 - Matthias Hendler - Printing of custom tag "@deprecated" removed.
4713  *                                 Printing of any custom tag added. Now user can define his own
4714  *								   custom tags which he can evaluate in the XSLT.
4715  *                                 This methode also documents global functions/procedures.
4716  */
4717   final public ASTProgramUnit ProgramUnit() throws ParseException {
4718  /*@bgen(jjtree) ProgramUnit */
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  /*@bgen(jjtree) ObjectNameDeclaration */
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  /*@bgen(jjtree) FormalParameter */
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  /*@bgen(jjtree) MethodDeclaration */
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  /*@bgen(jjtree) MethodDeclarator */
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); //ReadAhead
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  /*@bgen(jjtree) FormalParameters */
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  /*@bgen(jjtree) VariableOrConstantDeclarator */
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  /*@bgen(jjtree) VariableOrConstantDeclaratorId */
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  /*@bgen(jjtree) VariableOrConstantInitializer */
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  /*@bgen(jjtree) Datatype */
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         // this should be first
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  /*@bgen(jjtree) CompilationDataType */
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  /*@bgen(jjtree) CollectionTypeName */
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  /*@bgen(jjtree) ScalarDataTypeName */
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  /*@bgen(jjtree) DateTimeLiteral */
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  /*@bgen(jjtree) ExceptionHandler */
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  /*@bgen(jjtree) Skip2NextTerminator */
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  Read Tokens up to but not including the target String. 
9019 */
9020   final public void Skip2NextOccurrence(String target) throws ParseException {
9021  /*@bgen(jjtree) Skip2NextOccurrence */
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) ) //In case the target is a Special Token
9027          && nextToken.kind!=EOF //SRT 20110521 - Prevent endless loop when target does not exist in the input stream
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  Read Tokens up to and including the target String. 
9046 */
9047   final public void SkipPastNextOccurrence(String target) throws ParseException {
9048  /*@bgen(jjtree) SkipPastNextOccurrence */
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  Read Tokens up to but not including the target Token.kind. 
9067 */
9068   final public void Skip2NextTokenOccurrence(int target) throws ParseException {
9069  /*@bgen(jjtree) Skip2NextTokenOccurrence */
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 ) //In case the target is a Special Token
9076          && nextToken.kind!=EOF //SRT 20110521 - Prevent endless loop when target does not exist in the input stream
9077         )
9078   {
9079     /*
9080 	Check if the target appears as a SpecialToken 
9081 
9082 
9083 	nextToken.specialToken points to the _LAST_ of any SpecialTokens before the current normal Token.
9084 
9085 	It is the head of a doubly-linked list:
9086 
9087 	The ${specialToken}.specialToken field POINTS BACKWARDS TOWARDS the FIRST occurring SpecialToken
9088 	The ${specialToken}.next field POINTS FORWARDS to to the LAST occurring SpecialToken
9089 
9090 	This means that if the program is interested in a specific SpecialToken, it must examine the linked list for every Token which has nexToken.specialToken != null.
9091     
9092     */
9093     specToken = nextToken.specialToken;
9094     if (null!= specToken)
9095     {
9096         //Walk backwards through the list looking for this Token as a Special Token 
9097         while (specToken != null && specToken.kind != target)
9098         {
9099                 specToken = specToken.specialToken;
9100         }
9101 
9102         //We have found the target as a SpecialToken - break out of normal Token search
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  Read Tokens up to and including the target Token.kind. 
9125 */
9126   final public void SkipPastNextTokenOccurrence(int target) throws ParseException {
9127  /*@bgen(jjtree) SkipPastNextTokenOccurrence */
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  Read Tokens up to but not including the target String. 
9146 */
9147   final public ASTRead2NextOccurrence Read2NextOccurrence(String target) throws ParseException {
9148  /*@bgen(jjtree) Read2NextOccurrence */
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  Read Tokens up to and including the target String. 
9175 */
9176   final public ASTReadPastNextOccurrence ReadPastNextOccurrence(String target) throws ParseException {
9177  /*@bgen(jjtree) ReadPastNextOccurrence */
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(); // Chomp this one 
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  * 2006-05-24 - Matthias Hendler - added MERGE
9199  */
9200   final public ASTSqlStatement SqlStatement(String initiator, String terminator) throws ParseException {
9201  /*@bgen(jjtree) SqlStatement */
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  * 2011-05-15 - SRT - Added to cope with wrapped objects
9278   A wrapped function looks like this (always terminated by one or more equals signs "="):-
9279   "  CREATE OR REPLACE FUNCTION "TESTUSER"."GET_DATE_STRING"
9280 / ** Return SYSDATE formatted using the provided template.
9281  *
9282  *
9283  *  @param p_date_format normal TO_CHARE/TO_DATE date template
9284  *  @return formatted datestring
9285  *  @see http://www.oracle-base.com/articles/10g/WrapAndDBMS_DDL_10gR2.php#dbms_ddl
9286  * /
9287 wrapped
9288 a000000
9289 369
9290 abcd
9291 abcd
9292 abcd
9293 abcd
9294 abcd
9295 abcd
9296 abcd
9297 abcd
9298 abcd
9299 abcd
9300 abcd
9301 abcd
9302 abcd
9303 abcd
9304 abcd
9305 8
9306 89 b6
9307 /SBrhM8+1iUO4QAih+qD2SK8kSowg8eZgcfLCNL+XlquYvSuoVah8JbRPpdHDLHn479SdFLw
9308 v04omzJ0zOfHdMAzuHQlw+fAsr2ym9YI8I521pRTbnFVAHOOUw4JqPkIyj7wj4VwyL17nhYb
9309 3qPVuL6SvhZTmEBnRtaErHpzaDuIpqZ0G4s=
9310   "
9311  */
9312   final public void WrappedObject() throws ParseException {
9313  /*@bgen(jjtree) WrappedObject */
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); //ReadAhead
9324                 while (
9325                      null != nextToken && nextToken.kind!=EOF
9326                      )
9327                 {
9328                         nextToken = getNextToken();
9329 
9330                         //Execute manual readahead 
9331                         nextToken = getToken(1); //ReadAhead 1 Token 
9332                 }
9333                 {if (true) return;}
9334     } finally {
9335           if (jjtc000) {
9336             jjtree.closeNodeScope(jjtn000, true);
9337           }
9338     }
9339   }
9340 
9341 // ============================================================================
9342 // S T A T E M E N T S
9343 // ============================================================================
9344 
9345 /**
9346  * 2006-05-24 - Matthias Hendler - added MERGE, EXECUTE choice and LOOKAHEAD at <LOOP>
9347  */
9348   final public ASTUnlabelledStatement UnlabelledStatement() throws ParseException {
9349  /*@bgen(jjtree) UnlabelledStatement */
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  /*@bgen(jjtree) Statement */
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 LabelledStatement created solely to conform with PMD Java AST (for PMD DataFlow Analysis - DFA)
10008 N.B. equivalent Java AST* class is ASTLabeledStatement (single "l" rather than double "ll")
10009 */
10010   final public ASTLabelledStatement LabelledStatement() throws ParseException {
10011  /*@bgen(jjtree) LabelledStatement */
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  /*@bgen(jjtree) CaseStatement */
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  /*@bgen(jjtree) CaseWhenClause */
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  /*@bgen(jjtree) ElseClause */
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  /*@bgen(jjtree) ElsifClause */
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  /*@bgen(jjtree) LoopStatement */
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 /** Scope rule: the loop index only exists within the Loop */
11578   final public ASTForStatement ForStatement() throws ParseException {
11579  /*@bgen(jjtree) ForStatement */
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  /*@bgen(jjtree) WhileStatement */
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  /*@bgen(jjtree) IfStatement */
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 /** Scope rule: the loop index only exists within the statement */
12548 /**
12549 ForIndex is declared implicitly, unlike most variables or constants.
12550 */
12551   final public ASTForIndex ForIndex() throws ParseException {
12552  /*@bgen(jjtree) ForIndex */
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 ForAllIndex is declared implicitly, unlike most variables or constants.
12585 */
12586   final public ASTForAllIndex ForAllIndex() throws ParseException {
12587  /*@bgen(jjtree) ForAllIndex */
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  /*@bgen(jjtree) ForAllStatement */
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  /*@bgen(jjtree) GotoStatement */
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  /*@bgen(jjtree) ReturnStatement */
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  /*@bgen(jjtree) ContinueStatement */
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  /*@bgen(jjtree) ExitStatement */
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  /*@bgen(jjtree) RaiseStatement */
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  /*@bgen(jjtree) CloseStatement */
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  /*@bgen(jjtree) OpenStatement */
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  /*@bgen(jjtree) FetchStatement */
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  /*@bgen(jjtree) EmbeddedSqlStatement */
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  /*@bgen(jjtree) PipelineStatement */
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  /*@bgen(jjtree) ConditionalCompilationStatement */
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  /*@bgen(jjtree) SubTypeDefinition */
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  /*@bgen(jjtree) FieldDeclaration */
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                                                           /*@bgen(jjtree) CollectionTypeDefinition */
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                                                     /*@bgen(jjtree) CollectionDeclaration */
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                                             /*@bgen(jjtree) ObjectDeclaration */
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 /** Java stored procedure, external function*/
16173   final public ASTCallSpecTail CallSpecTail() throws ParseException {
16174                                   /*@bgen(jjtree) CallSpecTail */
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 /** Cursor (common part of specification and body) */
16316   final public ASTCursorUnit CursorUnit() throws ParseException {
16317  /*@bgen(jjtree) CursorUnit */
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                                                  /*@bgen(jjtree) CursorSpecification */
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                                /*@bgen(jjtree) CursorBody */
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 // E X P R E S S I O N S
16454 // ============================================================================
16455 
16456 /*
16457 String expression() :
16458 {}
16459 {
16460 	"test"
16461 	{ return ""; }
16462 }
16463 */
16464   final public ASTExpression Expression() throws ParseException {
16465  /*@bgen(jjtree) Expression */
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  /*@bgen(jjtree) CompilationExpression */
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  /*@bgen(jjtree) Assignment */
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  /*@bgen(jjtree) CaseExpression */
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 LIKE ( Expression ) [ <ESCAPE> <STRINGLITERAL>
17180 */
17181   final public ASTLikeExpression LikeExpression() throws ParseException {
17182  /*@bgen(jjtree) LikeExpression */
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  /*@bgen(jjtree) TrimExpression */
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 TREAT ( Expression AS datatype)
17566 CAST ( Expression AS datatype)
17567 */
17568   final public ASTObjectExpression ObjectExpression() throws ParseException {
17569  /*@bgen(jjtree) ObjectExpression */
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  /*@bgen(jjtree) ConditionalOrExpression */
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  /*@bgen(jjtree) ConditionalAndExpression */
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  /*@bgen(jjtree) EqualityExpression */
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  * 2006-05-23 - Matthias Hendler - added FROM
17812  */
17813   final public ASTRelationalExpression RelationalExpression() throws ParseException {
17814  /*@bgen(jjtree) RelationalExpression */
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  /*@bgen(jjtree) AdditiveExpression */
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  /*@bgen(jjtree) StringExpression */
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  /*@bgen(jjtree) MultiplicativeExpression */
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  /*@bgen(jjtree) UnaryExpression */
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  /*@bgen(jjtree) UnaryExpressionNotPlusMinus */
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  * 2006-05-23 - Matthias Hendler - Added lookahead otherwise warning encountered.
18805  *                                 Warning arised while adding methode triggerUnit(). 
18806  * 2011-04-27 - SRT - Add optional NEW Keyword to cope with Object Type constructors
18807  */
18808   final public ASTPrimaryExpression PrimaryExpression() throws ParseException {
18809  /*@bgen(jjtree) PrimaryExpression */
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  /*@bgen(jjtree) PrimaryPrefix */
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  /*@bgen(jjtree) PrimarySuffix */
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  /*@bgen(jjtree) Literal */
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         //<STRING_LITERAL> {literal = token.toString(); }
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  /*@bgen(jjtree) StringLiteral */
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    This might be Q-Quoted string and this might be only a partial string
20096    The token will only match up to the first single quote.
20097    The code below appends any remaining part, theh returns the complete string
20098    */
20099    if (thisToken.image.toUpperCase().startsWith("Q'")
20100        && thisToken.image.length() > 2
20101       )
20102    {
20103    // Get the first token of the string so that the delimiter can be identified
20104 
20105      startDelimiter= thisToken.image.charAt(2) ;
20106      /*
20107      if the start delimiter is one of [, {, <, or (, the end delimiter
20108      is the corresponding closing character
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        //Loop until we find atoken that ends with a single-quote precede by the terminator
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  /*@bgen(jjtree) BooleanLiteral */
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  /*@bgen(jjtree) NullLiteral */
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  /*@bgen(jjtree) MultiSetCondition */
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 /** Recognizes a numeric literal.
20217 * This may look like token, but it isn't. Not atomic enough.
20218 * E.g. "+1" would be valid literal, which make parsing of "i+1" impossible
20219 * (here, we have tokens "i", "+" and "1")
20220 */
20221   final public ASTNumericLiteral NumericLiteral() throws ParseException {
20222  /*@bgen(jjtree) NumericLiteral */
20223  ASTNumericLiteral jjtn000 = new ASTNumericLiteral(this, JJTNUMERICLITERAL);
20224  boolean jjtc000 = true;
20225  jjtree.openNodeScope(jjtn000);Token t = null ;
20226     try {
20227       //Essentially unchanged, as it previouly returned a Token 
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 /** This cannot be a token because these are valid labels '<< next_msg >>", '<<"OUTER LOOP">>'  
20242 */
20243   final public ASTLabel Label() throws ParseException {
20244  /*@bgen(jjtree) Label */
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  /*@bgen(jjtree) Name */
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         //QualifiedID() 
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  /*@bgen(jjtree) QualifiedName */
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  /*@bgen(jjtree) Arguments */
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  /*@bgen(jjtree) ArgumentList */
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  /*@bgen(jjtree) Argument */
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 // D E C L A R A T I O N S
20783 // ============================================================================
20784   final public ASTVariableOrConstantDeclaration VariableOrConstantDeclaration() throws ParseException {
20785  /*@bgen(jjtree) VariableOrConstantDeclaration */
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  /*@bgen(jjtree) DatatypeDeclaration */
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  /*@bgen(jjtree) Pragma */
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  /*@bgen(jjtree) InlinePragma */
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  /*@bgen(jjtree) ExceptionDeclaration */
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  /*@bgen(jjtree) ParallelClause */
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  /*@bgen(jjtree) AccessibleByClause */
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 // Copyright (C) 2002 Albert Tumanov
21826 
21827 /**
21828  * 2006-05-10 - Matthias Hendler - merged SIV and sourceforge sources
21829  */
21830 
21831 // SRT *
21832   final public ASTTable Table() throws ParseException {
21833  /*@bgen(jjtree) Table */
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  /*@bgen(jjtree) TableColumn */
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  /*@bgen(jjtree) View */
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  /*@bgen(jjtree) Synonym */
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  /*@bgen(jjtree) Directory */
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  /*@bgen(jjtree) DatabaseLink */
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  /*@bgen(jjtree) ViewColumn */
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  /*@bgen(jjtree) Comment */
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 // SRT * /
22872   final public ASTTypeMethod TypeMethod() throws ParseException {
22873  /*@bgen(jjtree) TypeMethod */
22874   ASTTypeMethod jjtn000 = new ASTTypeMethod(this, JJTTYPEMETHOD);
22875   boolean jjtc000 = true;
22876   jjtree.openNodeScope(jjtn000);
22877     try {
22878         getToken(1);
22879         //System.err.println("typeMethod: Result of getToken(1) is \"" + startToken.toString() + "\"" );
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  /*@bgen(jjtree) TypeSpecification */
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  /*@bgen(jjtree) AlterTypeSpec */
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 ASTTypeBody TypeBody()  :
26237 { Token name=null; }
26238 {
26239 	[<CREATE> [<OR> <REPLACE>]]
26240 
26241 	<TYPE> <BODY> (LOOKAHEAD(2) ID()".")? name=ID()
26242 
26243 	(
26244 	  (
26245 	    WrappedObject() 
26246 	  )
26247 	  |
26248 	  (
26249 	    (<IS> | <AS>)
26250 
26251 		    DeclarativeSection() //SRT 20110524 Allow PLDOc in Type Bodies 
26252 
26253 	    [ <BEGIN> (Statement())* (ExceptionHandler())? ] <END> [ID()] ";" 
26254 	  )
26255 	)
26256 }
26257 */
26258 
26259 
26260 /**
26261   * Method 
26262 **/
26263   final public ASTAttributeDeclaration AttributeDeclaration() throws ParseException {
26264  /*@bgen(jjtree) AttributeDeclaration */
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  /*@bgen(jjtree) Attribute */
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  This was quick cut from PRAGMA
26330 */
26331   final public ASTPragmaClause PragmaClause() throws ParseException {
26332  /*@bgen(jjtree) PragmaClause */
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  * Trigger
26783  * Triggers are always outside of a package.
26784  *
26785  *  2006-05-17 - Matthias Hendler - added 
26786  */
26787 
26788 /*
26789   11g Trigger Syntax 
26790 
26791  create_trigger : 
26792  CREATE [OR REPLACE] TRIGGER [schema.]trigger 
26793 ( simple_dml_trigger | compound_dml_trigger | non_dml_trigger )
26794 [ FOLLOWS ( [schema.]trigger) ( , [schema.]trigger)*  ]
26795 [ ENABLE  | DISABLE ]
26796 ( WHEN ( trigger_condition ) 
26797 trigger_body
26798 
26799 
26800 simple_dml_trigger :
26801 (BEFORE |AFTER | INSTEAD OF)
26802 dml_event_clause 
26803 [ referencing_clause ]
26804 [ FOR EACH ROW ]
26805 
26806 
26807 
26808 compound_dml_trigger :
26809 FOR dml_event_clause 
26810 [ referencing_clause ]
26811 
26812 
26813 non_dml_trigger :
26814 (BEFORE> |<AFTER> ) 
26815 (DDLEvent | database_event) ( OR (DDLEvent | database_event))*
26816 ON
26817 (DATABASE | [schema.]SCHEMA
26818 
26819 
26820 
26821 trigger_body :
26822 (plsql_block | compound_trigger_block | CALL routine_clause)
26823 
26824 
26825 
26826 dml_event_clause:
26827 ( DELETE | INSERT | UPDATE [ OF column (, column ) ] )
26828 ON ( (schema.table | NESTED TABLE nested_table_column OF [schema.]view )
26829 
26830 referencing_clause:
26831 REFERENCING 
26832 (OLD AS old_alias | NEW AS new_alias | PARENT AS parent_alias )*  
26833 
26834 
26835 compound_trigger_block :
26836 COMPOUND TRIGGER 
26837 declare_section 
26838 (timing_point_section)+  
26839 END [trigger_name] ;
26840 
26841 timing_point_section:
26842 (
26843 BEFORE STATEMENT IS tps_body END BEFORE STATEMENT 
26844 |BEFORE EACH ROW IS tps_body END BEFORE EACH ROW 
26845 |AFTER STATEMENT IS tps_body END AFTER STATEMENT 
26846 |AFTER EACH ROW IS tps_body END AFTER EACH ROW 
26847 )
26848 
26849 
26850 tps_body:
26851 (statement)+
26852 (EXCEPTION exception_handler )*
26853 
26854 */
26855   final public ASTTriggerUnit TriggerUnit() throws ParseException {
26856  /*@bgen(jjtree) TriggerUnit */
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  /*@bgen(jjtree) TriggerTimingPointSection */
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  /*@bgen(jjtree) CompoundTriggerBlock */
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 non_dml_trigger :
28769 (BEFORE> |<AFTER> ) 
28770 (DDLEvent | database_event) ( OR (DDLEvent | database_event))*
28771 ON
28772 (DATABASE | [schema.]SCHEMA
28773 */
28774   final public ASTNonDMLTrigger NonDMLTrigger() throws ParseException {
28775  /*@bgen(jjtree) NonDMLTrigger */
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                          /*@bgen(jjtree) DDLEvent */
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                                    /*@bgen(jjtree) DatabaseEvent */
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                                /*@bgen(jjtree) NonDMLEvent */
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 When DBMS_METADATA.GET_DDL returns a trigger, it can come in 2 DDL statements.
29416 The first is the CREATE OR REPLACE TRIGER statement; the second is an ALTER TRIGGER statement,
29417 enabling or disabling the trigger.
29418 
29419 Unlike the ALTER TYPE, it does not seem to alter the structure of the object.
29420 */
29421   final public void AlterTrigger() throws ParseException {
29422  /*@bgen(jjtree) AlterTrigger */
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 //SRT 2011-04-17 - START 
29456   final public ASTKEYWORD_RESERVED KEYWORD_RESERVED() throws ParseException {
29457                                           /*@bgen(jjtree) KEYWORD_RESERVED */
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                                               /*@bgen(jjtree) KEYWORD_UNRESERVED */
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 //SRT 2011-04-17 - END  */
30364 /**
30365  * 2006-05-20 - Matthias Hendler - added <OLD> and <PARENT>  
30366  */
30367   final public ASTID ID() throws ParseException {
30368              /*@bgen(jjtree) ID */
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  * 2006-05-20 - Matthias Hendler - added <OLD>, <NEW>, <LOOP>, <INT>
31009  */
31010   final public ASTUnqualifiedID UnqualifiedID() throws ParseException {
31011                                    /*@bgen(jjtree) UnqualifiedID */
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  * 2006-05-20 - Matthias Hendler - added <LIMIT>
31310  */
31311   final public ASTQualifiedID QualifiedID() throws ParseException {
31312                                /*@bgen(jjtree) QualifiedID */
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                                /*@bgen(jjtree) TypeKeyword */
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                                              /*@bgen(jjtree) JavaInterfaceClass */
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  * Tests, if the new Token if type ID is identical to the old Token of type ID.
32039  * 
32040  * 2006-05-18 - Matthias Hendler - added: Just for understanding javacc and not used,
32041  *                                        cause to many closing ENDs (IDENTIFIER) were mistyped.
32042  */
32043   final public PLSQLNode EqualsOldIDNewID(PLSQLNode pOldID) throws ParseException {
32044  /*@bgen(jjtree) EqualsOldIDNewID */
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   /** Generated Token Manager. */
39614   public PLSQLParserTokenManager token_source;
39615   SimpleCharStream jj_input_stream;
39616   /** Current token. */
39617   public Token token;
39618   /** Next token. */
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   /** Constructor with InputStream. */
39701   public PLSQLParser(java.io.InputStream stream) {
39702      this(stream, null);
39703   }
39704   /** Constructor with InputStream and supplied encoding */
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   /** Reinitialise. */
39716   public void ReInit(java.io.InputStream stream) {
39717      ReInit(stream, null);
39718   }
39719   /** Reinitialise. */
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   /** Constructor. */
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   /** Reinitialise. */
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   /** Constructor with generated Token Manager. */
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   /** Reinitialise. */
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 /** Get the next Token. */
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 /** Get the specific Token. */
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   /** Generate ParseException. */
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   /** Enable tracing. */
39946   final public void enable_tracing() {
39947   }
39948 
39949   /** Disable tracing. */
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 }