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