KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > apache > derby > impl > tools > ij


1 /* Generated By:JavaCC: Do not edit this line. ij.java */
2 package org.apache.derby.impl.tools.ij;
3
4 import org.apache.derby.iapi.reference.JDBC20Translation;
5 import org.apache.derby.iapi.reference.JDBC30Translation;
6
7 import org.apache.derby.tools.JDBCDisplayUtil;
8
9
10 import org.apache.derby.iapi.tools.i18n.LocalizedInput;
11 import org.apache.derby.iapi.tools.i18n.LocalizedResource;
12
13 import org.apache.derby.iapi.services.info.JVMInfo;
14 import org.apache.derby.tools.URLCheck;
15
16 import java.lang.reflect.*;
17 import java.sql.Connection JavaDoc;
18 import java.sql.DatabaseMetaData JavaDoc;
19 import java.sql.DriverManager JavaDoc;
20 import java.sql.Statement JavaDoc;
21 import java.sql.PreparedStatement JavaDoc;
22 import java.sql.ResultSet JavaDoc;
23 import java.sql.ResultSetMetaData JavaDoc;
24 import java.sql.SQLException JavaDoc;
25 import java.sql.SQLWarning JavaDoc;
26 import java.util.Hashtable JavaDoc;
27 import java.util.Properties JavaDoc;
28 import java.util.StringTokenizer JavaDoc;
29 import java.io.IOException JavaDoc;
30 import java.util.Vector JavaDoc;
31 import java.util.Enumeration JavaDoc;
32 import java.util.Locale JavaDoc;
33
34
35 /**
36     This parser works on a statement-at-a-time basis.
37     It maintains a connection environment that is
38     set by the caller and contains a list of
39     connections for the current thread/ij session.
40     Multi-user frameworks that use this parser
41     tend to maintain multiple connectionEnv's and
42     pass in the current one to set ij up.
43     A connectionEnv has a default connection in use,
44     and the ij connect/set connection/disconnect commands
45     are used to change the current connection.
46
47     Each connection has associated with it a list
48     of prepared statements and cursors, created by
49     the ij prepare and get cursor statements and
50     manipulated by additional ij statements.
51
52     To enable multiple display modes, this parser will
53     not output anything, but will return
54     objects that the caller can then display.
55
56     This means the caller is responsible for displaying
57     thrown exceptions and also SQLWarnings. So, our
58     return value is the JDBC object upon which warnings
59     will be hung, i.e. the one manipulated by the statement,
60     if any.
61
62     If there is no object to display, then a null is
63     returned.
64
65     @author ames
66  */

67 class ij implements ijConstants {
68         static final String JavaDoc PROTOCOL_PROPERTY = "ij.protocol";
69     static final String JavaDoc USER_PROPERTY = "ij.user";
70     static final String JavaDoc PASSWORD_PROPERTY = "ij.password";
71         static final String JavaDoc FRAMEWORK_PROPERTY = "framework";
72
73         boolean elapsedTime = false;
74
75         Connection JavaDoc theConnection = null;
76         ConnectionEnv currentConnEnv = null;
77
78         xaAbstractHelper xahelper = null;
79         boolean exit = false;
80
81         utilMain utilInstance = null;
82         Hashtable JavaDoc ignoreErrors = null;
83         String JavaDoc protocol = null; // the (single) unnamed protocol
84
Hashtable JavaDoc namedProtocols;
85
86
87
88         /**
89      * A constructor that understands the local state that needs to be
90      * initialized.
91      *
92      * @param tm The token manager to use
93      * @param utilInstance The util to use
94      */

95         ij(ijTokenManager tm, utilMain utilInstance) {
96                 this(tm);
97                 this.utilInstance = utilInstance;
98         }
99
100         /**
101        Initialize this parser from the environment
102        (system properties). Used when ij is being run
103        as a command line program.
104     */

105         void initFromEnvironment() {
106
107                 // load all protocols specified via properties
108
//
109
Properties JavaDoc p = System.getProperties();
110                 protocol = p.getProperty(PROTOCOL_PROPERTY);
111                 String JavaDoc framework_property = p.getProperty(FRAMEWORK_PROPERTY);
112
113                 if (ij.JDBC20X() && ij.JTA() && ij.JNDI())
114                 {
115                         try {
116                                 xahelper = (xaAbstractHelper) Class.forName("org.apache.derby.impl.tools.ij.xaHelper").newInstance();
117                                 xahelper.setFramework(framework_property);
118                         } catch (Exception JavaDoc e) {
119                         }
120
121                 }
122
123
124                 namedProtocols = new Hashtable JavaDoc();
125                 String JavaDoc prefix = PROTOCOL_PROPERTY + ".";
126                 for (Enumeration JavaDoc e = p.propertyNames(); e.hasMoreElements(); )
127                 {
128                         String JavaDoc key = (String JavaDoc)e.nextElement();
129                         if (key.startsWith(prefix)) {
130                                 String JavaDoc name = key.substring(prefix.length());
131                                 installProtocol(name.toUpperCase(Locale.ENGLISH), p.getProperty(key));
132                         }
133                 }
134         }
135         /**
136      * Return whether or not JDBC 2.0 (and greater) extension classes can be loaded
137      *
138      * @return true if JDBC 2.0 (and greater) extension classes can be loaded
139      */

140         private static boolean JDBC20X()
141         {
142                 try
143                 {
144                         Class.forName("javax.sql.DataSource");
145                         Class.forName("javax.sql.ConnectionPoolDataSource");
146                         Class.forName("javax.sql.PooledConnection");
147                         Class.forName("javax.sql.XAConnection");
148                         Class.forName("javax.sql.XADataSource");
149                 }
150                 catch(ClassNotFoundException JavaDoc cnfe)
151                 {
152                         return false;
153                 }
154                 return true;
155         }
156         /**
157      * Return whether or not JTA classes can be loaded
158      *
159      * @return true if JTA classes can be loaded
160      */

161         private static boolean JTA()
162         {
163                 try
164                 {
165                         Class.forName("javax.transaction.xa.Xid");
166                         Class.forName("javax.transaction.xa.XAResource");
167                         Class.forName("javax.transaction.xa.XAException");
168                 }
169                 catch(ClassNotFoundException JavaDoc cnfe)
170                 {
171                         return false;
172                 }
173                 return true;
174         }
175
176         /**
177      * Return whether or not JNDI extension classes can be loaded
178      *
179      * @return true if JNDI extension classes can be loaded
180      */

181         private static boolean JNDI()
182         {
183                 try
184                 {
185                         Class.forName("javax.naming.spi.Resolver");
186                         Class.forName("javax.naming.Referenceable");
187                         Class.forName("javax.naming.directory.Attribute");
188                 }
189                 catch(ClassNotFoundException JavaDoc cnfe)
190                 {
191                         return false;
192                 }
193                 return true;
194         }
195 // FIXME: caller has to deal with ignoreErrors and handleSQLException behavior
196

197         /**
198         Add the warnings of wTail to the end of those of wHead.
199      */

200         SQLWarning JavaDoc appendWarnings(SQLWarning JavaDoc wHead, SQLWarning JavaDoc wTail) {
201                 if (wHead == null) return wTail;
202
203                 if (wHead.getNextException() == null) {
204                         wHead.setNextException(wTail);
205                 } else {
206                         appendWarnings(wHead.getNextWarning(), wTail);
207                 }
208                 return wHead;
209         }
210
211         /**
212      * Get the "elapsedTime state".
213      */

214         boolean getElapsedTimeState()
215         {
216                 return elapsedTime;
217         }
218
219         /**
220        this removes the outside quotes from the string.
221        it will also swizzle the special characters
222        into their actual characters, like '' for ', etc.
223      */

224         String JavaDoc stringValue(String JavaDoc s) {
225                 String JavaDoc result = s.substring(1,s.length()-1);
226                 char quotes = '\'';
227                 int index;
228
229                 /* Find the first occurrence of adjacent quotes. */
230                 index = result.indexOf(quotes);
231
232                 /* Replace each occurrence with a single quote and begin the
233          * search for the next occurrence from where we left off.
234          */

235                 while (index != -1)
236                 {
237                         result = result.substring(0, index + 1) + result.substring(index + 2);
238
239                         index = result.indexOf(quotes, index + 1);
240                 }
241
242                 return result;
243         }
244
245         void installProtocol(String JavaDoc name, String JavaDoc value) {
246             try {
247                         // `value' is a JDBC protocol;
248
// we load the "driver" in the prototypical
249
// manner, it will register itself with
250
// the DriverManager.
251
util.loadDriverIfKnown(value);
252             } catch (ClassNotFoundException JavaDoc e) {
253                         throw ijException.classNotFoundForProtocol(value);
254             } catch (IllegalArgumentException JavaDoc e) {
255                         throw ijException.classNotFoundForProtocol(value);
256             } catch (IllegalAccessException JavaDoc e) {
257                         throw ijException.classNotFoundForProtocol(value);
258             } catch (InstantiationException JavaDoc e) {
259                         throw ijException.classNotFoundForProtocol(value);
260             }
261                 if (name == null)
262                         protocol = value;
263                 else
264                         namedProtocols.put(name, value);
265         }
266
267         void haveConnection() {
268                 JDBCDisplayUtil.checkNotNull(theConnection, "connection");
269         }
270
271         /**
272         We do not reuse statement objects at all, because
273         some systems require you to close the object to release
274         resources (JBMS), while others will not let you reuse
275         the statement object once it is closed (WebLogic).
276
277         If you want to reuse statement objects, you need to
278         use the ij PREPARE and EXECUTE statements.
279
280         @param stmt the statement
281
282      **/

283         ijResult executeImmediate(String JavaDoc stmt) throws SQLException JavaDoc {
284                 Statement JavaDoc aStatement = null;
285                 try {
286                         long beginTime = 0;
287                         long endTime = 0;
288                         boolean cleanUpStmt = false;
289
290                         haveConnection();
291                         aStatement = theConnection.createStatement();
292
293                         // for JCC - remove comments at the beginning of the statement
294
// and trim; do the same for Derby Clients that have versions
295
// earlier than 10.2.
296
if (currentConnEnv != null) {
297                                 boolean trimForDNC = currentConnEnv.getSession().getIsDNC();
298                                 if (trimForDNC) {
299                                 // we're using the Derby Client, but we only want to trim
300
// if the version is earlier than 10.2.
301
DatabaseMetaData JavaDoc dbmd = theConnection.getMetaData();
302                                         int majorVersion = dbmd.getDriverMajorVersion();
303                                         if ((majorVersion > 10) || ((majorVersion == 10) &&
304                                                 (dbmd.getDriverMinorVersion() > 1)))
305                                         { // 10.2 or later, so don't trim/remove comments.
306
trimForDNC = false;
307                                         }
308                                 }
309                                 if (currentConnEnv.getSession().getIsJCC() || trimForDNC) {
310                                 // remove comments and trim.
311
int nextline;
312                                         while(stmt.startsWith("--"))
313                                         {
314                                                 nextline = stmt.indexOf('\n')+1;
315                                                 stmt = stmt.substring(nextline);
316                                         }
317                                         stmt = stmt.trim();
318                                 }
319                         }
320
321                         aStatement.execute(stmt);
322
323                         // FIXME: display results. return start time.
324
return new ijStatementResult(aStatement,true);
325
326                 } catch (SQLException JavaDoc e) {
327                         if (aStatement!=null) // free the resource
328
aStatement.close();
329                         throw e;
330                 }
331         }
332
333         ijResult quit() throws SQLException JavaDoc {
334                 exit = true;
335                 if (getExpect()) { // report stats
336
// FIXME: replace with MVC...
337
// FIXME: this is a kludgy way to quiet /0 and make 0/0=1...
338
int numExpectOr1 = (numExpect==0?1:numExpect);
339                         int numPassOr1 = (numPass==numExpect && numPass==0)?1:numPass;
340                         int numFailOr1 = (numFail==numExpect && numFail==0)?1:numFail;
341                         int numUnxOr1 = (numUnx==numExpect && numUnx==0)?1:numUnx;
342
343             LocalizedResource.OutputWriter().println(LocalizedResource.getMessage("IJ_TestsRun0Pass12Fail34",
344             new Object JavaDoc[]{
345                         LocalizedResource.getNumber(numExpect), LocalizedResource.getNumber(100*(numPassOr1/numExpectOr1)),
346                         LocalizedResource.getNumber(100*(numFailOr1/numExpectOr1))}));
347                         if (numUnx > 0) {
348                                                         LocalizedResource.OutputWriter().println();
349                                                         LocalizedResource.OutputWriter().println(LocalizedResource.getMessage("IJ_UnexpResulUnx01",
350                                                         LocalizedResource.getNumber(numUnx), LocalizedResource.getNumber(100*(numUnxOr1/numExpectOr1))));
351                         }
352                 }
353                 currentConnEnv.removeAllSessions();
354                 theConnection = null;
355                 return null;
356         }
357
358         /**
359         Async execution wants to return results off-cycle.
360         We want to control their output, and so will hold it
361         up until it is requested with a WAIT FOR asyncName
362         statement. WAIT FOR will return the results of
363         the async statement once they are ready. Note that using
364         a select only waits for the execute to complete; the
365         logic to step through the result set is in the caller.
366      **/

367         ijResult executeAsync(String JavaDoc stmt, String JavaDoc name) {
368                 AsyncStatement as = new AsyncStatement(theConnection, stmt);
369
370                 currentConnEnv.getSession().addAsyncStatement(name,as);
371
372                 as.start();
373
374                 return null;
375         }
376
377
378
379         void setConnection(ConnectionEnv connEnv, boolean multipleEnvironments) {
380                 Connection JavaDoc conn = connEnv.getConnection();
381
382                 if (connEnv != currentConnEnv) // single connenv is common case
383
currentConnEnv = connEnv;
384
385                 if (theConnection == conn) return; // not changed.
386

387                 if ((theConnection == null) || multipleEnvironments) {
388                         // must have switched env's (could check)
389
theConnection = conn;
390                 } else {
391                         throw ijException.needToDisconnect();
392                 }
393         }
394
395         /**
396         Note the Expect Result in the output and in the stats.
397
398         FIXME
399      */

400         int numExpect, numPass, numFail, numUnx;
401         private void noteExpect(boolean actual, boolean want) {
402                 numExpect++;
403                 if (actual) numPass++;
404                 else numFail++;
405
406                 LocalizedResource.OutputWriter().print(LocalizedResource.getMessage(actual?"IJ_Pass":"IJ_Fail"));
407                 if (actual != want) {
408                         numUnx++;
409                                         LocalizedResource.OutputWriter().println(LocalizedResource.getMessage("IJ_Unx"));
410                 }
411                 else LocalizedResource.OutputWriter().println();
412         }
413
414         private boolean getExpect() {
415                 return Boolean.getBoolean("ij.expect");
416         }
417
418         private ijResult addSession
419         (
420                 Connection JavaDoc newConnection,
421                 String JavaDoc name
422         )
423                 throws SQLException JavaDoc
424         {
425                 if (currentConnEnv.haveSession(name)) {
426                         throw ijException.alreadyHaveConnectionNamed(name);
427                 }
428
429                 currentConnEnv.addSession( newConnection, name );
430                 return new ijConnectionResult( newConnection );
431         }
432
433         private String JavaDoc[] sortConnectionNames()
434         {
435                 int size = 100;
436                 int count = 0;
437                 String JavaDoc[] array = new String JavaDoc[size];
438                 String JavaDoc key;
439
440                 Hashtable JavaDoc ss = currentConnEnv.getSessions();
441                 // Calculate the number of connections in the sessions list and
442
// build an array of all the connection names.
443
for (Enumeration JavaDoc connectionNames = ss.keys(); connectionNames.hasMoreElements();) {
444                     if (count == size) {
445                        // need to expand the array
446
size = size*2;
447                        String JavaDoc[] expandedArray = new String JavaDoc[size];
448                        System.arraycopy(array, 0, expandedArray, 0, count);
449                        array = expandedArray;
450                     }
451                     key = (String JavaDoc)connectionNames.nextElement();
452                     array[ count++ ] = key;
453                 }
454
455                 java.util.Arrays.sort(array, 0, count);
456
457         return array;
458         }
459
460             /**
461       This is used at the ij startup time to see if there are already some
462           connections made and if so, show connections made so far.
463       Following also gets executed when user types show connections command
464           in ij. In the former case, ignore0Rows is set whereas in the later cas
465       it's set to false. The reason for this is, at ij startup time, if there
466       are no connections made so far, we don't want to show anything. Only if
467       there are connections made, we show the connections. Whereas in show
468       connection command case, we want to show the connection status either way
469       ie if there are no connections, we say no connections. Otherwise we list
470       all the connections made so far.
471         */

472         public ijResult showConnectionsMethod(boolean ignore0Rows) throws SQLException JavaDoc {
473                 Hashtable JavaDoc ss = currentConnEnv.getSessions();
474                 Vector JavaDoc v = new Vector JavaDoc();
475                 SQLWarning JavaDoc w = null;
476         if (ss == null || ss.size() == 0) {
477                 if (!ignore0Rows)
478                 v.addElement(LocalizedResource.getMessage("IJ_NoConneAvail"));
479         }
480         else {
481                 boolean haveCurrent=false;
482                         int count = 0;
483                         for (Enumeration JavaDoc connectionNames = ss.keys(); connectionNames.hasMoreElements();
484                                                 connectionNames.nextElement())
485                         count++;
486             String JavaDoc[] array = sortConnectionNames();
487                     for ( int ictr = 0; ictr < count; ictr++ ) {
488                                 String JavaDoc connectionName = array[ ictr ];
489                 Session s = (Session)ss.get(connectionName);
490                 if (s.getConnection().isClosed()) {
491                         if (currentConnEnv.getSession() != null &&
492                                         connectionName.equals(currentConnEnv.getSession().getName())) {
493                                 currentConnEnv.removeCurrentSession();
494                                 theConnection = null;
495                         }
496                         else
497                         currentConnEnv.removeSession(connectionName);
498                 }
499                 else {
500                         StringBuffer JavaDoc row = new StringBuffer JavaDoc();
501                         row.append(connectionName);
502                         if (currentConnEnv.getSession() != null &&
503                                 connectionName.equals(currentConnEnv.getSession().getName())) {
504                                 row.append('*');
505                                 haveCurrent=true;
506                         }
507
508                                 //If ij.dataSource property is set, show only connection names.
509
//In this case, URL is not used to get connection, so do not append URL
510
String JavaDoc dsName = util.getSystemProperty("ij.dataSource");
511                                         if(dsName == null){
512                                 row.append(" - \u0009");
513                                 row.append(s.getConnection().getMetaData().getURL());
514                                 }
515                         // save the warnings from these connections
516
w = appendWarnings(w,s.getConnection().getWarnings());
517                         s.getConnection().clearWarnings();
518                         v.addElement(row.toString());
519                 }
520                 }
521                 if (haveCurrent)
522                 v.addElement(LocalizedResource.getMessage("IJ_CurreConne"));
523                     else
524                 v.addElement(LocalizedResource.getMessage("IJ_NoCurreConne"));
525                 }
526                 return new ijVectorResult(v,w);
527         }
528
529         /**
530        Returns a subset of the input integer array
531        
532        @param input The input integer array
533        @param start Starting index, inclusive
534        @param end Ending index, exclusive
535      */

536         public static int[] intArraySubset(final int[] input, int start, int end) {
537                 int[] res = new int[end-start];
538                 System.arraycopy(input, start, res, 0, end-start);
539                 return res;
540         }
541
542         /**
543        Verify that a table exists within a schema. Throws an exception
544        if table does not exist.
545        
546        @param schema Schema for the table
547        @param table Name of table to check for existence of
548      */

549         public void verifyTableExists(String JavaDoc schema, String JavaDoc table)
550         throws SQLException JavaDoc {
551                 if(schema == null)
552                         return;
553
554                 ResultSet JavaDoc rs = null;
555                 try {
556                         DatabaseMetaData JavaDoc dbmd = theConnection.getMetaData();
557                         rs = dbmd.getTables(null,schema,table,null);
558                         if(!rs.next())
559                                 throw ijException.noSuchTable(table);
560                 } finally {
561                         if(rs!=null)
562                                 rs.close();
563                 }
564         }
565
566         /**
567        Return a resultset of tables (or views, procs...) in the given schema.
568
569        @param schema Schema to get tables for, or null for search
570                       in all schemas.
571        @param tableType Types of tables to return, see
572                       {@link java.sql.DatabaseMetaData#getTableTypes}
573      */

574         public ijResult showTables(String JavaDoc schema, String JavaDoc[] tableType) throws SQLException JavaDoc {
575                 ResultSet JavaDoc rs = null;
576                 try {
577                         haveConnection();
578
579                         DatabaseMetaData JavaDoc dbmd = theConnection.getMetaData();
580                         rs = dbmd.getTables(null,schema,null,tableType);
581
582                         int[] displayColumns = new int[] {
583                                 rs.findColumn("TABLE_SCHEM"),
584                                 rs.findColumn("TABLE_NAME"),
585                                 rs.findColumn("REMARKS"),
586                         };
587                         int[] columnWidths = new int[] {
588                                 20,
589                                 30,
590                                 20,
591                         };
592
593                         return new ijResultSetResult(rs, displayColumns, columnWidths);
594                 } catch (SQLException JavaDoc e) {
595                         if(rs!=null)
596                                 rs.close();
597                         throw e;
598                 }
599         }
600
601         /**
602        Return a resultset of indexes for the given table or schema
603
604        @param schema schema to find indexes for
605        @param table table to find indexes for
606      */

607         public ijResult showIndexes(String JavaDoc schema, String JavaDoc table) throws SQLException JavaDoc {
608                 ResultSet JavaDoc rs = null;
609                 try {
610                         haveConnection();
611                         verifyTableExists(schema, table);
612
613                         DatabaseMetaData JavaDoc dbmd = theConnection.getMetaData();
614                         rs = dbmd.getIndexInfo(null, schema, table, false, true);
615
616                         int[] displayColumns = new int[] {
617                                 rs.findColumn("TABLE_SCHEM"),
618                                 rs.findColumn("TABLE_NAME"),
619                                 rs.findColumn("COLUMN_NAME"),
620                                 rs.findColumn("NON_UNIQUE"),
621                                 rs.findColumn("TYPE"),
622                                 rs.findColumn("ASC_OR_DESC"),
623                                 rs.findColumn("CARDINALITY"),
624                                 rs.findColumn("PAGES"),
625                         };
626                         int[] columnWidths = new int[] {
627                                 20,
628                                 20,
629                                 20,
630                                 6,
631                                 4,
632                                 4,
633                                 8,
634                                 8,
635                         };
636
637                         if(schema!=null) {
638                                 displayColumns = intArraySubset(displayColumns, 1,
639                                                                                                 displayColumns.length);
640                                 columnWidths = intArraySubset(columnWidths, 1,
641                                                                                                 columnWidths.length);
642                         }
643                         return new ijResultSetResult(rs, displayColumns, columnWidths);
644                 } catch (SQLException JavaDoc e) {
645                         if(rs!=null)
646                                 rs.close();
647                         throw e;
648                 }
649         }
650
651         /**
652        Return a resultset of procedures from database metadata
653      */

654         public ijResult showProcedures(String JavaDoc schema) throws SQLException JavaDoc {
655                 ResultSet JavaDoc rs = null;
656                 try {
657                         haveConnection();
658
659                         DatabaseMetaData JavaDoc dbmd = theConnection.getMetaData();
660                         rs = dbmd.getProcedures(null,schema,null);
661
662                         int[] displayColumns = new int[] {
663                                 rs.findColumn("PROCEDURE_SCHEM"),
664                                 rs.findColumn("PROCEDURE_NAME"),
665                                 rs.findColumn("REMARKS"),
666                         };
667                         int[] columnWidths = new int[] {
668                                 20,
669                                 30,
670                                 20,
671                         };
672
673                         return new ijResultSetResult(rs, displayColumns, columnWidths);
674                 } catch (SQLException JavaDoc e) {
675                         if(rs!=null)
676                                 rs.close();
677                         throw e;
678                 }
679         }
680
681         /**
682        Return a resultset of schemas from database metadata
683      */

684         public ijResult showSchemas() throws SQLException JavaDoc {
685                 ResultSet JavaDoc rs = null;
686                 try {
687                         haveConnection();
688
689                         DatabaseMetaData JavaDoc dbmd = theConnection.getMetaData();
690                         rs = dbmd.getSchemas();
691
692                         int[] displayColumns = new int[] {
693                                 rs.findColumn("TABLE_SCHEM")
694                         };
695                         int[] columnWidths = new int[] {
696                                 30
697                         };
698
699                         return new ijResultSetResult(rs, displayColumns, columnWidths);
700                 } catch (SQLException JavaDoc e) {
701                         if(rs!=null)
702                                 rs.close();
703                         throw e;
704                 }
705         }
706
707         /**
708        Outputs the names of all fields of given table. Outputs field
709        names and data type.
710      */

711         public ijResult describeTable(String JavaDoc schema, String JavaDoc table) throws SQLException JavaDoc {
712                 ResultSet JavaDoc rs = null;
713                 try {
714                         haveConnection();
715                         verifyTableExists(schema,table);
716
717                         DatabaseMetaData JavaDoc dbmd = theConnection.getMetaData();
718                         rs = dbmd.getColumns(null,schema,table,null);
719
720                         int[] displayColumns = new int[] {
721                                 rs.findColumn("TABLE_SCHEM"),
722                                 rs.findColumn("TABLE_NAME"),
723                                 rs.findColumn("COLUMN_NAME"),
724                                 rs.findColumn("TYPE_NAME"),
725                                 rs.findColumn("DECIMAL_DIGITS"),
726                                 rs.findColumn("NUM_PREC_RADIX"),
727                                 rs.findColumn("COLUMN_SIZE"),
728                                 rs.findColumn("COLUMN_DEF"),
729                                 rs.findColumn("CHAR_OCTET_LENGTH"),
730                                 rs.findColumn("IS_NULLABLE"),
731                         };
732                         int[] columnWidths = new int[] {
733                                 20,
734                                 20,
735                                 20,
736                                 9,
737                                 4,
738                                 4,
739                                 6,
740                                 10,
741                                 10,
742                                 8
743                         };
744
745                         //
746
// If schema is specified (if util.getSelectedSchema in
747
// DescTableStatement() returns correct value), then we
748
// don't need to output schema and table names.
749
if(schema!=null) {
750                                 displayColumns = intArraySubset(displayColumns, 2,
751                                                                                                 displayColumns.length);
752                                 columnWidths = intArraySubset(columnWidths, 2,
753                                                                                                 columnWidths.length);
754                         }
755
756                         return new ijResultSetResult(rs, displayColumns, columnWidths);
757                 } catch (SQLException JavaDoc e) {
758                         if(rs!=null)
759                                 rs.close();
760                         throw e;
761                 }
762         }
763
764         private Object JavaDoc makeXid(int xid)
765         {
766                 return null;
767         }
768
769 //
770
// start of BNF rules
771
//
772
final public ijResult ijStatement() throws ParseException, SQLException JavaDoc {
773         ijResult r = null;
774     if (jj_2_56(2)) {
775       if (getToken(1).kind == ROLLBACK &&
776                               (!(getToken(3).kind == TO || getToken(3).kind == SAVEPOINT))) {
777         r = RollbackStatement();
778       } else if (jj_2_1(2)) {
779         r = AbsoluteStatement();
780       } else if (jj_2_2(2)) {
781         r = AfterLastStatement();
782       } else if (jj_2_3(2)) {
783         r = AutocommitStatement();
784       } else if (jj_2_4(2)) {
785         r = AsyncStatement();
786       } else if (jj_2_5(2)) {
787         r = Bang();
788       } else if (jj_2_6(2)) {
789         r = BeforeFirstStatement();
790       } else if (jj_2_7(2)) {
791         r = CloseStatement();
792       } else if (jj_2_8(2)) {
793         r = CommitStatement();
794       } else if (jj_2_9(2)) {
795         r = ConnectStatement();
796       } else if (jj_2_10(2)) {
797         r = DescTableStatement();
798       } else if (jj_2_11(2)) {
799         r = DisconnectStatement();
800       } else if (jj_2_12(2)) {
801         r = DriverStatement();
802       } else if (jj_2_13(2)) {
803         r = ElapsedTimeStatement();
804       } else if (jj_2_14(2)) {
805         r = ExecuteStatement();
806       } else if (jj_2_15(2)) {
807         r = FirstStatement();
808       } else if (jj_2_16(2)) {
809         r = FirstStatement();
810       } else if (jj_2_17(2)) {
811         r = JBMSPreparedStatementExec();
812       } else if (jj_2_18(2)) {
813         r = F2KExecuteProcedure();
814       } else if (jj_2_19(2)) {
815         r = ExitStatement();
816       } else if (jj_2_20(2)) {
817         r = ExpectStatement();
818       } else if (jj_2_21(2)) {
819         r = GetCursorStatement();
820       } else if (jj_2_22(2)) {
821         r = GetCurrentRowNumber();
822       } else if (jj_2_23(2)) {
823         r = HelpStatement();
824       } else if (jj_2_24(2)) {
825         r = IllegalStatementName();
826       } else if (jj_2_25(2)) {
827         r = LastStatement();
828       } else if (jj_2_26(2)) {
829         r = LocalizedDisplay();
830       } else if (jj_2_27(2)) {
831         r = MaximumDisplayWidthStatement();
832       } else if (jj_2_28(2)) {
833         r = NextStatement();
834       } else if (jj_2_29(2)) {
835         r = NoHoldForConnectionStatement();
836       } else if (jj_2_30(2)) {
837         r = PrepareStatement();
838       } else if (jj_2_31(2)) {
839         r = PreviousStatement();
840       } else if (jj_2_32(2)) {
841         r = ProtocolStatement();
842       } else if (jj_2_33(2)) {
843         r = ReadOnlyStatement();
844       } else if (jj_2_34(2)) {
845         r = RelativeStatement();
846       } else if (jj_2_35(2)) {
847         r = RemoveStatement();
848       } else if (jj_2_36(2)) {
849         r = RunStatement();
850       } else if (jj_2_37(2)) {
851         r = SetConnectionStatement();
852       } else if (jj_2_38(2)) {
853         r = ShowStatement();
854       } else if (jj_2_39(2)) {
855         r = WaitForStatement();
856       } else if (jj_2_40(2)) {
857         r = XA_DataSourceStatement();
858       } else if (jj_2_41(2)) {
859         r = XA_ConnectStatement();
860       } else if (jj_2_42(2)) {
861         r = XA_CommitStatement();
862       } else if (jj_2_43(2)) {
863         r = XA_DisconnectStatement();
864       } else if (jj_2_44(2)) {
865         r = XA_GetConnectionStatement();
866       } else if (jj_2_45(2)) {
867         r = XA_EndStatement();
868       } else if (jj_2_46(2)) {
869         r = XA_ForgetStatement();
870       } else if (jj_2_47(2)) {
871         r = XA_PrepareStatement();
872       } else if (jj_2_48(2)) {
873         r = XA_RecoverStatement();
874       } else if (jj_2_49(2)) {
875         r = XA_RollbackStatement();
876       } else if (jj_2_50(2)) {
877         r = XA_StartStatement();
878       } else if (jj_2_51(2)) {
879         r = DataSourceStatement();
880       } else if (jj_2_52(2)) {
881         r = CP_DataSourceStatement();
882       } else if (jj_2_53(2)) {
883         r = CP_ConnectStatement();
884       } else if (jj_2_54(2)) {
885         r = CP_GetConnectionStatement();
886       } else if (jj_2_55(2)) {
887         r = CP_DisconnectStatement();
888       } else {
889         jj_consume_token(-1);
890         throw new ParseException();
891       }
892     } else {
893       ;
894     }
895     jj_consume_token(0);
896                 {if (true) return r;}
897     throw new Error JavaDoc("Missing return statement in function");
898   }
899
900 /**
901  * ProtocolStatement is PROTOCOL 'JDBC protocol' where
902  * the protocol is used to prefix any connect request that
903  * cannot find a driver. We will take a stab at loading
904  * a driver as each protocol comes in -- we only know about
905  * two.
906  */

907   final public ijResult ProtocolStatement() throws ParseException, SQLException JavaDoc {
908         Token t;
909         String JavaDoc n = null;
910     jj_consume_token(PROTOCOL);
911     t = jj_consume_token(STRING);
912     if (jj_2_57(2)) {
913       jj_consume_token(AS);
914       n = identifier();
915     } else {
916       ;
917     }
918                 installProtocol(n, stringValue(t.image));
919                 {if (true) return null;}
920     throw new Error JavaDoc("Missing return statement in function");
921   }
922
923 /**
924  * DriverStatement is DRIVER 'class' where class is the
925  * name of a class that is a JDBC driver. It is loaded
926  * into the DriverManager with a Class.forName call.
927  * <p>
928  * You can load as many drivers as you want, the idea is
929  * to load up the appropriate one(s) for the connect(s)
930  * that you will be issuing.
931  */

932   final public ijResult DriverStatement() throws ParseException, SQLException JavaDoc {
933         Token t;
934         String JavaDoc sVal = null;
935     jj_consume_token(DRIVER);
936     t = jj_consume_token(STRING);
937             try {
938                 // t.image is a class name;
939
// we load the "driver" in the prototypical
940
// manner, it will register itself with
941
// the DriverManager.
942
sVal = stringValue(t.image);
943                         util.loadDriver(sVal);
944             } catch (ClassNotFoundException JavaDoc e) {
945                         {if (true) throw ijException.classNotFound(sVal);}
946             } catch (IllegalArgumentException JavaDoc e) {
947                         {if (true) throw ijException.driverNotClassName(sVal);}
948             } catch (IllegalAccessException JavaDoc e) {
949                         {if (true) throw ijException.classNotFound(sVal);}
950             } catch (InstantiationException JavaDoc e) {
951                         {if (true) throw ijException.classNotFound(sVal);}
952             }
953                 {if (true) return null;}
954     throw new Error JavaDoc("Missing return statement in function");
955   }
956
957   final public ijResult ConnectStatement() throws ParseException, SQLException JavaDoc {
958         ijResult result;
959     if (jj_2_60(2)) {
960       jj_consume_token(CONNECT);
961       jj_consume_token(TO);
962       result = dynamicConnection(true);
963                 {if (true) return result;}
964     } else if (jj_2_61(2)) {
965       jj_consume_token(CONNECT);
966       if (jj_2_58(2)) {
967         result = dynamicConnection(false);
968       } else if (jj_2_59(2)) {
969         result = staticConnection();
970       } else {
971         jj_consume_token(-1);
972         throw new ParseException();
973       }
974                 {if (true) return result;}
975     } else {
976       jj_consume_token(-1);
977       throw new ParseException();
978     }
979     throw new Error JavaDoc("Missing return statement in function");
980   }
981
982 /**
983  * ConnectStatement is CONNECT 'url' [ PROTOCOL proto ]
984     [ USER String PASSWORD String ]
985     [ATTRIBUTES attributeName = value [, attributeName = value]* ]
986     [ AS ident ], where url is the
987  * url for the database, i.e. jdbc:protocol:dbname etc.
988  * Attributes are connection attributes to
989  * <p>
990  * There can only be one connection at a time; if there
991  * is already one, it is put on hold and this one takes its place.
992  * <p>
993  * if a driver can't be found, the current protocol will
994  * be added at the front.
995  * <p>
996  * the as ident part is used for set connection. If you don't
997  * specify a name, we create one that is CONNECTION# for the #
998  * of open connections that now exists. If the name duplicates,
999  * an error results.
1000 */

1001  final public ijResult dynamicConnection(boolean simplifiedPath) throws ParseException, SQLException JavaDoc {
1002        Token t;
1003        Token userT = null;
1004        Token passwordT = null;
1005        String JavaDoc n = null, p = null, sVal;
1006    String JavaDoc userS = util.getSystemProperty(USER_PROPERTY);
1007    String JavaDoc passwordS = util.getSystemProperty(PASSWORD_PROPERTY);
1008        Properties JavaDoc connInfo = null;
1009    t = jj_consume_token(STRING);
1010    if (jj_2_62(2)) {
1011      jj_consume_token(PROTOCOL);
1012      p = identifier();
1013    } else {
1014      ;
1015    }
1016    if (jj_2_63(2)) {
1017      jj_consume_token(USER);
1018      userT = jj_consume_token(STRING);
1019    } else {
1020      ;
1021    }
1022    if (jj_2_64(2)) {
1023      jj_consume_token(PASSWORD);
1024      passwordT = jj_consume_token(STRING);
1025    } else {
1026      ;
1027    }
1028    if (jj_2_65(2)) {
1029      jj_consume_token(ATTRIBUTES);
1030      connInfo = attributeList();
1031    } else {
1032      ;
1033    }
1034    if (jj_2_66(2)) {
1035      jj_consume_token(AS);
1036      n = identifier();
1037    } else {
1038      ;
1039    }
1040                // t.image is a database URL
1041
// we get the connection and salt it away
1042
// for use with other statements.
1043
//
1044
// FUTURE: we could have the syntax be
1045
// CONNECT <STRING> AS <IDENTIFIER>
1046
// and have a SET CONNECTION string to
1047
// re-activate a named connection.
1048
// Or not, and wait for SQL-J to support that
1049
// statement... although then we will have to
1050
// figure out if we will allow that SQL-J through
1051
// JDBC or not.
1052
// get the value of the string
1053
// n.b. at some point this will have to deal with ''s
1054
if (userT != null)
1055                userS = stringValue(userT.image);
1056
1057        if (passwordT != null)
1058                passwordS = stringValue(passwordT.image);
1059
1060        //If ij.dataSource property is set,use DataSource to get the connection
1061
String JavaDoc dsName = util.getSystemProperty("ij.dataSource");
1062                if (dsName != null){
1063                //Check that t.image does not start with jdbc:
1064
//If it starts with jdbc:, do not use DataSource to get connection
1065
sVal = stringValue(t.image);
1066                if(!sVal.startsWith("jdbc:") ){
1067                        theConnection = util.getDataSourceConnection(dsName,userS,passwordS,sVal,false);
1068                        {if (true) return addSession( theConnection, n );}
1069                }
1070        }
1071
1072                if (simplifiedPath)
1073                        // url for the database W/O 'jdbc:protocol:', i.e. just a dbname
1074
// For example,
1075
// CONNECT TO 'test'
1076
// is equivalent to
1077
// CONNECT TO 'jdbc:derby:test'
1078
sVal = "jdbc:derby:" + stringValue(t.image);
1079                else
1080                        sVal = stringValue(t.image);
1081
1082                // add named protocol if it was specified
1083
if (p != null) {
1084                        String JavaDoc protocol = (String JavaDoc)namedProtocols.get(p);
1085                        if (protocol == null) { {if (true) throw ijException.noSuchProtocol(p);} }
1086                        sVal = protocol + sVal;
1087                }
1088
1089                // add protocol if no driver matches url
1090
boolean noDriver = false;
1091                        // if we have a full URL, make sure it's loaded first
1092
try {
1093                                if (sVal.startsWith("jdbc:"))
1094                                        util.loadDriverIfKnown(sVal);
1095                        } catch (Exception JavaDoc e) {
1096                                // want to continue with the attempt
1097
}
1098                        // By default perform extra checking on the URL attributes.
1099
// This checking does not change the processing.
1100
if (System.getProperty("ij.URLCheck") == null || Boolean.getBoolean("ij.URLCheck")) {
1101                          URLCheck aCheck = new URLCheck(sVal);
1102                        }
1103                if (!sVal.startsWith("jdbc:") && (p == null) && (protocol != null)) {
1104                        sVal = protocol + sVal;
1105                }
1106
1107
1108                // If no ATTRIBUTES on the connection get them from the
1109
// defaults
1110
if (connInfo == null)
1111                        connInfo = util.updateConnInfo(userS,passwordS,
1112                        utilInstance.getConnAttributeDefaults());
1113                else
1114                        connInfo = util.updateConnInfo(userS,passwordS, connInfo);
1115
1116
1117                theConnection = DriverManager.getConnection(sVal,connInfo);
1118
1119                {if (true) return addSession( theConnection, n );}
1120    throw new Error JavaDoc("Missing return statement in function");
1121  }
1122
1123/**
1124 * Handles DESCRIBE table
1125 */

1126  final public ijResult DescTableStatement() throws ParseException, SQLException JavaDoc {
1127        String JavaDoc i = null;
1128        String JavaDoc i2 = null;
1129        Token s = null;
1130    jj_consume_token(DESCRIBE);
1131    if (jj_2_67(2)) {
1132      i = identifier();
1133      jj_consume_token(PERIOD);
1134      i2 = identifier();
1135    } else if (jj_2_68(2)) {
1136      i2 = identifier();
1137    } else if (jj_2_69(2)) {
1138      s = jj_consume_token(STRING);
1139    } else {
1140      jj_consume_token(-1);
1141      throw new ParseException();
1142    }
1143                if(s!=null) {
1144                        String JavaDoc image = stringValue(s.image.toUpperCase());
1145
1146                        int dotPosition = image.indexOf('.');
1147                        if(dotPosition!=-1) {
1148                                i = image.substring(0,dotPosition);
1149                                i2 = image.substring(dotPosition+1);
1150                        }
1151                }
1152
1153                if(i==null)
1154                        i = util.getSelectedSchema(theConnection);
1155
1156                {if (true) return describeTable(i,i2);}
1157    throw new Error JavaDoc("Missing return statement in function");
1158  }
1159
1160/**
1161  * Handles CONNECT yadda.yadda.foo( stringArg, ... stringArg ) AS connectionName
1162  */

1163  final public ijResult staticConnection() throws ParseException, SQLException JavaDoc {
1164        String JavaDoc name = null;
1165        Vector JavaDoc idList;
1166        int idx = 0;
1167        int lastID = 0;
1168        StringBuffer JavaDoc buffer;
1169        String JavaDoc className;
1170        String JavaDoc methodName;
1171        Class JavaDoc classC;
1172        Method method;
1173        int argCount;
1174        String JavaDoc[] args;
1175        Class JavaDoc stringClass;
1176        Class JavaDoc[] argTypes;
1177        ijResult result = null;
1178    idList = staticMethodName();
1179    args = staticMethodArgs();
1180    if (jj_2_70(2)) {
1181      jj_consume_token(AS);
1182      name = identifier();
1183    } else {
1184      ;
1185    }
1186                lastID = idList.size() - 1;
1187                buffer = new StringBuffer JavaDoc();
1188
1189                for ( ; idx < lastID; idx++ )
1190                {
1191                        if ( idx > 0 ) { buffer.append( "." ); }
1192                        buffer.append( (String JavaDoc) idList.elementAt( idx ) );
1193                }
1194                methodName = (String JavaDoc) idList.elementAt( idx );
1195                className = buffer.toString();
1196
1197                try {
1198                        argCount = args.length;
1199                        argTypes = new Class JavaDoc[ argCount ];
1200                        stringClass = Class.forName( "java.lang.String" );
1201                        for ( idx = 0; idx < argCount; idx++ ) { argTypes[ idx ] = stringClass; }
1202
1203                        classC = Class.forName( className );
1204                        method = classC.getMethod( methodName, argTypes );
1205                        theConnection = (Connection JavaDoc) method.invoke( null, args );
1206                        result = addSession( theConnection, name );
1207
1208                }
1209                catch (java.lang.reflect.InvocationTargetException JavaDoc ite) {
1210                        Throwable JavaDoc t = ite.getTargetException();
1211                        if (t instanceof SQLException JavaDoc)
1212                                {if (true) throw (SQLException JavaDoc) t;}
1213
1214                        {if (true) throw new SQLException JavaDoc( t.toString() );}
1215                }
1216                catch (Exception JavaDoc e) { {if (true) throw new SQLException JavaDoc( e.toString() );} }
1217
1218                {if (true) return result;}
1219    throw new Error JavaDoc("Missing return statement in function");
1220  }
1221
1222/**
1223 * SetConnectionStatement is SET CONNECTION ident
1224 * <p>
1225 * Moves to the named session, if it exists. If it doesn't
1226 * exist, remains on the current session and returns an error.
1227 */

1228  final public ijResult SetConnectionStatement() throws ParseException, SQLException JavaDoc {
1229        String JavaDoc t;
1230    jj_consume_token(SET);
1231    jj_consume_token(CONNECTION);
1232    t = identifier();
1233                if (!currentConnEnv.haveSession(t)) {
1234                        {if (true) throw ijException.noSuchConnection(t);}
1235                }
1236                currentConnEnv.setCurrentSession(t);
1237                theConnection = currentConnEnv.getConnection();
1238                {if (true) return new ijConnectionResult(theConnection);}
1239    throw new Error JavaDoc("Missing return statement in function");
1240  }
1241
1242/**
1243 * Handles showing current connections for the current environment, and
1244 * SHOW TABLES/VIEWS/... commands.
1245 */

1246  final public ijResult ShowStatement() throws ParseException, SQLException JavaDoc {
1247        String JavaDoc schema = null;
1248        String JavaDoc tblname = null;
1249        String JavaDoc str = null;
1250        String JavaDoc[] types = null;
1251        Token t = null;
1252        Token v = null;
1253    if (jj_2_81(2)) {
1254      jj_consume_token(SHOW);
1255      jj_consume_token(CONNECTIONS);
1256                {if (true) return showConnectionsMethod(false);}
1257    } else if (jj_2_82(2)) {
1258      jj_consume_token(SHOW);
1259      if (jj_2_71(2)) {
1260        t = jj_consume_token(TABLES);
1261      } else if (jj_2_72(2)) {
1262        v = jj_consume_token(VIEWS);
1263      } else if (jj_2_73(2)) {
1264        jj_consume_token(SYNONYMS);
1265      } else if (jj_2_74(2)) {
1266        jj_consume_token(ALIASES);
1267      } else {
1268        jj_consume_token(-1);
1269        throw new ParseException();
1270      }
1271      if (jj_2_75(2)) {
1272        jj_consume_token(IN);
1273        schema = identifier();
1274      } else {
1275        ;
1276      }
1277                if(t!=null) {
1278                    types = new String JavaDoc[] { "TABLE", "SYSTEM TABLE" };
1279                }
1280                else if(v!=null)
1281                        types = new String JavaDoc[] { "VIEW" };
1282                else
1283                        types = new String JavaDoc[] { "ALIAS" };
1284                {if (true) return showTables(schema, types);}
1285    } else if (jj_2_83(2)) {
1286      jj_consume_token(SHOW);
1287      jj_consume_token(INDEXES);
1288      if (jj_2_79(2)) {
1289        if (jj_2_77(2)) {
1290          jj_consume_token(IN);
1291          schema = identifier();
1292        } else if (jj_2_78(2)) {
1293          jj_consume_token(FROM);
1294          tblname = identifier();
1295          if (jj_2_76(2)) {
1296            jj_consume_token(PERIOD);
1297            str = identifier();
1298          } else {
1299            ;
1300          }
1301        } else {
1302          jj_consume_token(-1);
1303          throw new ParseException();
1304        }
1305      } else {
1306        ;
1307      }
1308                if(str != null) {
1309                        // if absolute table reference given
1310
schema = tblname;
1311                        tblname = str;
1312                }
1313
1314                // If user specifies a table name, then assume schema is
1315
// current schema. Note that getSelectedSchema may return
1316
// null for some DBMSes.
1317
if(schema == null && tblname != null)
1318                        schema = util.getSelectedSchema(theConnection);
1319                {if (true) return showIndexes(schema,tblname);}
1320    } else if (jj_2_84(2)) {
1321      jj_consume_token(SHOW);
1322      jj_consume_token(PROCEDURES);
1323      if (jj_2_80(2)) {
1324        jj_consume_token(IN);
1325        schema = identifier();
1326      } else {
1327        ;
1328      }
1329                {if (true) return showProcedures(schema);}
1330    } else if (jj_2_85(2)) {
1331      jj_consume_token(SHOW);
1332      jj_consume_token(SCHEMAS);
1333                {if (true) return showSchemas();}
1334    } else {
1335      jj_consume_token(-1);
1336      throw new ParseException();
1337    }
1338    throw new Error JavaDoc("Missing return statement in function");
1339  }
1340
1341/**
1342 * CommitStatement is simply COMMIT.
1343 * It commits the current transation.
1344 */

1345  final public ijResult CommitStatement() throws ParseException, SQLException JavaDoc {
1346    jj_consume_token(COMMIT);
1347    if (jj_2_86(2)) {
1348      jj_consume_token(WORK);
1349    } else {
1350      ;
1351    }
1352                haveConnection();
1353                theConnection.commit();
1354                {if (true) return null;}
1355    throw new Error JavaDoc("Missing return statement in function");
1356  }
1357
1358/**
1359 * RollbackStatement is simply ROLLBACK.
1360 * It undoes the current transation.
1361 */

1362  final public ijResult RollbackStatement() throws ParseException, SQLException JavaDoc {
1363    jj_consume_token(ROLLBACK);
1364    if (jj_2_87(2)) {
1365      jj_consume_token(WORK);
1366    } else {
1367      ;
1368    }
1369                haveConnection();
1370                theConnection.rollback();
1371                {if (true) return null;}
1372    throw new Error JavaDoc("Missing return statement in function");
1373  }
1374
1375/**
1376 * DisconnectStatement is simply DISCONNECT [ ALL | CURRENT | connectionName ]
1377 * it ends the specified connection(s) and
1378 * releases its statement resource.
1379 * <p>
1380 * If ALL is specified, it disconnects all available sessions
1381 * in the current environment.
1382 */

1383  final public ijResult DisconnectStatement() throws ParseException, SQLException JavaDoc {
1384        Token a = null;
1385        String JavaDoc n = null;
1386    jj_consume_token(DISCONNECT);
1387    if (jj_2_91(2)) {
1388      if (jj_2_88(2)) {
1389        jj_consume_token(CURRENT);
1390      } else if (jj_2_89(2)) {
1391        a = jj_consume_token(ALL);
1392      } else if (jj_2_90(2)) {
1393        n = identifier();
1394      } else {
1395        jj_consume_token(-1);
1396        throw new ParseException();
1397      }
1398    } else {
1399      ;
1400    }
1401                if ( a == null ) {
1402                        if (n == null) {
1403                        // only remove the current session
1404
haveConnection();
1405                            // Also need to release the session object
1406
currentConnEnv.removeCurrentSession();
1407                            theConnection = null;
1408                        }
1409                        else {
1410                            if (! currentConnEnv.haveSession(n))
1411                                    {if (true) throw ijException.noSuchConnection(n);}
1412                                currentConnEnv.removeSession(n);
1413                            if (currentConnEnv.getSession() == null)
1414                                    theConnection = null;
1415                        }
1416                } else {
1417                        currentConnEnv.removeAllSessions();
1418                        theConnection = null;
1419                }
1420                {if (true) return null;}
1421    throw new Error JavaDoc("Missing return statement in function");
1422  }
1423
1424  final public ijResult ExitStatement() throws ParseException, SQLException JavaDoc {
1425    if (jj_2_92(2)) {
1426      jj_consume_token(EXIT);
1427                {if (true) return quit();}
1428    } else if (jj_2_93(2)) {
1429      jj_consume_token(QUIT);
1430                {if (true) return quit();}
1431    } else {
1432      jj_consume_token(-1);
1433      throw new ParseException();
1434    }
1435    throw new Error JavaDoc("Missing return statement in function");
1436  }
1437
1438  final public ijResult IllegalStatementName() throws ParseException, SQLException JavaDoc {
1439        Token s = null;
1440    jj_consume_token(PREPARE);
1441    jj_consume_token(PROCEDURE);
1442    jj_consume_token(AS);
1443    s = jj_consume_token(STRING);
1444                // "procedure" is not allowed as a statement name. this is
1445
// because "execute procedure" is a valid Foundation2000
1446
// command
1447
{if (true) throw ijException.illegalStatementName( "procedure" );}
1448    throw new Error JavaDoc("Missing return statement in function");
1449  }
1450
1451  final public ijResult PrepareStatement() throws ParseException, SQLException JavaDoc {
1452        Token t;
1453        String JavaDoc i;
1454        PreparedStatement JavaDoc ps;
1455        String JavaDoc sVal;
1456    jj_consume_token(PREPARE);
1457    i = identifier();
1458    jj_consume_token(AS);
1459    t = jj_consume_token(STRING);
1460                haveConnection();
1461                sVal = stringValue(t.image);
1462                ps = theConnection.prepareStatement(sVal);
1463                JDBCDisplayUtil.checkNotNull(ps,"prepared statement");
1464                currentConnEnv.getSession().addPreparedStatement(i,ps);
1465
1466                // all we want callers to see are the warnings.
1467
SQLWarning JavaDoc w = ps.getWarnings();
1468                ps.clearWarnings();
1469                {if (true) return new ijWarningResult(w);}
1470    throw new Error JavaDoc("Missing return statement in function");
1471  }
1472
1473  final public ijResult GetCursorStatement() throws ParseException, SQLException JavaDoc {
1474        haveConnection();
1475        int scrollType = JDBC20Translation.TYPE_FORWARD_ONLY;
1476        Token s;
1477        Token scrolling = null;
1478        Token withtoken = null;
1479        int holdType = utilInstance.getHoldability(theConnection);
1480        String JavaDoc c;
1481        Statement JavaDoc st = null;
1482        String JavaDoc sVal;
1483        ResultSet JavaDoc rs = null;
1484        SQLWarning JavaDoc warns;
1485    jj_consume_token(GET);
1486    if (jj_2_94(2)) {
1487      scrolling = jj_consume_token(SCROLL);
1488      scrollType = scrollType();
1489    } else {
1490      ;
1491    }
1492    if (jj_2_95(2)) {
1493      withtoken = jj_consume_token(WITH);
1494      holdType = holdType();
1495    } else {
1496      ;
1497    }
1498    jj_consume_token(CURSOR);
1499    c = identifier();
1500    jj_consume_token(AS);
1501    s = jj_consume_token(STRING);
1502                sVal = stringValue(s.image);
1503                try {
1504                        st = utilInstance.createStatement(theConnection, scrollType, holdType);
1505                        JDBCDisplayUtil.checkNotNull(st,"cursor");
1506                        st.setCursorName(c);
1507                        rs = st.executeQuery(sVal);
1508                        JDBCDisplayUtil.checkNotNull(rs,"cursor");
1509                        Session sn = currentConnEnv.getSession();
1510                        sn.addCursorStatement(c,st);
1511                        sn.addCursor(c,rs);
1512                } catch (SQLException JavaDoc e) {
1513                        if (rs!=null) rs.close();
1514                        if (st!=null) st.close();
1515                        {if (true) throw e;}
1516                }
1517
1518                // all we want callers to see are the warnings.
1519
SQLWarning JavaDoc w1 = theConnection.getWarnings();
1520                SQLWarning JavaDoc w2 = st.getWarnings();
1521                SQLWarning JavaDoc w3 = rs.getWarnings();
1522                theConnection.clearWarnings();
1523                st.clearWarnings();
1524                rs.clearWarnings();
1525                warns = appendWarnings(w1,w2);
1526                {if (true) return new ijWarningResult(appendWarnings(warns,w3));}
1527    throw new Error JavaDoc("Missing return statement in function");
1528  }
1529
1530  final public int scrollType() throws ParseException, SQLException JavaDoc {
1531    if (jj_2_96(2)) {
1532      jj_consume_token(INSENSITIVE);
1533                {if (true) return JDBC20Translation.TYPE_SCROLL_INSENSITIVE;}
1534    } else if (jj_2_97(2)) {
1535      jj_consume_token(SENSITIVE);
1536                {if (true) return JDBC20Translation.TYPE_SCROLL_SENSITIVE;}
1537    } else {
1538      jj_consume_token(-1);
1539      throw new ParseException();
1540    }
1541    throw new Error JavaDoc("Missing return statement in function");
1542  }
1543
1544  final public int holdType() throws ParseException, SQLException JavaDoc {
1545    if (jj_2_98(2)) {
1546      jj_consume_token(HOLD);
1547                {if (true) return JDBC30Translation.HOLD_CURSORS_OVER_COMMIT;}
1548    } else if (jj_2_99(2)) {
1549      jj_consume_token(NOHOLD);
1550                {if (true) return JDBC30Translation.CLOSE_CURSORS_AT_COMMIT;}
1551    } else {
1552      jj_consume_token(-1);
1553      throw new ParseException();
1554    }
1555    throw new Error JavaDoc("Missing return statement in function");
1556  }
1557
1558  final public ijResult AbsoluteStatement() throws ParseException, SQLException JavaDoc {
1559        int row;
1560        String JavaDoc c;
1561        ResultSet JavaDoc rs;
1562    jj_consume_token(ABSOLUTE);
1563    row = intLiteral();
1564    c = identifier();
1565                haveConnection();
1566                // Verify that we have JDBC 2.0
1567
Session s = currentConnEnv.getSession();
1568                rs = (ResultSet JavaDoc) s.getCursor(c);
1569                JDBCDisplayUtil.checkNotNull(rs,"cursor");
1570
1571                {if (true) return utilInstance.absolute(rs, row);}
1572    throw new Error JavaDoc("Missing return statement in function");
1573  }
1574
1575  final public ijResult RelativeStatement() throws ParseException, SQLException JavaDoc {
1576        int row;
1577        String JavaDoc c;
1578        ResultSet JavaDoc rs;
1579    jj_consume_token(RELATIVE);
1580    row = intLiteral();
1581    c = identifier();
1582                haveConnection();
1583                // Verify that we have JDBC 2.0
1584
Session s = currentConnEnv.getSession();
1585                rs = (ResultSet JavaDoc) s.getCursor(c);
1586                JDBCDisplayUtil.checkNotNull(rs,"cursor");
1587
1588                {if (true) return utilInstance.relative(rs, row);}
1589    throw new Error JavaDoc("Missing return statement in function");
1590  }
1591
1592  final public ijResult BeforeFirstStatement() throws ParseException, SQLException JavaDoc {
1593        String JavaDoc c;
1594        ResultSet JavaDoc rs;
1595    jj_consume_token(BEFORE);
1596    jj_consume_token(FIRST);
1597    c = identifier();
1598                haveConnection();
1599                // Verify that we have JDBC 2.0
1600
Session s = currentConnEnv.getSession();
1601                rs = (ResultSet JavaDoc) s.getCursor(c);
1602                JDBCDisplayUtil.checkNotNull(rs,"cursor");
1603
1604                {if (true) return utilInstance.beforeFirst(rs);}
1605    throw new Error JavaDoc("Missing return statement in function");
1606  }
1607
1608  final public ijResult FirstStatement() throws ParseException, SQLException JavaDoc {
1609        String JavaDoc c;
1610        ResultSet JavaDoc rs;
1611    jj_consume_token(FIRST);
1612    c = identifier();
1613                haveConnection();
1614                // Verify that we have JDBC 2.0
1615
Session s = currentConnEnv.getSession();
1616                rs = (ResultSet JavaDoc) s.getCursor(c);
1617                JDBCDisplayUtil.checkNotNull(rs,"cursor");
1618
1619                {if (true) return utilInstance.first(rs);}
1620    throw new Error JavaDoc("Missing return statement in function");
1621  }
1622
1623  final public ijResult NextStatement() throws ParseException, SQLException JavaDoc {
1624        String JavaDoc c;
1625        ResultSet JavaDoc rs;
1626    jj_consume_token(NEXT);
1627    c = identifier();
1628                haveConnection();
1629                Session s = currentConnEnv.getSession();
1630                rs = (ResultSet JavaDoc) s.getCursor(c);
1631                JDBCDisplayUtil.checkNotNull(rs,"cursor");
1632
1633                {if (true) return new ijRowResult(rs, rs.next());}
1634    throw new Error JavaDoc("Missing return statement in function");
1635  }
1636
1637  final public ijResult AfterLastStatement() throws ParseException, SQLException JavaDoc {
1638        String JavaDoc c;
1639        ResultSet JavaDoc rs;
1640    jj_consume_token(AFTER);
1641    jj_consume_token(LAST);
1642    c = identifier();
1643                haveConnection();
1644                // Verify that we have JDBC 2.0
1645
Session s = currentConnEnv.getSession();
1646                rs = (ResultSet JavaDoc) s.getCursor(c);
1647                JDBCDisplayUtil.checkNotNull(rs,"cursor");
1648
1649                {if (true) return utilInstance.afterLast(rs);}
1650    throw new Error JavaDoc("Missing return statement in function");
1651  }
1652
1653  final public ijResult LastStatement() throws ParseException, SQLException JavaDoc {
1654        String JavaDoc c;
1655        ResultSet JavaDoc rs;
1656    jj_consume_token(LAST);
1657    c = identifier();
1658                haveConnection();
1659                // Verify that we have JDBC 2.0
1660
Session s = currentConnEnv.getSession();
1661                rs = (ResultSet JavaDoc) s.getCursor(c);
1662                JDBCDisplayUtil.checkNotNull(rs,"cursor");
1663
1664                {if (true) return utilInstance.last(rs);}
1665    throw new Error JavaDoc("Missing return statement in function");
1666  }
1667
1668  final public ijResult PreviousStatement() throws ParseException, SQLException JavaDoc {
1669        String JavaDoc c;
1670        ResultSet JavaDoc rs;
1671    jj_consume_token(PREVIOUS);
1672    c = identifier();
1673                haveConnection();
1674                // Verify that we have JDBC 2.0
1675
Session s = currentConnEnv.getSession();
1676                rs = (ResultSet JavaDoc) s.getCursor(c);
1677                JDBCDisplayUtil.checkNotNull(rs,"cursor");
1678
1679                {if (true) return utilInstance.previous(rs);}
1680    throw new Error JavaDoc("Missing return statement in function");
1681  }
1682
1683  final public ijResult GetCurrentRowNumber() throws ParseException, SQLException JavaDoc {
1684        ResultSet JavaDoc rs;
1685        String JavaDoc c;
1686    jj_consume_token(GETCURRENTROWNUMBER);
1687    c = identifier();
1688                haveConnection();
1689                // Verify that we have JDBC 2.0
1690
Session s = currentConnEnv.getSession();
1691                rs = (ResultSet JavaDoc) s.getCursor(c);
1692                JDBCDisplayUtil.checkNotNull(rs,"cursor");
1693
1694        LocalizedResource.OutputWriter().println(utilInstance.getCurrentRowNumber(rs));
1695                {if (true) return null;}
1696    throw new Error JavaDoc("Missing return statement in function");
1697  }
1698
1699  final public ijResult CloseStatement() throws ParseException, SQLException JavaDoc {
1700        String JavaDoc c;
1701        ResultSet JavaDoc rs;
1702        Statement JavaDoc s;
1703    jj_consume_token(CLOSE);
1704    c = identifier();
1705                haveConnection();
1706                Session sn = currentConnEnv.getSession();
1707                rs = (ResultSet JavaDoc) sn.getCursor(c);
1708                JDBCDisplayUtil.checkNotNull(rs,"cursor");
1709                s = (Statement JavaDoc) sn.getCursorStatement(c);
1710                JDBCDisplayUtil.checkNotNull(s,"cursor");
1711                rs.close();
1712                s.close();
1713                sn.removeCursor(c);
1714                sn.removeCursorStatement(c);
1715
1716                {if (true) return null;}
1717    throw new Error JavaDoc("Missing return statement in function");
1718  }
1719
1720/**
1721 * Hack to get the grammar to leave a
1722 * EXECUTE STATEMENT &lt;stmt&gt; alone. Short
1723 * circuit the ij EXECUTE built in.
1724 */

1725  final public ijResult JBMSPreparedStatementExec() throws ParseException, SQLException JavaDoc {
1726        Token s = null;
1727    jj_consume_token(EXECUTE);
1728    jj_consume_token(STATEMENT);
1729    s = jj_consume_token(STRING);
1730                {if (true) return executeImmediate(stringValue(s.image));}
1731    throw new Error JavaDoc("Missing return statement in function");
1732  }
1733
1734/**
1735 * Hack to get the grammar to leave a
1736 * EXECUTE PROCEDURE &lt;procSpec&gt; alone. Short
1737 * circuit the ij EXECUTE built in so that
1738 * we can deploy ij against Foundation2000.
1739 */

1740  final public ijResult F2KExecuteProcedure() throws ParseException, SQLException JavaDoc {
1741        Token s = null;
1742    jj_consume_token(EXECUTE);
1743    jj_consume_token(PROCEDURE);
1744    s = jj_consume_token(STRING);
1745                haveConnection();
1746
1747                Statement JavaDoc aStatement = theConnection.createStatement();
1748                String JavaDoc text = "execute procedure " + s;
1749
1750                aStatement.execute( text );
1751
1752                {if (true) return new ijStatementResult( aStatement,true );}
1753    throw new Error JavaDoc("Missing return statement in function");
1754  }
1755
1756/**
1757 * Two forms of execute: immediate, with a string
1758 * and prepared, with the id of a prepared statement.
1759 * We expect the latter form will
1760 * eventually support a USING clause to supply
1761 * parameter values (that will be constants).
1762 * No parameters yet, however.
1763 * <p>
1764 * Syntax:
1765 * EXECUTE statementSource [ USING statementSource] ;
1766 *
1767 * statementSource is an identifier of a previously prepared statement
1768 * or a string containing SQL-J text.
1769 */

1770  final public ijResult ExecuteStatement() throws ParseException, SQLException JavaDoc {
1771        String JavaDoc i = null;
1772        Token s = null;
1773        PreparedStatement JavaDoc ps;
1774        String JavaDoc sVal = null;
1775
1776        String JavaDoc iUsing = null;
1777        Token sUsing = null;
1778        Token usingObject = null;
1779    jj_consume_token(EXECUTE);
1780    if (jj_2_100(2)) {
1781      i = identifier();
1782    } else if (jj_2_101(2)) {
1783      s = jj_consume_token(STRING);
1784    } else {
1785      jj_consume_token(-1);
1786      throw new ParseException();
1787    }
1788    if (jj_2_104(2)) {
1789      jj_consume_token(USING);
1790      if (jj_2_102(2)) {
1791        iUsing = identifier();
1792      } else if (jj_2_103(2)) {
1793        sUsing = jj_consume_token(STRING);
1794      } else {
1795        jj_consume_token(-1);
1796        throw new ParseException();
1797      }
1798    } else {
1799      ;
1800    }
1801            if (iUsing!=null || sUsing!=null) { // parameters in use
1802
String JavaDoc sUsingVal = null;
1803                        PreparedStatement JavaDoc psUsing;
1804                        SQLWarning JavaDoc warns = null;
1805
1806                        haveConnection();
1807
1808                        /*
1809                Steps:
1810                1. find or prepare the statement
1811                2. execute the using statement
1812                3. push the row of the using statement into the parameters
1813                4. execute the statement against those parameters
1814                5. clear the parameters
1815             */

1816                        /*
1817                get the prepared statement
1818             */

1819                        boolean closeWhenDone = false; // will we close the ps when done?
1820
if (i!=null) {
1821                                ps = (PreparedStatement JavaDoc) currentConnEnv.getSession().getPreparedStatement(i);
1822                                JDBCDisplayUtil.checkNotNull(ps,"prepared statement "+i);
1823                }
1824                else { // (s!=null)
1825
sVal = stringValue(s.image);
1826                                ps = theConnection.prepareStatement(sVal);
1827                                closeWhenDone = true;
1828                                JDBCDisplayUtil.checkNotNull(ps,"prepared statement");
1829                                warns = appendWarnings(warns, ps.getWarnings());
1830                                ps.clearWarnings();
1831                }
1832
1833                        /*
1834                execute the using statement
1835             */

1836                if (iUsing!=null) {
1837                                psUsing = (PreparedStatement JavaDoc) currentConnEnv.getSession().getPreparedStatement(iUsing);
1838                                JDBCDisplayUtil.checkNotNull(psUsing,"prepared statement "+iUsing);
1839                }
1840                else { // (sUsing!=null)
1841
sUsingVal = stringValue(sUsing.image);
1842                                psUsing = theConnection.prepareStatement(sUsingVal);
1843                                JDBCDisplayUtil.checkNotNull(psUsing,"prepared statement");
1844                                warns = appendWarnings(warns, psUsing.getWarnings());
1845                                psUsing.clearWarnings();
1846                }
1847
1848                        ResultSet JavaDoc rsUsing;
1849                        /*
1850                If the USING statement is not a query, we
1851                will not execute the statement; the number of
1852                rows controls the execution.
1853             */

1854                        if (psUsing.execute()) {
1855                                rsUsing = psUsing.getResultSet();
1856
1857                                /*
1858                    push the row of the using statement into the parameters
1859                 */

1860
1861                                ResultSetMetaData JavaDoc rsmdUsing = rsUsing.getMetaData();
1862                                int numCols = rsmdUsing.getColumnCount();
1863
1864                                /*
1865                    Insufficient or too many parameters will
1866                    be caught at the JDBC level, and halt execution.
1867                 */

1868                                boolean exec = false;
1869
1870                                /* Only do 1 next on rsUsing if autocommit is on,
1871                 * since rsUsing will be closed when ps is closed.
1872                 */

1873                            boolean autoCommited = false;
1874                                ijMultiResult result = new ijMultiResult(ps,rsUsing,closeWhenDone);
1875
1876// while (! autoCommited && rsUsing.next()) {
1877
// // note the first time through
1878
// if (!exec) {
1879
// exec = true;
1880
//
1881
// // send a warning if additional results may be lost
1882
// if (theConnection.getAutoCommit()) {
1883
// // FIXME: currOut.println("IJ WARNING: Autocommit may close using result set");
1884
// autoCommited = true;
1885
// }
1886
// }
1887
// for (int c=1; c<=numCols; c++) {
1888
// if (usingObject == null)
1889
// {
1890
// ps.setObject(c,rsUsing.getObject(c),
1891
// rsmdUsing.getColumnType(c));
1892
// }
1893
// else
1894
// {
1895
// ps.setObject(c,rsUsing.getObject(c));
1896
// }
1897
// }
1898
//
1899
// /*
1900
// 4. execute the statement against those parameters
1901
// */
1902
//
1903
// ps.execute();
1904
// result.addStatementResult(ps);
1905
//
1906
// /*
1907
// 5. clear the parameters
1908
// */
1909
// ps.clearParameters();
1910
//
1911
// }
1912
// if (!exec) {
1913
// throw ijException.noUsingResults();
1914
// }
1915
//
1916
// if (! theConnection.getAutoCommit())
1917
// {
1918
// rsUsing.close();
1919
// }
1920
// // REMIND: any way to look for more rsUsing rows if autoCommit?
1921
// // perhaps just document the behavior...
1922

1923                                {if (true) return result;}
1924                        }
1925                        else
1926                                {if (true) throw ijException.noUsingResults();}
1927                }
1928                else { // no parameters in use
1929
if (i!=null) {
1930                                haveConnection();
1931                                ps = (PreparedStatement JavaDoc) currentConnEnv.getSession().getPreparedStatement(i);
1932                                JDBCDisplayUtil.checkNotNull(ps,"prepared statement "+i);
1933                                ps.execute();
1934
1935                                {if (true) return new ijStatementResult(ps,false);}
1936                }
1937                else { // (s!=null)
1938
{if (true) return executeImmediate(stringValue(s.image));}
1939                }
1940            }
1941    throw new Error JavaDoc("Missing return statement in function");
1942  }
1943
1944/**
1945 * Async: like execute immediate, without using,
1946 * but runs the statement in a separate thread, against
1947 * the current connection.
1948 * <p>
1949 * Syntax:
1950 * ASYNC asyncName statementSource
1951 *
1952 * statementSource is a string containing SQL-J text.
1953 */

1954  final public ijResult AsyncStatement() throws ParseException, SQLException JavaDoc {
1955        Token s = null;
1956        String JavaDoc n = null;
1957    jj_consume_token(ASYNC);
1958    n = identifier();
1959    s = jj_consume_token(STRING);
1960            {if (true) return executeAsync(stringValue(s.image), n);}
1961    throw new Error JavaDoc("Missing return statement in function");
1962  }
1963
1964/**
1965 * Wait for: the second half of Async, waits for completion
1966 * if needed and then supplies the result. Only execute is done,
1967 * not row fetching.
1968 * <p>
1969 * Syntax:
1970 * WAIT FOR asyncName
1971 *
1972 * asyncName is a name used in an ASYNC statement previously
1973 */

1974  final public ijResult WaitForStatement() throws ParseException, SQLException JavaDoc {
1975        Token s = null;
1976        String JavaDoc n = null;
1977    jj_consume_token(WAIT);
1978    jj_consume_token(FOR);
1979    n = identifier();
1980                AsyncStatement as = currentConnEnv.getSession().getAsyncStatement(n);
1981                if (as == null) {if (true) throw ijException.noSuchAsyncStatement(n);}
1982                try {
1983                    as.join(); // we wait for it to finish.
1984
} catch (InterruptedException JavaDoc ie) {
1985                        {if (true) throw ijException.waitInterrupted(ie);}
1986                }
1987                {if (true) return as.getResult();}
1988    throw new Error JavaDoc("Missing return statement in function");
1989  }
1990
1991/**
1992 * RemoveStatement is REMOVE identifier. It identifies
1993 * a previously prepared statement. We would prefer a DROP
1994 * syntax, but SQL-J is using that word and I want to point out
1995 * that special processing will be needed to give that parser
1996 * this parser's input for unrecognized text.
1997 */

1998  final public ijResult RemoveStatement() throws ParseException, SQLException JavaDoc {
1999        String JavaDoc i;
2000        PreparedStatement JavaDoc ps;
2001    jj_consume_token(REMOVE);
2002    i = identifier();
2003                haveConnection();
2004                Session s = currentConnEnv.getSession();
2005                ps = (PreparedStatement JavaDoc) s.getPreparedStatement(i);
2006                JDBCDisplayUtil.checkNotNull(ps,"prepared statement "+i);
2007                ps.close();
2008                s.removePreparedStatement(i);
2009
2010                {if (true) return null;}
2011    throw new Error JavaDoc("Missing return statement in function");
2012  }
2013
2014  final public ijResult RunStatement() throws ParseException, SQLException JavaDoc {
2015        Token i;
2016    Token r = null;
2017        PreparedStatement JavaDoc ps;
2018    jj_consume_token(RUN);
2019    if (jj_2_105(2)) {
2020      r = jj_consume_token(RESOURCE);
2021    } else {
2022      ;
2023    }
2024    i = jj_consume_token(STRING);
2025                if (utilInstance==null) {if (true) return null;}
2026            if (r == null)
2027                        utilInstance.newInput(stringValue(i.image));
2028                else
2029            utilInstance.newResourceInput(stringValue(i.image));
2030                {if (true) return null;}
2031    throw new Error JavaDoc("Missing return statement in function");
2032  }
2033
2034/**
2035 * Autocommit lets you control this aspect of the connection.
2036 * REMIND: should have a general way to set all connection attributes,
2037 * this is a shortcut for immediate needs.
2038 * <p>
2039 * Syntax:
2040 * AUTOCOMMIT [ ON | OFF ] ;
2041 */

2042  final public ijResult AutocommitStatement() throws ParseException, SQLException JavaDoc {
2043        Token on=null;
2044    jj_consume_token(AUTOCOMMIT);
2045    if (jj_2_106(2)) {
2046      on = jj_consume_token(ON);
2047    } else if (jj_2_107(2)) {
2048      jj_consume_token(OFF);
2049    } else {
2050      jj_consume_token(-1);
2051      throw new ParseException();
2052    }
2053                haveConnection();
2054                // REMIND: want to warn if unchanged?
2055
theConnection.setAutoCommit((on==null?false:true));
2056
2057                {if (true) return null;}
2058    throw new Error JavaDoc("Missing return statement in function");
2059  }
2060
2061/**
2062 * By default, holdability is set to true for Connection objects. This syntax NOHOLDFORCONNECTION lets you set it to close cursors at commit.
2063 * Syntax:
2064 * NOHOLDFORCONNECTION ;
2065 */

2066  final public ijResult NoHoldForConnectionStatement() throws ParseException, SQLException JavaDoc {
2067        Token on=null;
2068    jj_consume_token(NOHOLDFORCONNECTION);
2069                haveConnection();
2070                theConnection = utilInstance.setHoldability(theConnection, JDBC30Translation.CLOSE_CURSORS_AT_COMMIT);
2071
2072                {if (true) return null;}
2073    throw new Error JavaDoc("Missing return statement in function");
2074  }
2075
2076/**
2077 * Localizeddisplay controls locale sensitive data representayion
2078 * <p>
2079 * Syntax:
2080 * LOCALIZEDDISPLAY [ ON | OFF ] ;
2081 */

2082  final public ijResult LocalizedDisplay() throws ParseException {
2083        Token on=null;
2084    jj_consume_token(LOCALIZEDDISPLAY);
2085    if (jj_2_108(2)) {
2086      on = jj_consume_token(ON);
2087    } else if (jj_2_109(2)) {
2088      jj_consume_token(OFF);
2089    } else {
2090      jj_consume_token(-1);
2091      throw new ParseException();
2092    }
2093                LocalizedResource.enableLocalization((on==null?false:true));
2094                {if (true) return null;}
2095    throw new Error JavaDoc("Missing return statement in function");
2096  }
2097
2098/**
2099 * ReadOnly lets you control this aspect of the connection.
2100 * REMIND: should have a general way to set all connection attributes,
2101 * this is a shortcut for immediate needs.
2102 * <p>
2103 * Syntax:
2104 * READONLY [ ON | OFF ] ;
2105 */

2106  final public ijResult ReadOnlyStatement() throws ParseException, SQLException JavaDoc {
2107        Token on=null;
2108    jj_consume_token(READONLY);
2109    if (jj_2_110(2)) {
2110      on = jj_consume_token(ON);
2111    } else if (jj_2_111(2)) {
2112      jj_consume_token(OFF);
2113    } else {
2114      jj_consume_token(-1);
2115      throw new ParseException();
2116    }
2117                haveConnection();
2118                theConnection.setReadOnly((on==null?false:true));
2119                {if (true) return null;}
2120    throw new Error JavaDoc("Missing return statement in function");
2121  }
2122
2123/**
2124 * Elapsedtime on causes ij to dump out the elapsed time it takes
2125 * to run a user statement at the end of that statement.
2126 * <p>
2127 * Syntax:
2128 * ELAPSEDTIME [ ON | OFF ] ;
2129 */

2130  final public ijResult ElapsedTimeStatement() throws ParseException {
2131        Token on=null;
2132    jj_consume_token(ELAPSEDTIME);
2133    if (jj_2_112(2)) {
2134      on = jj_consume_token(ON);
2135    } else if (jj_2_113(2)) {
2136      jj_consume_token(OFF);
2137    } else {
2138      jj_consume_token(-1);
2139      throw new ParseException();
2140    }
2141                elapsedTime = (on != null);
2142                {if (true) return null;}
2143    throw new Error JavaDoc("Missing return statement in function");
2144  }
2145
2146/**
2147 * MaximumDisplayWidth EXACT_NUMERIC changes the maximum display width for
2148 * java.lang.String to the specified EXACT_NUMERIC.
2149 * This is only used by the console view.
2150 * <p>
2151 * Syntax:
2152 * MAXIMUMDISPLAYWIDTH INTEGER ;
2153 */

2154  final public ijResult MaximumDisplayWidthStatement() throws ParseException {
2155        int maxWidth;
2156    jj_consume_token(MAXIMUMDISPLAYWIDTH);
2157    maxWidth = intValue();
2158                JDBCDisplayUtil.setMaxDisplayWidth(maxWidth);
2159                {if (true) return null;}
2160    throw new Error JavaDoc("Missing return statement in function");
2161  }
2162
2163  final public int intValue() throws ParseException {
2164        Token t;
2165    t = jj_consume_token(INTEGER);
2166                {if (true) return Integer.parseInt(t.image);}
2167    throw new Error JavaDoc("Missing return statement in function");
2168  }
2169
2170/**
2171 * Bang lets you issue a system command using System.exec.
2172 * <p>
2173 * Syntax:
2174 * ! 'command to issue' ;
2175 */

2176  final public ijResult Bang() throws ParseException {
2177        Token cmd=null;
2178    jj_consume_token(BANG);
2179    cmd = jj_consume_token(STRING);
2180          ijResult result = null;
2181          try {
2182                Process JavaDoc p = Runtime.getRuntime().exec(stringValue(cmd.image));
2183                LocalizedInput in = new LocalizedInput(p.getInputStream());
2184                int c;
2185                Vector JavaDoc v = new Vector JavaDoc();
2186                StringBuffer JavaDoc output = new StringBuffer JavaDoc();
2187                // echo output
2188
while ((c = in.read()) != -1) {
2189                        output.append((char)c);
2190                }
2191                in.close();
2192                // echo errors
2193
in = new LocalizedInput(p.getErrorStream());
2194                // echo output
2195
while ((c = in.read()) != -1) {
2196                        output.append((char)c);
2197                }
2198                in.close();
2199                v.addElement(output);
2200                result = new ijVectorResult(v,null);
2201                // wait for completion
2202
try {
2203                        p.waitFor();
2204                } catch (InterruptedException JavaDoc e) {
2205                        {if (true) throw ijException.bangException(e);}
2206                }
2207          } catch (IOException JavaDoc ioe) {
2208                {if (true) throw ijException.bangException(ioe);}
2209          }
2210          {if (true) return result;}
2211    throw new Error JavaDoc("Missing return statement in function");
2212  }
2213
2214/**
2215    ExpectStatement is EXPECT [ FAIL ] {'String'}* END EXPECT
2216    <p>
2217    Will eventually detect the lines that the strings are without
2218    special literals, but for now this is expedient (except for the
2219    doubling of quotes...)
2220    <p>
2221    Used to test the previous statement's output. Note that ij must be
2222    in "expect" mode to use this statement, otherwise it is just
2223    ignored. This is due to the overhead of tracking the prior statement's
2224    output.
2225 */

2226  final public ijResult ExpectStatement() throws ParseException {
2227        Token f = null;
2228        Vector JavaDoc stringVector = new Vector JavaDoc();
2229    jj_consume_token(EXPECT);
2230    if (jj_2_114(2)) {
2231      f = jj_consume_token(FAIL);
2232    } else {
2233      ;
2234    }
2235    StringList(stringVector);
2236    jj_consume_token(END);
2237    jj_consume_token(EXPECT);
2238                if (!getExpect()) {if (true) return null;} // don't bother processing.
2239

2240                // FIXME
2241

2242                // Do the comparison of the string list to the prior rows of
2243
// output, using a row-by-row perl-regex comparison.
2244
boolean result = true;
2245
2246                // register the result and whether it should be true or false
2247
// FIXME: how to find the expecter??
2248
noteExpect(result, f==null);
2249
2250                {if (true) return null;}
2251    throw new Error JavaDoc("Missing return statement in function");
2252  }
2253
2254  final public void StringList(Vector JavaDoc v) throws ParseException {
2255    StringItem(v);
2256    label_1:
2257    while (true) {
2258      if (jj_2_115(2)) {
2259        ;
2260      } else {
2261        break label_1;
2262      }
2263      StringItem(v);
2264    }
2265  }
2266
2267  final public void StringItem(Vector JavaDoc v) throws ParseException {
2268        Token s;
2269    s = jj_consume_token(STRING);
2270                v.addElement(s);
2271  }
2272
2273/**
2274    Haven't included: ASYNC, !, EXPECT
2275    Don't include: XA_*
2276 **/

2277  final public ijResult HelpStatement() throws ParseException {
2278    jj_consume_token(HELP);
2279                Vector JavaDoc v = new Vector JavaDoc();
2280
2281                StringTokenizer JavaDoc st = new StringTokenizer JavaDoc(LocalizedResource.getMessage("IJ_HelpText"), "\n");
2282                while (st.hasMoreTokens()) {
2283                    v.addElement(st.nextToken());
2284                }
2285
2286                {if (true) return new ijVectorResult(v,null);}
2287    throw new Error JavaDoc("Missing return statement in function");
2288  }
2289
2290  final public String JavaDoc identifier() throws ParseException {
2291        Token t;
2292    t = jj_consume_token(IDENTIFIER);
2293                // identifiers are case insensitive, so we map them up.
2294
// ij doesn't recognize any use of delimited identifiers in its syntax.
2295
{if (true) return (t.image.toUpperCase(Locale.ENGLISH));}
2296    throw new Error JavaDoc("Missing return statement in function");
2297  }
2298
2299  final public int intLiteral() throws ParseException, SQLException JavaDoc {
2300        String JavaDoc sign = "";
2301        Token tok;
2302    if (jj_2_116(2)) {
2303      sign = sign();
2304    } else {
2305      ;
2306    }
2307    tok = jj_consume_token(INTEGER);
2308                /*
2309        ** The various java parse utilities can't handle leading +,
2310        ** so only concatenate leading -.
2311        */

2312
2313                String JavaDoc num = tok.image;
2314
2315                if (sign.equals("-"))
2316                {
2317                        num = sign.concat(num);
2318                }
2319
2320                {if (true) return Integer.parseInt(num);}
2321    throw new Error JavaDoc("Missing return statement in function");
2322  }
2323
2324  final public Vector JavaDoc staticMethodName() throws ParseException, SQLException JavaDoc {
2325        Vector JavaDoc list = new Vector JavaDoc();
2326    methodLeg(list);
2327    label_2:
2328    while (true) {
2329      jj_consume_token(PERIOD);
2330      methodLeg(list);
2331      if (jj_2_117(2)) {
2332        ;
2333      } else {
2334        break label_2;
2335      }
2336    }
2337                {if (true) return list;}
2338    throw new Error JavaDoc("Missing return statement in function");
2339  }
2340
2341  final public void methodLeg(Vector JavaDoc list) throws ParseException, SQLException JavaDoc {
2342        Token id;
2343    id = jj_consume_token(IDENTIFIER);
2344                list.addElement( id.image );
2345  }
2346
2347  final public String JavaDoc[] staticMethodArgs() throws ParseException, SQLException JavaDoc {
2348        Vector JavaDoc list = new Vector JavaDoc();
2349        String JavaDoc[] args;
2350    jj_consume_token(LEFT_PAREN);
2351    if (jj_2_119(2)) {
2352      oneStaticArg(list);
2353      label_3:
2354      while (true) {
2355        if (jj_2_118(2)) {
2356          ;
2357        } else {
2358          break label_3;
2359        }
2360        jj_consume_token(COMMA);
2361        oneStaticArg(list);
2362      }
2363    } else {
2364      ;
2365    }
2366    jj_consume_token(RIGHT_PAREN);
2367                args = new String JavaDoc[ list.size() ];
2368                list.copyInto( args );
2369
2370                {if (true) return args;}
2371    throw new Error JavaDoc("Missing return statement in function");
2372  }
2373
2374  final public void oneStaticArg(Vector JavaDoc list) throws ParseException, SQLException JavaDoc {
2375        Token tok;
2376    tok = jj_consume_token(STRING);
2377                list.addElement( stringValue( tok.image ) );
2378  }
2379
2380/*
2381 * <A NAME="sign">sign</A>
2382 */

2383  final public String JavaDoc sign() throws ParseException, SQLException JavaDoc {
2384        Token s;
2385    if (jj_2_120(2)) {
2386      s = jj_consume_token(PLUS_SIGN);
2387                {if (true) return s.image;}
2388    } else if (jj_2_121(2)) {
2389      s = jj_consume_token(MINUS_SIGN);
2390                {if (true) return s.image;}
2391    } else {
2392      jj_consume_token(-1);
2393      throw new ParseException();
2394    }
2395    throw new Error JavaDoc("Missing return statement in function");
2396  }
2397
2398/**
2399    Undocumented commands to help XA testing.
2400
2401    This is the grammer for the XA commands
2402
2403    &lt;XA_DATASOURCE&gt; 'dbname' ( &lt;CREATE&gt; | shutdown )
2404         - get a XADataSource whose database name is dbname and make that
2405        XADataSource the current XADataSource
2406
2407    &lt;XA_CONNECT&gt; [ &lt;USER&gt; 'user' ]
2408            [ &lt;PASSWORD&gt; 'password' ]
2409            [ &lt;AS&gt; xaconnid ]
2410        - make an XAConnection using the current XADataSource and make
2411        that XAConnection the current XAConnection. If xaconnid is
2412        given, then associate xaconnid with the XAConnection.
2413        (xaconnid not implemeneted)
2414
2415
2416    &lt;XA_COMMIT&gt; ( &lt;XA_1PHASE&gt; | &lt;XA_2PHASE&gt; ) xid
2417        - commit a global transaction xid
2418
2419
2420    &lt;XA_DISCONNECT&gt; [ xaconnid = identifier() ]
2421        - disconnect an XAConnection. If xaconnid is given, then
2422        disconnect the XAConnection with the given xaconnid.
2423        (xaconnid not implemeneted)
2424
2425
2426    &lt;XA_END&gt; ( &lt;XA_SUSPEND&gt; | &lt;XA_SUCCESS&gt; | &lt;XA_FAIL&gt; ) xid
2427        - dissociate a transaction from the current XAConnection or end
2428        an already suspened one
2429
2430    &lt;XA_FORGET&gt; xid - forget about a global transaction
2431
2432    &lt;XA_GETCONNECTION&gt; [ &lt;AS&gt; connid ]
2433        - get a Connection object from the current XAConnection.
2434        If connid is given, then associate connid with the connection.
2435        (connid not implemented)
2436
2437    &lt;XA_PREPARE&gt; xid - prepare a global transaction
2438
2439    &lt;XA_RECOVER&gt; ( &lt;XA_NOFLAGS&gt; | &lt;XA_STARTRSCAN&gt; | &lt;XA_ENDRSCAN&gt; )
2440        - return the list of in-doubt transactions
2441
2442    &lt;XA_ROLLBACK&gt; xid - rollback a global transaction
2443
2444    &lt;XA_START&gt; ( &lt;XA_NOFLAGS&gt; | &lt;XA_JOIN&gt; | &lt;XA_RESUME&gt; ) xid
2445        - associate a transaction or start a new global
2446        transaction with the current XAConnection.
2447
2448    The following is for testing other JDBC2.0 ext interface, DataSource
2449    and ConnectionPoolDataSource. Strictly speaking, these are not xa, but
2450    their functionality will be lumped into xaHelper because these are here
2451    only for testing purposes.
2452
2453    &lt;DATASOURCE&gt; 'dbname' [ &lt;PROTOCOL&gt; 'protocol' ]
2454                [ &lt;USER&gt; 'user' ]
2455                [ &lt;PASSWORD&gt; 'password' ]
2456                [ &lt;AS&gt; n=identifier() ]
2457        - get a data source whose database name is dbname and make that
2458        DataSource the current DataSource. If &lt;PROTOCOL&gt; is specified,
2459        the DataSource may be remote. Get a connection from that
2460        dataSource and use the user/password if specified.
2461
2462    &lt;CP_DATASOURCE&gt; 'dbname' [ &lt;PROTOCOL&gt; 'protocol' ]
2463        - get a connection pool data source whose database name is
2464        dbname and make that DataSource the current CPDataSource.
2465        If &lt;PROTOCOL&gt; is specified, the DataSource may be
2466        remote.
2467
2468    &lt;CP_CONNECT&gt; [ &lt;USER&gt; 'user' ]
2469            [ &lt;PASSWORD&gt; 'password' ]
2470            [ &lt;AS&gt; cpconnid ]
2471        - make a PooledConnection using the current CPDataSource and
2472        make that PooledConnection the current PooledConnection.
2473        If cpconnid is given, then associate cpconnid with the
2474        PooledConnection. (cpconnid not implemented).
2475
2476    &lt;CP_GETCONNECTION&gt; [ &lt;AS&gt; connid ]
2477        - get a Connection object from the current PooledConnection.
2478        If connid is given, the associate connid with the connection.
2479        (connid not implemented)
2480
2481    &lt;CP_DISCONNECT&gt; [ cpconnid = identifier() ]
2482        - disconnect a PooledConnection. If cpconnid is given, then
2483        disconnect the PooledConnection with the given cpconnid.
2484        (cpconnid not implemented)
2485
2486*/

2487
2488
2489/**
2490 * XA_DataSourceStatement is XA_DataSource 'dbname' ( create | shutdown )
2491 * We new'ed an instance of XADataSource as the current DataSource and set its
2492 * database name to dbname.
2493 */

2494  final public ijResult XA_DataSourceStatement() throws ParseException, SQLException JavaDoc {
2495        Token dbname = null;
2496        Token shut = null;
2497        String JavaDoc create = null;
2498    jj_consume_token(XA_DATASOURCE);
2499    dbname = jj_consume_token(STRING);
2500    if (jj_2_124(2)) {
2501      if (jj_2_122(2)) {
2502        shut = jj_consume_token(SHUTDOWN);
2503      } else if (jj_2_123(2)) {
2504        create = identifier();
2505      } else {
2506        jj_consume_token(-1);
2507        throw new ParseException();
2508      }
2509    } else {
2510      ;
2511    }
2512                xahelper.XADataSourceStatement(this, dbname, shut, create);
2513
2514                {if (true) return null;}
2515    throw new Error JavaDoc("Missing return statement in function");
2516  }
2517
2518/**
2519 * XA_ConnectStatement is XA_CONNECT (&lt;AS&gt; connid)
2520 * make a XAConnection using the currentXADataSource and make that XAConnection
2521 * the current XAConnection. If connid is given, then associate connid with
2522 * the XAConnection. This connid is not th xid.
2523 */

2524  final public ijResult XA_ConnectStatement() throws ParseException, SQLException JavaDoc {
2525        Token userT = null;
2526        Token passwordT = null;
2527        String JavaDoc n = null;
2528    jj_consume_token(XA_CONNECT);
2529    if (jj_2_125(2)) {
2530      jj_consume_token(USER);
2531      userT = jj_consume_token(STRING);
2532    } else {
2533      ;
2534    }
2535    if (jj_2_126(2)) {
2536      jj_consume_token(PASSWORD);
2537      passwordT = jj_consume_token(STRING);
2538    } else {
2539      ;
2540    }
2541    if (jj_2_127(2)) {
2542      jj_consume_token(AS);
2543      n = identifier();
2544    } else {
2545      ;
2546    }
2547                xahelper.XAConnectStatement(this, userT, passwordT, n);
2548                {if (true) return null;}
2549    throw new Error JavaDoc("Missing return statement in function");
2550  }
2551
2552/**
2553 * XA_DisconnectStatement is XA_DISCONNECT [xaconnid = identifier()]
2554 * disconnect the current XAConnection
2555 * If xaconnid is given, then disconnect XAConnection with xaconnid (xaconnid
2556 * not implemented).
2557 *
2558 */

2559  final public ijResult XA_DisconnectStatement() throws ParseException, SQLException JavaDoc {
2560        String JavaDoc n = null;
2561    jj_consume_token(XA_DISCONNECT);
2562    if (jj_2_128(2)) {
2563      n = identifier();
2564    } else {
2565      ;
2566    }
2567                xahelper.XADisconnectStatement(this, n);
2568                {if (true) return null;}
2569    throw new Error JavaDoc("Missing return statement in function");
2570  }
2571
2572/**
2573 * XA_CommitStatement is XA_COMMIT [ XA_1PHASE | XA_2PHASE ] xid
2574 * commits a global transaction xid
2575 */

2576  final public ijResult XA_CommitStatement() throws ParseException, SQLException JavaDoc {
2577        Token onePhase=null;
2578        Token twoPhase=null;
2579        int xid = 0;
2580    jj_consume_token(XA_COMMIT);
2581    if (jj_2_129(2)) {
2582      onePhase = jj_consume_token(XA_1PHASE);
2583    } else if (jj_2_130(2)) {
2584      twoPhase = jj_consume_token(XA_2PHASE);
2585    } else {
2586      jj_consume_token(-1);
2587      throw new ParseException();
2588    }
2589    xid = intValue();
2590                xahelper.CommitStatement(this, onePhase, twoPhase, xid);
2591                {if (true) return null;}
2592    throw new Error JavaDoc("Missing return statement in function");
2593  }
2594
2595/**
2596 * XA_EndStatement is XA_END [ XA_SUSPEND | XA_SUCCESS | XA_FAIL] xid
2597 * dissociates a transaction from the current XAConnection or end an already
2598 * suspended one
2599 */

2600  final public ijResult XA_EndStatement() throws ParseException, SQLException JavaDoc {
2601        int flag = 0;
2602        int xid = 0;
2603    jj_consume_token(XA_END);
2604    flag = xatmflag();
2605    xid = intValue();
2606                xahelper.EndStatement(this, flag, xid);
2607                {if (true) return null;}
2608    throw new Error JavaDoc("Missing return statement in function");
2609  }
2610
2611/**
2612 * XA_ForgetStatement is XA_FORGET xid
2613 * forgets about a heuristically completed transaction
2614 */

2615  final public ijResult XA_ForgetStatement() throws ParseException, SQLException JavaDoc {
2616        int xid = 0;
2617    jj_consume_token(XA_FORGET);
2618    xid = intValue();
2619                xahelper.ForgetStatement(this, xid);
2620                {if (true) return null;}
2621    throw new Error JavaDoc("Missing return statement in function");
2622  }
2623
2624/**
2625 * XA_GetConnectionStatement is XA_GETCONNECTION
2626 * it gets a Connection from the currentXAConnection and uses that as the
2627 * current connection
2628 */

2629  final public ijResult XA_GetConnectionStatement() throws ParseException, SQLException JavaDoc {
2630        String JavaDoc n = "XA";
2631    jj_consume_token(XA_GETCONNECTION);
2632    if (jj_2_131(2)) {
2633      jj_consume_token(AS);
2634      n = identifier();
2635    } else {
2636      ;
2637    }
2638                theConnection = xahelper.XAGetConnectionStatement(this, n);
2639                currentConnEnv.addSession(theConnection, n);
2640
2641                {if (true) return new ijConnectionResult(theConnection);}
2642    throw new Error JavaDoc("Missing return statement in function");
2643  }
2644
2645/**
2646 * XA_PrepareStatement is XA_PREPARE xid
2647 * prepares a global transaction
2648 */

2649  final public ijResult XA_PrepareStatement() throws ParseException, SQLException JavaDoc {
2650        int xid = 0;
2651    jj_consume_token(XA_PREPARE);
2652    xid = intValue();
2653                xahelper.PrepareStatement(this, xid);
2654                {if (true) return null;}
2655    throw new Error JavaDoc("Missing return statement in function");
2656  }
2657
2658/**
2659 * XA_RecoverStatement is XA_RECOVER flag
2660 * displays the list of prepared transactions
2661 */

2662  final public ijResult XA_RecoverStatement() throws ParseException, SQLException JavaDoc {
2663        int flag = 0;
2664    jj_consume_token(XA_RECOVER);
2665    flag = xatmflag();
2666                {if (true) return xahelper.RecoverStatement(this, flag);}
2667    throw new Error JavaDoc("Missing return statement in function");
2668  }
2669
2670/**
2671 * XA_RollbackStatement is XA_Rollback xid
2672 * rolls back a global transaction
2673 */

2674  final public ijResult XA_RollbackStatement() throws ParseException, SQLException JavaDoc {
2675        int xid = 0;
2676    jj_consume_token(XA_ROLLBACK);
2677    xid = intValue();
2678                xahelper.RollbackStatement(this, xid);
2679                {if (true) return null;}
2680    throw new Error JavaDoc("Missing return statement in function");
2681  }
2682
2683/**
2684 * XA_StartStatement is XA_START [ XA_NOFLAGS | XA_JOIN | XA_RESUME ] xid
2685 * start or associates a transaction with the current XAConnection
2686 */

2687  final public ijResult XA_StartStatement() throws ParseException, SQLException JavaDoc {
2688        int flag = 0;
2689        int xid = 0;
2690    jj_consume_token(XA_START);
2691    flag = xatmflag();
2692    xid = intValue();
2693                xahelper.StartStatement(this, flag, xid);
2694                {if (true) return null;}
2695    throw new Error JavaDoc("Missing return statement in function");
2696  }
2697
2698  final public int xatmflag() throws ParseException, SQLException JavaDoc {
2699    if (jj_2_132(2)) {
2700      jj_consume_token(XA_ENDRSCAN);
2701                {if (true) return JDBC20Translation.XA_ENDRSCAN;}
2702    } else if (jj_2_133(2)) {
2703      jj_consume_token(XA_FAIL);
2704                {if (true) return JDBC20Translation.XA_FAIL;}
2705    } else if (jj_2_134(2)) {
2706      jj_consume_token(XA_JOIN);
2707                {if (true) return JDBC20Translation.XA_JOIN;}
2708    } else if (jj_2_135(2)) {
2709      jj_consume_token(XA_NOFLAGS);
2710                {if (true) return JDBC20Translation.XA_NOFLAGS;}
2711    } else if (jj_2_136(2)) {
2712      jj_consume_token(XA_RESUME);
2713                {if (true) return JDBC20Translation.XA_RESUME;}
2714    } else if (jj_2_137(2)) {
2715      jj_consume_token(XA_STARTRSCAN);
2716                {if (true) return JDBC20Translation.XA_STARTRSCAN;}
2717    } else if (jj_2_138(2)) {
2718      jj_consume_token(XA_SUCCESS);
2719                {if (true) return JDBC20Translation.XA_SUCCESS;}
2720    } else if (jj_2_139(2)) {
2721      jj_consume_token(XA_SUSPEND);
2722                {if (true) return JDBC20Translation.XA_SUSPEND;}
2723    } else {
2724      jj_consume_token(-1);
2725      throw new ParseException();
2726    }
2727    throw new Error JavaDoc("Missing return statement in function");
2728  }
2729
2730/**
2731 * DataSourceStatement is
2732 * DataSource 'dbname'
2733 * [ &lt;PROTCOL&gt; 'protocol']
2734 * [ &lt;USER&gt; 'user' ]
2735 * [ &lt;PASSWORD&gt; 'password' ]
2736 * [ &lt;AS&gt; n=identifier() ]
2737 *
2738 * We new'ed an instance of DataSource as the current DataSource and set its
2739 * database name to dbname. Also get a connection
2740 */

2741  final public ijResult DataSourceStatement() throws ParseException, SQLException JavaDoc {
2742        Token dbname = null;
2743        Token protocol = null;
2744        Token userT = null;
2745        Token passwordT = null;
2746        String JavaDoc n = null;
2747    jj_consume_token(DATASOURCE);
2748    dbname = jj_consume_token(STRING);
2749    if (jj_2_140(2)) {
2750      jj_consume_token(PROTOCOL);
2751      protocol = jj_consume_token(STRING);
2752    } else {
2753      ;
2754    }
2755    if (jj_2_141(2)) {
2756      jj_consume_token(USER);
2757      userT = jj_consume_token(STRING);
2758    } else {
2759      ;
2760    }
2761    if (jj_2_142(2)) {
2762      jj_consume_token(PASSWORD);
2763      passwordT = jj_consume_token(STRING);
2764    } else {
2765      ;
2766    }
2767    if (jj_2_143(2)) {
2768      jj_consume_token(AS);
2769      n = identifier();
2770    } else {
2771      ;
2772    }
2773                theConnection = xahelper.DataSourceStatement(this, dbname, protocol,
2774                        userT, passwordT, n);
2775
2776                {if (true) return addSession( theConnection, n );}
2777    throw new Error JavaDoc("Missing return statement in function");
2778  }
2779
2780/**
2781 * CP_DataSourceStatement is
2782 * CP_DataSource 'dbname' [ &lt;PROTOCOL&gt; 'protocol' ]
2783 * - get a connection pool data source whose database name is
2784 * dbname and make that DataSource the current CPDataSource.
2785 * If &lt;PROTOCOL&gt; is specified, the DataSource may be
2786 * remote.
2787 */

2788  final public ijResult CP_DataSourceStatement() throws ParseException, SQLException JavaDoc {
2789        Token dbname = null;
2790        Token protocol = null;
2791    jj_consume_token(CP_DATASOURCE);
2792    dbname = jj_consume_token(STRING);
2793    if (jj_2_144(2)) {
2794      jj_consume_token(PROTOCOL);
2795      protocol = jj_consume_token(STRING);
2796    } else {
2797      ;
2798    }
2799                xahelper.CPDataSourceStatement(this, dbname, protocol);
2800                {if (true) return null;}
2801    throw new Error JavaDoc("Missing return statement in function");
2802  }
2803
2804/**
2805 * CP_ConnectStatement is
2806 * &lt;CP_CONNECT&gt; [ &lt;USER&gt; 'user' ]
2807 * [ &lt;PASSWORD&gt; 'password' ]
2808 * [ &lt;AS&gt; cpconnid ]
2809 * make a PooledConnection using the current CPDataSource and
2810 * make that PooledConnection the current PooledConnection.
2811 * If cpconnid is given, then associate cpconnid with the
2812 * PooledConnection. (cpconnid not implemented).
2813 */

2814  final public ijResult CP_ConnectStatement() throws ParseException, SQLException JavaDoc {
2815        Token userT = null;
2816        Token passwordT = null;
2817        String JavaDoc n = null;
2818    jj_consume_token(CP_CONNECT);
2819    if (jj_2_145(2)) {
2820      jj_consume_token(USER);
2821      userT = jj_consume_token(STRING);
2822    } else {
2823      ;
2824    }
2825    if (jj_2_146(2)) {
2826      jj_consume_token(PASSWORD);
2827      passwordT = jj_consume_token(STRING);
2828    } else {
2829      ;
2830    }
2831    if (jj_2_147(2)) {
2832      jj_consume_token(AS);
2833      n = identifier();
2834    } else {
2835      ;
2836    }
2837                xahelper.CPConnectStatement(this, userT, passwordT, n);
2838                {if (true) return null;}
2839    throw new Error JavaDoc("Missing return statement in function");
2840  }
2841
2842/**
2843 * CP_GetConnectionStatement is
2844 * &lt;CP_GETCONNECTION&gt; [ &lt;AS&gt; connid ]
2845 * get a Connection object from the current PooledConnection.
2846 * If connid is given, the associate connid with the connection.
2847 * (connid not implemented)
2848 */

2849  final public ijResult CP_GetConnectionStatement() throws ParseException, SQLException JavaDoc {
2850        String JavaDoc n = "Pooled";
2851    jj_consume_token(CP_GETCONNECTION);
2852    if (jj_2_148(2)) {
2853      jj_consume_token(AS);
2854      n = identifier();
2855    } else {
2856      ;
2857    }
2858                theConnection = xahelper.CPGetConnectionStatement(this, n);
2859                currentConnEnv.addSession(theConnection, n);
2860                {if (true) return new ijConnectionResult(theConnection);}
2861    throw new Error JavaDoc("Missing return statement in function");
2862  }
2863
2864/**
2865 * CP_DisconnectStatement is
2866 * &lt;CP_DISCONNECT&gt; [ cpconnid = identifier() ]
2867 * disconnect a PooledConnection. If cpconnid is given, then
2868 * disconnect the PooledConnection with the given cpconnid.
2869 * (cpconnid not implemented)
2870 */

2871  final public ijResult CP_DisconnectStatement() throws ParseException, SQLException JavaDoc {
2872        String JavaDoc n = null;
2873    jj_consume_token(CP_DISCONNECT);
2874    if (jj_2_149(2)) {
2875      n = identifier();
2876    } else {
2877      ;
2878    }
2879                xahelper.CPDisconnectStatement(this, n);
2880                {if (true) return null;}
2881    throw new Error JavaDoc("Missing return statement in function");
2882  }
2883
2884  final public Properties JavaDoc attributeList() throws ParseException {
2885        Properties JavaDoc properties = new Properties JavaDoc();
2886        Token tok;
2887        String JavaDoc value;
2888    if (jj_2_151(2)) {
2889      property(properties);
2890      label_4:
2891      while (true) {
2892        if (jj_2_150(2)) {
2893          ;
2894        } else {
2895          break label_4;
2896        }
2897        jj_consume_token(COMMA);
2898        property(properties);
2899      }
2900    } else {
2901      ;
2902    }
2903                //properties.put(tok.image,value);
2904
{if (true) return properties;}
2905    throw new Error JavaDoc("Missing return statement in function");
2906  }
2907
2908  final public void property(Properties JavaDoc properties) throws ParseException {
2909        String JavaDoc key;
2910        String JavaDoc value;
2911    key = caseSensitiveIdentifierOrKeyword();
2912    jj_consume_token(EQUALS_OPERATOR);
2913    value = caseSensitiveIdentifierOrKeyword();
2914                properties.put(key, value);
2915  }
2916
2917  final public String JavaDoc caseSensitiveIdentifierOrKeyword() throws ParseException {
2918        String JavaDoc value=null;
2919        Token tok;
2920    if (jj_2_152(2)) {
2921      value = keyword();
2922                {if (true) return value;}
2923    } else if (jj_2_153(2)) {
2924      tok = jj_consume_token(IDENTIFIER);
2925                {if (true) return tok.image;}
2926    } else {
2927      jj_consume_token(-1);
2928      throw new ParseException();
2929    }
2930    throw new Error JavaDoc("Missing return statement in function");
2931  }
2932
2933  final public String JavaDoc caseSensitiveIdentifier() throws ParseException {
2934        Token tok;
2935    tok = jj_consume_token(IDENTIFIER);
2936                {if (true) return tok.image;}
2937    throw new Error JavaDoc("Missing return statement in function");
2938  }
2939
2940  final public String JavaDoc keyword() throws ParseException {
2941        Token tok;
2942        String JavaDoc value= null;
2943    if (jj_2_154(2)) {
2944      tok = jj_consume_token(ABSOLUTE);
2945    } else if (jj_2_155(2)) {
2946      tok = jj_consume_token(AFTER);
2947    } else if (jj_2_156(2)) {
2948      tok = jj_consume_token(ALIASES);
2949    } else if (jj_2_157(2)) {
2950      tok = jj_consume_token(ALL);
2951    } else if (jj_2_158(2)) {
2952      tok = jj_consume_token(AS);
2953    } else if (jj_2_159(2)) {
2954      tok = jj_consume_token(ASYNC);
2955    } else if (jj_2_160(2)) {
2956      tok = jj_consume_token(ATTRIBUTES);
2957    } else if (jj_2_161(2)) {
2958      tok = jj_consume_token(AUTOCOMMIT);
2959    } else if (jj_2_162(2)) {
2960      tok = jj_consume_token(BANG);
2961    } else if (jj_2_163(2)) {
2962      tok = jj_consume_token(BEFORE);
2963    } else if (jj_2_164(2)) {
2964      tok = jj_consume_token(CLOSE);
2965    } else if (jj_2_165(2)) {
2966      tok = jj_consume_token(COMMIT);
2967    } else if (jj_2_166(2)) {
2968      tok = jj_consume_token(CONNECT);
2969    } else if (jj_2_167(2)) {
2970      tok = jj_consume_token(CONNECTION);
2971    } else if (jj_2_168(2)) {
2972      tok = jj_consume_token(CONNECTIONS);
2973    } else if (jj_2_169(2)) {
2974      tok = jj_consume_token(CURRENT);
2975    } else if (jj_2_170(2)) {
2976      tok = jj_consume_token(CURSOR);
2977    } else if (jj_2_171(2)) {
2978      tok = jj_consume_token(DESCRIBE);
2979    } else if (jj_2_172(2)) {
2980      tok = jj_consume_token(DISCONNECT);
2981    } else if (jj_2_173(2)) {
2982      tok = jj_consume_token(DRIVER);
2983    } else if (jj_2_174(2)) {
2984      tok = jj_consume_token(ELAPSEDTIME);
2985    } else if (jj_2_175(2)) {
2986      tok = jj_consume_token(END);
2987    } else if (jj_2_176(2)) {
2988      tok = jj_consume_token(EXECUTE);
2989    } else if (jj_2_177(2)) {
2990      tok = jj_consume_token(EXIT);
2991    } else if (jj_2_178(2)) {
2992      tok = jj_consume_token(EXPECT);
2993    } else if (jj_2_179(2)) {
2994      tok = jj_consume_token(FAIL);
2995    } else if (jj_2_180(2)) {
2996      tok = jj_consume_token(FIRST);
2997    } else if (jj_2_181(2)) {
2998      tok = jj_consume_token(FOR);
2999    } else if (jj_2_182(2)) {
3000      tok = jj_consume_token(FROM);
3001    } else if (jj_2_183(2)) {
3002      tok = jj_consume_token(GET);
3003    } else if (jj_2_184(2)) {
3004      tok = jj_consume_token(GETCURRENTROWNUMBER);
3005    } else if (jj_2_185(2)) {
3006      tok = jj_consume_token(HOLD);
3007    } else if (jj_2_186(2)) {
3008      tok = jj_consume_token(HELP);
3009    } else if (jj_2_187(2)) {
3010      tok = jj_consume_token(IN);
3011    } else if (jj_2_188(2)) {
3012      tok = jj_consume_token(INDEXES);
3013    } else if (jj_2_189(2)) {
3014      tok = jj_consume_token(INSENSITIVE);
3015    } else if (jj_2_190(2)) {
3016      tok = jj_consume_token(INTO);
3017    } else if (jj_2_191(2)) {
3018      tok = jj_consume_token(LAST);
3019    } else if (jj_2_192(2)) {
3020      tok = jj_consume_token(LOCALIZEDDISPLAY);
3021    } else if (jj_2_193(2)) {
3022      tok = jj_consume_token(MAXIMUMDISPLAYWIDTH);
3023    } else if (jj_2_194(2)) {
3024      tok = jj_consume_token(NAME);
3025    } else if (jj_2_195(2)) {
3026      tok = jj_consume_token(NEXT);
3027    } else if (jj_2_196(2)) {
3028      tok = jj_consume_token(NOHOLD);
3029    } else if (jj_2_197(2)) {
3030      tok = jj_consume_token(NOHOLDFORCONNECTION);
3031    } else if (jj_2_198(2)) {
3032      tok = jj_consume_token(OFF);
3033    } else if (jj_2_199(2)) {
3034      tok = jj_consume_token(ON);
3035    } else if (jj_2_200(2)) {
3036      tok = jj_consume_token(PASSWORD);
3037    } else if (jj_2_201(2)) {
3038      tok = jj_consume_token(PERIOD);
3039    } else if (jj_2_202(2)) {
3040      tok = jj_consume_token(PREPARE);
3041    } else if (jj_2_203(2)) {
3042      tok = jj_consume_token(PREVIOUS);
3043    } else if (jj_2_204(2)) {
3044      tok = jj_consume_token(PROCEDURE);
3045    } else if (jj_2_205(2)) {
3046      tok = jj_consume_token(PROCEDURES);
3047    } else if (jj_2_206(2)) {
3048      tok = jj_consume_token(PROPERTIES);
3049    } else if (jj_2_207(2)) {
3050      tok = jj_consume_token(PROTOCOL);
3051    } else if (jj_2_208(2)) {
3052      tok = jj_consume_token(QUIT);
3053    } else if (jj_2_209(2)) {
3054      tok = jj_consume_token(READONLY);
3055    } else if (jj_2_210(2)) {
3056      tok = jj_consume_token(RELATIVE);
3057    } else if (jj_2_211(2)) {
3058      tok = jj_consume_token(REMOVE);
3059    } else if (jj_2_212(2)) {
3060      tok = jj_consume_token(RESOURCE);
3061    } else if (jj_2_213(2)) {
3062      tok = jj_consume_token(ROLLBACK);
3063    } else if (jj_2_214(2)) {
3064      tok = jj_consume_token(RUN);
3065    } else if (jj_2_215(2)) {
3066      tok = jj_consume_token(TO);
3067    } else if (jj_2_216(2)) {
3068      tok = jj_consume_token(SCHEMAS);
3069    } else if (jj_2_217(2)) {
3070      tok = jj_consume_token(SCROLL);
3071    } else if (jj_2_218(2)) {
3072      tok = jj_consume_token(SENSITIVE);
3073    } else if (jj_2_219(2)) {
3074      tok = jj_consume_token(SET);
3075    } else if (jj_2_220(2)) {
3076      tok = jj_consume_token(SHOW);
3077    } else if (jj_2_221(2)) {
3078      tok = jj_consume_token(SHUTDOWN);
3079    } else if (jj_2_222(2)) {
3080      tok = jj_consume_token(STATEMENT);
3081    } else if (jj_2_223(2)) {
3082      tok = jj_consume_token(SYNONYMS);
3083    } else if (jj_2_224(2)) {
3084      tok = jj_consume_token(TABLES);
3085    } else if (jj_2_225(2)) {
3086      tok = jj_consume_token(USER);
3087    } else if (jj_2_226(2)) {
3088      tok = jj_consume_token(USING);
3089    } else if (jj_2_227(2)) {
3090      tok = jj_consume_token(VIEWS);
3091    } else if (jj_2_228(2)) {
3092      tok = jj_consume_token(WAIT);
3093    } else if (jj_2_229(2)) {
3094      tok = jj_consume_token(WITH);
3095    } else if (jj_2_230(2)) {
3096      tok = jj_consume_token(XA_1PHASE);
3097    } else if (jj_2_231(2)) {
3098      tok = jj_consume_token(XA_2PHASE);
3099    } else if (jj_2_232(2)) {
3100      tok = jj_consume_token(XA_DATASOURCE);
3101    } else if (jj_2_233(2)) {
3102      tok = jj_consume_token(XA_CONNECT);
3103    } else if (jj_2_234(2)) {
3104      tok = jj_consume_token(XA_COMMIT);
3105    } else if (jj_2_235(2)) {
3106      tok = jj_consume_token(XA_DISCONNECT);
3107    } else if (jj_2_236(2)) {
3108      tok = jj_consume_token(XA_END);
3109    } else if (jj_2_237(2)) {
3110      tok = jj_consume_token(XA_ENDRSCAN);
3111    } else if (jj_2_238(2)) {
3112      tok = jj_consume_token(XA_FAIL);
3113    } else if (jj_2_239(2)) {
3114      tok = jj_consume_token(XA_FORGET);
3115    } else if (jj_2_240(2)) {
3116      tok = jj_consume_token(XA_GETCONNECTION);
3117    } else if (jj_2_241(2)) {
3118      tok = jj_consume_token(XA_JOIN);
3119    } else if (jj_2_242(2)) {
3120      tok = jj_consume_token(XA_NOFLAGS);
3121    } else if (jj_2_243(2)) {
3122      tok = jj_consume_token(XA_PREPARE);
3123    } else if (jj_2_244(2)) {
3124      tok = jj_consume_token(XA_RECOVER);
3125    } else if (jj_2_245(2)) {
3126      tok = jj_consume_token(XA_RESUME);
3127    } else if (jj_2_246(2)) {
3128      tok = jj_consume_token(XA_ROLLBACK);
3129    } else if (jj_2_247(2)) {
3130      tok = jj_consume_token(XA_START);
3131    } else if (jj_2_248(2)) {
3132      tok = jj_consume_token(XA_STARTRSCAN);
3133    } else if (jj_2_249(2)) {
3134      tok = jj_consume_token(XA_SUCCESS);
3135    } else if (jj_2_250(2)) {
3136      tok = jj_consume_token(XA_SUSPEND);
3137    } else if (jj_2_251(2)) {
3138      tok = jj_consume_token(DATASOURCE);
3139    } else if (jj_2_252(2)) {
3140      tok = jj_consume_token(CP_DATASOURCE);
3141    } else if (jj_2_253(2)) {
3142      tok = jj_consume_token(CP_CONNECT);
3143    } else if (jj_2_254(2)) {
3144      tok = jj_consume_token(CP_GETCONNECTION);
3145    } else if (jj_2_255(2)) {
3146      tok = jj_consume_token(CP_DISCONNECT);
3147    } else if (jj_2_256(2)) {
3148      tok = jj_consume_token(WORK);
3149    } else {
3150      jj_consume_token(-1);
3151      throw new ParseException();
3152    }
3153                {if (true) return tok.image;}
3154    throw new Error JavaDoc("Missing return statement in function");
3155  }
3156
3157  final private boolean jj_2_1(int xla) {
3158    jj_la = xla; jj_lastpos = jj_scanpos = token;
3159    try { return !jj_3_1(); }
3160    catch(LookaheadSuccess ls) { return true; }
3161    finally { jj_save(0, xla); }
3162  }
3163
3164  final private boolean jj_2_2(int xla) {
3165    jj_la = xla; jj_lastpos = jj_scanpos = token;
3166    try { return !jj_3_2(); }
3167    catch(LookaheadSuccess ls) { return true; }
3168    finally { jj_save(1, xla); }
3169  }
3170
3171  final private boolean jj_2_3(int xla) {
3172    jj_la = xla; jj_lastpos = jj_scanpos = token;
3173    try { return !jj_3_3(); }
3174    catch(LookaheadSuccess ls) { return true; }
3175    finally { jj_save(2, xla); }
3176  }
3177
3178  final private boolean jj_2_4(int xla) {
3179    jj_la = xla; jj_lastpos = jj_scanpos = token;
3180    try { return !jj_3_4(); }
3181    catch(LookaheadSuccess ls) { return true; }
3182    finally { jj_save(3, xla); }
3183  }
3184
3185  final private boolean jj_2_5(int xla) {
3186    jj_la = xla; jj_lastpos = jj_scanpos = token;
3187    try { return !jj_3_5(); }
3188    catch(LookaheadSuccess ls) { return true; }
3189    finally { jj_save(4, xla); }
3190  }
3191
3192  final private boolean jj_2_6(int xla) {
3193    jj_la = xla; jj_lastpos = jj_scanpos = token;
3194    try { return !jj_3_6(); }
3195    catch(LookaheadSuccess ls) { return true; }
3196    finally { jj_save(5, xla); }
3197  }
3198
3199  final private boolean jj_2_7(int xla) {
3200    jj_la = xla; jj_lastpos = jj_scanpos = token;
3201    try { return !jj_3_7(); }
3202    catch(LookaheadSuccess ls) { return true; }
3203    finally { jj_save(6, xla); }
3204  }
3205
3206  final private boolean jj_2_8(int xla) {
3207    jj_la = xla; jj_lastpos = jj_scanpos = token;
3208    try { return !jj_3_8(); }
3209    catch(LookaheadSuccess ls) { return true; }
3210    finally { jj_save(7, xla); }
3211  }
3212
3213  final private boolean jj_2_9(int xla) {
3214    jj_la = xla; jj_lastpos = jj_scanpos = token;
3215    try { return !jj_3_9(); }
3216    catch(LookaheadSuccess ls) { return true; }
3217    finally { jj_save(8, xla); }
3218  }
3219
3220  final private boolean jj_2_10(int xla) {
3221    jj_la = xla; jj_lastpos = jj_scanpos = token;
3222    try { return !jj_3_10(); }
3223    catch(LookaheadSuccess ls) { return true; }
3224    finally { jj_save(9, xla); }
3225  }
3226
3227  final private boolean jj_2_11(int xla) {
3228    jj_la = xla; jj_lastpos = jj_scanpos = token;
3229    try { return !jj_3_11(); }
3230    catch(LookaheadSuccess ls) { return true; }
3231    finally { jj_save(10, xla); }
3232  }
3233
3234  final private boolean jj_2_12(int xla) {
3235    jj_la = xla; jj_lastpos = jj_scanpos = token;
3236    try { return !jj_3_12(); }
3237    catch(LookaheadSuccess ls) { return true; }
3238    finally { jj_save(11, xla); }
3239  }
3240
3241  final private boolean jj_2_13(int xla) {
3242    jj_la = xla; jj_lastpos = jj_scanpos = token;
3243    try { return !jj_3_13(); }
3244    catch(LookaheadSuccess ls) { return true; }
3245    finally { jj_save(12, xla); }
3246  }
3247
3248  final private boolean jj_2_14(int xla) {
3249    jj_la = xla; jj_lastpos = jj_scanpos = token;
3250    try { return !jj_3_14(); }
3251    catch(LookaheadSuccess ls) { return true; }
3252    finally { jj_save(13, xla); }
3253  }
3254
3255  final private boolean jj_2_15(int xla) {
3256    jj_la = xla; jj_lastpos = jj_scanpos = token;
3257    try { return !jj_3_15(); }
3258    catch(LookaheadSuccess ls) { return true; }
3259    finally { jj_save(14, xla); }
3260  }
3261
3262  final private boolean jj_2_16(int xla) {
3263    jj_la = xla; jj_lastpos = jj_scanpos = token;
3264    try { return !jj_3_16(); }
3265    catch(LookaheadSuccess ls) { return true; }
3266    finally { jj_save(15, xla); }
3267  }
3268
3269  final private boolean jj_2_17(int xla) {
3270    jj_la = xla; jj_lastpos = jj_scanpos = token;
3271    try { return !jj_3_17(); }
3272    catch(LookaheadSuccess ls) { return true; }
3273    finally { jj_save(16, xla); }
3274  }
3275
3276  final private boolean jj_2_18(int xla) {
3277    jj_la = xla; jj_lastpos = jj_scanpos = token;
3278    try { return !jj_3_18(); }
3279    catch(LookaheadSuccess ls) { return true; }
3280    finally { jj_save(17, xla); }
3281  }
3282
3283  final private boolean jj_2_19(int xla) {
3284    jj_la = xla; jj_lastpos = jj_scanpos = token;
3285    try { return !jj_3_19(); }
3286    catch(LookaheadSuccess ls) { return true; }
3287    finally { jj_save(18, xla); }
3288  }
3289
3290  final private boolean jj_2_20(int xla) {
3291    jj_la = xla; jj_lastpos = jj_scanpos = token;
3292    try { return !jj_3_20(); }
3293    catch(LookaheadSuccess ls) { return true; }
3294    finally { jj_save(19, xla); }
3295  }
3296
3297  final private boolean jj_2_21(int xla) {
3298    jj_la = xla; jj_lastpos = jj_scanpos = token;
3299    try { return !jj_3_21(); }
3300    catch(LookaheadSuccess ls) { return true; }
3301    finally { jj_save(20, xla); }
3302  }
3303
3304  final private boolean jj_2_22(int xla) {
3305    jj_la = xla; jj_lastpos = jj_scanpos = token;
3306    try { return !jj_3_22(); }
3307    catch(LookaheadSuccess ls) { return true; }
3308    finally { jj_save(21, xla); }
3309  }
3310
3311  final private boolean jj_2_23(int xla) {
3312    jj_la = xla; jj_lastpos = jj_scanpos = token;
3313    try { return !jj_3_23(); }
3314    catch(LookaheadSuccess ls) { return true; }
3315    finally { jj_save(22, xla); }
3316  }
3317
3318  final private boolean jj_2_24(int xla) {
3319    jj_la = xla; jj_lastpos = jj_scanpos = token;
3320    try { return !jj_3_24(); }
3321    catch(LookaheadSuccess ls) { return true; }
3322    finally { jj_save(23, xla); }
3323  }
3324
3325  final private boolean jj_2_25(int xla) {
3326    jj_la = xla; jj_lastpos = jj_scanpos = token;
3327    try { return !jj_3_25(); }
3328    catch(LookaheadSuccess ls) { return true; }
3329    finally { jj_save(24, xla); }
3330  }
3331
3332  final private boolean jj_2_26(int xla) {
3333    jj_la = xla; jj_lastpos = jj_scanpos = token;
3334    try { return !jj_3_26(); }
3335    catch(LookaheadSuccess ls) { return true; }
3336    finally { jj_save(25, xla); }
3337  }
3338
3339  final private boolean jj_2_27(int xla) {
3340    jj_la = xla; jj_lastpos = jj_scanpos = token;
3341    try { return !jj_3_27(); }
3342    catch(LookaheadSuccess ls) { return true; }
3343    finally { jj_save(26, xla); }
3344  }
3345
3346  final private boolean jj_2_28(int xla) {
3347    jj_la = xla; jj_lastpos = jj_scanpos = token;
3348    try { return !jj_3_28(); }
3349    catch(LookaheadSuccess ls) { return true; }
3350    finally { jj_save(27, xla); }
3351  }
3352
3353  final private boolean jj_2_29(int xla) {
3354    jj_la = xla; jj_lastpos = jj_scanpos = token;
3355    try { return !jj_3_29(); }
3356    catch(LookaheadSuccess ls) { return true; }
3357    finally { jj_save(28, xla); }
3358  }
3359
3360  final private boolean jj_2_30(int xla) {
3361    jj_la = xla; jj_lastpos = jj_scanpos = token;
3362    try { return !jj_3_30(); }
3363    catch(LookaheadSuccess ls) { return true; }
3364    finally { jj_save(29, xla); }
3365  }
3366
3367  final private boolean jj_2_31(int xla) {
3368    jj_la = xla; jj_lastpos = jj_scanpos = token;
3369    try { return !jj_3_31(); }
3370    catch(LookaheadSuccess ls) { return true; }
3371    finally { jj_save(30, xla); }
3372  }
3373
3374  final private boolean jj_2_32(int xla) {
3375    jj_la = xla; jj_lastpos = jj_scanpos = token;
3376    try { return !jj_3_32(); }
3377    catch(LookaheadSuccess ls) { return true; }
3378    finally { jj_save(31, xla); }
3379  }
3380
3381  final private boolean jj_2_33(int xla) {
3382    jj_la = xla; jj_lastpos = jj_scanpos = token;
3383    try { return !jj_3_33(); }
3384    catch(LookaheadSuccess ls) { return true; }
3385    finally { jj_save(32, xla); }
3386  }
3387
3388  final private boolean jj_2_34(int xla) {
3389    jj_la = xla; jj_lastpos = jj_scanpos = token;
3390    try { return !jj_3_34(); }
3391    catch(LookaheadSuccess ls) { return true; }
3392    finally { jj_save(33, xla); }
3393  }
3394
3395  final private boolean jj_2_35(int xla) {
3396    jj_la = xla; jj_lastpos = jj_scanpos = token;
3397    try { return !jj_3_35(); }
3398    catch(LookaheadSuccess ls) { return true; }
3399    finally { jj_save(34, xla); }
3400  }
3401
3402  final private boolean jj_2_36(int xla) {
3403    jj_la = xla; jj_lastpos = jj_scanpos = token;
3404    try { return !jj_3_36(); }
3405    catch(LookaheadSuccess ls) { return true; }
3406    finally { jj_save(35, xla); }
3407  }
3408
3409  final private boolean jj_2_37(int xla) {
3410    jj_la = xla; jj_lastpos = jj_scanpos = token;
3411    try { return !jj_3_37(); }
3412    catch(LookaheadSuccess ls) { return true; }
3413    finally { jj_save(36, xla); }
3414  }
3415
3416  final private boolean jj_2_38(int xla) {
3417    jj_la = xla; jj_lastpos = jj_scanpos = token;
3418    try { return !jj_3_38(); }
3419    catch(LookaheadSuccess ls) { return true; }
3420    finally { jj_save(37, xla); }
3421  }
3422
3423  final private boolean jj_2_39(int xla) {
3424    jj_la = xla; jj_lastpos = jj_scanpos = token;
3425    try { return !jj_3_39(); }
3426    catch(LookaheadSuccess ls) { return true; }
3427    finally { jj_save(38, xla); }
3428  }
3429
3430  final private boolean jj_2_40(int xla) {
3431    jj_la = xla; jj_lastpos = jj_scanpos = token;
3432    try { return !jj_3_40(); }
3433    catch(LookaheadSuccess ls) { return true; }
3434    finally { jj_save(39, xla); }
3435  }
3436
3437  final private boolean jj_2_41(int xla) {
3438    jj_la = xla; jj_lastpos = jj_scanpos = token;
3439    try { return !jj_3_41(); }
3440    catch(LookaheadSuccess ls) { return true; }
3441    finally { jj_save(40, xla); }
3442  }
3443
3444  final private boolean jj_2_42(int xla) {
3445    jj_la = xla; jj_lastpos = jj_scanpos = token;
3446    try { return !jj_3_42(); }
3447    catch(LookaheadSuccess ls) { return true; }
3448    finally { jj_save(41, xla); }
3449  }
3450
3451  final private boolean jj_2_43(int xla) {
3452    jj_la = xla; jj_lastpos = jj_scanpos = token;
3453    try { return !jj_3_43(); }
3454    catch(LookaheadSuccess ls) { return true; }
3455    finally { jj_save(42, xla); }
3456  }
3457
3458  final private boolean jj_2_44(int xla) {
3459    jj_la = xla; jj_lastpos = jj_scanpos = token;
3460    try { return !jj_3_44(); }
3461    catch(LookaheadSuccess ls) { return true; }
3462    finally { jj_save(43, xla); }
3463  }
3464
3465  final private boolean jj_2_45(int xla) {
3466    jj_la = xla; jj_lastpos = jj_scanpos = token;
3467    try { return !jj_3_45(); }
3468    catch(LookaheadSuccess ls) { return true; }
3469    finally { jj_save(44, xla); }
3470  }
3471
3472  final private boolean jj_2_46(int xla) {
3473    jj_la = xla; jj_lastpos = jj_scanpos = token;
3474    try { return !jj_3_46(); }
3475    catch(LookaheadSuccess ls) { return true; }
3476    finally { jj_save(45, xla); }
3477  }
3478
3479  final private boolean jj_2_47(int xla) {
3480    jj_la = xla; jj_lastpos = jj_scanpos = token;
3481    try { return !jj_3_47(); }
3482    catch(LookaheadSuccess ls) { return true; }
3483    finally { jj_save(46, xla); }
3484  }
3485
3486  final private boolean jj_2_48(int xla) {
3487    jj_la = xla; jj_lastpos = jj_scanpos = token;
3488    try { return !jj_3_48(); }
3489    catch(LookaheadSuccess ls) { return true; }
3490    finally { jj_save(47, xla); }
3491  }
3492
3493  final private boolean jj_2_49(int xla) {
3494    jj_la = xla; jj_lastpos = jj_scanpos = token;
3495    try { return !jj_3_49(); }
3496    catch(LookaheadSuccess ls) { return true; }
3497    finally { jj_save(48, xla); }
3498  }
3499
3500  final private boolean jj_2_50(int xla) {
3501    jj_la = xla; jj_lastpos = jj_scanpos = token;
3502    try { return !jj_3_50(); }
3503    catch(LookaheadSuccess ls) { return true; }
3504    finally { jj_save(49, xla); }
3505  }
3506
3507  final private boolean jj_2_51(int xla) {
3508    jj_la = xla; jj_lastpos = jj_scanpos = token;
3509    try { return !jj_3_51(); }
3510    catch(LookaheadSuccess ls) { return true; }
3511    finally { jj_save(50, xla); }
3512  }
3513
3514  final private boolean jj_2_52(int xla) {
3515    jj_la = xla; jj_lastpos = jj_scanpos = token;
3516    try { return !jj_3_52(); }
3517    catch(LookaheadSuccess ls) { return true; }
3518    finally { jj_save(51, xla); }
3519  }
3520
3521  final private boolean jj_2_53(int xla) {
3522    jj_la = xla; jj_lastpos = jj_scanpos = token;
3523    try { return !jj_3_53(); }
3524    catch(LookaheadSuccess ls) { return true; }
3525    finally { jj_save(52, xla); }
3526  }
3527
3528  final private boolean jj_2_54(int xla) {
3529    jj_la = xla; jj_lastpos = jj_scanpos = token;
3530    try { return !jj_3_54(); }
3531    catch(LookaheadSuccess ls) { return true; }
3532    finally { jj_save(53, xla); }
3533  }
3534
3535  final private boolean jj_2_55(int xla) {
3536    jj_la = xla; jj_lastpos = jj_scanpos = token;
3537    try { return !jj_3_55(); }
3538    catch(LookaheadSuccess ls) { return true; }
3539    finally { jj_save(54, xla); }
3540  }
3541
3542  final private boolean jj_2_56(int xla) {
3543    jj_la = xla; jj_lastpos = jj_scanpos = token;
3544    try { return !jj_3_56(); }
3545    catch(LookaheadSuccess ls) { return true; }
3546    finally { jj_save(55, xla); }
3547  }
3548
3549  final private boolean jj_2_57(int xla) {
3550    jj_la = xla; jj_lastpos = jj_scanpos = token;
3551    try { return !jj_3_57(); }
3552    catch(LookaheadSuccess ls) { return true; }
3553    finally { jj_save(56, xla); }
3554  }
3555
3556  final private boolean jj_2_58(int xla) {
3557    jj_la = xla; jj_lastpos = jj_scanpos = token;
3558    try { return !jj_3_58(); }
3559    catch(LookaheadSuccess ls) { return true; }
3560    finally { jj_save(57, xla); }
3561  }
3562
3563  final private boolean jj_2_59(int xla) {
3564    jj_la = xla; jj_lastpos = jj_scanpos = token;
3565    try { return !jj_3_59(); }
3566    catch(LookaheadSuccess ls) { return true; }
3567    finally { jj_save(58, xla); }
3568  }
3569
3570  final private boolean jj_2_60(int xla) {
3571    jj_la = xla; jj_lastpos = jj_scanpos = token;
3572    try { return !jj_3_60(); }
3573    catch(LookaheadSuccess ls) { return true; }
3574    finally { jj_save(59, xla); }
3575  }
3576
3577  final private boolean jj_2_61(int xla) {
3578    jj_la = xla; jj_lastpos = jj_scanpos = token;
3579    try { return !jj_3_61(); }
3580    catch(LookaheadSuccess ls) { return true; }
3581    finally { jj_save(60, xla); }
3582  }
3583
3584  final private boolean jj_2_62(int xla) {
3585    jj_la = xla; jj_lastpos = jj_scanpos = token;
3586    try { return !jj_3_62(); }
3587    catch(LookaheadSuccess ls) { return true; }
3588    finally { jj_save(61, xla); }
3589  }
3590
3591  final private boolean jj_2_63(int xla) {
3592    jj_la = xla; jj_lastpos = jj_scanpos = token;
3593    try { return !jj_3_63(); }
3594    catch(LookaheadSuccess ls) { return true; }
3595    finally { jj_save(62, xla); }
3596  }
3597
3598  final private boolean jj_2_64(int xla) {
3599    jj_la = xla; jj_lastpos = jj_scanpos = token;
3600    try { return !jj_3_64(); }
3601    catch(LookaheadSuccess ls) { return true; }
3602    finally { jj_save(63, xla); }
3603  }
3604
3605  final private boolean jj_2_65(int xla) {
3606    jj_la = xla; jj_lastpos = jj_scanpos = token;
3607    try { return !jj_3_65(); }
3608    catch(LookaheadSuccess ls) { return true; }
3609    finally { jj_save(64, xla); }
3610  }
3611
3612  final private boolean jj_2_66(int xla) {
3613    jj_la = xla; jj_lastpos = jj_scanpos = token;
3614    try { return !jj_3_66(); }
3615    catch(LookaheadSuccess ls) { return true; }
3616    finally { jj_save(65, xla); }
3617  }
3618
3619  final private boolean jj_2_67(int xla) {
3620    jj_la = xla; jj_lastpos = jj_scanpos = token;
3621    try { return !jj_3_67(); }
3622    catch(LookaheadSuccess ls) { return true; }
3623    finally { jj_save(66, xla); }
3624  }
3625
3626  final private boolean jj_2_68(int xla) {
3627    jj_la = xla; jj_lastpos = jj_scanpos = token;
3628    try { return !jj_3_68(); }
3629    catch(LookaheadSuccess ls) { return true; }
3630    finally { jj_save(67, xla); }
3631  }
3632
3633  final private boolean jj_2_69(int xla) {
3634    jj_la = xla; jj_lastpos = jj_scanpos = token;
3635    try { return !jj_3_69(); }
3636    catch(LookaheadSuccess ls) { return true; }
3637    finally { jj_save(68, xla); }
3638  }
3639
3640  final private boolean jj_2_70(int xla) {
3641    jj_la = xla; jj_lastpos = jj_scanpos = token;
3642    try { return !jj_3_70(); }
3643    catch(LookaheadSuccess ls) { return true; }
3644    finally { jj_save(69, xla); }
3645  }
3646
3647  final private boolean jj_2_71(int xla) {
3648    jj_la = xla; jj_lastpos = jj_scanpos = token;
3649    try { return !jj_3_71(); }
3650    catch(LookaheadSuccess ls) { return true; }
3651    finally { jj_save(70, xla); }
3652  }
3653
3654  final private boolean jj_2_72(int xla) {
3655    jj_la = xla; jj_lastpos = jj_scanpos = token;
3656    try { return !jj_3_72(); }
3657    catch(LookaheadSuccess ls) { return true; }
3658    finally { jj_save(71, xla); }
3659  }
3660
3661  final private boolean jj_2_73(int xla) {
3662    jj_la = xla; jj_lastpos = jj_scanpos = token;
3663    try { return !jj_3_73(); }
3664    catch(LookaheadSuccess ls) { return true; }
3665    finally { jj_save(72, xla); }
3666  }
3667
3668  final private boolean jj_2_74(int xla) {
3669    jj_la = xla; jj_lastpos = jj_scanpos = token;
3670    try { return !jj_3_74(); }
3671    catch(LookaheadSuccess ls) { return true; }
3672    finally { jj_save(73, xla); }
3673  }
3674
3675  final private boolean jj_2_75(int xla) {
3676    jj_la = xla; jj_lastpos = jj_scanpos = token;
3677    try { return !jj_3_75(); }
3678    catch(LookaheadSuccess ls) { return true; }
3679    finally { jj_save(74, xla); }
3680  }
3681
3682  final private boolean jj_2_76(int xla) {
3683    jj_la = xla; jj_lastpos = jj_scanpos = token;
3684    try { return !jj_3_76(); }
3685    catch(LookaheadSuccess ls) { return true; }
3686    finally { jj_save(75, xla); }
3687  }
3688
3689  final private boolean jj_2_77(int xla) {
3690    jj_la = xla; jj_lastpos = jj_scanpos = token;
3691    try { return !jj_3_77(); }
3692    catch(LookaheadSuccess ls) { return true; }
3693    finally { jj_save(76, xla); }
3694  }
3695
3696  final private boolean jj_2_78(int xla) {
3697    jj_la = xla; jj_lastpos = jj_scanpos = token;
3698    try { return !jj_3_78(); }
3699    catch(LookaheadSuccess ls) { return true; }
3700    finally { jj_save(77, xla); }
3701  }
3702
3703  final private boolean jj_2_79(int xla) {
3704    jj_la = xla; jj_lastpos = jj_scanpos = token;
3705    try { return !jj_3_79(); }
3706    catch(LookaheadSuccess ls) { return true; }
3707    finally { jj_save(78, xla); }
3708  }
3709
3710  final private boolean jj_2_80(int xla) {
3711    jj_la = xla; jj_lastpos = jj_scanpos = token;
3712    try { return !jj_3_80(); }
3713    catch(LookaheadSuccess ls) { return true; }
3714    finally { jj_save(79, xla); }
3715  }
3716
3717  final private boolean jj_2_81(int xla) {
3718    jj_la = xla; jj_lastpos = jj_scanpos = token;
3719    try { return !jj_3_81(); }
3720    catch(LookaheadSuccess ls) { return true; }
3721    finally { jj_save(80, xla); }
3722  }
3723
3724  final private boolean jj_2_82(int xla) {
3725    jj_la = xla; jj_lastpos = jj_scanpos = token;
3726    try { return !jj_3_82(); }
3727    catch(LookaheadSuccess ls) { return true; }
3728    finally { jj_save(81, xla); }
3729  }
3730
3731  final private boolean jj_2_83(int xla) {
3732    jj_la = xla; jj_lastpos = jj_scanpos = token;
3733    try { return !jj_3_83(); }
3734    catch(LookaheadSuccess ls) { return true; }
3735    finally { jj_save(82, xla); }
3736  }
3737
3738  final private boolean jj_2_84(int xla) {
3739    jj_la = xla; jj_lastpos = jj_scanpos = token;
3740    try { return !jj_3_84(); }
3741    catch(LookaheadSuccess ls) { return true; }
3742    finally { jj_save(83, xla); }
3743  }
3744
3745  final private boolean jj_2_85(int xla) {
3746    jj_la = xla; jj_lastpos = jj_scanpos = token;
3747    try { return !jj_3_85(); }
3748    catch(LookaheadSuccess ls) { return true; }
3749    finally { jj_save(84, xla); }
3750  }
3751
3752  final private boolean jj_2_86(int xla) {
3753    jj_la = xla; jj_lastpos = jj_scanpos = token;
3754    try { return !jj_3_86(); }
3755    catch(LookaheadSuccess ls) { return true; }
3756    finally { jj_save(85, xla); }
3757  }
3758
3759  final private boolean jj_2_87(int xla) {
3760    jj_la = xla; jj_lastpos = jj_scanpos = token;
3761    try { return !jj_3_87(); }
3762    catch(LookaheadSuccess ls) { return true; }
3763    finally { jj_save(86, xla); }
3764  }
3765
3766  final private boolean jj_2_88(int xla) {
3767    jj_la = xla; jj_lastpos = jj_scanpos = token;
3768    try { return !jj_3_88(); }
3769    catch(LookaheadSuccess ls) { return true; }
3770    finally { jj_save(87, xla); }
3771  }
3772
3773  final private boolean jj_2_89(int xla) {
3774    jj_la = xla; jj_lastpos = jj_scanpos = token;
3775    try { return !jj_3_89(); }
3776    catch(LookaheadSuccess ls) { return true; }
3777    finally { jj_save(88, xla); }
3778  }
3779
3780  final private boolean jj_2_90(int xla) {
3781    jj_la = xla; jj_lastpos = jj_scanpos = token;
3782    try { return !jj_3_90(); }
3783    catch(LookaheadSuccess ls) { return true; }
3784    finally { jj_save(89, xla); }
3785  }
3786
3787  final private boolean jj_2_91(int xla) {
3788    jj_la = xla; jj_lastpos = jj_scanpos = token;
3789    try { return !jj_3_91(); }
3790    catch(LookaheadSuccess ls) { return true; }
3791    finally { jj_save(90, xla); }
3792  }
3793
3794  final private boolean jj_2_92(int xla) {
3795    jj_la = xla; jj_lastpos = jj_scanpos = token;
3796    try { return !jj_3_92(); }
3797    catch(LookaheadSuccess ls) { return true; }
3798    finally { jj_save(91, xla); }
3799  }
3800
3801  final private boolean jj_2_93(int xla) {
3802    jj_la = xla; jj_lastpos = jj_scanpos = token;
3803    try { return !jj_3_93(); }
3804    catch(LookaheadSuccess ls) { return true; }
3805    finally { jj_save(92, xla); }
3806  }
3807
3808  final private boolean jj_2_94(int xla) {
3809    jj_la = xla; jj_lastpos = jj_scanpos = token;
3810    try { return !jj_3_94(); }
3811    catch(LookaheadSuccess ls) { return true; }
3812    finally { jj_save(93, xla); }
3813  }
3814
3815  final private boolean jj_2_95(int xla) {
3816    jj_la = xla; jj_lastpos = jj_scanpos = token;
3817    try { return !jj_3_95(); }
3818    catch(LookaheadSuccess ls) { return true; }
3819    finally { jj_save(94, xla); }
3820  }
3821
3822  final private boolean jj_2_96(int xla) {
3823    jj_la = xla; jj_lastpos = jj_scanpos = token;
3824    try { return !jj_3_96(); }
3825    catch(LookaheadSuccess ls) { return true; }
3826    finally { jj_save(95, xla); }
3827  }
3828
3829  final private boolean jj_2_97(int xla) {
3830    jj_la = xla; jj_lastpos = jj_scanpos = token;
3831    try { return !jj_3_97(); }
3832    catch(LookaheadSuccess ls) { return true; }
3833    finally { jj_save(96, xla); }
3834  }
3835
3836  final private boolean jj_2_98(int xla) {
3837    jj_la = xla; jj_lastpos = jj_scanpos = token;
3838    try { return !jj_3_98(); }
3839    catch(LookaheadSuccess ls) { return true; }
3840    finally { jj_save(97, xla); }
3841  }
3842
3843  final private boolean jj_2_99(int xla) {
3844    jj_la = xla; jj_lastpos = jj_scanpos = token;
3845    try { return !jj_3_99(); }
3846    catch(LookaheadSuccess ls) { return true; }
3847    finally { jj_save(98, xla); }
3848  }
3849
3850  final private boolean jj_2_100(int xla) {
3851    jj_la = xla; jj_lastpos = jj_scanpos = token;
3852    try { return !jj_3_100(); }
3853    catch(LookaheadSuccess ls) { return true; }
3854    finally { jj_save(99, xla); }
3855  }
3856
3857  final private boolean jj_2_101(int xla) {
3858    jj_la = xla; jj_lastpos = jj_scanpos = token;
3859    try { return !jj_3_101(); }
3860    catch(LookaheadSuccess ls) { return true; }
3861    finally { jj_save(100, xla); }
3862  }
3863
3864  final private boolean jj_2_102(int xla) {
3865    jj_la = xla; jj_lastpos = jj_scanpos = token;
3866    try { return !jj_3_102(); }
3867    catch(LookaheadSuccess ls) { return true; }
3868    finally { jj_save(101, xla); }
3869  }
3870
3871  final private boolean jj_2_103(int xla) {
3872    jj_la = xla; jj_lastpos = jj_scanpos = token;
3873    try { return !jj_3_103(); }
3874    catch(LookaheadSuccess ls) { return true; }
3875    finally { jj_save(102, xla); }
3876  }
3877
3878  final private boolean jj_2_104(int xla) {
3879    jj_la = xla; jj_lastpos = jj_scanpos = token;
3880    try { return !jj_3_104(); }
3881    catch(LookaheadSuccess ls) { return true; }
3882    finally { jj_save(103, xla); }
3883  }
3884
3885  final private boolean jj_2_105(int xla) {
3886    jj_la = xla; jj_lastpos = jj_scanpos = token;
3887    try { return !jj_3_105(); }
3888    catch(LookaheadSuccess ls) { return true; }
3889    finally { jj_save(104, xla); }
3890  }
3891
3892  final private boolean jj_2_106(int xla) {
3893    jj_la = xla; jj_lastpos = jj_scanpos = token;
3894    try { return !jj_3_106(); }
3895    catch(LookaheadSuccess ls) { return true; }
3896    finally { jj_save(105, xla); }
3897  }
3898
3899  final private boolean jj_2_107(int xla) {
3900    jj_la = xla; jj_lastpos = jj_scanpos = token;
3901    try { return !jj_3_107(); }
3902    catch(LookaheadSuccess ls) { return true; }
3903    finally { jj_save(106, xla); }
3904  }
3905
3906  final private boolean jj_2_108(int xla) {
3907    jj_la = xla; jj_lastpos = jj_scanpos = token;
3908    try { return !jj_3_108(); }
3909    catch(LookaheadSuccess ls) { return true; }
3910    finally { jj_save(107, xla); }
3911  }
3912
3913  final private boolean jj_2_109(int xla) {
3914    jj_la = xla; jj_lastpos = jj_scanpos = token;
3915    try { return !jj_3_109(); }
3916    catch(LookaheadSuccess ls) { return true; }
3917    finally { jj_save(108, xla); }
3918  }
3919
3920  final private boolean jj_2_110(int xla) {
3921    jj_la = xla; jj_lastpos = jj_scanpos = token;
3922    try { return !jj_3_110(); }
3923    catch(LookaheadSuccess ls) { return true; }
3924    finally { jj_save(109, xla); }
3925  }
3926
3927  final private boolean jj_2_111(int xla) {
3928    jj_la = xla; jj_lastpos = jj_scanpos = token;
3929    try { return !jj_3_111(); }
3930    catch(LookaheadSuccess ls) { return true; }
3931    finally { jj_save(110, xla); }
3932  }
3933
3934  final private boolean jj_2_112(int xla) {
3935    jj_la = xla; jj_lastpos = jj_scanpos = token;
3936    try { return !jj_3_112(); }
3937    catch(LookaheadSuccess ls) { return true; }
3938    finally { jj_save(111, xla); }
3939  }
3940
3941  final private boolean jj_2_113(int xla) {
3942    jj_la = xla; jj_lastpos = jj_scanpos = token;
3943    try { return !jj_3_113(); }
3944    catch(LookaheadSuccess ls) { return true; }
3945    finally { jj_save(112, xla); }
3946  }
3947
3948  final private boolean jj_2_114(int xla) {
3949    jj_la = xla; jj_lastpos = jj_scanpos = token;
3950    try { return !jj_3_114(); }
3951    catch(LookaheadSuccess ls) { return true; }
3952    finally { jj_save(113, xla); }
3953  }
3954
3955  final private boolean jj_2_115(int xla) {
3956    jj_la = xla; jj_lastpos = jj_scanpos = token;
3957    try { return !jj_3_115(); }
3958    catch(LookaheadSuccess ls) { return true; }
3959    finally { jj_save(114, xla); }
3960  }
3961
3962  final private boolean jj_2_116(int xla) {
3963    jj_la = xla; jj_lastpos = jj_scanpos = token;
3964    try { return !jj_3_116(); }
3965    catch(LookaheadSuccess ls) { return true; }
3966    finally { jj_save(115, xla); }
3967  }
3968
3969  final private boolean jj_2_117(int xla) {
3970    jj_la = xla; jj_lastpos = jj_scanpos = token;
3971    try { return !jj_3_117(); }
3972    catch(LookaheadSuccess ls) { return true; }
3973    finally { jj_save(116, xla); }
3974  }
3975
3976  final private boolean jj_2_118(int xla) {
3977    jj_la = xla; jj_lastpos = jj_scanpos = token;
3978    try { return !jj_3_118(); }
3979    catch(LookaheadSuccess ls) { return true; }
3980    finally { jj_save(117, xla); }
3981  }
3982
3983  final private boolean jj_2_119(int xla) {
3984    jj_la = xla; jj_lastpos = jj_scanpos = token;
3985    try { return !jj_3_119(); }
3986    catch(LookaheadSuccess ls) { return true; }
3987    finally { jj_save(118, xla); }
3988  }
3989
3990  final private boolean jj_2_120(int xla) {
3991    jj_la = xla; jj_lastpos = jj_scanpos = token;
3992    try { return !jj_3_120(); }
3993    catch(LookaheadSuccess ls) { return true; }
3994    finally { jj_save(119, xla); }
3995  }
3996
3997  final private boolean jj_2_121(int xla) {
3998    jj_la = xla; jj_lastpos = jj_scanpos = token;
3999    try { return !jj_3_121(); }
4000    catch(LookaheadSuccess ls) { return true; }
4001    finally { jj_save(120, xla); }
4002  }
4003
4004  final private boolean jj_2_122(int xla) {
4005    jj_la = xla; jj_lastpos = jj_scanpos = token;
4006    try { return !jj_3_122(); }
4007    catch(LookaheadSuccess ls) { return true; }
4008    finally { jj_save(121, xla); }
4009  }
4010
4011  final private boolean jj_2_123(int xla) {
4012    jj_la = xla; jj_lastpos = jj_scanpos = token;
4013    try { return !jj_3_123(); }
4014    catch(LookaheadSuccess ls) { return true; }
4015    finally { jj_save(122, xla); }
4016  }
4017
4018  final private boolean jj_2_124(int xla) {
4019    jj_la = xla; jj_lastpos = jj_scanpos = token;
4020    try { return !jj_3_124(); }
4021    catch(LookaheadSuccess ls) { return true; }
4022    finally { jj_save(123, xla); }
4023  }
4024
4025  final private boolean jj_2_125(int xla) {
4026    jj_la = xla; jj_lastpos = jj_scanpos = token;
4027    try { return !jj_3_125(); }
4028    catch(LookaheadSuccess ls) { return true; }
4029    finally { jj_save(124, xla); }
4030  }
4031
4032  final private boolean jj_2_126(int xla) {
4033    jj_la = xla; jj_lastpos = jj_scanpos = token;
4034    try { return !jj_3_126(); }
4035    catch(LookaheadSuccess ls) { return true; }
4036    finally { jj_save(125, xla); }
4037  }
4038
4039  final private boolean jj_2_127(int xla) {
4040    jj_la = xla; jj_lastpos = jj_scanpos = token;
4041    try { return !jj_3_127(); }
4042    catch(LookaheadSuccess ls) { return true; }
4043    finally { jj_save(126, xla); }
4044  }
4045
4046  final private boolean jj_2_128(int xla) {
4047    jj_la = xla; jj_lastpos = jj_scanpos = token;
4048    try { return !jj_3_128(); }
4049    catch(LookaheadSuccess ls) { return true; }
4050    finally { jj_save(127, xla); }
4051  }
4052
4053  final private boolean jj_2_129(int xla) {
4054    jj_la = xla; jj_lastpos = jj_scanpos = token;
4055    try { return !jj_3_129(); }
4056    catch(LookaheadSuccess ls) { return true; }
4057    finally { jj_save(128, xla); }
4058  }
4059
4060  final private boolean jj_2_130(int xla) {
4061    jj_la = xla; jj_lastpos = jj_scanpos = token;
4062    try { return !jj_3_130(); }
4063    catch(LookaheadSuccess ls) { return true; }
4064    finally { jj_save(129, xla); }
4065  }
4066
4067  final private boolean jj_2_131(int xla) {
4068    jj_la = xla; jj_lastpos = jj_scanpos = token;
4069    try { return !jj_3_131(); }
4070    catch(LookaheadSuccess ls) { return true; }
4071    finally { jj_save(130, xla); }
4072  }
4073
4074  final private boolean jj_2_132(int xla) {
4075    jj_la = xla; jj_lastpos = jj_scanpos = token;
4076    try { return !jj_3_132(); }
4077    catch(LookaheadSuccess ls) { return true; }
4078    finally { jj_save(131, xla); }
4079  }
4080
4081  final private boolean jj_2_133(int xla) {
4082    jj_la = xla; jj_lastpos = jj_scanpos = token;
4083    try { return !jj_3_133(); }
4084    catch(LookaheadSuccess ls) { return true; }
4085    finally { jj_save(132, xla); }
4086  }
4087
4088  final private boolean jj_2_134(int xla) {
4089    jj_la = xla; jj_lastpos = jj_scanpos = token;
4090    try { return !jj_3_134(); }
4091    catch(LookaheadSuccess ls) { return true; }
4092    finally { jj_save(133, xla); }
4093  }
4094
4095  final private boolean jj_2_135(int xla) {
4096    jj_la = xla; jj_lastpos = jj_scanpos = token;
4097    try { return !jj_3_135(); }
4098    catch(LookaheadSuccess ls) { return true; }
4099    finally { jj_save(134, xla); }
4100  }
4101
4102  final private boolean jj_2_136(int xla) {
4103    jj_la = xla; jj_lastpos = jj_scanpos = token;
4104    try { return !jj_3_136(); }
4105    catch(LookaheadSuccess ls) { return true; }
4106    finally { jj_save(135, xla); }
4107  }
4108
4109  final private boolean jj_2_137(int xla) {
4110    jj_la = xla; jj_lastpos = jj_scanpos = token;
4111    try { return !jj_3_137(); }
4112    catch(LookaheadSuccess ls) { return true; }
4113    finally { jj_save(136, xla); }
4114  }
4115
4116  final private boolean jj_2_138(int xla) {
4117    jj_la = xla; jj_lastpos = jj_scanpos = token;
4118    try { return !jj_3_138(); }
4119    catch(LookaheadSuccess ls) { return true; }
4120    finally { jj_save(137, xla); }
4121  }
4122
4123  final private boolean jj_2_139(int xla) {
4124    jj_la = xla; jj_lastpos = jj_scanpos = token;
4125    try { return !jj_3_139(); }
4126    catch(LookaheadSuccess ls) { return true; }
4127    finally { jj_save(138, xla); }
4128  }
4129
4130  final private boolean jj_2_140(int xla) {
4131    jj_la = xla; jj_lastpos = jj_scanpos = token;
4132    try { return !jj_3_140(); }
4133    catch(LookaheadSuccess ls) { return true; }
4134    finally { jj_save(139, xla); }
4135  }
4136
4137  final private boolean jj_2_141(int xla) {
4138    jj_la = xla; jj_lastpos = jj_scanpos = token;
4139    try { return !jj_3_141(); }
4140    catch(LookaheadSuccess ls) { return true; }
4141    finally { jj_save(140, xla); }
4142  }
4143
4144  final private boolean jj_2_142(int xla) {
4145    jj_la = xla; jj_lastpos = jj_scanpos = token;
4146    try { return !jj_3_142(); }
4147    catch(LookaheadSuccess ls) { return true; }
4148    finally { jj_save(141, xla); }
4149  }
4150
4151  final private boolean jj_2_143(int xla) {
4152    jj_la = xla; jj_lastpos = jj_scanpos = token;
4153    try { return !jj_3_143(); }
4154    catch(LookaheadSuccess ls) { return true; }
4155    finally { jj_save(142, xla); }
4156  }
4157
4158  final private boolean jj_2_144(int xla) {
4159    jj_la = xla; jj_lastpos = jj_scanpos = token;
4160    try { return !jj_3_144(); }
4161    catch(LookaheadSuccess ls) { return true; }
4162    finally { jj_save(143, xla); }
4163  }
4164
4165  final private boolean jj_2_145(int xla) {
4166    jj_la = xla; jj_lastpos = jj_scanpos = token;
4167    try { return !jj_3_145(); }
4168    catch(LookaheadSuccess ls) { return true; }
4169    finally { jj_save(144, xla); }
4170  }
4171
4172  final private boolean jj_2_146(int xla) {
4173    jj_la = xla; jj_lastpos = jj_scanpos = token;
4174    try { return !jj_3_146(); }
4175    catch(LookaheadSuccess ls) { return true; }
4176    finally { jj_save(145, xla); }
4177  }
4178
4179  final private boolean jj_2_147(int xla) {
4180    jj_la = xla; jj_lastpos = jj_scanpos = token;
4181    try { return !jj_3_147(); }
4182    catch(LookaheadSuccess ls) { return true; }
4183    finally { jj_save(146, xla); }
4184  }
4185
4186  final private boolean jj_2_148(int xla) {
4187    jj_la = xla; jj_lastpos = jj_scanpos = token;
4188    try { return !jj_3_148(); }
4189    catch(LookaheadSuccess ls) { return true; }
4190    finally { jj_save(147, xla); }
4191  }
4192
4193  final private boolean jj_2_149(int xla) {
4194    jj_la = xla; jj_lastpos = jj_scanpos = token;
4195    try { return !jj_3_149(); }
4196    catch(LookaheadSuccess ls) { return true; }
4197    finally { jj_save(148, xla); }
4198  }
4199
4200  final private boolean jj_2_150(int xla) {
4201    jj_la = xla; jj_lastpos = jj_scanpos = token;
4202    try { return !jj_3_150(); }
4203    catch(LookaheadSuccess ls) { return true; }
4204    finally { jj_save(149, xla); }
4205  }
4206
4207  final private boolean jj_2_151(int xla) {
4208    jj_la = xla; jj_lastpos = jj_scanpos = token;
4209    try { return !jj_3_151(); }
4210    catch(LookaheadSuccess ls) { return true; }
4211    finally { jj_save(150, xla); }
4212  }
4213
4214  final private boolean jj_2_152(int xla) {
4215    jj_la = xla; jj_lastpos = jj_scanpos = token;
4216    try { return !jj_3_152(); }
4217    catch(LookaheadSuccess ls) { return true; }
4218    finally { jj_save(151, xla); }
4219  }
4220
4221  final private boolean jj_2_153(int xla) {
4222    jj_la = xla; jj_lastpos = jj_scanpos = token;
4223    try { return !jj_3_153(); }
4224    catch(LookaheadSuccess ls) { return true; }
4225    finally { jj_save(152, xla); }
4226  }
4227
4228  final private boolean jj_2_154(int xla) {
4229    jj_la = xla; jj_lastpos = jj_scanpos = token;
4230    try { return !jj_3_154(); }
4231    catch(LookaheadSuccess ls) { return true; }
4232    finally { jj_save(153, xla); }
4233  }
4234
4235  final private boolean jj_2_155(int xla) {
4236    jj_la = xla; jj_lastpos = jj_scanpos = token;
4237    try { return !jj_3_155(); }
4238    catch(LookaheadSuccess ls) { return true; }
4239    finally { jj_save(154, xla); }
4240  }
4241
4242  final private boolean jj_2_156(int xla) {
4243    jj_la = xla; jj_lastpos = jj_scanpos = token;
4244    try { return !jj_3_156(); }
4245    catch(LookaheadSuccess ls) { return true; }
4246    finally { jj_save(155, xla); }
4247  }
4248
4249  final private boolean jj_2_157(int xla) {
4250    jj_la = xla; jj_lastpos = jj_scanpos = token;
4251    try { return !jj_3_157(); }
4252    catch(LookaheadSuccess ls) { return true; }
4253    finally { jj_save(156, xla); }
4254  }
4255
4256  final private boolean jj_2_158(int xla) {
4257    jj_la = xla; jj_lastpos = jj_scanpos = token;
4258    try { return !jj_3_158(); }
4259    catch(LookaheadSuccess ls) { return true; }
4260    finally { jj_save(157, xla); }
4261  }
4262
4263  final private boolean jj_2_159(int xla) {
4264    jj_la = xla; jj_lastpos = jj_scanpos = token;
4265    try { return !jj_3_159(); }
4266    catch(LookaheadSuccess ls) { return true; }
4267    finally { jj_save(158, xla); }
4268  }
4269
4270  final private boolean jj_2_160(int xla) {
4271    jj_la = xla; jj_lastpos = jj_scanpos = token;
4272    try { return !jj_3_160(); }
4273    catch(LookaheadSuccess ls) { return true; }
4274    finally { jj_save(159, xla); }
4275  }
4276
4277  final private boolean jj_2_161(int xla) {
4278    jj_la = xla; jj_lastpos = jj_scanpos = token;
4279    try { return !jj_3_161(); }
4280    catch(LookaheadSuccess ls) { return true; }
4281    finally { jj_save(160, xla); }
4282  }
4283
4284  final private boolean jj_2_162(int xla) {
4285    jj_la = xla; jj_lastpos = jj_scanpos = token;
4286    try { return !jj_3_162(); }
4287    catch(LookaheadSuccess ls) { return true; }
4288    finally { jj_save(161, xla); }
4289  }
4290
4291  final private boolean jj_2_163(int xla) {
4292    jj_la = xla; jj_lastpos = jj_scanpos = token;
4293    try { return !jj_3_163(); }
4294    catch(LookaheadSuccess ls) { return true; }
4295    finally { jj_save(162, xla); }
4296  }
4297
4298  final private boolean jj_2_164(int xla) {
4299    jj_la = xla; jj_lastpos = jj_scanpos = token;
4300    try { return !jj_3_164(); }
4301    catch(LookaheadSuccess ls) { return true; }
4302    finally { jj_save(163, xla); }
4303  }
4304
4305  final private boolean jj_2_165(int xla) {
4306    jj_la = xla; jj_lastpos = jj_scanpos = token;
4307    try { return !jj_3_165(); }
4308    catch(LookaheadSuccess ls) { return true; }
4309    finally { jj_save(164, xla); }
4310  }
4311
4312  final private boolean jj_2_166(int xla) {
4313    jj_la = xla; jj_lastpos = jj_scanpos = token;
4314    try { return !jj_3_166(); }
4315    catch(LookaheadSuccess ls) { return true; }
4316    finally { jj_save(165, xla); }
4317  }
4318
4319  final private boolean jj_2_167(int xla) {
4320    jj_la = xla; jj_lastpos = jj_scanpos = token;
4321    try { return !jj_3_167(); }
4322    catch(LookaheadSuccess ls) { return true; }
4323    finally { jj_save(166, xla); }
4324  }
4325
4326  final private boolean jj_2_168(int xla) {
4327    jj_la = xla; jj_lastpos = jj_scanpos = token;
4328    try { return !jj_3_168(); }
4329    catch(LookaheadSuccess ls) { return true; }
4330    finally { jj_save(167, xla); }
4331  }
4332
4333  final private boolean jj_2_169(int xla) {
4334    jj_la = xla; jj_lastpos = jj_scanpos = token;
4335    try { return !jj_3_169(); }
4336    catch(LookaheadSuccess ls) { return true; }
4337    finally { jj_save(168, xla); }
4338  }
4339
4340  final private boolean jj_2_170(int xla) {
4341    jj_la = xla; jj_lastpos = jj_scanpos = token;
4342    try { return !jj_3_170(); }
4343    catch(LookaheadSuccess ls) { return true; }
4344    finally { jj_save(169, xla); }
4345  }
4346
4347  final private boolean jj_2_171(int xla) {
4348    jj_la = xla; jj_lastpos = jj_scanpos = token;
4349    try { return !jj_3_171(); }
4350    catch(LookaheadSuccess ls) { return true; }
4351    finally { jj_save(170, xla); }
4352  }
4353
4354  final private boolean jj_2_172(int xla) {
4355    jj_la = xla; jj_lastpos = jj_scanpos = token;
4356    try { return !jj_3_172(); }
4357    catch(LookaheadSuccess ls) { return true; }
4358    finally { jj_save(171, xla); }
4359  }
4360
4361  final private boolean jj_2_173(int xla) {
4362    jj_la = xla; jj_lastpos = jj_scanpos = token;
4363    try { return !jj_3_173(); }
4364    catch(LookaheadSuccess ls) { return true; }
4365    finally { jj_save(172, xla); }
4366  }
4367
4368  final private boolean jj_2_174(int xla) {
4369    jj_la = xla; jj_lastpos = jj_scanpos = token;
4370    try { return !jj_3_174(); }
4371    catch(LookaheadSuccess ls) { return true; }
4372    finally { jj_save(173, xla); }
4373  }
4374
4375  final private boolean jj_2_175(int xla) {
4376    jj_la = xla; jj_lastpos = jj_scanpos = token;
4377    try { return !jj_3_175(); }
4378    catch(LookaheadSuccess ls) { return true; }
4379    finally { jj_save(174, xla); }
4380  }
4381
4382  final private boolean jj_2_176(int xla) {
4383    jj_la = xla; jj_lastpos = jj_scanpos = token;
4384    try { return !jj_3_176(); }
4385    catch(LookaheadSuccess ls) { return true; }
4386    finally { jj_save(175, xla); }
4387  }
4388
4389  final private boolean jj_2_177(int xla) {
4390    jj_la = xla; jj_lastpos = jj_scanpos = token;
4391    try { return !jj_3_177(); }
4392    catch(LookaheadSuccess ls) { return true; }
4393    finally { jj_save(176, xla); }
4394  }
4395
4396  final private boolean jj_2_178(int xla) {
4397    jj_la = xla; jj_lastpos = jj_scanpos = token;
4398    try { return !jj_3_178(); }
4399    catch(LookaheadSuccess ls) { return true; }
4400    finally { jj_save(177, xla); }
4401  }
4402
4403  final private boolean jj_2_179(int xla) {
4404    jj_la = xla; jj_lastpos = jj_scanpos = token;
4405    try { return !jj_3_179(); }
4406    catch(LookaheadSuccess ls) { return true; }
4407    finally { jj_save(178, xla); }
4408  }
4409
4410  final private boolean jj_2_180(int xla) {
4411    jj_la = xla; jj_lastpos = jj_scanpos = token;
4412    try { return !jj_3_180(); }
4413    catch(LookaheadSuccess ls) { return true; }
4414    finally { jj_save(179, xla); }
4415  }
4416
4417  final private boolean jj_2_181(int xla) {
4418    jj_la = xla; jj_lastpos = jj_scanpos = token;
4419    try { return !jj_3_181(); }
4420    catch(LookaheadSuccess ls) { return true; }
4421    finally { jj_save(180, xla); }
4422  }
4423
4424  final private boolean jj_2_182(int xla) {
4425    jj_la = xla; jj_lastpos = jj_scanpos = token;
4426    try { return !jj_3_182(); }
4427    catch(LookaheadSuccess ls) { return true; }
4428    finally { jj_save(181, xla); }
4429  }
4430
4431  final private boolean jj_2_183(int xla) {
4432    jj_la = xla; jj_lastpos = jj_scanpos = token;
4433    try { return !jj_3_183(); }
4434    catch(LookaheadSuccess ls) { return true; }
4435    finally { jj_save(182, xla); }
4436  }
4437
4438  final private boolean jj_2_184(int xla) {
4439    jj_la = xla; jj_lastpos = jj_scanpos = token;
4440    try { return !jj_3_184(); }
4441    catch(LookaheadSuccess ls) { return true; }
4442    finally { jj_save(183, xla); }
4443  }
4444
4445  final private boolean jj_2_185(int xla) {
4446    jj_la = xla; jj_lastpos = jj_scanpos = token;
4447    try { return !jj_3_185(); }
4448    catch(LookaheadSuccess ls) { return true; }
4449    finally { jj_save(184, xla); }
4450  }
4451
4452  final private boolean jj_2_186(int xla) {
4453    jj_la = xla; jj_lastpos = jj_scanpos = token;
4454    try { return !jj_3_186(); }
4455    catch(LookaheadSuccess ls) { return true; }
4456    finally { jj_save(185, xla); }
4457  }
4458
4459  final private boolean jj_2_187(int xla) {
4460    jj_la = xla; jj_lastpos = jj_scanpos = token;
4461    try { return !jj_3_187(); }
4462    catch(LookaheadSuccess ls) { return true; }
4463    finally { jj_save(186, xla); }
4464  }
4465
4466  final private boolean jj_2_188(int xla) {
4467    jj_la = xla; jj_lastpos = jj_scanpos = token;
4468    try { return !jj_3_188(); }
4469    catch(LookaheadSuccess ls) { return true; }
4470    finally { jj_save(187, xla); }
4471  }
4472
4473  final private boolean jj_2_189(int xla) {
4474    jj_la = xla; jj_lastpos = jj_scanpos = token;
4475    try { return !jj_3_189(); }
4476    catch(LookaheadSuccess ls) { return true; }
4477    finally { jj_save(188, xla); }
4478  }
4479
4480  final private boolean jj_2_190(int xla) {
4481    jj_la = xla; jj_lastpos = jj_scanpos = token;
4482    try { return !jj_3_190(); }
4483    catch(LookaheadSuccess ls) { return true; }
4484    finally { jj_save(189, xla); }
4485  }
4486
4487  final private boolean jj_2_191(int xla) {
4488    jj_la = xla; jj_lastpos = jj_scanpos = token;
4489    try { return !jj_3_191(); }
4490    catch(LookaheadSuccess ls) { return true; }
4491    finally { jj_save(190, xla); }
4492  }
4493
4494  final private boolean jj_2_192(int xla) {
4495    jj_la = xla; jj_lastpos = jj_scanpos = token;
4496    try { return !jj_3_192(); }
4497    catch(LookaheadSuccess ls) { return true; }
4498    finally { jj_save(191, xla); }
4499  }
4500
4501  final private boolean jj_2_193(int xla) {
4502    jj_la = xla; jj_lastpos = jj_scanpos = token;
4503    try { return !jj_3_193(); }
4504    catch(LookaheadSuccess ls) { return true; }
4505    finally { jj_save(192, xla); }
4506  }
4507
4508  final private boolean jj_2_194(int xla) {
4509    jj_la = xla; jj_lastpos = jj_scanpos = token;
4510    try { return !jj_3_194(); }
4511    catch(LookaheadSuccess ls) { return true; }
4512    finally { jj_save(193, xla); }
4513  }
4514
4515  final private boolean jj_2_195(int xla) {
4516    jj_la = xla; jj_lastpos = jj_scanpos = token;
4517    try { return !jj_3_195(); }
4518    catch(LookaheadSuccess ls) { return true; }
4519    finally { jj_save(194, xla); }
4520  }
4521
4522  final private boolean jj_2_196(int xla) {
4523    jj_la = xla; jj_lastpos = jj_scanpos = token;
4524    try { return !jj_3_196(); }
4525    catch(LookaheadSuccess ls) { return true; }
4526    finally { jj_save(195, xla); }
4527  }
4528
4529  final private boolean jj_2_197(int xla) {
4530    jj_la = xla; jj_lastpos = jj_scanpos = token;
4531    try { return !jj_3_197(); }
4532    catch(LookaheadSuccess ls) { return true; }
4533    finally { jj_save(196, xla); }
4534  }
4535
4536  final private boolean jj_2_198(int xla) {
4537    jj_la = xla; jj_lastpos = jj_scanpos = token;
4538    try { return !jj_3_198(); }
4539    catch(LookaheadSuccess ls) { return true; }
4540    finally { jj_save(197, xla); }
4541  }
4542
4543  final private boolean jj_2_199(int xla) {
4544    jj_la = xla; jj_lastpos = jj_scanpos = token;
4545    try { return !jj_3_199(); }
4546    catch(LookaheadSuccess ls) { return true; }
4547    finally { jj_save(198, xla); }
4548  }
4549
4550  final private boolean jj_2_200(int xla) {
4551    jj_la = xla; jj_lastpos = jj_scanpos = token;
4552    try { return !jj_3_200(); }
4553    catch(LookaheadSuccess ls) { return true; }
4554    finally { jj_save(199, xla); }
4555  }
4556
4557  final private boolean jj_2_201(int xla) {
4558    jj_la = xla; jj_lastpos = jj_scanpos = token;
4559    try { return !jj_3_201(); }
4560    catch(LookaheadSuccess ls) { return true; }
4561    finally { jj_save(200, xla); }
4562  }
4563
4564  final private boolean jj_2_202(int xla) {
4565    jj_la = xla; jj_lastpos = jj_scanpos = token;
4566    try { return !jj_3_202(); }
4567    catch(LookaheadSuccess ls) { return true; }
4568    finally { jj_save(201, xla); }
4569  }
4570
4571  final private boolean jj_2_203(int xla) {
4572    jj_la = xla; jj_lastpos = jj_scanpos = token;
4573    try { return !jj_3_203(); }
4574    catch(LookaheadSuccess ls) { return true; }
4575    finally { jj_save(202, xla); }
4576  }
4577
4578  final private boolean jj_2_204(int xla) {
4579    jj_la = xla; jj_lastpos = jj_scanpos = token;
4580    try { return !jj_3_204(); }
4581    catch(LookaheadSuccess ls) { return true; }
4582    finally { jj_save(203, xla); }
4583  }
4584
4585  final private boolean jj_2_205(int xla) {
4586    jj_la = xla; jj_lastpos = jj_scanpos = token;
4587    try { return !jj_3_205(); }
4588    catch(LookaheadSuccess ls) { return true; }
4589    finally { jj_save(204, xla); }
4590  }
4591
4592  final private boolean jj_2_206(int xla) {
4593    jj_la = xla; jj_lastpos = jj_scanpos = token;
4594    try { return !jj_3_206(); }
4595    catch(LookaheadSuccess ls) { return true; }
4596    finally { jj_save(205, xla); }
4597  }
4598
4599  final private boolean jj_2_207(int xla) {
4600    jj_la = xla; jj_lastpos = jj_scanpos = token;
4601    try { return !jj_3_207(); }
4602    catch(LookaheadSuccess ls) { return true; }
4603    finally { jj_save(206, xla); }
4604  }
4605
4606  final private boolean jj_2_208(int xla) {
4607    jj_la = xla; jj_lastpos = jj_scanpos = token;
4608    try { return !jj_3_208(); }
4609    catch(LookaheadSuccess ls) { return true; }
4610    finally { jj_save(207, xla); }
4611  }
4612
4613  final private boolean jj_2_209(int xla) {
4614    jj_la = xla; jj_lastpos = jj_scanpos = token;
4615    try { return !jj_3_209(); }
4616    catch(LookaheadSuccess ls) { return true; }
4617    finally { jj_save(208, xla); }
4618  }
4619
4620  final private boolean jj_2_210(int xla) {
4621    jj_la = xla; jj_lastpos = jj_scanpos = token;
4622    try { return !jj_3_210(); }
4623    catch(LookaheadSuccess ls) { return true; }
4624    finally { jj_save(209, xla); }
4625  }
4626
4627  final private boolean jj_2_211(int xla) {
4628    jj_la = xla; jj_lastpos = jj_scanpos = token;
4629    try { return !jj_3_211(); }
4630    catch(LookaheadSuccess ls) { return true; }
4631    finally { jj_save(210, xla); }
4632  }
4633
4634  final private boolean jj_2_212(int xla) {
4635    jj_la = xla; jj_lastpos = jj_scanpos = token;
4636    try { return !jj_3_212(); }
4637    catch(LookaheadSuccess ls) { return true; }
4638    finally { jj_save(211, xla); }
4639  }
4640
4641  final private boolean jj_2_213(int xla) {
4642    jj_la = xla; jj_lastpos = jj_scanpos = token;
4643    try { return !jj_3_213(); }
4644    catch(LookaheadSuccess ls) { return true; }
4645    finally { jj_save(212, xla); }
4646  }
4647
4648  final private boolean jj_2_214(int xla) {
4649    jj_la = xla; jj_lastpos = jj_scanpos = token;
4650    try { return !jj_3_214(); }
4651    catch(LookaheadSuccess ls) { return true; }
4652    finally { jj_save(213, xla); }
4653  }
4654
4655  final private boolean jj_2_215(int xla) {
4656    jj_la = xla; jj_lastpos = jj_scanpos = token;
4657    try { return !jj_3_215(); }
4658    catch(LookaheadSuccess ls) { return true; }
4659    finally { jj_save(214, xla); }
4660  }
4661
4662  final private boolean jj_2_216(int xla) {
4663    jj_la = xla; jj_lastpos = jj_scanpos = token;
4664    try { return !jj_3_216(); }
4665    catch(LookaheadSuccess ls) { return true; }
4666    finally { jj_save(215, xla); }
4667  }
4668
4669  final private boolean jj_2_217(int xla) {
4670    jj_la = xla; jj_lastpos = jj_scanpos = token;
4671    try { return !jj_3_217(); }
4672    catch(LookaheadSuccess ls) { return true; }
4673    finally { jj_save(216, xla); }
4674  }
4675
4676  final private boolean jj_2_218(int xla) {
4677    jj_la = xla; jj_lastpos = jj_scanpos = token;
4678    try { return !jj_3_218(); }
4679    catch(LookaheadSuccess ls) { return true; }
4680    finally { jj_save(217, xla); }
4681  }
4682
4683  final private boolean jj_2_219(int xla) {
4684    jj_la = xla; jj_lastpos = jj_scanpos = token;
4685    try { return !jj_3_219(); }
4686    catch(LookaheadSuccess ls) { return true; }
4687    finally { jj_save(218, xla); }
4688  }
4689
4690  final private boolean jj_2_220(int xla) {
4691    jj_la = xla; jj_lastpos = jj_scanpos = token;
4692    try { return !jj_3_220(); }
4693    catch(LookaheadSuccess ls) { return true; }
4694    finally { jj_save(219, xla); }
4695  }
4696
4697  final private boolean jj_2_221(int xla) {
4698    jj_la = xla; jj_lastpos = jj_scanpos = token;
4699    try { return !jj_3_221(); }
4700    catch(LookaheadSuccess ls) { return true; }
4701    finally { jj_save(220, xla); }
4702  }
4703
4704  final private boolean jj_2_222(int xla) {
4705    jj_la = xla; jj_lastpos = jj_scanpos = token;
4706    try { return !jj_3_222(); }
4707    catch(LookaheadSuccess ls) { return true; }
4708    finally { jj_save(221, xla); }
4709  }
4710
4711  final private boolean jj_2_223(int xla) {
4712    jj_la = xla; jj_lastpos = jj_scanpos = token;
4713    try { return !jj_3_223(); }
4714    catch(LookaheadSuccess ls) { return true; }
4715    finally { jj_save(222, xla); }
4716  }
4717
4718  final private boolean jj_2_224(int xla) {
4719    jj_la = xla; jj_lastpos = jj_scanpos = token;
4720    try { return !jj_3_224(); }
4721    catch(LookaheadSuccess ls) { return true; }
4722    finally { jj_save(223, xla); }
4723  }
4724
4725  final private boolean jj_2_225(int xla) {
4726    jj_la = xla; jj_lastpos = jj_scanpos = token;
4727    try { return !jj_3_225(); }
4728    catch(LookaheadSuccess ls) { return true; }
4729    finally { jj_save(224, xla); }
4730  }
4731
4732  final private boolean jj_2_226(int xla) {
4733    jj_la = xla; jj_lastpos = jj_scanpos = token;
4734    try { return !jj_3_226(); }
4735    catch(LookaheadSuccess ls) { return true; }
4736    finally { jj_save(225, xla); }
4737  }
4738
4739  final private boolean jj_2_227(int xla) {
4740    jj_la = xla; jj_lastpos = jj_scanpos = token;
4741    try { return !jj_3_227(); }
4742    catch(LookaheadSuccess ls) { return true; }
4743    finally { jj_save(226, xla); }
4744  }
4745
4746  final private boolean jj_2_228(int xla) {
4747    jj_la = xla; jj_lastpos = jj_scanpos = token;
4748    try { return !jj_3_228(); }
4749    catch(LookaheadSuccess ls) { return true; }
4750    finally { jj_save(227, xla); }
4751  }
4752
4753  final private boolean jj_2_229(int xla) {
4754    jj_la = xla; jj_lastpos = jj_scanpos = token;
4755    try { return !jj_3_229(); }
4756    catch(LookaheadSuccess ls) { return true; }
4757    finally { jj_save(228, xla); }
4758  }
4759
4760  final private boolean jj_2_230(int xla) {
4761    jj_la = xla; jj_lastpos = jj_scanpos = token;
4762    try { return !jj_3_230(); }
4763    catch(LookaheadSuccess ls) { return true; }
4764    finally { jj_save(229, xla); }
4765  }
4766
4767  final private boolean jj_2_231(int xla) {
4768    jj_la = xla; jj_lastpos = jj_scanpos = token;
4769    try { return !jj_3_231(); }
4770    catch(LookaheadSuccess ls) { return true; }
4771    finally { jj_save(230, xla); }
4772  }
4773
4774  final private boolean jj_2_232(int xla) {
4775    jj_la = xla; jj_lastpos = jj_scanpos = token;
4776    try { return !jj_3_232(); }
4777    catch(LookaheadSuccess ls) { return true; }
4778    finally { jj_save(231, xla); }
4779  }
4780
4781  final private boolean jj_2_233(int xla) {
4782    jj_la = xla; jj_lastpos = jj_scanpos = token;
4783    try { return !jj_3_233(); }
4784    catch(LookaheadSuccess ls) { return true; }
4785    finally { jj_save(232, xla); }
4786  }
4787
4788  final private boolean jj_2_234(int xla) {
4789    jj_la = xla; jj_lastpos = jj_scanpos = token;
4790    try { return !jj_3_234(); }
4791    catch(LookaheadSuccess ls) { return true; }
4792    finally { jj_save(233, xla); }
4793  }
4794
4795  final private boolean jj_2_235(int xla) {
4796    jj_la = xla; jj_lastpos = jj_scanpos = token;
4797    try { return !jj_3_235(); }
4798    catch(LookaheadSuccess ls) { return true; }
4799    finally { jj_save(234, xla); }
4800  }
4801
4802  final private boolean jj_2_236(int xla) {
4803    jj_la = xla; jj_lastpos = jj_scanpos = token;
4804    try { return !jj_3_236(); }
4805    catch(LookaheadSuccess ls) { return true; }
4806    finally { jj_save(235, xla); }
4807  }
4808
4809  final private boolean jj_2_237(int xla) {
4810    jj_la = xla; jj_lastpos = jj_scanpos = token;
4811    try { return !jj_3_237(); }
4812    catch(LookaheadSuccess ls) { return true; }
4813    finally { jj_save(236, xla); }
4814  }
4815
4816  final private boolean jj_2_238(int xla) {
4817    jj_la = xla; jj_lastpos = jj_scanpos = token;
4818    try { return !jj_3_238(); }
4819    catch(LookaheadSuccess ls) { return true; }
4820    finally { jj_save(237, xla); }
4821  }
4822
4823  final private boolean jj_2_239(int xla) {
4824    jj_la = xla; jj_lastpos = jj_scanpos = token;
4825    try { return !jj_3_239(); }
4826    catch(LookaheadSuccess ls) { return true; }
4827    finally { jj_save(238, xla); }
4828  }
4829
4830  final private boolean jj_2_240(int xla) {
4831    jj_la = xla; jj_lastpos = jj_scanpos = token;
4832    try { return !jj_3_240(); }
4833    catch(LookaheadSuccess ls) { return true; }
4834    finally { jj_save(239, xla); }
4835  }
4836
4837  final private boolean jj_2_241(int xla) {
4838    jj_la = xla; jj_lastpos = jj_scanpos = token;
4839    try { return !jj_3_241(); }
4840    catch(LookaheadSuccess ls) { return true; }
4841    finally { jj_save(240, xla); }
4842  }
4843
4844  final private boolean jj_2_242(int xla) {
4845    jj_la = xla; jj_lastpos = jj_scanpos = token;
4846    try { return !jj_3_242(); }
4847    catch(LookaheadSuccess ls) { return true; }
4848    finally { jj_save(241, xla); }
4849  }
4850
4851  final private boolean jj_2_243(int xla) {
4852    jj_la = xla; jj_lastpos = jj_scanpos = token;
4853    try { return !jj_3_243(); }
4854    catch(LookaheadSuccess ls) { return true; }
4855    finally { jj_save(242, xla); }
4856  }
4857
4858  final private boolean jj_2_244(int xla) {
4859    jj_la = xla; jj_lastpos = jj_scanpos = token;
4860    try { return !jj_3_244(); }
4861    catch(LookaheadSuccess ls) { return true; }
4862    finally { jj_save(243, xla); }
4863  }
4864
4865  final private boolean jj_2_245(int xla) {
4866    jj_la = xla; jj_lastpos = jj_scanpos = token;
4867    try { return !jj_3_245(); }
4868    catch(LookaheadSuccess ls) { return true; }
4869    finally { jj_save(244, xla); }
4870  }
4871
4872  final private boolean jj_2_246(int xla) {
4873    jj_la = xla; jj_lastpos = jj_scanpos = token;
4874    try { return !jj_3_246(); }
4875    catch(LookaheadSuccess ls) { return true; }
4876    finally { jj_save(245, xla); }
4877  }
4878
4879  final private boolean jj_2_247(int xla) {
4880    jj_la = xla; jj_lastpos = jj_scanpos = token;
4881    try { return !jj_3_247(); }
4882    catch(LookaheadSuccess ls) { return true; }
4883    finally { jj_save(246, xla); }
4884  }
4885
4886  final private boolean jj_2_248(int xla) {
4887    jj_la = xla; jj_lastpos = jj_scanpos = token;
4888    try { return !jj_3_248(); }
4889    catch(LookaheadSuccess ls) { return true; }
4890    finally { jj_save(247, xla); }
4891  }
4892
4893  final private boolean jj_2_249(int xla) {
4894    jj_la = xla; jj_lastpos = jj_scanpos = token;
4895    try { return !jj_3_249(); }
4896    catch(LookaheadSuccess ls) { return true; }
4897    finally { jj_save(248, xla); }
4898  }
4899
4900  final private boolean jj_2_250(int xla) {
4901    jj_la = xla; jj_lastpos = jj_scanpos = token;
4902    try { return !jj_3_250(); }
4903    catch(LookaheadSuccess ls) { return true; }
4904    finally { jj_save(249, xla); }
4905  }
4906
4907  final private boolean jj_2_251(int xla) {
4908    jj_la = xla; jj_lastpos = jj_scanpos = token;
4909    try { return !jj_3_251(); }
4910    catch(LookaheadSuccess ls) { return true; }
4911    finally { jj_save(250, xla); }
4912  }
4913
4914  final private boolean jj_2_252(int xla) {
4915    jj_la = xla; jj_lastpos = jj_scanpos = token;
4916    try { return !jj_3_252(); }
4917    catch(LookaheadSuccess ls) { return true; }
4918    finally { jj_save(251, xla); }
4919  }
4920
4921  final private boolean jj_2_253(int xla) {
4922    jj_la = xla; jj_lastpos = jj_scanpos = token;
4923    try { return !jj_3_253(); }
4924    catch(LookaheadSuccess ls) { return true; }
4925    finally { jj_save(252, xla); }
4926  }
4927
4928  final private boolean jj_2_254(int xla) {
4929    jj_la = xla; jj_lastpos = jj_scanpos = token;
4930    try { return !jj_3_254(); }
4931    catch(LookaheadSuccess ls) { return true; }
4932    finally { jj_save(253, xla); }
4933  }
4934
4935  final private boolean jj_2_255(int xla) {
4936    jj_la = xla; jj_lastpos = jj_scanpos = token;
4937    try { return !jj_3_255(); }
4938    catch(LookaheadSuccess ls) { return true; }
4939    finally { jj_save(254, xla); }
4940  }
4941
4942  final private boolean jj_2_256(int xla) {
4943    jj_la = xla; jj_lastpos = jj_scanpos = token;
4944    try { return !jj_3_256(); }
4945    catch(LookaheadSuccess ls) { return true; }
4946    finally { jj_save(255, xla); }
4947  }
4948
4949  final private boolean jj_3R_48() {
4950    if (jj_scan_token(XA_END)) return true;
4951    if (jj_3R_75()) return true;
4952    return false;
4953  }
4954
4955  final private boolean jj_3_69() {
4956    if (jj_scan_token(STRING)) return true;
4957    return false;
4958  }
4959
4960  final private boolean jj_3_68() {
4961    if (jj_3R_60()) return true;
4962    return false;
4963  }
4964
4965  final private boolean jj_3_67() {
4966    if (jj_3R_60()) return true;
4967    if (jj_scan_token(PERIOD)) return true;
4968    return false;
4969  }
4970
4971  final private boolean jj_3_129() {
4972    if (jj_scan_token(XA_1PHASE)) return true;
4973    return false;
4974  }
4975
4976  final private boolean jj_3R_14() {
4977    if (jj_scan_token(DESCRIBE)) return true;
4978    Token xsp;
4979    xsp = jj_scanpos;
4980    if (jj_3_67()) {
4981    jj_scanpos = xsp;
4982    if (jj_3_68()) {
4983    jj_scanpos = xsp;
4984    if (jj_3_69()) return true;
4985    }
4986    }
4987    return false;
4988  }
4989
4990  final private boolean jj_3R_45() {
4991    if (jj_scan_token(XA_COMMIT)) return true;
4992    Token xsp;
4993    xsp = jj_scanpos;
4994    if (jj_3_129()) {
4995    jj_scanpos = xsp;
4996    if (jj_3_130()) return true;
4997    }
4998    return false;
4999  }
5000
5001  final private boolean jj_3_128() {
5002    if (jj_3R_60()) return true;
5003    return false;
5004  }
5005
5006  final private boolean jj_3R_46() {
5007    if (jj_scan_token(XA_DISCONNECT)) return true;
5008    Token xsp;
5009    xsp = jj_scanpos;
5010    if (jj_3_128()) jj_scanpos = xsp;
5011    return false;
5012  }
5013
5014  final private boolean jj_3_127() {
5015    if (jj_scan_token(AS)) return true;
5016    if (jj_3R_60()) return true;
5017    return false;
5018  }
5019
5020  final private boolean jj_3_126() {
5021    if (jj_scan_token(PASSWORD)) return true;
5022    if (jj_scan_token(STRING)) return true;
5023    return false;
5024  }
5025
5026  final private boolean jj_3_125() {
5027    if (jj_scan_token(USER)) return true;
5028    if (jj_scan_token(STRING)) return true;
5029    return false;
5030  }
5031
5032  final private boolean jj_3_123() {
5033    if (jj_3R_60()) return true;
5034    return false;
5035  }
5036
5037  final private boolean jj_3_103() {
5038    if (jj_scan_token(STRING)) return true;
5039    return false;
5040  }
5041
5042  final private boolean jj_3R_44() {
5043    if (jj_scan_token(XA_CONNECT)) return true;
5044    Token xsp;
5045    xsp = jj_scanpos;
5046    if (jj_3_125()) jj_scanpos = xsp;
5047    xsp = jj_scanpos;
5048    if (jj_3_126()) jj_scanpos = xsp;
5049    xsp = jj_scanpos;
5050    if (jj_3_127()) jj_scanpos = xsp;
5051    return false;
5052  }
5053
5054  final private boolean jj_3_102() {
5055    if (jj_3R_60()) return true;
5056    return false;
5057  }
5058
5059  final private boolean jj_3_122() {
5060    if (jj_scan_token(SHUTDOWN)) return true;
5061    return false;
5062  }
5063
5064  final private boolean jj_3_124() {
5065    Token xsp;
5066    xsp = jj_scanpos;
5067    if (jj_3_122()) {
5068    jj_scanpos = xsp;
5069    if (jj_3_123()) return true;
5070    }
5071    return false;
5072  }
5073
5074  final private boolean jj_3_66() {
5075    if (jj_scan_token(AS)) return true;
5076    if (jj_3R_60()) return true;
5077    return false;
5078  }
5079
5080  final private boolean jj_3_104() {
5081    if (jj_scan_token(USING)) return true;
5082    Token xsp;
5083    xsp = jj_scanpos;
5084    if (jj_3_102()) {
5085    jj_scanpos = xsp;
5086    if (jj_3_103()) return true;
5087    }
5088    return false;
5089  }
5090
5091  final private boolean jj_3_64() {
5092    if (jj_scan_token(PASSWORD)) return true;
5093    if (jj_scan_token(STRING)) return true;
5094    return false;
5095  }
5096
5097  final private boolean jj_3_101() {
5098    if (jj_scan_token(STRING)) return true;
5099    return false;
5100  }
5101
5102  final private boolean jj_3_63() {
5103    if (jj_scan_token(USER)) return true;
5104    if (jj_scan_token(STRING)) return true;
5105    return false;
5106  }
5107
5108  final private boolean jj_3_100() {
5109    if (jj_3R_60()) return true;
5110    return false;
5111  }
5112
5113  final private boolean jj_3R_18() {
5114    if (jj_scan_token(EXECUTE)) return true;
5115    Token xsp;
5116    xsp = jj_scanpos;
5117    if (jj_3_100()) {
5118    jj_scanpos = xsp;
5119    if (jj_3_101()) return true;
5120    }
5121    return false;
5122  }
5123
5124  final private boolean jj_3_65() {
5125    if (jj_scan_token(ATTRIBUTES)) return true;
5126    if (jj_3R_63()) return true;
5127    return false;
5128  }
5129
5130  final private boolean jj_3R_43() {
5131    if (jj_scan_token(XA_DATASOURCE)) return true;
5132    if (jj_scan_token(STRING)) return true;
5133    return false;
5134  }
5135
5136  final private boolean jj_3_62() {
5137    if (jj_scan_token(PROTOCOL)) return true;
5138    if (jj_3R_60()) return true;
5139    return false;
5140  }
5141
5142  final private boolean jj_3R_61() {
5143    if (jj_scan_token(STRING)) return true;
5144    Token xsp;
5145    xsp = jj_scanpos;
5146    if (jj_3_62()) jj_scanpos = xsp;
5147    xsp = jj_scanpos;
5148    if (jj_3_63()) jj_scanpos = xsp;
5149    xsp = jj_scanpos;
5150    if (jj_3_64()) jj_scanpos = xsp;
5151    xsp = jj_scanpos;
5152    if (jj_3_65()) jj_scanpos = xsp;
5153    xsp = jj_scanpos;
5154    if (jj_3_66()) jj_scanpos = xsp;
5155    return false;
5156  }
5157
5158  final private boolean jj_3_59() {
5159    if (jj_3R_62()) return true;
5160    return false;
5161  }
5162
5163  final private boolean jj_3R_21() {
5164    if (jj_scan_token(EXECUTE)) return true;
5165    if (jj_scan_token(PROCEDURE)) return true;
5166    return false;
5167  }
5168
5169  final private boolean jj_3R_20() {
5170    if (jj_scan_token(EXECUTE)) return true;
5171    if (jj_scan_token(STATEMENT)) return true;
5172    return false;
5173  }
5174
5175  final private boolean jj_3_58() {
5176    if (jj_3R_61()) return true;
5177    return false;
5178  }
5179
5180  final private boolean jj_3_61() {
5181    if (jj_scan_token(CONNECT)) return true;
5182    Token xsp;
5183    xsp = jj_scanpos;
5184    if (jj_3_58()) {
5185    jj_scanpos = xsp;
5186    if (jj_3_59()) return true;
5187    }
5188    return false;
5189  }
5190
5191  final private boolean jj_3_60() {
5192    if (jj_scan_token(CONNECT)) return true;
5193    if (jj_scan_token(TO)) return true;
5194    return false;
5195  }
5196
5197  final private boolean jj_3R_13() {
5198    Token xsp;
5199    xsp = jj_scanpos;
5200    if (jj_3_60()) {
5201    jj_scanpos = xsp;
5202    if (jj_3_61()) return true;
5203    }
5204    return false;
5205  }
5206
5207  final private boolean jj_3R_11() {
5208    if (jj_scan_token(CLOSE)) return true;
5209    if (jj_3R_60()) return true;
5210    return false;
5211  }
5212
5213  final private boolean jj_3R_16() {
5214    if (jj_scan_token(DRIVER)) return true;
5215    if (jj_scan_token(STRING)) return true;
5216    return false;
5217  }
5218
5219  final private boolean jj_3_57() {
5220    if (jj_scan_token(AS)) return true;
5221    if (jj_3R_60()) return true;
5222    return false;
5223  }
5224
5225  final private boolean jj_3R_25() {
5226    if (jj_scan_token(GETCURRENTROWNUMBER)) return true;
5227    if (jj_3R_60()) return true;
5228    return false;
5229  }
5230
5231  final private boolean jj_3_121() {
5232    if (jj_scan_token(MINUS_SIGN)) return true;
5233    return false;
5234  }
5235
5236  final private boolean jj_3R_67() {
5237    Token xsp;
5238    xsp = jj_scanpos;
5239    if (jj_3_120()) {
5240    jj_scanpos = xsp;
5241    if (jj_3_121()) return true;
5242    }
5243    return false;
5244  }
5245
5246  final private boolean jj_3_120() {
5247    if (jj_scan_token(PLUS_SIGN)) return true;
5248    return false;
5249  }
5250
5251  final private boolean jj_3_118() {
5252    if (jj_scan_token(COMMA)) return true;
5253    if (jj_3R_69()) return true;
5254    return false;
5255  }
5256
5257  final private boolean jj_3R_35() {
5258    if (jj_scan_token(PROTOCOL)) return true;
5259    if (jj_scan_token(STRING)) return true;
5260    return false;
5261  }
5262
5263  final private boolean jj_3R_34() {
5264    if (jj_scan_token(PREVIOUS)) return true;
5265    if (jj_3R_60()) return true;
5266    return false;
5267  }
5268
5269  final private boolean jj_3R_69() {
5270    if (jj_scan_token(STRING)) return true;
5271    return false;
5272  }
5273
5274  final private boolean jj_3_119() {
5275    if (jj_3R_69()) return true;
5276    Token xsp;
5277    while (true) {
5278      xsp = jj_scanpos;
5279      if (jj_3_118()) { jj_scanpos = xsp; break; }
5280    }
5281    return false;
5282  }
5283
5284  final private boolean jj_3_55() {
5285    if (jj_3R_58()) return true;
5286    return false;
5287  }
5288
5289  final private boolean jj_3_54() {
5290    if (jj_3R_57()) return true;
5291    return false;
5292  }
5293
5294  final private boolean jj_3_53() {
5295    if (jj_3R_56()) return true;
5296    return false;
5297  }
5298
5299  final private boolean jj_3_52() {
5300    if (jj_3R_55()) return true;
5301    return false;
5302  }
5303
5304  final private boolean jj_3_51() {
5305    if (jj_3R_54()) return true;
5306    return false;
5307  }
5308
5309  final private boolean jj_3R_28() {
5310    if (jj_scan_token(LAST)) return true;
5311    if (jj_3R_60()) return true;
5312    return false;
5313  }
5314
5315  final private boolean jj_3_50() {
5316    if (jj_3R_53()) return true;
5317    return false;
5318  }
5319
5320  final private boolean jj_3_49() {
5321    if (jj_3R_52()) return true;
5322    return false;
5323  }
5324
5325  final private boolean jj_3_48() {
5326    if (jj_3R_51()) return true;
5327    return false;
5328  }
5329
5330  final private boolean jj_3_47() {
5331    if (jj_3R_50()) return true;
5332    return false;
5333  }
5334
5335  final private boolean jj_3_46() {
5336    if (jj_3R_49()) return true;
5337    return false;
5338  }
5339
5340  final private boolean jj_3_45() {
5341    if (jj_3R_48()) return true;
5342    return false;
5343  }
5344
5345  final private boolean jj_3_117() {
5346    if (jj_scan_token(PERIOD)) return true;
5347    if (jj_3R_68()) return true;
5348    return false;
5349  }
5350
5351  final private boolean jj_3_44() {
5352    if (jj_3R_47()) return true;
5353    return false;
5354  }
5355
5356  final private boolean jj_3_43() {
5357    if (jj_3R_46()) return true;
5358    return false;
5359  }
5360
5361  final private boolean jj_3_42() {
5362    if (jj_3R_45()) return true;
5363    return false;
5364  }
5365
5366  final private boolean jj_3_41() {
5367    if (jj_3R_44()) return true;
5368    return false;
5369  }
5370
5371  final private boolean jj_3_40() {
5372    if (jj_3R_43()) return true;
5373    return false;
5374  }
5375
5376  final private boolean jj_3_39() {
5377    if (jj_3R_42()) return true;
5378    return false;
5379  }
5380
5381  final private boolean jj_3_38() {
5382    if (jj_3R_41()) return true;
5383    return false;
5384  }
5385
5386  final private boolean jj_3R_68() {
5387    if (jj_scan_token(IDENTIFIER)) return true;
5388    return false;
5389  }
5390
5391  final private boolean jj_3_37() {
5392    if (jj_3R_40()) return true;
5393    return false;
5394  }
5395
5396  final private boolean jj_3_36() {
5397    if (jj_3R_39()) return true;
5398    return false;
5399  }
5400
5401  final private boolean jj_3_35() {
5402    if (jj_3R_38()) return true;
5403    return false;
5404  }
5405
5406  final private boolean jj_3_34() {
5407    if (jj_3R_37()) return true;
5408    return false;
5409  }
5410
5411  final private boolean jj_3_33() {
5412    if (jj_3R_36()) return true;
5413    return false;
5414  }
5415
5416  final private boolean jj_3_32() {
5417    if (jj_3R_35()) return true;
5418    return false;
5419  }
5420
5421  final private boolean jj_3_31() {
5422    if (jj_3R_34()) return true;
5423    return false;
5424  }
5425
5426  final private boolean jj_3_30() {
5427    if (jj_3R_33()) return true;
5428    return false;
5429  }
5430
5431  final private boolean jj_3R_6() {
5432    if (jj_scan_token(AFTER)) return true;
5433    if (jj_scan_token(LAST)) return true;
5434    return false;
5435  }
5436
5437  final private boolean jj_3_29() {
5438    if (jj_3R_32()) return true;
5439    return false;
5440  }
5441
5442  final private boolean jj_3_28() {
5443    if (jj_3R_31()) return true;
5444    return false;
5445  }
5446
5447  final private boolean jj_3_27() {
5448    if (jj_3R_30()) return true;
5449    return false;
5450  }
5451
5452  final private boolean jj_3_26() {
5453    if (jj_3R_29()) return true;
5454    return false;
5455  }
5456
5457  final private boolean jj_3R_77() {
5458    if (jj_3R_68()) return true;
5459    Token xsp;
5460    if (jj_3_117()) return true;
5461    while (true) {
5462      xsp = jj_scanpos;
5463      if (jj_3_117()) { jj_scanpos = xsp; break; }
5464    }
5465    return false;
5466  }
5467
5468  final private boolean jj_3_25() {
5469    if (jj_3R_28()) return true;
5470    return false;
5471  }
5472
5473  final private boolean jj_3_24() {
5474    if (jj_3R_27()) return true;
5475    return false;
5476  }
5477
5478  final private boolean jj_3_23() {
5479    if (jj_3R_26()) return true;
5480    return false;
5481  }
5482
5483  final private boolean jj_3_22() {
5484    if (jj_3R_25()) return true;
5485    return false;
5486  }
5487
5488  final private boolean jj_3_21() {
5489    if (jj_3R_24()) return true;
5490    return false;
5491  }
5492
5493  final private boolean jj_3_20() {
5494    if (jj_3R_23()) return true;
5495    return false;
5496  }
5497
5498  final private boolean jj_3_19() {
5499    if (jj_3R_22()) return true;
5500    return false;
5501  }
5502
5503  final private boolean jj_3_18() {
5504    if (jj_3R_21()) return true;
5505    return false;
5506  }
5507
5508  final private boolean jj_3_17() {
5509    if (jj_3R_20()) return true;
5510    return false;
5511  }
5512
5513  final private boolean jj_3_16() {
5514    if (jj_3R_19()) return true;
5515    return false;
5516  }
5517
5518  final private boolean jj_3_15() {
5519    if (jj_3R_19()) return true;
5520    return false;
5521  }
5522
5523  final private boolean jj_3_14() {
5524    if (jj_3R_18()) return true;
5525    return false;
5526  }
5527
5528  final private boolean jj_3_13() {
5529    if (jj_3R_17()) return true;
5530    return false;
5531  }
5532
5533  final private boolean jj_3_12() {
5534    if (jj_3R_16()) return true;
5535    return false;
5536  }
5537
5538  final private boolean jj_3_11() {
5539    if (jj_3R_15()) return true;
5540    return false;
5541  }
5542
5543  final private boolean jj_3_10() {
5544    if (jj_3R_14()) return true;
5545    return false;
5546  }
5547
5548  final private boolean jj_3R_31() {
5549    if (jj_scan_token(NEXT)) return true;
5550    if (jj_3R_60()) return true;
5551    return false;
5552  }
5553
5554  final private boolean jj_3_9() {
5555    if (jj_3R_13()) return true;
5556    return false;
5557  }
5558
5559  final private boolean jj_3_8() {
5560    if (jj_3R_12()) return true;
5561    return false;
5562  }
5563
5564  final private boolean jj_3_7() {
5565    if (jj_3R_11()) return true;
5566    return false;
5567  }
5568
5569  final private boolean jj_3_6() {
5570    if (jj_3R_10()) return true;
5571    return false;
5572  }
5573
5574  final private boolean jj_3_5() {
5575    if (jj_3R_9()) return true;
5576    return false;
5577  }
5578
5579  final private boolean jj_3_4() {
5580    if (jj_3R_8()) return true;
5581    return false;
5582  }
5583
5584  final private boolean jj_3_256() {
5585    if (jj_scan_token(WORK)) return true;
5586    return false;
5587  }
5588
5589  final private boolean jj_3_3() {
5590    if (jj_3R_7()) return true;
5591    return false;
5592  }
5593
5594  final private boolean jj_3_116() {
5595    if (jj_3R_67()) return true;
5596    return false;
5597  }
5598
5599  final private boolean jj_3_255() {
5600    if (jj_scan_token(CP_DISCONNECT)) return true;
5601    return false;
5602  }
5603
5604  final private boolean jj_3_2() {
5605    if (jj_3R_6()) return true;
5606    return false;
5607  }
5608
5609  final private boolean jj_3_254() {
5610    if (jj_scan_token(CP_GETCONNECTION)) return true;
5611    return false;
5612  }
5613
5614  final private boolean jj_3R_72() {
5615    Token xsp;
5616    xsp = jj_scanpos;
5617    if (jj_3_116()) jj_scanpos = xsp;
5618    if (jj_scan_token(INTEGER)) return true;
5619    return false;
5620  }
5621
5622  final private boolean jj_3_1() {
5623    if (jj_3R_5()) return true;
5624    return false;
5625  }
5626
5627  final private boolean jj_3_253() {
5628    if (jj_scan_token(CP_CONNECT)) return true;
5629    return false;
5630  }
5631
5632  final private boolean jj_3_252() {
5633    if (jj_scan_token(CP_DATASOURCE)) return true;
5634    return false;
5635  }
5636
5637  final private boolean jj_3_251() {
5638    if (jj_scan_token(DATASOURCE)) return true;
5639    return false;
5640  }
5641
5642  final private boolean jj_3_250() {
5643    if (jj_scan_token(XA_SUSPEND)) return true;
5644    return false;
5645  }
5646
5647  final private boolean jj_3_249() {
5648    if (jj_scan_token(XA_SUCCESS)) return true;
5649    return false;
5650  }
5651
5652  final private boolean jj_3_248() {
5653    if (jj_scan_token(XA_STARTRSCAN)) return true;
5654    return false;
5655  }
5656
5657  final private boolean jj_3R_59() {
5658    if (jj_3R_76()) return true;
5659    return false;
5660  }
5661
5662  final private boolean jj_3_56() {
5663    Token xsp;
5664    xsp = jj_scanpos;
5665    lookingAhead = true;
5666    jj_semLA = getToken(1).kind == ROLLBACK &&
5667                        (!(getToken(3).kind == TO || getToken(3).kind == SAVEPOINT));
5668    lookingAhead = false;
5669    if (!jj_semLA || jj_3R_59()) {
5670    jj_scanpos = xsp;
5671    if (jj_3_1()) {
5672    jj_scanpos = xsp;
5673    if (jj_3_2()) {
5674    jj_scanpos = xsp;
5675    if (jj_3_3()) {
5676    jj_scanpos = xsp;
5677    if (jj_3_4()) {
5678    jj_scanpos = xsp;
5679    if (jj_3_5()) {
5680    jj_scanpos = xsp;
5681    if (jj_3_6()) {
5682    jj_scanpos = xsp;
5683    if (jj_3_7()) {
5684    jj_scanpos = xsp;
5685    if (jj_3_8()) {
5686    jj_scanpos = xsp;
5687    if (jj_3_9()) {
5688    jj_scanpos = xsp;
5689    if (jj_3_10()) {
5690    jj_scanpos = xsp;
5691    if (jj_3_11()) {
5692    jj_scanpos = xsp;
5693    if (jj_3_12()) {
5694    jj_scanpos = xsp;
5695    if (jj_3_13()) {
5696    jj_scanpos = xsp;
5697    if (jj_3_14()) {
5698    jj_scanpos = xsp;
5699    if (jj_3_15()) {
5700    jj_scanpos = xsp;
5701    if (jj_3_16()) {
5702    jj_scanpos = xsp;
5703    if (jj_3_17()) {
5704    jj_scanpos = xsp;
5705    if (jj_3_18()) {
5706    jj_scanpos = xsp;
5707    if (jj_3_19()) {
5708    jj_scanpos = xsp;
5709    if (jj_3_20()) {
5710    jj_scanpos = xsp;
5711    if (jj_3_21()) {
5712    jj_scanpos = xsp;
5713    if (jj_3_22()) {
5714    jj_scanpos = xsp;
5715    if (jj_3_23()) {
5716    jj_scanpos = xsp;
5717    if (jj_3_24()) {
5718    jj_scanpos = xsp;
5719    if (jj_3_25()) {
5720    jj_scanpos = xsp;
5721    if (jj_3_26()) {
5722    jj_scanpos = xsp;
5723    if (jj_3_27()) {
5724    jj_scanpos = xsp;
5725    if (jj_3_28()) {
5726    jj_scanpos = xsp;
5727    if (jj_3_29()) {
5728    jj_scanpos = xsp;
5729    if (jj_3_30()) {
5730    jj_scanpos = xsp;
5731    if (jj_3_31()) {
5732    jj_scanpos = xsp;
5733    if (jj_3_32()) {
5734    jj_scanpos = xsp;
5735    if (jj_3_33()) {
5736    jj_scanpos = xsp;
5737    if (jj_3_34()) {
5738    jj_scanpos = xsp;
5739    if (jj_3_35()) {
5740    jj_scanpos = xsp;
5741    if (jj_3_36()) {
5742    jj_scanpos = xsp;
5743    if (jj_3_37()) {
5744    jj_scanpos = xsp;
5745    if (jj_3_38()) {
5746    jj_scanpos = xsp;
5747    if (jj_3_39()) {
5748    jj_scanpos = xsp;
5749    if (jj_3_40()) {
5750    jj_scanpos = xsp;
5751    if (jj_3_41()) {
5752    jj_scanpos = xsp;
5753    if (jj_3_42()) {
5754    jj_scanpos = xsp;
5755    if (jj_3_43()) {
5756    jj_scanpos = xsp;
5757    if (jj_3_44()) {
5758    jj_scanpos = xsp;
5759    if (jj_3_45()) {
5760    jj_scanpos = xsp;
5761    if (jj_3_46()) {
5762    jj_scanpos = xsp;
5763    if (jj_3_47()) {
5764    jj_scanpos = xsp;
5765    if (jj_3_48()) {
5766    jj_scanpos = xsp;
5767    if (jj_3_49()) {
5768    jj_scanpos = xsp;
5769    if (jj_3_50()) {
5770    jj_scanpos = xsp;
5771    if (jj_3_51()) {
5772    jj_scanpos = xsp;
5773    if (jj_3_52()) {
5774    jj_scanpos = xsp;
5775    if (jj_3_53()) {
5776    jj_scanpos = xsp;
5777    if (jj_3_54()) {
5778    jj_scanpos = xsp;
5779    if (jj_3_55()) return true;
5780    }
5781    }
5782    }
5783    }
5784    }
5785    }
5786    }
5787    }
5788    }
5789    }
5790    }
5791    }
5792    }
5793    }
5794    }
5795    }
5796    }
5797    }
5798    }
5799    }
5800    }
5801    }
5802    }
5803    }
5804    }
5805    }
5806    }
5807    }
5808    }
5809    }
5810    }
5811    }
5812    }
5813    }
5814    }
5815    }
5816    }
5817    }
5818    }
5819    }
5820    }
5821    }
5822    }
5823    }
5824    }
5825    }
5826    }
5827    }
5828    }
5829    }
5830    }
5831    }
5832    }
5833    }
5834    }
5835    return false;
5836  }
5837
5838  final private boolean jj_3_247() {
5839    if (jj_scan_token(XA_START)) return true;
5840    return false;
5841  }
5842
5843  final private boolean jj_3_246() {
5844    if (jj_scan_token(XA_ROLLBACK)) return true;
5845    return false;
5846  }
5847
5848  final private boolean jj_3_245() {
5849    if (jj_scan_token(XA_RESUME)) return true;
5850    return false;
5851  }
5852
5853  final private boolean jj_3_244() {
5854    if (jj_scan_token(XA_RECOVER)) return true;
5855    return false;
5856  }
5857
5858  final private boolean jj_3_243() {
5859    if (jj_scan_token(XA_PREPARE)) return true;
5860    return false;
5861  }
5862
5863  final private boolean jj_3_242() {
5864    if (jj_scan_token(XA_NOFLAGS)) return true;
5865    return false;
5866  }
5867
5868  final private boolean jj_3R_19() {
5869    if (jj_scan_token(FIRST)) return true;
5870    if (jj_3R_60()) return true;
5871    return false;
5872  }
5873
5874  final private boolean jj_3_241() {
5875    if (jj_scan_token(XA_JOIN)) return true;
5876    return false;
5877  }
5878
5879  final private boolean jj_3_240() {
5880    if (jj_scan_token(XA_GETCONNECTION)) return true;
5881    return false;
5882  }
5883
5884  final private boolean jj_3_239() {
5885    if (jj_scan_token(XA_FORGET)) return true;
5886    return false;
5887  }
5888
5889  final private boolean jj_3R_60() {
5890    if (jj_scan_token(IDENTIFIER)) return true;
5891    return false;
5892  }
5893
5894  final private boolean jj_3_238() {
5895    if (jj_scan_token(XA_FAIL)) return true;
5896    return false;
5897  }
5898
5899  final private boolean jj_3_237() {
5900    if (jj_scan_token(XA_ENDRSCAN)) return true;
5901    return false;
5902  }
5903
5904  final private boolean jj_3_236() {
5905    if (jj_scan_token(XA_END)) return true;
5906    return false;
5907  }
5908
5909  final private boolean jj_3_235() {
5910    if (jj_scan_token(XA_DISCONNECT)) return true;
5911    return false;
5912  }
5913
5914  final private boolean jj_3_234() {
5915    if (jj_scan_token(XA_COMMIT)) return true;
5916    return false;
5917  }
5918
5919  final private boolean jj_3_233() {
5920    if (jj_scan_token(XA_CONNECT)) return true;
5921    return false;
5922  }
5923
5924  final private boolean jj_3_232() {
5925    if (jj_scan_token(XA_DATASOURCE)) return true;
5926    return false;
5927  }
5928
5929  final private boolean jj_3_231() {
5930    if (jj_scan_token(XA_2PHASE)) return true;
5931    return false;
5932  }
5933
5934  final private boolean jj_3_230() {
5935    if (jj_scan_token(XA_1PHASE)) return true;
5936    return false;
5937  }
5938
5939  final private boolean jj_3_229() {
5940    if (jj_scan_token(WITH)) return true;
5941    return false;
5942  }
5943
5944  final private boolean jj_3_228() {
5945    if (jj_scan_token(WAIT)) return true;
5946    return false;
5947  }
5948
5949  final private boolean jj_3_227() {
5950    if (jj_scan_token(VIEWS)) return true;
5951    return false;
5952  }
5953
5954  final private boolean jj_3_226() {
5955    if (jj_scan_token(USING)) return true;
5956    return false;
5957  }
5958
5959  final private boolean jj_3_225() {
5960    if (jj_scan_token(USER)) return true;
5961    return false;
5962  }
5963
5964  final private boolean jj_3_224() {
5965    if (jj_scan_token(TABLES)) return true;
5966    return false;
5967  }
5968
5969  final private boolean jj_3_223() {
5970    if (jj_scan_token(SYNONYMS)) return true;
5971    return false;
5972  }
5973
5974  final private boolean jj_3_222() {
5975    if (jj_scan_token(STATEMENT)) return true;
5976    return false;
5977  }
5978
5979  final private boolean jj_3_221() {
5980    if (jj_scan_token(SHUTDOWN)) return true;
5981    return false;
5982  }
5983
5984  final private boolean jj_3R_10() {
5985    if (jj_scan_token(BEFORE)) return true;
5986    if (jj_scan_token(FIRST)) return true;
5987    return false;
5988  }
5989
5990  final private boolean jj_3_220() {
5991    if (jj_scan_token(SHOW)) return true;
5992    return false;
5993  }
5994
5995  final private boolean jj_3R_26() {
5996    if (jj_scan_token(HELP)) return true;
5997    return false;
5998  }
5999
6000  final private boolean jj_3_219() {
6001    if (jj_scan_token(SET)) return true;
6002    return false;
6003  }
6004
6005  final private boolean jj_3_218() {
6006    if (jj_scan_token(SENSITIVE)) return true;
6007    return false;
6008  }
6009
6010  final private boolean jj_3_217() {
6011    if (jj_scan_token(SCROLL)) return true;
6012    return false;
6013  }
6014
6015  final private boolean jj_3_216() {
6016    if (jj_scan_token(SCHEMAS)) return true;
6017    return false;
6018  }
6019
6020  final private boolean jj_3_215() {
6021    if (jj_scan_token(TO)) return true;
6022    return false;
6023  }
6024
6025  final private boolean jj_3_214() {
6026    if (jj_scan_token(RUN)) return true;
6027    return false;
6028  }
6029
6030  final private boolean jj_3_213() {
6031    if (jj_scan_token(ROLLBACK)) return true;
6032    return false;
6033  }
6034
6035  final private boolean jj_3_212() {
6036    if (jj_scan_token(RESOURCE)) return true;
6037    return false;
6038  }
6039
6040  final private boolean jj_3_115() {
6041    if (jj_3R_66()) return true;
6042    return false;
6043  }
6044
6045  final private boolean jj_3_211() {
6046    if (jj_scan_token(REMOVE)) return true;
6047    return false;
6048  }
6049
6050  final private boolean jj_3_210() {
6051    if (jj_scan_token(RELATIVE)) return true;
6052    return false;
6053  }
6054
6055  final private boolean jj_3_209() {
6056    if (jj_scan_token(READONLY)) return true;
6057    return false;
6058  }
6059
6060  final private boolean jj_3_208() {
6061    if (jj_scan_token(QUIT)) return true;
6062    return false;
6063  }
6064
6065  final private boolean jj_3_207() {
6066    if (jj_scan_token(PROTOCOL)) return true;
6067    return false;
6068  }
6069
6070  final private boolean jj_3_206() {
6071    if (jj_scan_token(PROPERTIES)) return true;
6072    return false;
6073  }
6074
6075  final private boolean jj_3_205() {
6076    if (jj_scan_token(PROCEDURES)) return true;
6077    return false;
6078  }
6079
6080  final private boolean jj_3R_66() {
6081    if (jj_scan_token(STRING)) return true;
6082    return false;
6083  }
6084
6085  final private boolean jj_3_204() {
6086    if (jj_scan_token(PROCEDURE)) return true;
6087    return false;
6088  }
6089
6090  final private boolean jj_3_203() {
6091    if (jj_scan_token(PREVIOUS)) return true;
6092    return false;
6093  }
6094
6095  final private boolean jj_3_202() {
6096    if (jj_scan_token(PREPARE)) return true;
6097    return false;
6098  }
6099
6100  final private boolean jj_3_201() {
6101    if (jj_scan_token(PERIOD)) return true;
6102    return false;
6103  }
6104
6105  final private boolean jj_3_200() {
6106    if (jj_scan_token(PASSWORD)) return true;
6107    return false;
6108  }
6109
6110  final private boolean jj_3R_37() {
6111    if (jj_scan_token(RELATIVE)) return true;
6112    if (jj_3R_72()) return true;
6113    return false;
6114  }
6115
6116  final private boolean jj_3_199() {
6117    if (jj_scan_token(ON)) return true;
6118    return false;
6119  }
6120
6121  final private boolean jj_3_198() {
6122    if (jj_scan_token(OFF)) return true;
6123    return false;
6124  }
6125
6126  final private boolean jj_3_197() {
6127    if (jj_scan_token(NOHOLDFORCONNECTION)) return true;
6128    return false;
6129  }
6130
6131  final private boolean jj_3_196() {
6132    if (jj_scan_token(NOHOLD)) return true;
6133    return false;
6134  }
6135
6136  final private boolean jj_3R_73() {
6137    if (jj_3R_66()) return true;
6138    return false;
6139  }
6140
6141  final private boolean jj_3_195() {
6142    if (jj_scan_token(NEXT)) return true;
6143    return false;
6144  }
6145
6146  final private boolean jj_3_194() {
6147    if (jj_scan_token(NAME)) return true;
6148    return false;
6149  }
6150
6151  final private boolean jj_3_193() {
6152    if (jj_scan_token(MAXIMUMDISPLAYWIDTH)) return true;
6153    return false;
6154  }
6155
6156  final private boolean jj_3_192() {
6157    if (jj_scan_token(LOCALIZEDDISPLAY)) return true;
6158    return false;
6159  }
6160
6161  final private boolean jj_3_191() {
6162    if (jj_scan_token(LAST)) return true;
6163    return false;
6164  }
6165
6166  final private boolean jj_3_190() {
6167    if (jj_scan_token(INTO)) return true;
6168    return false;
6169  }
6170
6171  final private boolean jj_3_189() {
6172    if (jj_scan_token(INSENSITIVE)) return true;
6173    return false;
6174  }
6175
6176  final private boolean jj_3_188() {
6177    if (jj_scan_token(INDEXES)) return true;
6178    return false;
6179  }
6180
6181  final private boolean jj_3_187() {
6182    if (jj_scan_token(IN)) return true;
6183    return false;
6184  }
6185
6186  final private boolean jj_3_186() {
6187    if (jj_scan_token(HELP)) return true;
6188    return false;
6189  }
6190
6191  final private boolean jj_3_185() {
6192    if (jj_scan_token(HOLD)) return true;
6193    return false;
6194  }
6195
6196  final private boolean jj_3_184() {
6197    if (jj_scan_token(GETCURRENTROWNUMBER)) return true;
6198    return false;
6199  }
6200
6201  final private boolean jj_3_114() {
6202    if (jj_scan_token(FAIL)) return true;
6203    return false;
6204  }
6205
6206  final private boolean jj_3_183() {
6207    if (jj_scan_token(GET)) return true;
6208    return false;
6209  }
6210
6211  final private boolean jj_3_182() {
6212    if (jj_scan_token(FROM)) return true;
6213    return false;
6214  }
6215
6216  final private boolean jj_3_181() {
6217    if (jj_scan_token(FOR)) return true;
6218    return false;
6219  }
6220
6221  final private boolean jj_3_180() {
6222    if (jj_scan_token(FIRST)) return true;
6223    return false;
6224  }
6225
6226  final private boolean jj_3_179() {
6227    if (jj_scan_token(FAIL)) return true;
6228    return false;
6229  }
6230
6231  final private boolean jj_3_178() {
6232    if (jj_scan_token(EXPECT)) return true;
6233    return false;
6234  }
6235
6236  final private boolean jj_3R_5() {
6237    if (jj_scan_token(ABSOLUTE)) return true;
6238    if (jj_3R_72()) return true;
6239    return false;
6240  }
6241
6242  final private boolean jj_3_177() {
6243    if (jj_scan_token(EXIT)) return true;
6244    return false;
6245  }
6246
6247  final private boolean jj_3_176() {
6248    if (jj_scan_token(EXECUTE)) return true;
6249    return false;
6250  }
6251
6252  final private boolean jj_3_175() {
6253    if (jj_scan_token(END)) return true;
6254    return false;
6255  }
6256
6257  final private boolean jj_3_174() {
6258    if (jj_scan_token(ELAPSEDTIME)) return true;
6259    return false;
6260  }
6261
6262  final private boolean jj_3_173() {
6263    if (jj_scan_token(DRIVER)) return true;
6264    return false;
6265  }
6266
6267  final private boolean jj_3R_23() {
6268    if (jj_scan_token(EXPECT)) return true;
6269    Token xsp;
6270    xsp = jj_scanpos;
6271    if (jj_3_114()) jj_scanpos = xsp;
6272    if (jj_3R_73()) return true;
6273    return false;
6274  }
6275
6276  final private boolean jj_3_172() {
6277    if (jj_scan_token(DISCONNECT)) return true;
6278    return false;
6279  }
6280
6281  final private boolean jj_3_171() {
6282    if (jj_scan_token(DESCRIBE)) return true;
6283    return false;
6284  }
6285
6286  final private boolean jj_3_170() {
6287    if (jj_scan_token(CURSOR)) return true;
6288    return false;
6289  }
6290
6291  final private boolean jj_3_169() {
6292    if (jj_scan_token(CURRENT)) return true;
6293    return false;
6294  }
6295
6296  final private boolean jj_3_168() {
6297    if (jj_scan_token(CONNECTIONS)) return true;
6298    return false;
6299  }
6300
6301  final private boolean jj_3_167() {
6302    if (jj_scan_token(CONNECTION)) return true;
6303    return false;
6304  }
6305
6306  final private boolean jj_3_166() {
6307    if (jj_scan_token(CONNECT)) return true;
6308    return false;
6309  }
6310
6311  final private boolean jj_3_165() {
6312    if (jj_scan_token(COMMIT)) return true;
6313    return false;
6314  }
6315
6316  final private boolean jj_3_164() {
6317    if (jj_scan_token(CLOSE)) return true;
6318    return false;
6319  }
6320
6321  final private boolean jj_3_163() {
6322    if (jj_scan_token(BEFORE)) return true;
6323    return false;
6324  }
6325
6326  final private boolean jj_3_162() {
6327    if (jj_scan_token(BANG)) return true;
6328    return false;
6329  }
6330
6331  final private boolean jj_3_99() {
6332    if (jj_scan_token(NOHOLD)) return true;
6333    return false;
6334  }
6335
6336  final private boolean jj_3_161() {
6337    if (jj_scan_token(AUTOCOMMIT)) return true;
6338    return false;
6339  }
6340
6341  final private boolean jj_3_160() {
6342    if (jj_scan_token(ATTRIBUTES)) return true;
6343    return false;
6344  }
6345
6346  final private boolean jj_3_159() {
6347    if (jj_scan_token(ASYNC)) return true;
6348    return false;
6349  }
6350
6351  final private boolean jj_3_158() {
6352    if (jj_scan_token(AS)) return true;
6353    return false;
6354  }
6355
6356  final private boolean jj_3_157() {
6357    if (jj_scan_token(ALL)) return true;
6358    return false;
6359  }
6360
6361  final private boolean jj_3R_65() {
6362    Token xsp;
6363    xsp = jj_scanpos;
6364    if (jj_3_98()) {
6365    jj_scanpos = xsp;
6366    if (jj_3_99()) return true;
6367    }
6368    return false;
6369  }
6370
6371  final private boolean jj_3_98() {
6372    if (jj_scan_token(HOLD)) return true;
6373    return false;
6374  }
6375
6376  final private boolean jj_3_156() {
6377    if (jj_scan_token(ALIASES)) return true;
6378    return false;
6379  }
6380
6381  final private boolean jj_3_155() {
6382    if (jj_scan_token(AFTER)) return true;
6383    return false;
6384  }
6385
6386  final private boolean jj_3_154() {
6387    if (jj_scan_token(ABSOLUTE)) return true;
6388    return false;
6389  }
6390
6391  final private boolean jj_3R_71() {
6392    Token xsp;
6393    xsp = jj_scanpos;
6394    if (jj_3_154()) {
6395    jj_scanpos = xsp;
6396    if (jj_3_155()) {
6397    jj_scanpos = xsp;
6398    if (jj_3_156()) {
6399    jj_scanpos = xsp;
6400    if (jj_3_157()) {
6401    jj_scanpos = xsp;
6402    if (jj_3_158()) {
6403    jj_scanpos = xsp;
6404    if (jj_3_159()) {
6405    jj_scanpos = xsp;
6406    if (jj_3_160()) {
6407    jj_scanpos = xsp;
6408    if (jj_3_161()) {
6409    jj_scanpos = xsp;
6410    if (jj_3_162()) {
6411    jj_scanpos = xsp;
6412    if (jj_3_163()) {
6413    jj_scanpos = xsp;
6414    if (jj_3_164()) {
6415    jj_scanpos = xsp;
6416    if (jj_3_165()) {
6417    jj_scanpos = xsp;
6418    if (jj_3_166()) {
6419    jj_scanpos = xsp;
6420    if (jj_3_167()) {
6421    jj_scanpos = xsp;
6422    if (jj_3_168()) {
6423    jj_scanpos = xsp;
6424    if (jj_3_169()) {
6425    jj_scanpos = xsp;
6426    if (jj_3_170()) {
6427    jj_scanpos = xsp;
6428    if (jj_3_171()) {
6429    jj_scanpos = xsp;
6430    if (jj_3_172()) {
6431    jj_scanpos = xsp;
6432    if (jj_3_173()) {
6433    jj_scanpos = xsp;
6434    if (jj_3_174()) {
6435    jj_scanpos = xsp;
6436    if (jj_3_175()) {
6437    jj_scanpos = xsp;
6438    if (jj_3_176()) {
6439    jj_scanpos = xsp;
6440    if (jj_3_177()) {
6441    jj_scanpos = xsp;
6442    if (jj_3_178()) {
6443    jj_scanpos = xsp;
6444    if (jj_3_179()) {
6445    jj_scanpos = xsp;
6446    if (jj_3_180()) {
6447    jj_scanpos = xsp;
6448    if (jj_3_181()) {
6449    jj_scanpos = xsp;
6450    if (jj_3_182()) {
6451    jj_scanpos = xsp;
6452    if (jj_3_183()) {
6453    jj_scanpos = xsp;
6454    if (jj_3_184()) {
6455    jj_scanpos = xsp;
6456    if (jj_3_185()) {
6457    jj_scanpos = xsp;
6458    if (jj_3_186()) {
6459    jj_scanpos = xsp;
6460    if (jj_3_187()) {
6461    jj_scanpos = xsp;
6462    if (jj_3_188()) {
6463    jj_scanpos = xsp;
6464    if (jj_3_189()) {
6465    jj_scanpos = xsp;
6466    if (jj_3_190()) {
6467    jj_scanpos = xsp;
6468    if (jj_3_191()) {
6469    jj_scanpos = xsp;
6470    if (jj_3_192()) {
6471    jj_scanpos = xsp;
6472    if (jj_3_193()) {
6473    jj_scanpos = xsp;
6474    if (jj_3_194()) {
6475    jj_scanpos = xsp;
6476    if (jj_3_195()) {
6477    jj_scanpos = xsp;
6478    if (jj_3_196()) {
6479    jj_scanpos = xsp;
6480    if (jj_3_197()) {
6481    jj_scanpos = xsp;
6482    if (jj_3_198()) {
6483    jj_scanpos = xsp;
6484    if (jj_3_199()) {
6485    jj_scanpos = xsp;
6486    if (jj_3_200()) {
6487    jj_scanpos = xsp;
6488    if (jj_3_201()) {
6489    jj_scanpos = xsp;
6490    if (jj_3_202()) {
6491    jj_scanpos = xsp;
6492    if (jj_3_203()) {
6493    jj_scanpos = xsp;
6494    if (jj_3_204()) {
6495    jj_scanpos = xsp;
6496    if (jj_3_205()) {
6497    jj_scanpos = xsp;
6498    if (jj_3_206()) {
6499    jj_scanpos = xsp;
6500    if (jj_3_207()) {
6501    jj_scanpos = xsp;
6502    if (jj_3_208()) {
6503    jj_scanpos = xsp;
6504    if (jj_3_209()) {
6505    jj_scanpos = xsp;
6506    if (jj_3_210()) {
6507    jj_scanpos = xsp;
6508    if (jj_3_211()) {
6509    jj_scanpos = xsp;
6510    if (jj_3_212()) {
6511    jj_scanpos = xsp;
6512    if (jj_3_213()) {
6513    jj_scanpos = xsp;
6514    if (jj_3_214()) {
6515    jj_scanpos = xsp;
6516    if (jj_3_215()) {
6517    jj_scanpos = xsp;
6518    if (jj_3_216()) {
6519    jj_scanpos = xsp;
6520    if (jj_3_217()) {
6521    jj_scanpos = xsp;
6522    if (jj_3_218()) {
6523    jj_scanpos = xsp;
6524    if (jj_3_219()) {
6525    jj_scanpos = xsp;
6526    if (jj_3_220()) {
6527    jj_scanpos = xsp;
6528    if (jj_3_221()) {
6529    jj_scanpos = xsp;
6530    if (jj_3_222()) {
6531    jj_scanpos = xsp;
6532    if (jj_3_223()) {
6533    jj_scanpos = xsp;
6534    if (jj_3_224()) {
6535    jj_scanpos = xsp;
6536    if (jj_3_225()) {
6537    jj_scanpos = xsp;
6538    if (jj_3_226()) {
6539    jj_scanpos = xsp;
6540    if (jj_3_227()) {
6541    jj_scanpos = xsp;
6542    if (jj_3_228()) {
6543    jj_scanpos = xsp;
6544    if (jj_3_229()) {
6545    jj_scanpos = xsp;
6546    if (jj_3_230()) {
6547    jj_scanpos = xsp;
6548    if (jj_3_231()) {
6549    jj_scanpos = xsp;
6550    if (jj_3_232()) {
6551    jj_scanpos = xsp;
6552    if (jj_3_233()) {
6553    jj_scanpos = xsp;
6554    if (jj_3_234()) {
6555    jj_scanpos = xsp;
6556    if (jj_3_235()) {
6557    jj_scanpos = xsp;
6558    if (jj_3_236()) {
6559    jj_scanpos = xsp;
6560    if (jj_3_237()) {
6561    jj_scanpos = xsp;
6562    if (jj_3_238()) {
6563    jj_scanpos = xsp;
6564    if (jj_3_239()) {
6565    jj_scanpos = xsp;
6566    if (jj_3_240()) {
6567    jj_scanpos = xsp;
6568    if (jj_3_241()) {
6569    jj_scanpos = xsp;
6570    if (jj_3_242()) {
6571    jj_scanpos = xsp;
6572    if (jj_3_243()) {
6573    jj_scanpos = xsp;
6574    if (jj_3_244()) {
6575    jj_scanpos = xsp;
6576    if (jj_3_245()) {
6577    jj_scanpos = xsp;
6578    if (jj_3_246()) {
6579    jj_scanpos = xsp;
6580    if (jj_3_247()) {
6581    jj_scanpos = xsp;
6582    if (jj_3_248()) {
6583    jj_scanpos = xsp;
6584    if (jj_3_249()) {
6585    jj_scanpos = xsp;
6586    if (jj_3_250()) {
6587    jj_scanpos = xsp;
6588    if (jj_3_251()) {
6589    jj_scanpos = xsp;
6590    if (jj_3_252()) {
6591    jj_scanpos = xsp;
6592    if (jj_3_253()) {
6593    jj_scanpos = xsp;
6594    if (jj_3_254()) {
6595    jj_scanpos = xsp;
6596    if (jj_3_255()) {
6597    jj_scanpos = xsp;
6598    if (jj_3_256()) return true;
6599    }
6600    }
6601    }
6602    }
6603    }
6604    }
6605    }
6606    }
6607    }
6608    }
6609    }
6610    }
6611    }
6612    }
6613    }
6614    }
6615    }
6616    }
6617    }
6618    }
6619    }
6620    }
6621    }
6622    }
6623    }
6624    }
6625    }
6626    }
6627    }
6628    }
6629    }
6630    }
6631    }
6632    }
6633    }
6634    }
6635    }
6636    }
6637    }
6638    }
6639    }
6640    }
6641    }
6642    }
6643    }
6644    }
6645    }
6646    }
6647    }
6648    }
6649    }
6650    }
6651    }
6652    }
6653    }
6654    }
6655    }
6656    }
6657    }
6658    }
6659    }
6660    }
6661    }
6662    }
6663    }
6664    }
6665    }
6666    }
6667    }
6668    }
6669    }
6670    }
6671    }
6672    }
6673    }
6674    }
6675    }
6676    }
6677    }
6678    }
6679    }
6680    }
6681    }
6682    }
6683    }
6684    }
6685    }
6686    }
6687    }
6688    }
6689    }
6690    }
6691    }
6692    }
6693    }
6694    }
6695    }
6696    }
6697    }
6698    }
6699    }
6700    }
6701    return false;
6702  }
6703
6704  final private boolean jj_3_97() {
6705    if (jj_scan_token(SENSITIVE)) return true;
6706    return false;
6707  }
6708
6709  final private boolean jj_3R_64() {
6710    Token xsp;
6711    xsp = jj_scanpos;
6712    if (jj_3_96()) {
6713    jj_scanpos = xsp;
6714    if (jj_3_97()) return true;
6715    }
6716    return false;
6717  }
6718
6719  final private boolean jj_3_96() {
6720    if (jj_scan_token(INSENSITIVE)) return true;
6721    return false;
6722  }
6723
6724  final private boolean jj_3_153() {
6725    if (jj_scan_token(IDENTIFIER)) return true;
6726    return false;
6727  }
6728
6729  final private boolean jj_3R_78() {
6730    Token xsp;
6731    xsp = jj_scanpos;
6732    if (jj_3_152()) {
6733    jj_scanpos = xsp;
6734    if (jj_3_153()) return true;
6735    }
6736    return false;
6737  }
6738
6739  final private boolean jj_3_152() {
6740    if (jj_3R_71()) return true;
6741    return false;
6742  }
6743
6744  final private boolean jj_3R_9() {
6745    if (jj_scan_token(BANG)) return true;
6746    if (jj_scan_token(STRING)) return true;
6747    return false;
6748  }
6749
6750  final private boolean jj_3_150() {
6751    if (jj_scan_token(COMMA)) return true;
6752    if (jj_3R_70()) return true;
6753    return false;
6754  }
6755
6756  final private boolean jj_3_94() {
6757    if (jj_scan_token(SCROLL)) return true;
6758    if (jj_3R_64()) return true;
6759    return false;
6760  }
6761
6762  final private boolean jj_3R_70() {
6763    if (jj_3R_78()) return true;
6764    if (jj_scan_token(EQUALS_OPERATOR)) return true;
6765    return false;
6766  }
6767
6768  final private boolean jj_3_95() {
6769    if (jj_scan_token(WITH)) return true;
6770    if (jj_3R_65()) return true;
6771    return false;
6772  }
6773
6774  final private boolean jj_3R_24() {
6775    if (jj_scan_token(GET)) return true;
6776    Token xsp;
6777    xsp = jj_scanpos;
6778    if (jj_3_94()) jj_scanpos = xsp;
6779    xsp = jj_scanpos;
6780    if (jj_3_95()) jj_scanpos = xsp;
6781    if (jj_scan_token(CURSOR)) return true;
6782    return false;
6783  }
6784
6785  final private boolean jj_3R_74() {
6786    if (jj_scan_token(INTEGER)) return true;
6787    return false;
6788  }
6789
6790  final private boolean jj_3_151() {
6791    if (jj_3R_70()) return true;
6792    return false;
6793  }
6794
6795  final private boolean jj_3R_63() {
6796    Token xsp;
6797    xsp = jj_scanpos;
6798    if (jj_3_151()) jj_scanpos = xsp;
6799    return false;
6800  }
6801
6802  final private boolean jj_3_149() {
6803    if (jj_3R_60()) return true;
6804    return false;
6805  }
6806
6807  final private boolean jj_3R_30() {
6808    if (jj_scan_token(MAXIMUMDISPLAYWIDTH)) return true;
6809    if (jj_3R_74()) return true;
6810    return false;
6811  }
6812
6813  final private boolean jj_3R_58() {
6814    if (jj_scan_token(CP_DISCONNECT)) return true;
6815    Token xsp;
6816    xsp = jj_scanpos;
6817    if (jj_3_149()) jj_scanpos = xsp;
6818    return false;
6819  }
6820
6821  final private boolean jj_3_148() {
6822    if (jj_scan_token(AS)) return true;
6823    if (jj_3R_60()) return true;
6824    return false;
6825  }
6826
6827  final private boolean jj_3R_33() {
6828    if (jj_scan_token(PREPARE)) return true;
6829    if (jj_3R_60()) return true;
6830    return false;
6831  }
6832
6833  final private boolean jj_3_113() {
6834    if (jj_scan_token(OFF)) return true;
6835    return false;
6836  }
6837
6838  final private boolean jj_3_112() {
6839    if (jj_scan_token(ON)) return true;
6840    return false;
6841  }
6842
6843  final private boolean jj_3R_17() {
6844    if (jj_scan_token(ELAPSEDTIME)) return true;
6845    Token xsp;
6846    xsp = jj_scanpos;
6847    if (jj_3_112()) {
6848    jj_scanpos = xsp;
6849    if (jj_3_113()) return true;
6850    }
6851    return false;
6852  }
6853
6854  final private boolean jj_3R_57() {
6855    if (jj_scan_token(CP_GETCONNECTION)) return true;
6856    Token xsp;
6857    xsp = jj_scanpos;
6858    if (jj_3_148()) jj_scanpos = xsp;
6859    return false;
6860  }
6861
6862  final private boolean jj_3R_27() {
6863    if (jj_scan_token(PREPARE)) return true;
6864    if (jj_scan_token(PROCEDURE)) return true;
6865    return false;
6866  }
6867
6868  final private boolean jj_3_147() {
6869    if (jj_scan_token(AS)) return true;
6870    if (jj_3R_60()) return true;
6871    return false;
6872  }
6873
6874  final private boolean jj_3_146() {
6875    if (jj_scan_token(PASSWORD)) return true;
6876    if (jj_scan_token(STRING)) return true;
6877    return false;
6878  }
6879
6880  final private boolean jj_3_145() {
6881    if (jj_scan_token(USER)) return true;
6882    if (jj_scan_token(STRING)) return true;
6883    return false;
6884  }
6885
6886  final private boolean jj_3_111() {
6887    if (jj_scan_token(OFF)) return true;
6888    return false;
6889  }
6890
6891  final private boolean jj_3_110() {
6892    if (jj_scan_token(ON)) return true;
6893    return false;
6894  }
6895
6896  final private boolean jj_3R_36() {
6897    if (jj_scan_token(READONLY)) return true;
6898    Token xsp;
6899    xsp = jj_scanpos;
6900    if (jj_3_110()) {
6901    jj_scanpos = xsp;
6902    if (jj_3_111()) return true;
6903    }
6904    return false;
6905  }
6906
6907  final private boolean jj_3_90() {
6908    if (jj_3R_60()) return true;
6909    return false;
6910  }
6911
6912  final private boolean jj_3_144() {
6913    if (jj_scan_token(PROTOCOL)) return true;
6914    if (jj_scan_token(STRING)) return true;
6915    return false;
6916  }
6917
6918  final private boolean jj_3_93() {
6919    if (jj_scan_token(QUIT)) return true;
6920    return false;
6921  }
6922
6923  final private boolean jj_3_92() {
6924    if (jj_scan_token(EXIT)) return true;
6925    return false;
6926  }
6927
6928  final private boolean jj_3R_22() {
6929    Token xsp;
6930    xsp = jj_scanpos;
6931    if (jj_3_92()) {
6932    jj_scanpos = xsp;
6933    if (jj_3_93()) return true;
6934    }
6935    return false;
6936  }
6937
6938  final private boolean jj_3R_56() {
6939    if (jj_scan_token(CP_CONNECT)) return true;
6940    Token xsp;
6941    xsp = jj_scanpos;
6942    if (jj_3_145()) jj_scanpos = xsp;
6943    xsp = jj_scanpos;
6944    if (jj_3_146()) jj_scanpos = xsp;
6945    xsp = jj_scanpos;
6946    if (jj_3_147()) jj_scanpos = xsp;
6947    return false;
6948  }
6949
6950  final private boolean jj_3_89() {
6951    if (jj_scan_token(ALL)) return true;
6952    return false;
6953  }
6954
6955  final private boolean jj_3_109() {
6956    if (jj_scan_token(OFF)) return true;
6957    return false;
6958  }
6959
6960  final private boolean jj_3_108() {
6961    if (jj_scan_token(ON)) return true;
6962    return false;
6963  }
6964
6965  final private boolean jj_3_88() {
6966    if (jj_scan_token(CURRENT)) return true;
6967    return false;
6968  }
6969
6970  final private boolean jj_3_91() {
6971    Token xsp;
6972    xsp = jj_scanpos;
6973    if (jj_3_88()) {
6974    jj_scanpos = xsp;
6975    if (jj_3_89()) {
6976    jj_scanpos = xsp;
6977    if (jj_3_90()) return true;
6978    }
6979    }
6980    return false;
6981  }
6982
6983  final private boolean jj_3R_29() {
6984    if (jj_scan_token(LOCALIZEDDISPLAY)) return true;
6985    Token xsp;
6986    xsp = jj_scanpos;
6987    if (jj_3_108()) {
6988    jj_scanpos = xsp;
6989    if (jj_3_109()) return true;
6990    }
6991    return false;
6992  }
6993
6994  final private boolean jj_3_143() {
6995    if (jj_scan_token(AS)) return true;
6996    if (jj_3R_60()) return true;
6997    return false;
6998  }
6999
7000  final private boolean jj_3_142() {
7001    if (jj_scan_token(PASSWORD)) return true;
7002    if (jj_scan_token(STRING)) return true;
7003    return false;
7004  }
7005
7006  final private boolean jj_3_141() {
7007    if (jj_scan_token(USER)) return true;
7008    if (jj_scan_token(STRING)) return true;
7009    return false;
7010  }
7011
7012  final private boolean jj_3_140() {
7013    if (jj_scan_token(PROTOCOL)) return true;
7014    if (jj_scan_token(STRING)) return true;
7015    return false;
7016  }
7017
7018  final private boolean jj_3R_55() {
7019    if (jj_scan_token(CP_DATASOURCE)) return true;
7020    if (jj_scan_token(STRING)) return true;
7021    return false;
7022  }
7023
7024  final private boolean jj_3R_15() {
7025    if (jj_scan_token(DISCONNECT)) return true;
7026    Token xsp;
7027    xsp = jj_scanpos;
7028    if (jj_3_91()) jj_scanpos = xsp;
7029    return false;
7030  }
7031
7032  final private boolean jj_3R_32() {
7033    if (jj_scan_token(NOHOLDFORCONNECTION)) return true;
7034    return false;
7035  }
7036
7037  final private boolean jj_3_87() {
7038    if (jj_scan_token(WORK)) return true;
7039    return false;
7040  }
7041
7042  final private boolean jj_3R_54() {
7043    if (jj_scan_token(DATASOURCE)) return true;
7044    if (jj_scan_token(STRING)) return true;
7045    return false;
7046  }
7047
7048  final private boolean jj_3R_76() {
7049    if (jj_scan_token(ROLLBACK)) return true;
7050    Token xsp;
7051    xsp = jj_scanpos;
7052    if (jj_3_87()) jj_scanpos = xsp;
7053    return false;
7054  }
7055
7056  final private boolean jj_3_107() {
7057    if (jj_scan_token(OFF)) return true;
7058    return false;
7059  }
7060
7061  final private boolean jj_3_106() {
7062    if (jj_scan_token(ON)) return true;
7063    return false;
7064  }
7065
7066  final private boolean jj_3R_7() {
7067    if (jj_scan_token(AUTOCOMMIT)) return true;
7068    Token xsp;
7069    xsp = jj_scanpos;
7070    if (jj_3_106()) {
7071    jj_scanpos = xsp;
7072    if (jj_3_107()) return true;
7073    }
7074    return false;
7075  }
7076
7077  final private boolean jj_3_86() {
7078    if (jj_scan_token(WORK)) return true;
7079    return false;
7080  }
7081
7082  final private boolean jj_3_76() {
7083    if (jj_scan_token(PERIOD)) return true;
7084    if (jj_3R_60()) return true;
7085    return false;
7086  }
7087
7088  final private boolean jj_3R_12() {
7089    if (jj_scan_token(COMMIT)) return true;
7090    Token xsp;
7091    xsp = jj_scanpos;
7092    if (jj_3_86()) jj_scanpos = xsp;
7093    return false;
7094  }
7095
7096  final private boolean jj_3_105() {
7097    if (jj_scan_token(RESOURCE)) return true;
7098    return false;
7099  }
7100
7101  final private boolean jj_3_74() {
7102    if (jj_scan_token(ALIASES)) return true;
7103    return false;
7104  }
7105
7106  final private boolean jj_3_139() {
7107    if (jj_scan_token(XA_SUSPEND)) return true;
7108    return false;
7109  }
7110
7111  final private boolean jj_3_80() {
7112    if (jj_scan_token(IN)) return true;
7113    if (jj_3R_60()) return true;
7114    return false;
7115  }
7116
7117  final private boolean jj_3_138() {
7118    if (jj_scan_token(XA_SUCCESS)) return true;
7119    return false;
7120  }
7121
7122  final private boolean jj_3R_39() {
7123    if (jj_scan_token(RUN)) return true;
7124    Token xsp;
7125    xsp = jj_scanpos;
7126    if (jj_3_105()) jj_scanpos = xsp;
7127    if (jj_scan_token(STRING)) return true;
7128    return false;
7129  }
7130
7131  final private boolean jj_3_85() {
7132    if (jj_scan_token(SHOW)) return true;
7133    if (jj_scan_token(SCHEMAS)) return true;
7134    return false;
7135  }
7136
7137  final private boolean jj_3_137() {
7138    if (jj_scan_token(XA_STARTRSCAN)) return true;
7139    return false;
7140  }
7141
7142  final private boolean jj_3_84() {
7143    if (jj_scan_token(SHOW)) return true;
7144    if (jj_scan_token(PROCEDURES)) return true;
7145    return false;
7146  }
7147
7148  final private boolean jj_3_73() {
7149    if (jj_scan_token(SYNONYMS)) return true;
7150    return false;
7151  }
7152
7153  final private boolean jj_3_136() {
7154    if (jj_scan_token(XA_RESUME)) return true;
7155    return false;
7156  }
7157
7158  final private boolean jj_3_78() {
7159    if (jj_scan_token(FROM)) return true;
7160    if (jj_3R_60()) return true;
7161    return false;
7162  }
7163
7164  final private boolean jj_3_79() {
7165    Token xsp;
7166    xsp = jj_scanpos;
7167    if (jj_3_77()) {
7168    jj_scanpos = xsp;
7169    if (jj_3_78()) return true;
7170    }
7171    return false;
7172  }
7173
7174  final private boolean jj_3_77() {
7175    if (jj_scan_token(IN)) return true;
7176    if (jj_3R_60()) return