00001: /* Generated By:JavaCC: Do not edit this line. ij.java */
00002: package org.apache.derby.impl.tools.ij;
00003:
00004: import org.apache.derby.iapi.reference.JDBC20Translation;
00005: import org.apache.derby.iapi.reference.JDBC30Translation;
00006:
00007: import org.apache.derby.tools.JDBCDisplayUtil;
00008:
00009: import org.apache.derby.iapi.tools.i18n.LocalizedInput;
00010: import org.apache.derby.iapi.tools.i18n.LocalizedResource;
00011:
00012: import org.apache.derby.iapi.services.info.JVMInfo;
00013: import org.apache.derby.tools.URLCheck;
00014:
00015: import java.lang.reflect.*;
00016: import java.sql.Connection;
00017: import java.sql.DatabaseMetaData;
00018: import java.sql.DriverManager;
00019: import java.sql.Statement;
00020: import java.sql.PreparedStatement;
00021: import java.sql.ResultSet;
00022: import java.sql.ResultSetMetaData;
00023: import java.sql.SQLException;
00024: import java.sql.SQLWarning;
00025: import java.util.Hashtable;
00026: import java.util.Properties;
00027: import java.util.StringTokenizer;
00028: import java.io.IOException;
00029: import java.util.Vector;
00030: import java.util.Enumeration;
00031: import java.util.Locale;
00032:
00033: /**
00034: This parser works on a statement-at-a-time basis.
00035: It maintains a connection environment that is
00036: set by the caller and contains a list of
00037: connections for the current thread/ij session.
00038: Multi-user frameworks that use this parser
00039: tend to maintain multiple connectionEnv's and
00040: pass in the current one to set ij up.
00041: A connectionEnv has a default connection in use,
00042: and the ij connect/set connection/disconnect commands
00043: are used to change the current connection.
00044:
00045: Each connection has associated with it a list
00046: of prepared statements and cursors, created by
00047: the ij prepare and get cursor statements and
00048: manipulated by additional ij statements.
00049:
00050: To enable multiple display modes, this parser will
00051: not output anything, but will return
00052: objects that the caller can then display.
00053:
00054: This means the caller is responsible for displaying
00055: thrown exceptions and also SQLWarnings. So, our
00056: return value is the JDBC object upon which warnings
00057: will be hung, i.e. the one manipulated by the statement,
00058: if any.
00059:
00060: If there is no object to display, then a null is
00061: returned.
00062:
00063: @author ames
00064: */
00065: class ij implements ijConstants {
00066: static final String PROTOCOL_PROPERTY = "ij.protocol";
00067: static final String USER_PROPERTY = "ij.user";
00068: static final String PASSWORD_PROPERTY = "ij.password";
00069: static final String FRAMEWORK_PROPERTY = "framework";
00070:
00071: boolean elapsedTime = false;
00072:
00073: Connection theConnection = null;
00074: ConnectionEnv currentConnEnv = null;
00075:
00076: xaAbstractHelper xahelper = null;
00077: boolean exit = false;
00078:
00079: utilMain utilInstance = null;
00080: Hashtable ignoreErrors = null;
00081: String protocol = null; // the (single) unnamed protocol
00082: Hashtable namedProtocols;
00083:
00084: /**
00085: * A constructor that understands the local state that needs to be
00086: * initialized.
00087: *
00088: * @param tm The token manager to use
00089: * @param utilInstance The util to use
00090: */
00091: ij(ijTokenManager tm, utilMain utilInstance) {
00092: this (tm);
00093: this .utilInstance = utilInstance;
00094: }
00095:
00096: /**
00097: Initialize this parser from the environment
00098: (system properties). Used when ij is being run
00099: as a command line program.
00100: */
00101: void initFromEnvironment() {
00102:
00103: // load all protocols specified via properties
00104: //
00105: Properties p = System.getProperties();
00106: protocol = p.getProperty(PROTOCOL_PROPERTY);
00107: String framework_property = p.getProperty(FRAMEWORK_PROPERTY);
00108:
00109: if (ij.JDBC20X() && ij.JTA() && ij.JNDI()) {
00110: try {
00111: xahelper = (xaAbstractHelper) Class.forName(
00112: "org.apache.derby.impl.tools.ij.xaHelper")
00113: .newInstance();
00114: xahelper.setFramework(framework_property);
00115: } catch (Exception e) {
00116: }
00117:
00118: }
00119:
00120: namedProtocols = new Hashtable();
00121: String prefix = PROTOCOL_PROPERTY + ".";
00122: for (Enumeration e = p.propertyNames(); e.hasMoreElements();) {
00123: String key = (String) e.nextElement();
00124: if (key.startsWith(prefix)) {
00125: String name = key.substring(prefix.length());
00126: installProtocol(name.toUpperCase(Locale.ENGLISH), p
00127: .getProperty(key));
00128: }
00129: }
00130: }
00131:
00132: /**
00133: * Return whether or not JDBC 2.0 (and greater) extension classes can be loaded
00134: *
00135: * @return true if JDBC 2.0 (and greater) extension classes can be loaded
00136: */
00137: private static boolean JDBC20X() {
00138: try {
00139: Class.forName("javax.sql.DataSource");
00140: Class.forName("javax.sql.ConnectionPoolDataSource");
00141: Class.forName("javax.sql.PooledConnection");
00142: Class.forName("javax.sql.XAConnection");
00143: Class.forName("javax.sql.XADataSource");
00144: } catch (ClassNotFoundException cnfe) {
00145: return false;
00146: }
00147: return true;
00148: }
00149:
00150: /**
00151: * Return whether or not JTA classes can be loaded
00152: *
00153: * @return true if JTA classes can be loaded
00154: */
00155: private static boolean JTA() {
00156: try {
00157: Class.forName("javax.transaction.xa.Xid");
00158: Class.forName("javax.transaction.xa.XAResource");
00159: Class.forName("javax.transaction.xa.XAException");
00160: } catch (ClassNotFoundException cnfe) {
00161: return false;
00162: }
00163: return true;
00164: }
00165:
00166: /**
00167: * Return whether or not JNDI extension classes can be loaded
00168: *
00169: * @return true if JNDI extension classes can be loaded
00170: */
00171: private static boolean JNDI() {
00172: try {
00173: Class.forName("javax.naming.spi.Resolver");
00174: Class.forName("javax.naming.Referenceable");
00175: Class.forName("javax.naming.directory.Attribute");
00176: } catch (ClassNotFoundException cnfe) {
00177: return false;
00178: }
00179: return true;
00180: }
00181:
00182: // FIXME: caller has to deal with ignoreErrors and handleSQLException behavior
00183:
00184: /**
00185: Add the warnings of wTail to the end of those of wHead.
00186: */
00187: SQLWarning appendWarnings(SQLWarning wHead, SQLWarning wTail) {
00188: if (wHead == null)
00189: return wTail;
00190:
00191: if (wHead.getNextException() == null) {
00192: wHead.setNextException(wTail);
00193: } else {
00194: appendWarnings(wHead.getNextWarning(), wTail);
00195: }
00196: return wHead;
00197: }
00198:
00199: /**
00200: * Get the "elapsedTime state".
00201: */
00202: boolean getElapsedTimeState() {
00203: return elapsedTime;
00204: }
00205:
00206: /**
00207: this removes the outside quotes from the string.
00208: it will also swizzle the special characters
00209: into their actual characters, like '' for ', etc.
00210: */
00211: String stringValue(String s) {
00212: String result = s.substring(1, s.length() - 1);
00213: char quotes = '\'';
00214: int index;
00215:
00216: /* Find the first occurrence of adjacent quotes. */
00217: index = result.indexOf(quotes);
00218:
00219: /* Replace each occurrence with a single quote and begin the
00220: * search for the next occurrence from where we left off.
00221: */
00222: while (index != -1) {
00223: result = result.substring(0, index + 1)
00224: + result.substring(index + 2);
00225:
00226: index = result.indexOf(quotes, index + 1);
00227: }
00228:
00229: return result;
00230: }
00231:
00232: void installProtocol(String name, String value) {
00233: try {
00234: // `value' is a JDBC protocol;
00235: // we load the "driver" in the prototypical
00236: // manner, it will register itself with
00237: // the DriverManager.
00238: util.loadDriverIfKnown(value);
00239: } catch (ClassNotFoundException e) {
00240: throw ijException.classNotFoundForProtocol(value);
00241: } catch (IllegalArgumentException e) {
00242: throw ijException.classNotFoundForProtocol(value);
00243: } catch (IllegalAccessException e) {
00244: throw ijException.classNotFoundForProtocol(value);
00245: } catch (InstantiationException e) {
00246: throw ijException.classNotFoundForProtocol(value);
00247: }
00248: if (name == null)
00249: protocol = value;
00250: else
00251: namedProtocols.put(name, value);
00252: }
00253:
00254: void haveConnection() {
00255: JDBCDisplayUtil.checkNotNull(theConnection, "connection");
00256: }
00257:
00258: /**
00259: We do not reuse statement objects at all, because
00260: some systems require you to close the object to release
00261: resources (JBMS), while others will not let you reuse
00262: the statement object once it is closed (WebLogic).
00263:
00264: If you want to reuse statement objects, you need to
00265: use the ij PREPARE and EXECUTE statements.
00266:
00267: @param stmt the statement
00268:
00269: **/
00270: ijResult executeImmediate(String stmt) throws SQLException {
00271: Statement aStatement = null;
00272: try {
00273: long beginTime = 0;
00274: long endTime = 0;
00275: boolean cleanUpStmt = false;
00276:
00277: haveConnection();
00278: aStatement = theConnection.createStatement();
00279:
00280: // for JCC - remove comments at the beginning of the statement
00281: // and trim; do the same for Derby Clients that have versions
00282: // earlier than 10.2.
00283: if (currentConnEnv != null) {
00284: boolean trimForDNC = currentConnEnv.getSession()
00285: .getIsDNC();
00286: if (trimForDNC) {
00287: // we're using the Derby Client, but we only want to trim
00288: // if the version is earlier than 10.2.
00289: DatabaseMetaData dbmd = theConnection.getMetaData();
00290: int majorVersion = dbmd.getDriverMajorVersion();
00291: if ((majorVersion > 10)
00292: || ((majorVersion == 10) && (dbmd
00293: .getDriverMinorVersion() > 1))) { // 10.2 or later, so don't trim/remove comments.
00294: trimForDNC = false;
00295: }
00296: }
00297: if (currentConnEnv.getSession().getIsJCC()
00298: || trimForDNC) {
00299: // remove comments and trim.
00300: int nextline;
00301: while (stmt.startsWith("--")) {
00302: nextline = stmt.indexOf('\n') + 1;
00303: stmt = stmt.substring(nextline);
00304: }
00305: stmt = stmt.trim();
00306: }
00307: }
00308:
00309: aStatement.execute(stmt);
00310:
00311: // FIXME: display results. return start time.
00312: return new ijStatementResult(aStatement, true);
00313:
00314: } catch (SQLException e) {
00315: if (aStatement != null) // free the resource
00316: aStatement.close();
00317: throw e;
00318: }
00319: }
00320:
00321: ijResult quit() throws SQLException {
00322: exit = true;
00323: if (getExpect()) { // report stats
00324: // FIXME: replace with MVC...
00325: // FIXME: this is a kludgy way to quiet /0 and make 0/0=1...
00326: int numExpectOr1 = (numExpect == 0 ? 1 : numExpect);
00327: int numPassOr1 = (numPass == numExpect && numPass == 0) ? 1
00328: : numPass;
00329: int numFailOr1 = (numFail == numExpect && numFail == 0) ? 1
00330: : numFail;
00331: int numUnxOr1 = (numUnx == numExpect && numUnx == 0) ? 1
00332: : numUnx;
00333:
00334: LocalizedResource
00335: .OutputWriter()
00336: .println(
00337: LocalizedResource
00338: .getMessage(
00339: "IJ_TestsRun0Pass12Fail34",
00340: new Object[] {
00341: LocalizedResource
00342: .getNumber(numExpect),
00343: LocalizedResource
00344: .getNumber(100 * (numPassOr1 / numExpectOr1)),
00345: LocalizedResource
00346: .getNumber(100 * (numFailOr1 / numExpectOr1)) }));
00347: if (numUnx > 0) {
00348: LocalizedResource.OutputWriter().println();
00349: LocalizedResource
00350: .OutputWriter()
00351: .println(
00352: LocalizedResource
00353: .getMessage(
00354: "IJ_UnexpResulUnx01",
00355: LocalizedResource
00356: .getNumber(numUnx),
00357: LocalizedResource
00358: .getNumber(100 * (numUnxOr1 / numExpectOr1))));
00359: }
00360: }
00361: currentConnEnv.removeAllSessions();
00362: theConnection = null;
00363: return null;
00364: }
00365:
00366: /**
00367: Async execution wants to return results off-cycle.
00368: We want to control their output, and so will hold it
00369: up until it is requested with a WAIT FOR asyncName
00370: statement. WAIT FOR will return the results of
00371: the async statement once they are ready. Note that using
00372: a select only waits for the execute to complete; the
00373: logic to step through the result set is in the caller.
00374: **/
00375: ijResult executeAsync(String stmt, String name) {
00376: AsyncStatement as = new AsyncStatement(theConnection, stmt);
00377:
00378: currentConnEnv.getSession().addAsyncStatement(name, as);
00379:
00380: as.start();
00381:
00382: return null;
00383: }
00384:
00385: void setConnection(ConnectionEnv connEnv,
00386: boolean multipleEnvironments) {
00387: Connection conn = connEnv.getConnection();
00388:
00389: if (connEnv != currentConnEnv) // single connenv is common case
00390: currentConnEnv = connEnv;
00391:
00392: if (theConnection == conn)
00393: return; // not changed.
00394:
00395: if ((theConnection == null) || multipleEnvironments) {
00396: // must have switched env's (could check)
00397: theConnection = conn;
00398: } else {
00399: throw ijException.needToDisconnect();
00400: }
00401: }
00402:
00403: /**
00404: Note the Expect Result in the output and in the stats.
00405:
00406: FIXME
00407: */
00408: int numExpect, numPass, numFail, numUnx;
00409:
00410: private void noteExpect(boolean actual, boolean want) {
00411: numExpect++;
00412: if (actual)
00413: numPass++;
00414: else
00415: numFail++;
00416:
00417: LocalizedResource.OutputWriter().print(
00418: LocalizedResource.getMessage(actual ? "IJ_Pass"
00419: : "IJ_Fail"));
00420: if (actual != want) {
00421: numUnx++;
00422: LocalizedResource.OutputWriter().println(
00423: LocalizedResource.getMessage("IJ_Unx"));
00424: } else
00425: LocalizedResource.OutputWriter().println();
00426: }
00427:
00428: private boolean getExpect() {
00429: return Boolean.getBoolean("ij.expect");
00430: }
00431:
00432: private ijResult addSession(Connection newConnection, String name)
00433: throws SQLException {
00434: if (currentConnEnv.haveSession(name)) {
00435: throw ijException.alreadyHaveConnectionNamed(name);
00436: }
00437:
00438: currentConnEnv.addSession(newConnection, name);
00439: return new ijConnectionResult(newConnection);
00440: }
00441:
00442: private String[] sortConnectionNames() {
00443: int size = 100;
00444: int count = 0;
00445: String[] array = new String[size];
00446: String key;
00447:
00448: Hashtable ss = currentConnEnv.getSessions();
00449: // Calculate the number of connections in the sessions list and
00450: // build an array of all the connection names.
00451: for (Enumeration connectionNames = ss.keys(); connectionNames
00452: .hasMoreElements();) {
00453: if (count == size) {
00454: // need to expand the array
00455: size = size * 2;
00456: String[] expandedArray = new String[size];
00457: System.arraycopy(array, 0, expandedArray, 0, count);
00458: array = expandedArray;
00459: }
00460: key = (String) connectionNames.nextElement();
00461: array[count++] = key;
00462: }
00463:
00464: java.util.Arrays.sort(array, 0, count);
00465:
00466: return array;
00467: }
00468:
00469: /**
00470: This is used at the ij startup time to see if there are already some
00471: connections made and if so, show connections made so far.
00472: Following also gets executed when user types show connections command
00473: in ij. In the former case, ignore0Rows is set whereas in the later cas
00474: it's set to false. The reason for this is, at ij startup time, if there
00475: are no connections made so far, we don't want to show anything. Only if
00476: there are connections made, we show the connections. Whereas in show
00477: connection command case, we want to show the connection status either way
00478: ie if there are no connections, we say no connections. Otherwise we list
00479: all the connections made so far.
00480: */
00481: public ijResult showConnectionsMethod(boolean ignore0Rows)
00482: throws SQLException {
00483: Hashtable ss = currentConnEnv.getSessions();
00484: Vector v = new Vector();
00485: SQLWarning w = null;
00486: if (ss == null || ss.size() == 0) {
00487: if (!ignore0Rows)
00488: v.addElement(LocalizedResource
00489: .getMessage("IJ_NoConneAvail"));
00490: } else {
00491: boolean haveCurrent = false;
00492: int count = 0;
00493: for (Enumeration connectionNames = ss.keys(); connectionNames
00494: .hasMoreElements(); connectionNames.nextElement())
00495: count++;
00496: String[] array = sortConnectionNames();
00497: for (int ictr = 0; ictr < count; ictr++) {
00498: String connectionName = array[ictr];
00499: Session s = (Session) ss.get(connectionName);
00500: if (s.getConnection().isClosed()) {
00501: if (currentConnEnv.getSession() != null
00502: && connectionName.equals(currentConnEnv
00503: .getSession().getName())) {
00504: currentConnEnv.removeCurrentSession();
00505: theConnection = null;
00506: } else
00507: currentConnEnv.removeSession(connectionName);
00508: } else {
00509: StringBuffer row = new StringBuffer();
00510: row.append(connectionName);
00511: if (currentConnEnv.getSession() != null
00512: && connectionName.equals(currentConnEnv
00513: .getSession().getName())) {
00514: row.append('*');
00515: haveCurrent = true;
00516: }
00517:
00518: //If ij.dataSource property is set, show only connection names.
00519: //In this case, URL is not used to get connection, so do not append URL
00520: String dsName = util
00521: .getSystemProperty("ij.dataSource");
00522: if (dsName == null) {
00523: row.append(" - \u0009");
00524: row.append(s.getConnection().getMetaData()
00525: .getURL());
00526: }
00527: // save the warnings from these connections
00528: w = appendWarnings(w, s.getConnection()
00529: .getWarnings());
00530: s.getConnection().clearWarnings();
00531: v.addElement(row.toString());
00532: }
00533: }
00534: if (haveCurrent)
00535: v.addElement(LocalizedResource
00536: .getMessage("IJ_CurreConne"));
00537: else
00538: v.addElement(LocalizedResource
00539: .getMessage("IJ_NoCurreConne"));
00540: }
00541: return new ijVectorResult(v, w);
00542: }
00543:
00544: /**
00545: Returns a subset of the input integer array
00546:
00547: @param input The input integer array
00548: @param start Starting index, inclusive
00549: @param end Ending index, exclusive
00550: */
00551: public static int[] intArraySubset(final int[] input, int start,
00552: int end) {
00553: int[] res = new int[end - start];
00554: System.arraycopy(input, start, res, 0, end - start);
00555: return res;
00556: }
00557:
00558: /**
00559: Verify that a table exists within a schema. Throws an exception
00560: if table does not exist.
00561:
00562: @param schema Schema for the table
00563: @param table Name of table to check for existence of
00564: */
00565: public void verifyTableExists(String schema, String table)
00566: throws SQLException {
00567: if (schema == null)
00568: return;
00569:
00570: ResultSet rs = null;
00571: try {
00572: DatabaseMetaData dbmd = theConnection.getMetaData();
00573: rs = dbmd.getTables(null, schema, table, null);
00574: if (!rs.next())
00575: throw ijException.noSuchTable(table);
00576: } finally {
00577: if (rs != null)
00578: rs.close();
00579: }
00580: }
00581:
00582: /**
00583: Return a resultset of tables (or views, procs...) in the given schema.
00584:
00585: @param schema Schema to get tables for, or null for search
00586: in all schemas.
00587: @param tableType Types of tables to return, see
00588: {@link java.sql.DatabaseMetaData#getTableTypes}
00589: */
00590: public ijResult showTables(String schema, String[] tableType)
00591: throws SQLException {
00592: ResultSet rs = null;
00593: try {
00594: haveConnection();
00595:
00596: DatabaseMetaData dbmd = theConnection.getMetaData();
00597: rs = dbmd.getTables(null, schema, null, tableType);
00598:
00599: int[] displayColumns = new int[] {
00600: rs.findColumn("TABLE_SCHEM"),
00601: rs.findColumn("TABLE_NAME"),
00602: rs.findColumn("REMARKS"), };
00603: int[] columnWidths = new int[] { 20, 30, 20, };
00604:
00605: return new ijResultSetResult(rs, displayColumns,
00606: columnWidths);
00607: } catch (SQLException e) {
00608: if (rs != null)
00609: rs.close();
00610: throw e;
00611: }
00612: }
00613:
00614: /**
00615: Return a resultset of indexes for the given table or schema
00616:
00617: @param schema schema to find indexes for
00618: @param table table to find indexes for
00619: */
00620: public ijResult showIndexes(String schema, String table)
00621: throws SQLException {
00622: ResultSet rs = null;
00623: try {
00624: haveConnection();
00625: verifyTableExists(schema, table);
00626:
00627: DatabaseMetaData dbmd = theConnection.getMetaData();
00628: rs = dbmd.getIndexInfo(null, schema, table, false, true);
00629:
00630: int[] displayColumns = new int[] {
00631: rs.findColumn("TABLE_SCHEM"),
00632: rs.findColumn("TABLE_NAME"),
00633: rs.findColumn("COLUMN_NAME"),
00634: rs.findColumn("NON_UNIQUE"), rs.findColumn("TYPE"),
00635: rs.findColumn("ASC_OR_DESC"),
00636: rs.findColumn("CARDINALITY"),
00637: rs.findColumn("PAGES"), };
00638: int[] columnWidths = new int[] { 20, 20, 20, 6, 4, 4, 8, 8, };
00639:
00640: if (schema != null) {
00641: displayColumns = intArraySubset(displayColumns, 1,
00642: displayColumns.length);
00643: columnWidths = intArraySubset(columnWidths, 1,
00644: columnWidths.length);
00645: }
00646: return new ijResultSetResult(rs, displayColumns,
00647: columnWidths);
00648: } catch (SQLException e) {
00649: if (rs != null)
00650: rs.close();
00651: throw e;
00652: }
00653: }
00654:
00655: /**
00656: Return a resultset of procedures from database metadata
00657: */
00658: public ijResult showProcedures(String schema) throws SQLException {
00659: ResultSet rs = null;
00660: try {
00661: haveConnection();
00662:
00663: DatabaseMetaData dbmd = theConnection.getMetaData();
00664: rs = dbmd.getProcedures(null, schema, null);
00665:
00666: int[] displayColumns = new int[] {
00667: rs.findColumn("PROCEDURE_SCHEM"),
00668: rs.findColumn("PROCEDURE_NAME"),
00669: rs.findColumn("REMARKS"), };
00670: int[] columnWidths = new int[] { 20, 30, 20, };
00671:
00672: return new ijResultSetResult(rs, displayColumns,
00673: columnWidths);
00674: } catch (SQLException e) {
00675: if (rs != null)
00676: rs.close();
00677: throw e;
00678: }
00679: }
00680:
00681: /**
00682: Return a resultset of schemas from database metadata
00683: */
00684: public ijResult showSchemas() throws SQLException {
00685: ResultSet rs = null;
00686: try {
00687: haveConnection();
00688:
00689: DatabaseMetaData dbmd = theConnection.getMetaData();
00690: rs = dbmd.getSchemas();
00691:
00692: int[] displayColumns = new int[] { rs
00693: .findColumn("TABLE_SCHEM") };
00694: int[] columnWidths = new int[] { 30 };
00695:
00696: return new ijResultSetResult(rs, displayColumns,
00697: columnWidths);
00698: } catch (SQLException e) {
00699: if (rs != null)
00700: rs.close();
00701: throw e;
00702: }
00703: }
00704:
00705: /**
00706: Outputs the names of all fields of given table. Outputs field
00707: names and data type.
00708: */
00709: public ijResult describeTable(String schema, String table)
00710: throws SQLException {
00711: ResultSet rs = null;
00712: try {
00713: haveConnection();
00714: verifyTableExists(schema, table);
00715:
00716: DatabaseMetaData dbmd = theConnection.getMetaData();
00717: rs = dbmd.getColumns(null, schema, table, null);
00718:
00719: int[] displayColumns = new int[] {
00720: rs.findColumn("TABLE_SCHEM"),
00721: rs.findColumn("TABLE_NAME"),
00722: rs.findColumn("COLUMN_NAME"),
00723: rs.findColumn("TYPE_NAME"),
00724: rs.findColumn("DECIMAL_DIGITS"),
00725: rs.findColumn("NUM_PREC_RADIX"),
00726: rs.findColumn("COLUMN_SIZE"),
00727: rs.findColumn("COLUMN_DEF"),
00728: rs.findColumn("CHAR_OCTET_LENGTH"),
00729: rs.findColumn("IS_NULLABLE"), };
00730: int[] columnWidths = new int[] { 20, 20, 20, 9, 4, 4, 6,
00731: 10, 10, 8 };
00732:
00733: //
00734: // If schema is specified (if util.getSelectedSchema in
00735: // DescTableStatement() returns correct value), then we
00736: // don't need to output schema and table names.
00737: if (schema != null) {
00738: displayColumns = intArraySubset(displayColumns, 2,
00739: displayColumns.length);
00740: columnWidths = intArraySubset(columnWidths, 2,
00741: columnWidths.length);
00742: }
00743:
00744: return new ijResultSetResult(rs, displayColumns,
00745: columnWidths);
00746: } catch (SQLException e) {
00747: if (rs != null)
00748: rs.close();
00749: throw e;
00750: }
00751: }
00752:
00753: private Object makeXid(int xid) {
00754: return null;
00755: }
00756:
00757: //
00758: // start of BNF rules
00759: //
00760: final public ijResult ijStatement() throws ParseException,
00761: SQLException {
00762: ijResult r = null;
00763: if (jj_2_56(2)) {
00764: if (getToken(1).kind == ROLLBACK
00765: && (!(getToken(3).kind == TO || getToken(3).kind == SAVEPOINT))) {
00766: r = RollbackStatement();
00767: } else if (jj_2_1(2)) {
00768: r = AbsoluteStatement();
00769: } else if (jj_2_2(2)) {
00770: r = AfterLastStatement();
00771: } else if (jj_2_3(2)) {
00772: r = AutocommitStatement();
00773: } else if (jj_2_4(2)) {
00774: r = AsyncStatement();
00775: } else if (jj_2_5(2)) {
00776: r = Bang();
00777: } else if (jj_2_6(2)) {
00778: r = BeforeFirstStatement();
00779: } else if (jj_2_7(2)) {
00780: r = CloseStatement();
00781: } else if (jj_2_8(2)) {
00782: r = CommitStatement();
00783: } else if (jj_2_9(2)) {
00784: r = ConnectStatement();
00785: } else if (jj_2_10(2)) {
00786: r = DescTableStatement();
00787: } else if (jj_2_11(2)) {
00788: r = DisconnectStatement();
00789: } else if (jj_2_12(2)) {
00790: r = DriverStatement();
00791: } else if (jj_2_13(2)) {
00792: r = ElapsedTimeStatement();
00793: } else if (jj_2_14(2)) {
00794: r = ExecuteStatement();
00795: } else if (jj_2_15(2)) {
00796: r = FirstStatement();
00797: } else if (jj_2_16(2)) {
00798: r = FirstStatement();
00799: } else if (jj_2_17(2)) {
00800: r = JBMSPreparedStatementExec();
00801: } else if (jj_2_18(2)) {
00802: r = F2KExecuteProcedure();
00803: } else if (jj_2_19(2)) {
00804: r = ExitStatement();
00805: } else if (jj_2_20(2)) {
00806: r = ExpectStatement();
00807: } else if (jj_2_21(2)) {
00808: r = GetCursorStatement();
00809: } else if (jj_2_22(2)) {
00810: r = GetCurrentRowNumber();
00811: } else if (jj_2_23(2)) {
00812: r = HelpStatement();
00813: } else if (jj_2_24(2)) {
00814: r = IllegalStatementName();
00815: } else if (jj_2_25(2)) {
00816: r = LastStatement();
00817: } else if (jj_2_26(2)) {
00818: r = LocalizedDisplay();
00819: } else if (jj_2_27(2)) {
00820: r = MaximumDisplayWidthStatement();
00821: } else if (jj_2_28(2)) {
00822: r = NextStatement();
00823: } else if (jj_2_29(2)) {
00824: r = NoHoldForConnectionStatement();
00825: } else if (jj_2_30(2)) {
00826: r = PrepareStatement();
00827: } else if (jj_2_31(2)) {
00828: r = PreviousStatement();
00829: } else if (jj_2_32(2)) {
00830: r = ProtocolStatement();
00831: } else if (jj_2_33(2)) {
00832: r = ReadOnlyStatement();
00833: } else if (jj_2_34(2)) {
00834: r = RelativeStatement();
00835: } else if (jj_2_35(2)) {
00836: r = RemoveStatement();
00837: } else if (jj_2_36(2)) {
00838: r = RunStatement();
00839: } else if (jj_2_37(2)) {
00840: r = SetConnectionStatement();
00841: } else if (jj_2_38(2)) {
00842: r = ShowStatement();
00843: } else if (jj_2_39(2)) {
00844: r = WaitForStatement();
00845: } else if (jj_2_40(2)) {
00846: r = XA_DataSourceStatement();
00847: } else if (jj_2_41(2)) {
00848: r = XA_ConnectStatement();
00849: } else if (jj_2_42(2)) {
00850: r = XA_CommitStatement();
00851: } else if (jj_2_43(2)) {
00852: r = XA_DisconnectStatement();
00853: } else if (jj_2_44(2)) {
00854: r = XA_GetConnectionStatement();
00855: } else if (jj_2_45(2)) {
00856: r = XA_EndStatement();
00857: } else if (jj_2_46(2)) {
00858: r = XA_ForgetStatement();
00859: } else if (jj_2_47(2)) {
00860: r = XA_PrepareStatement();
00861: } else if (jj_2_48(2)) {
00862: r = XA_RecoverStatement();
00863: } else if (jj_2_49(2)) {
00864: r = XA_RollbackStatement();
00865: } else if (jj_2_50(2)) {
00866: r = XA_StartStatement();
00867: } else if (jj_2_51(2)) {
00868: r = DataSourceStatement();
00869: } else if (jj_2_52(2)) {
00870: r = CP_DataSourceStatement();
00871: } else if (jj_2_53(2)) {
00872: r = CP_ConnectStatement();
00873: } else if (jj_2_54(2)) {
00874: r = CP_GetConnectionStatement();
00875: } else if (jj_2_55(2)) {
00876: r = CP_DisconnectStatement();
00877: } else {
00878: jj_consume_token(-1);
00879: throw new ParseException();
00880: }
00881: } else {
00882: ;
00883: }
00884: jj_consume_token(0);
00885: {
00886: if (true)
00887: return r;
00888: }
00889: throw new Error("Missing return statement in function");
00890: }
00891:
00892: /**
00893: * ProtocolStatement is PROTOCOL 'JDBC protocol' where
00894: * the protocol is used to prefix any connect request that
00895: * cannot find a driver. We will take a stab at loading
00896: * a driver as each protocol comes in -- we only know about
00897: * two.
00898: */
00899: final public ijResult ProtocolStatement() throws ParseException,
00900: SQLException {
00901: Token t;
00902: String n = null;
00903: jj_consume_token(PROTOCOL);
00904: t = jj_consume_token(STRING);
00905: if (jj_2_57(2)) {
00906: jj_consume_token(AS);
00907: n = identifier();
00908: } else {
00909: ;
00910: }
00911: installProtocol(n, stringValue(t.image));
00912: {
00913: if (true)
00914: return null;
00915: }
00916: throw new Error("Missing return statement in function");
00917: }
00918:
00919: /**
00920: * DriverStatement is DRIVER 'class' where class is the
00921: * name of a class that is a JDBC driver. It is loaded
00922: * into the DriverManager with a Class.forName call.
00923: * <p>
00924: * You can load as many drivers as you want, the idea is
00925: * to load up the appropriate one(s) for the connect(s)
00926: * that you will be issuing.
00927: */
00928: final public ijResult DriverStatement() throws ParseException,
00929: SQLException {
00930: Token t;
00931: String sVal = null;
00932: jj_consume_token(DRIVER);
00933: t = jj_consume_token(STRING);
00934: try {
00935: // t.image is a class name;
00936: // we load the "driver" in the prototypical
00937: // manner, it will register itself with
00938: // the DriverManager.
00939: sVal = stringValue(t.image);
00940: util.loadDriver(sVal);
00941: } catch (ClassNotFoundException e) {
00942: {
00943: if (true)
00944: throw ijException.classNotFound(sVal);
00945: }
00946: } catch (IllegalArgumentException e) {
00947: {
00948: if (true)
00949: throw ijException.driverNotClassName(sVal);
00950: }
00951: } catch (IllegalAccessException e) {
00952: {
00953: if (true)
00954: throw ijException.classNotFound(sVal);
00955: }
00956: } catch (InstantiationException e) {
00957: {
00958: if (true)
00959: throw ijException.classNotFound(sVal);
00960: }
00961: }
00962: {
00963: if (true)
00964: return null;
00965: }
00966: throw new Error("Missing return statement in function");
00967: }
00968:
00969: final public ijResult ConnectStatement() throws ParseException,
00970: SQLException {
00971: ijResult result;
00972: if (jj_2_60(2)) {
00973: jj_consume_token(CONNECT);
00974: jj_consume_token(TO);
00975: result = dynamicConnection(true);
00976: {
00977: if (true)
00978: return result;
00979: }
00980: } else if (jj_2_61(2)) {
00981: jj_consume_token(CONNECT);
00982: if (jj_2_58(2)) {
00983: result = dynamicConnection(false);
00984: } else if (jj_2_59(2)) {
00985: result = staticConnection();
00986: } else {
00987: jj_consume_token(-1);
00988: throw new ParseException();
00989: }
00990: {
00991: if (true)
00992: return result;
00993: }
00994: } else {
00995: jj_consume_token(-1);
00996: throw new ParseException();
00997: }
00998: throw new Error("Missing return statement in function");
00999: }
01000:
01001: /**
01002: * ConnectStatement is CONNECT 'url' [ PROTOCOL proto ]
01003: [ USER String PASSWORD String ]
01004: [ATTRIBUTES attributeName = value [, attributeName = value]* ]
01005: [ AS ident ], where url is the
01006: * url for the database, i.e. jdbc:protocol:dbname etc.
01007: * Attributes are connection attributes to
01008: * <p>
01009: * There can only be one connection at a time; if there
01010: * is already one, it is put on hold and this one takes its place.
01011: * <p>
01012: * if a driver can't be found, the current protocol will
01013: * be added at the front.
01014: * <p>
01015: * the as ident part is used for set connection. If you don't
01016: * specify a name, we create one that is CONNECTION# for the #
01017: * of open connections that now exists. If the name duplicates,
01018: * an error results.
01019: */
01020: final public ijResult dynamicConnection(boolean simplifiedPath)
01021: throws ParseException, SQLException {
01022: Token t;
01023: Token userT = null;
01024: Token passwordT = null;
01025: String n = null, p = null, sVal;
01026: String userS = util.getSystemProperty(USER_PROPERTY);
01027: String passwordS = util.getSystemProperty(PASSWORD_PROPERTY);
01028: Properties connInfo = null;
01029: t = jj_consume_token(STRING);
01030: if (jj_2_62(2)) {
01031: jj_consume_token(PROTOCOL);
01032: p = identifier();
01033: } else {
01034: ;
01035: }
01036: if (jj_2_63(2)) {
01037: jj_consume_token(USER);
01038: userT = jj_consume_token(STRING);
01039: } else {
01040: ;
01041: }
01042: if (jj_2_64(2)) {
01043: jj_consume_token(PASSWORD);
01044: passwordT = jj_consume_token(STRING);
01045: } else {
01046: ;
01047: }
01048: if (jj_2_65(2)) {
01049: jj_consume_token(ATTRIBUTES);
01050: connInfo = attributeList();
01051: } else {
01052: ;
01053: }
01054: if (jj_2_66(2)) {
01055: jj_consume_token(AS);
01056: n = identifier();
01057: } else {
01058: ;
01059: }
01060: // t.image is a database URL
01061: // we get the connection and salt it away
01062: // for use with other statements.
01063: //
01064: // FUTURE: we could have the syntax be
01065: // CONNECT <STRING> AS <IDENTIFIER>
01066: // and have a SET CONNECTION string to
01067: // re-activate a named connection.
01068: // Or not, and wait for SQL-J to support that
01069: // statement... although then we will have to
01070: // figure out if we will allow that SQL-J through
01071: // JDBC or not.
01072: // get the value of the string
01073: // n.b. at some point this will have to deal with ''s
01074: if (userT != null)
01075: userS = stringValue(userT.image);
01076:
01077: if (passwordT != null)
01078: passwordS = stringValue(passwordT.image);
01079:
01080: //If ij.dataSource property is set,use DataSource to get the connection
01081: String dsName = util.getSystemProperty("ij.dataSource");
01082: if (dsName != null) {
01083: //Check that t.image does not start with jdbc:
01084: //If it starts with jdbc:, do not use DataSource to get connection
01085: sVal = stringValue(t.image);
01086: if (!sVal.startsWith("jdbc:")) {
01087: theConnection = util.getDataSourceConnection(dsName,
01088: userS, passwordS, sVal, false);
01089: {
01090: if (true)
01091: return addSession(theConnection, n);
01092: }
01093: }
01094: }
01095:
01096: if (simplifiedPath)
01097: // url for the database W/O 'jdbc:protocol:', i.e. just a dbname
01098: // For example,
01099: // CONNECT TO 'test'
01100: // is equivalent to
01101: // CONNECT TO 'jdbc:derby:test'
01102: sVal = "jdbc:derby:" + stringValue(t.image);
01103: else
01104: sVal = stringValue(t.image);
01105:
01106: // add named protocol if it was specified
01107: if (p != null) {
01108: String protocol = (String) namedProtocols.get(p);
01109: if (protocol == null) {
01110: {
01111: if (true)
01112: throw ijException.noSuchProtocol(p);
01113: }
01114: }
01115: sVal = protocol + sVal;
01116: }
01117:
01118: // add protocol if no driver matches url
01119: boolean noDriver = false;
01120: // if we have a full URL, make sure it's loaded first
01121: try {
01122: if (sVal.startsWith("jdbc:"))
01123: util.loadDriverIfKnown(sVal);
01124: } catch (Exception e) {
01125: // want to continue with the attempt
01126: }
01127: // By default perform extra checking on the URL attributes.
01128: // This checking does not change the processing.
01129: if (System.getProperty("ij.URLCheck") == null
01130: || Boolean.getBoolean("ij.URLCheck")) {
01131: URLCheck aCheck = new URLCheck(sVal);
01132: }
01133: if (!sVal.startsWith("jdbc:") && (p == null)
01134: && (protocol != null)) {
01135: sVal = protocol + sVal;
01136: }
01137:
01138: // If no ATTRIBUTES on the connection get them from the
01139: // defaults
01140: if (connInfo == null)
01141: connInfo = util.updateConnInfo(userS, passwordS,
01142: utilInstance.getConnAttributeDefaults());
01143: else
01144: connInfo = util.updateConnInfo(userS, passwordS, connInfo);
01145:
01146: theConnection = DriverManager.getConnection(sVal, connInfo);
01147:
01148: {
01149: if (true)
01150: return addSession(theConnection, n);
01151: }
01152: throw new Error("Missing return statement in function");
01153: }
01154:
01155: /**
01156: * Handles DESCRIBE table
01157: */
01158: final public ijResult DescTableStatement() throws ParseException,
01159: SQLException {
01160: String i = null;
01161: String i2 = null;
01162: Token s = null;
01163: jj_consume_token(DESCRIBE);
01164: if (jj_2_67(2)) {
01165: i = identifier();
01166: jj_consume_token(PERIOD);
01167: i2 = identifier();
01168: } else if (jj_2_68(2)) {
01169: i2 = identifier();
01170: } else if (jj_2_69(2)) {
01171: s = jj_consume_token(STRING);
01172: } else {
01173: jj_consume_token(-1);
01174: throw new ParseException();
01175: }
01176: if (s != null) {
01177: String image = stringValue(s.image.toUpperCase());
01178:
01179: int dotPosition = image.indexOf('.');
01180: if (dotPosition != -1) {
01181: i = image.substring(0, dotPosition);
01182: i2 = image.substring(dotPosition + 1);
01183: }
01184: }
01185:
01186: if (i == null)
01187: i = util.getSelectedSchema(theConnection);
01188:
01189: {
01190: if (true)
01191: return describeTable(i, i2);
01192: }
01193: throw new Error("Missing return statement in function");
01194: }
01195:
01196: /**
01197: * Handles CONNECT yadda.yadda.foo( stringArg, ... stringArg ) AS connectionName
01198: */
01199: final public ijResult staticConnection() throws ParseException,
01200: SQLException {
01201: String name = null;
01202: Vector idList;
01203: int idx = 0;
01204: int lastID = 0;
01205: StringBuffer buffer;
01206: String className;
01207: String methodName;
01208: Class classC;
01209: Method method;
01210: int argCount;
01211: String[] args;
01212: Class stringClass;
01213: Class[] argTypes;
01214: ijResult result = null;
01215: idList = staticMethodName();
01216: args = staticMethodArgs();
01217: if (jj_2_70(2)) {
01218: jj_consume_token(AS);
01219: name = identifier();
01220: } else {
01221: ;
01222: }
01223: lastID = idList.size() - 1;
01224: buffer = new StringBuffer();
01225:
01226: for (; idx < lastID; idx++) {
01227: if (idx > 0) {
01228: buffer.append(".");
01229: }
01230: buffer.append((String) idList.elementAt(idx));
01231: }
01232: methodName = (String) idList.elementAt(idx);
01233: className = buffer.toString();
01234:
01235: try {
01236: argCount = args.length;
01237: argTypes = new Class[argCount];
01238: stringClass = Class.forName("java.lang.String");
01239: for (idx = 0; idx < argCount; idx++) {
01240: argTypes[idx] = stringClass;
01241: }
01242:
01243: classC = Class.forName(className);
01244: method = classC.getMethod(methodName, argTypes);
01245: theConnection = (Connection) method.invoke(null, args);
01246: result = addSession(theConnection, name);
01247:
01248: } catch (java.lang.reflect.InvocationTargetException ite) {
01249: Throwable t = ite.getTargetException();
01250: if (t instanceof SQLException) {
01251: if (true)
01252: throw (SQLException) t;
01253: }
01254:
01255: {
01256: if (true)
01257: throw new SQLException(t.toString());
01258: }
01259: } catch (Exception e) {
01260: {
01261: if (true)
01262: throw new SQLException(e.toString());
01263: }
01264: }
01265:
01266: {
01267: if (true)
01268: return result;
01269: }
01270: throw new Error("Missing return statement in function");
01271: }
01272:
01273: /**
01274: * SetConnectionStatement is SET CONNECTION ident
01275: * <p>
01276: * Moves to the named session, if it exists. If it doesn't
01277: * exist, remains on the current session and returns an error.
01278: */
01279: final public ijResult SetConnectionStatement()
01280: throws ParseException, SQLException {
01281: String t;
01282: jj_consume_token(SET);
01283: jj_consume_token(CONNECTION);
01284: t = identifier();
01285: if (!currentConnEnv.haveSession(t)) {
01286: {
01287: if (true)
01288: throw ijException.noSuchConnection(t);
01289: }
01290: }
01291: currentConnEnv.setCurrentSession(t);
01292: theConnection = currentConnEnv.getConnection();
01293: {
01294: if (true)
01295: return new ijConnectionResult(theConnection);
01296: }
01297: throw new Error("Missing return statement in function");
01298: }
01299:
01300: /**
01301: * Handles showing current connections for the current environment, and
01302: * SHOW TABLES/VIEWS/... commands.
01303: */
01304: final public ijResult ShowStatement() throws ParseException,
01305: SQLException {
01306: String schema = null;
01307: String tblname = null;
01308: String str = null;
01309: String[] types = null;
01310: Token t = null;
01311: Token v = null;
01312: if (jj_2_81(2)) {
01313: jj_consume_token(SHOW);
01314: jj_consume_token(CONNECTIONS);
01315: {
01316: if (true)
01317: return showConnectionsMethod(false);
01318: }
01319: } else if (jj_2_82(2)) {
01320: jj_consume_token(SHOW);
01321: if (jj_2_71(2)) {
01322: t = jj_consume_token(TABLES);
01323: } else if (jj_2_72(2)) {
01324: v = jj_consume_token(VIEWS);
01325: } else if (jj_2_73(2)) {
01326: jj_consume_token(SYNONYMS);
01327: } else if (jj_2_74(2)) {
01328: jj_consume_token(ALIASES);
01329: } else {
01330: jj_consume_token(-1);
01331: throw new ParseException();
01332: }
01333: if (jj_2_75(2)) {
01334: jj_consume_token(IN);
01335: schema = identifier();
01336: } else {
01337: ;
01338: }
01339: if (t != null) {
01340: types = new String[] { "TABLE", "SYSTEM TABLE" };
01341: } else if (v != null)
01342: types = new String[] { "VIEW" };
01343: else
01344: types = new String[] { "ALIAS" };
01345: {
01346: if (true)
01347: return showTables(schema, types);
01348: }
01349: } else if (jj_2_83(2)) {
01350: jj_consume_token(SHOW);
01351: jj_consume_token(INDEXES);
01352: if (jj_2_79(2)) {
01353: if (jj_2_77(2)) {
01354: jj_consume_token(IN);
01355: schema = identifier();
01356: } else if (jj_2_78(2)) {
01357: jj_consume_token(FROM);
01358: tblname = identifier();
01359: if (jj_2_76(2)) {
01360: jj_consume_token(PERIOD);
01361: str = identifier();
01362: } else {
01363: ;
01364: }
01365: } else {
01366: jj_consume_token(-1);
01367: throw new ParseException();
01368: }
01369: } else {
01370: ;
01371: }
01372: if (str != null) {
01373: // if absolute table reference given
01374: schema = tblname;
01375: tblname = str;
01376: }
01377:
01378: // If user specifies a table name, then assume schema is
01379: // current schema. Note that getSelectedSchema may return
01380: // null for some DBMSes.
01381: if (schema == null && tblname != null)
01382: schema = util.getSelectedSchema(theConnection);
01383: {
01384: if (true)
01385: return showIndexes(schema, tblname);
01386: }
01387: } else if (jj_2_84(2)) {
01388: jj_consume_token(SHOW);
01389: jj_consume_token(PROCEDURES);
01390: if (jj_2_80(2)) {
01391: jj_consume_token(IN);
01392: schema = identifier();
01393: } else {
01394: ;
01395: }
01396: {
01397: if (true)
01398: return showProcedures(schema);
01399: }
01400: } else if (jj_2_85(2)) {
01401: jj_consume_token(SHOW);
01402: jj_consume_token(SCHEMAS);
01403: {
01404: if (true)
01405: return showSchemas();
01406: }
01407: } else {
01408: jj_consume_token(-1);
01409: throw new ParseException();
01410: }
01411: throw new Error("Missing return statement in function");
01412: }
01413:
01414: /**
01415: * CommitStatement is simply COMMIT.
01416: * It commits the current transation.
01417: */
01418: final public ijResult CommitStatement() throws ParseException,
01419: SQLException {
01420: jj_consume_token(COMMIT);
01421: if (jj_2_86(2)) {
01422: jj_consume_token(WORK);
01423: } else {
01424: ;
01425: }
01426: haveConnection();
01427: theConnection.commit();
01428: {
01429: if (true)
01430: return null;
01431: }
01432: throw new Error("Missing return statement in function");
01433: }
01434:
01435: /**
01436: * RollbackStatement is simply ROLLBACK.
01437: * It undoes the current transation.
01438: */
01439: final public ijResult RollbackStatement() throws ParseException,
01440: SQLException {
01441: jj_consume_token(ROLLBACK);
01442: if (jj_2_87(2)) {
01443: jj_consume_token(WORK);
01444: } else {
01445: ;
01446: }
01447: haveConnection();
01448: theConnection.rollback();
01449: {
01450: if (true)
01451: return null;
01452: }
01453: throw new Error("Missing return statement in function");
01454: }
01455:
01456: /**
01457: * DisconnectStatement is simply DISCONNECT [ ALL | CURRENT | connectionName ]
01458: * it ends the specified connection(s) and
01459: * releases its statement resource.
01460: * <p>
01461: * If ALL is specified, it disconnects all available sessions
01462: * in the current environment.
01463: */
01464: final public ijResult DisconnectStatement() throws ParseException,
01465: SQLException {
01466: Token a = null;
01467: String n = null;
01468: jj_consume_token(DISCONNECT);
01469: if (jj_2_91(2)) {
01470: if (jj_2_88(2)) {
01471: jj_consume_token(CURRENT);
01472: } else if (jj_2_89(2)) {
01473: a = jj_consume_token(ALL);
01474: } else if (jj_2_90(2)) {
01475: n = identifier();
01476: } else {
01477: jj_consume_token(-1);
01478: throw new ParseException();
01479: }
01480: } else {
01481: ;
01482: }
01483: if (a == null) {
01484: if (n == null) {
01485: // only remove the current session
01486: haveConnection();
01487: // Also need to release the session object
01488: currentConnEnv.removeCurrentSession();
01489: theConnection = null;
01490: } else {
01491: if (!currentConnEnv.haveSession(n)) {
01492: if (true)
01493: throw ijException.noSuchConnection(n);
01494: }
01495: currentConnEnv.removeSession(n);
01496: if (currentConnEnv.getSession() == null)
01497: theConnection = null;
01498: }
01499: } else {
01500: currentConnEnv.removeAllSessions();
01501: theConnection = null;
01502: }
01503: {
01504: if (true)
01505: return null;
01506: }
01507: throw new Error("Missing return statement in function");
01508: }
01509:
01510: final public ijResult ExitStatement() throws ParseException,
01511: SQLException {
01512: if (jj_2_92(2)) {
01513: jj_consume_token(EXIT);
01514: {
01515: if (true)
01516: return quit();
01517: }
01518: } else if (jj_2_93(2)) {
01519: jj_consume_token(QUIT);
01520: {
01521: if (true)
01522: return quit();
01523: }
01524: } else {
01525: jj_consume_token(-1);
01526: throw new ParseException();
01527: }
01528: throw new Error("Missing return statement in function");
01529: }
01530:
01531: final public ijResult IllegalStatementName() throws ParseException,
01532: SQLException {
01533: Token s = null;
01534: jj_consume_token(PREPARE);
01535: jj_consume_token(PROCEDURE);
01536: jj_consume_token(AS);
01537: s = jj_consume_token(STRING);
01538: // "procedure" is not allowed as a statement name. this is
01539: // because "execute procedure" is a valid Foundation2000
01540: // command
01541: {
01542: if (true)
01543: throw ijException.illegalStatementName("procedure");
01544: }
01545: throw new Error("Missing return statement in function");
01546: }
01547:
01548: final public ijResult PrepareStatement() throws ParseException,
01549: SQLException {
01550: Token t;
01551: String i;
01552: PreparedStatement ps;
01553: String sVal;
01554: jj_consume_token(PREPARE);
01555: i = identifier();
01556: jj_consume_token(AS);
01557: t = jj_consume_token(STRING);
01558: haveConnection();
01559: sVal = stringValue(t.image);
01560: ps = theConnection.prepareStatement(sVal);
01561: JDBCDisplayUtil.checkNotNull(ps, "prepared statement");
01562: currentConnEnv.getSession().addPreparedStatement(i, ps);
01563:
01564: // all we want callers to see are the warnings.
01565: SQLWarning w = ps.getWarnings();
01566: ps.clearWarnings();
01567: {
01568: if (true)
01569: return new ijWarningResult(w);
01570: }
01571: throw new Error("Missing return statement in function");
01572: }
01573:
01574: final public ijResult GetCursorStatement() throws ParseException,
01575: SQLException {
01576: haveConnection();
01577: int scrollType = JDBC20Translation.TYPE_FORWARD_ONLY;
01578: Token s;
01579: Token scrolling = null;
01580: Token withtoken = null;
01581: int holdType = utilInstance.getHoldability(theConnection);
01582: String c;
01583: Statement st = null;
01584: String sVal;
01585: ResultSet rs = null;
01586: SQLWarning warns;
01587: jj_consume_token(GET);
01588: if (jj_2_94(2)) {
01589: scrolling = jj_consume_token(SCROLL);
01590: scrollType = scrollType();
01591: } else {
01592: ;
01593: }
01594: if (jj_2_95(2)) {
01595: withtoken = jj_consume_token(WITH);
01596: holdType = holdType();
01597: } else {
01598: ;
01599: }
01600: jj_consume_token(CURSOR);
01601: c = identifier();
01602: jj_consume_token(AS);
01603: s = jj_consume_token(STRING);
01604: sVal = stringValue(s.image);
01605: try {
01606: st = utilInstance.createStatement(theConnection,
01607: scrollType, holdType);
01608: JDBCDisplayUtil.checkNotNull(st, "cursor");
01609: st.setCursorName(c);
01610: rs = st.executeQuery(sVal);
01611: JDBCDisplayUtil.checkNotNull(rs, "cursor");
01612: Session sn = currentConnEnv.getSession();
01613: sn.addCursorStatement(c, st);
01614: sn.addCursor(c, rs);
01615: } catch (SQLException e) {
01616: if (rs != null)
01617: rs.close();
01618: if (st != null)
01619: st.close();
01620: {
01621: if (true)
01622: throw e;
01623: }
01624: }
01625:
01626: // all we want callers to see are the warnings.
01627: SQLWarning w1 = theConnection.getWarnings();
01628: SQLWarning w2 = st.getWarnings();
01629: SQLWarning w3 = rs.getWarnings();
01630: theConnection.clearWarnings();
01631: st.clearWarnings();
01632: rs.clearWarnings();
01633: warns = appendWarnings(w1, w2);
01634: {
01635: if (true)
01636: return new ijWarningResult(appendWarnings(warns, w3));
01637: }
01638: throw new Error("Missing return statement in function");
01639: }
01640:
01641: final public int scrollType() throws ParseException, SQLException {
01642: if (jj_2_96(2)) {
01643: jj_consume_token(INSENSITIVE);
01644: {
01645: if (true)
01646: return JDBC20Translation.TYPE_SCROLL_INSENSITIVE;
01647: }
01648: } else if (jj_2_97(2)) {
01649: jj_consume_token(SENSITIVE);
01650: {
01651: if (true)
01652: return JDBC20Translation.TYPE_SCROLL_SENSITIVE;
01653: }
01654: } else {
01655: jj_consume_token(-1);
01656: throw new ParseException();
01657: }
01658: throw new Error("Missing return statement in function");
01659: }
01660:
01661: final public int holdType() throws ParseException, SQLException {
01662: if (jj_2_98(2)) {
01663: jj_consume_token(HOLD);
01664: {
01665: if (true)
01666: return JDBC30Translation.HOLD_CURSORS_OVER_COMMIT;
01667: }
01668: } else if (jj_2_99(2)) {
01669: jj_consume_token(NOHOLD);
01670: {
01671: if (true)
01672: return JDBC30Translation.CLOSE_CURSORS_AT_COMMIT;
01673: }
01674: } else {
01675: jj_consume_token(-1);
01676: throw new ParseException();
01677: }
01678: throw new Error("Missing return statement in function");
01679: }
01680:
01681: final public ijResult AbsoluteStatement() throws ParseException,
01682: SQLException {
01683: int row;
01684: String c;
01685: ResultSet rs;
01686: jj_consume_token(ABSOLUTE);
01687: row = intLiteral();
01688: c = identifier();
01689: haveConnection();
01690: // Verify that we have JDBC 2.0
01691: Session s = currentConnEnv.getSession();
01692: rs = (ResultSet) s.getCursor(c);
01693: JDBCDisplayUtil.checkNotNull(rs, "cursor");
01694:
01695: {
01696: if (true)
01697: return utilInstance.absolute(rs, row);
01698: }
01699: throw new Error("Missing return statement in function");
01700: }
01701:
01702: final public ijResult RelativeStatement() throws ParseException,
01703: SQLException {
01704: int row;
01705: String c;
01706: ResultSet rs;
01707: jj_consume_token(RELATIVE);
01708: row = intLiteral();
01709: c = identifier();
01710: haveConnection();
01711: // Verify that we have JDBC 2.0
01712: Session s = currentConnEnv.getSession();
01713: rs = (ResultSet) s.getCursor(c);
01714: JDBCDisplayUtil.checkNotNull(rs, "cursor");
01715:
01716: {
01717: if (true)
01718: return utilInstance.relative(rs, row);
01719: }
01720: throw new Error("Missing return statement in function");
01721: }
01722:
01723: final public ijResult BeforeFirstStatement() throws ParseException,
01724: SQLException {
01725: String c;
01726: ResultSet rs;
01727: jj_consume_token(BEFORE);
01728: jj_consume_token(FIRST);
01729: c = identifier();
01730: haveConnection();
01731: // Verify that we have JDBC 2.0
01732: Session s = currentConnEnv.getSession();
01733: rs = (ResultSet) s.getCursor(c);
01734: JDBCDisplayUtil.checkNotNull(rs, "cursor");
01735:
01736: {
01737: if (true)
01738: return utilInstance.beforeFirst(rs);
01739: }
01740: throw new Error("Missing return statement in function");
01741: }
01742:
01743: final public ijResult FirstStatement() throws ParseException,
01744: SQLException {
01745: String c;
01746: ResultSet rs;
01747: jj_consume_token(FIRST);
01748: c = identifier();
01749: haveConnection();
01750: // Verify that we have JDBC 2.0
01751: Session s = currentConnEnv.getSession();
01752: rs = (ResultSet) s.getCursor(c);
01753: JDBCDisplayUtil.checkNotNull(rs, "cursor");
01754:
01755: {
01756: if (true)
01757: return utilInstance.first(rs);
01758: }
01759: throw new Error("Missing return statement in function");
01760: }
01761:
01762: final public ijResult NextStatement() throws ParseException,
01763: SQLException {
01764: String c;
01765: ResultSet rs;
01766: jj_consume_token(NEXT);
01767: c = identifier();
01768: haveConnection();
01769: Session s = currentConnEnv.getSession();
01770: rs = (ResultSet) s.getCursor(c);
01771: JDBCDisplayUtil.checkNotNull(rs, "cursor");
01772:
01773: {
01774: if (true)
01775: return new ijRowResult(rs, rs.next());
01776: }
01777: throw new Error("Missing return statement in function");
01778: }
01779:
01780: final public ijResult AfterLastStatement() throws ParseException,
01781: SQLException {
01782: String c;
01783: ResultSet rs;
01784: jj_consume_token(AFTER);
01785: jj_consume_token(LAST);
01786: c = identifier();
01787: haveConnection();
01788: // Verify that we have JDBC 2.0
01789: Session s = currentConnEnv.getSession();
01790: rs = (ResultSet) s.getCursor(c);
01791: JDBCDisplayUtil.checkNotNull(rs, "cursor");
01792:
01793: {
01794: if (true)
01795: return utilInstance.afterLast(rs);
01796: }
01797: throw new Error("Missing return statement in function");
01798: }
01799:
01800: final public ijResult LastStatement() throws ParseException,
01801: SQLException {
01802: String c;
01803: ResultSet rs;
01804: jj_consume_token(LAST);
01805: c = identifier();
01806: haveConnection();
01807: // Verify that we have JDBC 2.0
01808: Session s = currentConnEnv.getSession();
01809: rs = (ResultSet) s.getCursor(c);
01810: JDBCDisplayUtil.checkNotNull(rs, "cursor");
01811:
01812: {
01813: if (true)
01814: return utilInstance.last(rs);
01815: }
01816: throw new Error("Missing return statement in function");
01817: }
01818:
01819: final public ijResult PreviousStatement() throws ParseException,
01820: SQLException {
01821: String c;
01822: ResultSet rs;
01823: jj_consume_token(PREVIOUS);
01824: c = identifier();
01825: haveConnection();
01826: // Verify that we have JDBC 2.0
01827: Session s = currentConnEnv.getSession();
01828: rs = (ResultSet) s.getCursor(c);
01829: JDBCDisplayUtil.checkNotNull(rs, "cursor");
01830:
01831: {
01832: if (true)
01833: return utilInstance.previous(rs);
01834: }
01835: throw new Error("Missing return statement in function");
01836: }
01837:
01838: final public ijResult GetCurrentRowNumber() throws ParseException,
01839: SQLException {
01840: ResultSet rs;
01841: String c;
01842: jj_consume_token(GETCURRENTROWNUMBER);
01843: c = identifier();
01844: haveConnection();
01845: // Verify that we have JDBC 2.0
01846: Session s = currentConnEnv.getSession();
01847: rs = (ResultSet) s.getCursor(c);
01848: JDBCDisplayUtil.checkNotNull(rs, "cursor");
01849:
01850: LocalizedResource.OutputWriter().println(
01851: utilInstance.getCurrentRowNumber(rs));
01852: {
01853: if (true)
01854: return null;
01855: }
01856: throw new Error("Missing return statement in function");
01857: }
01858:
01859: final public ijResult CloseStatement() throws ParseException,
01860: SQLException {
01861: String c;
01862: ResultSet rs;
01863: Statement s;
01864: jj_consume_token(CLOSE);
01865: c = identifier();
01866: haveConnection();
01867: Session sn = currentConnEnv.getSession();
01868: rs = (ResultSet) sn.getCursor(c);
01869: JDBCDisplayUtil.checkNotNull(rs, "cursor");
01870: s = (Statement) sn.getCursorStatement(c);
01871: JDBCDisplayUtil.checkNotNull(s, "cursor");
01872: rs.close();
01873: s.close();
01874: sn.removeCursor(c);
01875: sn.removeCursorStatement(c);
01876:
01877: {
01878: if (true)
01879: return null;
01880: }
01881: throw new Error("Missing return statement in function");
01882: }
01883:
01884: /**
01885: * Hack to get the grammar to leave a
01886: * EXECUTE STATEMENT <stmt> alone. Short
01887: * circuit the ij EXECUTE built in.
01888: */
01889: final public ijResult JBMSPreparedStatementExec()
01890: throws ParseException, SQLException {
01891: Token s = null;
01892: jj_consume_token(EXECUTE);
01893: jj_consume_token(STATEMENT);
01894: s = jj_consume_token(STRING);
01895: {
01896: if (true)
01897: return executeImmediate(stringValue(s.image));
01898: }
01899: throw new Error("Missing return statement in function");
01900: }
01901:
01902: /**
01903: * Hack to get the grammar to leave a
01904: * EXECUTE PROCEDURE <procSpec> alone. Short
01905: * circuit the ij EXECUTE built in so that
01906: * we can deploy ij against Foundation2000.
01907: */
01908: final public ijResult F2KExecuteProcedure() throws ParseException,
01909: SQLException {
01910: Token s = null;
01911: jj_consume_token(EXECUTE);
01912: jj_consume_token(PROCEDURE);
01913: s = jj_consume_token(STRING);
01914: haveConnection();
01915:
01916: Statement aStatement = theConnection.createStatement();
01917: String text = "execute procedure " + s;
01918:
01919: aStatement.execute(text);
01920:
01921: {
01922: if (true)
01923: return new ijStatementResult(aStatement, true);
01924: }
01925: throw new Error("Missing return statement in function");
01926: }
01927:
01928: /**
01929: * Two forms of execute: immediate, with a string
01930: * and prepared, with the id of a prepared statement.
01931: * We expect the latter form will
01932: * eventually support a USING clause to supply
01933: * parameter values (that will be constants).
01934: * No parameters yet, however.
01935: * <p>
01936: * Syntax:
01937: * EXECUTE statementSource [ USING statementSource] ;
01938: *
01939: * statementSource is an identifier of a previously prepared statement
01940: * or a string containing SQL-J text.
01941: */
01942: final public ijResult ExecuteStatement() throws ParseException,
01943: SQLException {
01944: String i = null;
01945: Token s = null;
01946: PreparedStatement ps;
01947: String sVal = null;
01948:
01949: String iUsing = null;
01950: Token sUsing = null;
01951: Token usingObject = null;
01952: jj_consume_token(EXECUTE);
01953: if (jj_2_100(2)) {
01954: i = identifier();
01955: } else if (jj_2_101(2)) {
01956: s = jj_consume_token(STRING);
01957: } else {
01958: jj_consume_token(-1);
01959: throw new ParseException();
01960: }
01961: if (jj_2_104(2)) {
01962: jj_consume_token(USING);
01963: if (jj_2_102(2)) {
01964: iUsing = identifier();
01965: } else if (jj_2_103(2)) {
01966: sUsing = jj_consume_token(STRING);
01967: } else {
01968: jj_consume_token(-1);
01969: throw new ParseException();
01970: }
01971: } else {
01972: ;
01973: }
01974: if (iUsing != null || sUsing != null) { // parameters in use
01975: String sUsingVal = null;
01976: PreparedStatement psUsing;
01977: SQLWarning warns = null;
01978:
01979: haveConnection();
01980:
01981: /*
01982: Steps:
01983: 1. find or prepare the statement
01984: 2. execute the using statement
01985: 3. push the row of the using statement into the parameters
01986: 4. execute the statement against those parameters
01987: 5. clear the parameters
01988: */
01989: /*
01990: get the prepared statement
01991: */
01992: boolean closeWhenDone = false; // will we close the ps when done?
01993: if (i != null) {
01994: ps = (PreparedStatement) currentConnEnv.getSession()
01995: .getPreparedStatement(i);
01996: JDBCDisplayUtil.checkNotNull(ps, "prepared statement "
01997: + i);
01998: } else { // (s!=null)
01999: sVal = stringValue(s.image);
02000: ps = theConnection.prepareStatement(sVal);
02001: closeWhenDone = true;
02002: JDBCDisplayUtil.checkNotNull(ps, "prepared statement");
02003: warns = appendWarnings(warns, ps.getWarnings());
02004: ps.clearWarnings();
02005: }
02006:
02007: /*
02008: execute the using statement
02009: */
02010: if (iUsing != null) {
02011: psUsing = (PreparedStatement) currentConnEnv
02012: .getSession().getPreparedStatement(iUsing);
02013: JDBCDisplayUtil.checkNotNull(psUsing,
02014: "prepared statement " + iUsing);
02015: } else { // (sUsing!=null)
02016: sUsingVal = stringValue(sUsing.image);
02017: psUsing = theConnection.prepareStatement(sUsingVal);
02018: JDBCDisplayUtil.checkNotNull(psUsing,
02019: "prepared statement");
02020: warns = appendWarnings(warns, psUsing.getWarnings());
02021: psUsing.clearWarnings();
02022: }
02023:
02024: ResultSet rsUsing;
02025: /*
02026: If the USING statement is not a query, we
02027: will not execute the statement; the number of
02028: rows controls the execution.
02029: */
02030: if (psUsing.execute()) {
02031: rsUsing = psUsing.getResultSet();
02032:
02033: /*
02034: push the row of the using statement into the parameters
02035: */
02036:
02037: ResultSetMetaData rsmdUsing = rsUsing.getMetaData();
02038: int numCols = rsmdUsing.getColumnCount();
02039:
02040: /*
02041: Insufficient or too many parameters will
02042: be caught at the JDBC level, and halt execution.
02043: */
02044: boolean exec = false;
02045:
02046: /* Only do 1 next on rsUsing if autocommit is on,
02047: * since rsUsing will be closed when ps is closed.
02048: */
02049: boolean autoCommited = false;
02050: ijMultiResult result = new ijMultiResult(ps, rsUsing,
02051: closeWhenDone);
02052:
02053: // while (! autoCommited && rsUsing.next()) {
02054: // // note the first time through
02055: // if (!exec) {
02056: // exec = true;
02057: //
02058: // // send a warning if additional results may be lost
02059: // if (theConnection.getAutoCommit()) {
02060: // // FIXME: currOut.println("IJ WARNING: Autocommit may close using result set");
02061: // autoCommited = true;
02062: // }
02063: // }
02064: // for (int c=1; c<=numCols; c++) {
02065: // if (usingObject == null)
02066: // {
02067: // ps.setObject(c,rsUsing.getObject(c),
02068: // rsmdUsing.getColumnType(c));
02069: // }
02070: // else
02071: // {
02072: // ps.setObject(c,rsUsing.getObject(c));
02073: // }
02074: // }
02075: //
02076: // /*
02077: // 4. execute the statement against those parameters
02078: // */
02079: //
02080: // ps.execute();
02081: // result.addStatementResult(ps);
02082: //
02083: // /*
02084: // 5. clear the parameters
02085: // */
02086: // ps.clearParameters();
02087: //
02088: // }
02089: // if (!exec) {
02090: // throw ijException.noUsingResults();
02091: // }
02092: //
02093: // if (! theConnection.getAutoCommit())
02094: // {
02095: // rsUsing.close();
02096: // }
02097: // // REMIND: any way to look for more rsUsing rows if autoCommit?
02098: // // perhaps just document the behavior...
02099:
02100: {
02101: if (true)
02102: return result;
02103: }
02104: } else {
02105: if (true)
02106: throw ijException.noUsingResults();
02107: }
02108: } else { // no parameters in use
02109: if (i != null) {
02110: haveConnection();
02111: ps = (PreparedStatement) currentConnEnv.getSession()
02112: .getPreparedStatement(i);
02113: JDBCDisplayUtil.checkNotNull(ps, "prepared statement "
02114: + i);
02115: ps.execute();
02116:
02117: {
02118: if (true)
02119: return new ijStatementResult(ps, false);
02120: }
02121: } else { // (s!=null)
02122: {
02123: if (true)
02124: return executeImmediate(stringValue(s.image));
02125: }
02126: }
02127: }
02128: throw new Error("Missing return statement in function");
02129: }
02130:
02131: /**
02132: * Async: like execute immediate, without using,
02133: * but runs the statement in a separate thread, against
02134: * the current connection.
02135: * <p>
02136: * Syntax:
02137: * ASYNC asyncName statementSource
02138: *
02139: * statementSource is a string containing SQL-J text.
02140: */
02141: final public ijResult AsyncStatement() throws ParseException,
02142: SQLException {
02143: Token s = null;
02144: String n = null;
02145: jj_consume_token(ASYNC);
02146: n = identifier();
02147: s = jj_consume_token(STRING);
02148: {
02149: if (true)
02150: return executeAsync(stringValue(s.image), n);
02151: }
02152: throw new Error("Missing return statement in function");
02153: }
02154:
02155: /**
02156: * Wait for: the second half of Async, waits for completion
02157: * if needed and then supplies the result. Only execute is done,
02158: * not row fetching.
02159: * <p>
02160: * Syntax:
02161: * WAIT FOR asyncName
02162: *
02163: * asyncName is a name used in an ASYNC statement previously
02164: */
02165: final public ijResult WaitForStatement() throws ParseException,
02166: SQLException {
02167: Token s = null;
02168: String n = null;
02169: jj_consume_token(WAIT);
02170: jj_consume_token(FOR);
02171: n = identifier();
02172: AsyncStatement as = currentConnEnv.getSession()
02173: .getAsyncStatement(n);
02174: if (as == null) {
02175: if (true)
02176: throw ijException.noSuchAsyncStatement(n);
02177: }
02178: try {
02179: as.join(); // we wait for it to finish.
02180: } catch (InterruptedException ie) {
02181: {
02182: if (true)
02183: throw ijException.waitInterrupted(ie);
02184: }
02185: }
02186: {
02187: if (true)
02188: return as.getResult();
02189: }
02190: throw new Error("Missing return statement in function");
02191: }
02192:
02193: /**
02194: * RemoveStatement is REMOVE identifier. It identifies
02195: * a previously prepared statement. We would prefer a DROP
02196: * syntax, but SQL-J is using that word and I want to point out
02197: * that special processing will be needed to give that parser
02198: * this parser's input for unrecognized text.
02199: */
02200: final public ijResult RemoveStatement() throws ParseException,
02201: SQLException {
02202: String i;
02203: PreparedStatement ps;
02204: jj_consume_token(REMOVE);
02205: i = identifier();
02206: haveConnection();
02207: Session s = currentConnEnv.getSession();
02208: ps = (PreparedStatement) s.getPreparedStatement(i);
02209: JDBCDisplayUtil.checkNotNull(ps, "prepared statement " + i);
02210: ps.close();
02211: s.removePreparedStatement(i);
02212:
02213: {
02214: if (true)
02215: return null;
02216: }
02217: throw new Error("Missing return statement in function");
02218: }
02219:
02220: final public ijResult RunStatement() throws ParseException,
02221: SQLException {
02222: Token i;
02223: Token r = null;
02224: PreparedStatement ps;
02225: jj_consume_token(RUN);
02226: if (jj_2_105(2)) {
02227: r = jj_consume_token(RESOURCE);
02228: } else {
02229: ;
02230: }
02231: i = jj_consume_token(STRING);
02232: if (utilInstance == null) {
02233: if (true)
02234: return null;
02235: }
02236: if (r == null)
02237: utilInstance.newInput(stringValue(i.image));
02238: else
02239: utilInstance.newResourceInput(stringValue(i.image));
02240: {
02241: if (true)
02242: return null;
02243: }
02244: throw new Error("Missing return statement in function");
02245: }
02246:
02247: /**
02248: * Autocommit lets you control this aspect of the connection.
02249: * REMIND: should have a general way to set all connection attributes,
02250: * this is a shortcut for immediate needs.
02251: * <p>
02252: * Syntax:
02253: * AUTOCOMMIT [ ON | OFF ] ;
02254: */
02255: final public ijResult AutocommitStatement() throws ParseException,
02256: SQLException {
02257: Token on = null;
02258: jj_consume_token(AUTOCOMMIT);
02259: if (jj_2_106(2)) {
02260: on = jj_consume_token(ON);
02261: } else if (jj_2_107(2)) {
02262: jj_consume_token(OFF);
02263: } else {
02264: jj_consume_token(-1);
02265: throw new ParseException();
02266: }
02267: haveConnection();
02268: // REMIND: want to warn if unchanged?
02269: theConnection.setAutoCommit((on == null ? false : true));
02270:
02271: {
02272: if (true)
02273: return null;
02274: }
02275: throw new Error("Missing return statement in function");
02276: }
02277:
02278: /**
02279: * By default, holdability is set to true for Connection objects. This syntax NOHOLDFORCONNECTION lets you set it to close cursors at commit.
02280: * Syntax:
02281: * NOHOLDFORCONNECTION ;
02282: */
02283: final public ijResult NoHoldForConnectionStatement()
02284: throws ParseException, SQLException {
02285: Token on = null;
02286: jj_consume_token(NOHOLDFORCONNECTION);
02287: haveConnection();
02288: theConnection = utilInstance.setHoldability(theConnection,
02289: JDBC30Translation.CLOSE_CURSORS_AT_COMMIT);
02290:
02291: {
02292: if (true)
02293: return null;
02294: }
02295: throw new Error("Missing return statement in function");
02296: }
02297:
02298: /**
02299: * Localizeddisplay controls locale sensitive data representayion
02300: * <p>
02301: * Syntax:
02302: * LOCALIZEDDISPLAY [ ON | OFF ] ;
02303: */
02304: final public ijResult LocalizedDisplay() throws ParseException {
02305: Token on = null;
02306: jj_consume_token(LOCALIZEDDISPLAY);
02307: if (jj_2_108(2)) {
02308: on = jj_consume_token(ON);
02309: } else if (jj_2_109(2)) {
02310: jj_consume_token(OFF);
02311: } else {
02312: jj_consume_token(-1);
02313: throw new ParseException();
02314: }
02315: LocalizedResource
02316: .enableLocalization((on == null ? false : true));
02317: {
02318: if (true)
02319: return null;
02320: }
02321: throw new Error("Missing return statement in function");
02322: }
02323:
02324: /**
02325: * ReadOnly lets you control this aspect of the connection.
02326: * REMIND: should have a general way to set all connection attributes,
02327: * this is a shortcut for immediate needs.
02328: * <p>
02329: * Syntax:
02330: * READONLY [ ON | OFF ] ;
02331: */
02332: final public ijResult ReadOnlyStatement() throws ParseException,
02333: SQLException {
02334: Token on = null;
02335: jj_consume_token(READONLY);
02336: if (jj_2_110(2)) {
02337: on = jj_consume_token(ON);
02338: } else if (jj_2_111(2)) {
02339: jj_consume_token(OFF);
02340: } else {
02341: jj_consume_token(-1);
02342: throw new ParseException();
02343: }
02344: haveConnection();
02345: theConnection.setReadOnly((on == null ? false : true));
02346: {
02347: if (true)
02348: return null;
02349: }
02350: throw new Error("Missing return statement in function");
02351: }
02352:
02353: /**
02354: * Elapsedtime on causes ij to dump out the elapsed time it takes
02355: * to run a user statement at the end of that statement.
02356: * <p>
02357: * Syntax:
02358: * ELAPSEDTIME [ ON | OFF ] ;
02359: */
02360: final public ijResult ElapsedTimeStatement() throws ParseException {
02361: Token on = null;
02362: jj_consume_token(ELAPSEDTIME);
02363: if (jj_2_112(2)) {
02364: on = jj_consume_token(ON);
02365: } else if (jj_2_113(2)) {
02366: jj_consume_token(OFF);
02367: } else {
02368: jj_consume_token(-1);
02369: throw new ParseException();
02370: }
02371: elapsedTime = (on != null);
02372: {
02373: if (true)
02374: return null;
02375: }
02376: throw new Error("Missing return statement in function");
02377: }
02378:
02379: /**
02380: * MaximumDisplayWidth EXACT_NUMERIC changes the maximum display width for
02381: * java.lang.String to the specified EXACT_NUMERIC.
02382: * This is only used by the console view.
02383: * <p>
02384: * Syntax:
02385: * MAXIMUMDISPLAYWIDTH INTEGER ;
02386: */
02387: final public ijResult MaximumDisplayWidthStatement()
02388: throws ParseException {
02389: int maxWidth;
02390: jj_consume_token(MAXIMUMDISPLAYWIDTH);
02391: maxWidth = intValue();
02392: JDBCDisplayUtil.setMaxDisplayWidth(maxWidth);
02393: {
02394: if (true)
02395: return null;
02396: }
02397: throw new Error("Missing return statement in function");
02398: }
02399:
02400: final public int intValue() throws ParseException {
02401: Token t;
02402: t = jj_consume_token(INTEGER);
02403: {
02404: if (true)
02405: return Integer.parseInt(t.image);
02406: }
02407: throw new Error("Missing return statement in function");
02408: }
02409:
02410: /**
02411: * Bang lets you issue a system command using System.exec.
02412: * <p>
02413: * Syntax:
02414: * ! 'command to issue' ;
02415: */
02416: final public ijResult Bang() throws ParseException {
02417: Token cmd = null;
02418: jj_consume_token(BANG);
02419: cmd = jj_consume_token(STRING);
02420: ijResult result = null;
02421: try {
02422: Process p = Runtime.getRuntime().exec(
02423: stringValue(cmd.image));
02424: LocalizedInput in = new LocalizedInput(p.getInputStream());
02425: int c;
02426: Vector v = new Vector();
02427: StringBuffer output = new StringBuffer();
02428: // echo output
02429: while ((c = in.read()) != -1) {
02430: output.append((char) c);
02431: }
02432: in.close();
02433: // echo errors
02434: in = new LocalizedInput(p.getErrorStream());
02435: // echo output
02436: while ((c = in.read()) != -1) {
02437: output.append((char) c);
02438: }
02439: in.close();
02440: v.addElement(output);
02441: result = new ijVectorResult(v, null);
02442: // wait for completion
02443: try {
02444: p.waitFor();
02445: } catch (InterruptedException e) {
02446: {
02447: if (true)
02448: throw ijException.bangException(e);
02449: }
02450: }
02451: } catch (IOException ioe) {
02452: {
02453: if (true)
02454: throw ijException.bangException(ioe);
02455: }
02456: }
02457: {
02458: if (true)
02459: return result;
02460: }
02461: throw new Error("Missing return statement in function");
02462: }
02463:
02464: /**
02465: ExpectStatement is EXPECT [ FAIL ] {'String'}* END EXPECT
02466: <p>
02467: Will eventually detect the lines that the strings are without
02468: special literals, but for now this is expedient (except for the
02469: doubling of quotes...)
02470: <p>
02471: Used to test the previous statement's output. Note that ij must be
02472: in "expect" mode to use this statement, otherwise it is just
02473: ignored. This is due to the overhead of tracking the prior statement's
02474: output.
02475: */
02476: final public ijResult ExpectStatement() throws ParseException {
02477: Token f = null;
02478: Vector stringVector = new Vector();
02479: jj_consume_token(EXPECT);
02480: if (jj_2_114(2)) {
02481: f = jj_consume_token(FAIL);
02482: } else {
02483: ;
02484: }
02485: StringList(stringVector);
02486: jj_consume_token(END);
02487: jj_consume_token(EXPECT);
02488: if (!getExpect()) {
02489: if (true)
02490: return null;
02491: } // don't bother processing.
02492:
02493: // FIXME
02494:
02495: // Do the comparison of the string list to the prior rows of
02496: // output, using a row-by-row perl-regex comparison.
02497: boolean result = true;
02498:
02499: // register the result and whether it should be true or false
02500: // FIXME: how to find the expecter??
02501: noteExpect(result, f == null);
02502:
02503: {
02504: if (true)
02505: return null;
02506: }
02507: throw new Error("Missing return statement in function");
02508: }
02509:
02510: final public void StringList(Vector v) throws ParseException {
02511: StringItem(v);
02512: label_1: while (true) {
02513: if (jj_2_115(2)) {
02514: ;
02515: } else {
02516: break label_1;
02517: }
02518: StringItem(v);
02519: }
02520: }
02521:
02522: final public void StringItem(Vector v) throws ParseException {
02523: Token s;
02524: s = jj_consume_token(STRING);
02525: v.addElement(s);
02526: }
02527:
02528: /**
02529: Haven't included: ASYNC, !, EXPECT
02530: Don't include: XA_*
02531: **/
02532: final public ijResult HelpStatement() throws ParseException {
02533: jj_consume_token(HELP);
02534: Vector v = new Vector();
02535:
02536: StringTokenizer st = new StringTokenizer(LocalizedResource
02537: .getMessage("IJ_HelpText"), "\n");
02538: while (st.hasMoreTokens()) {
02539: v.addElement(st.nextToken());
02540: }
02541:
02542: {
02543: if (true)
02544: return new ijVectorResult(v, null);
02545: }
02546: throw new Error("Missing return statement in function");
02547: }
02548:
02549: final public String identifier() throws ParseException {
02550: Token t;
02551: t = jj_consume_token(IDENTIFIER);
02552: // identifiers are case insensitive, so we map them up.
02553: // ij doesn't recognize any use of delimited identifiers in its syntax.
02554: {
02555: if (true)
02556: return (t.image.toUpperCase(Locale.ENGLISH));
02557: }
02558: throw new Error("Missing return statement in function");
02559: }
02560:
02561: final public int intLiteral() throws ParseException, SQLException {
02562: String sign = "";
02563: Token tok;
02564: if (jj_2_116(2)) {
02565: sign = sign();
02566: } else {
02567: ;
02568: }
02569: tok = jj_consume_token(INTEGER);
02570: /*
02571: ** The various java parse utilities can't handle leading +,
02572: ** so only concatenate leading -.
02573: */
02574:
02575: String num = tok.image;
02576:
02577: if (sign.equals("-")) {
02578: num = sign.concat(num);
02579: }
02580:
02581: {
02582: if (true)
02583: return Integer.parseInt(num);
02584: }
02585: throw new Error("Missing return statement in function");
02586: }
02587:
02588: final public Vector staticMethodName() throws ParseException,
02589: SQLException {
02590: Vector list = new Vector();
02591: methodLeg(list);
02592: label_2: while (true) {
02593: jj_consume_token(PERIOD);
02594: methodLeg(list);
02595: if (jj_2_117(2)) {
02596: ;
02597: } else {
02598: break label_2;
02599: }
02600: }
02601: {
02602: if (true)
02603: return list;
02604: }
02605: throw new Error("Missing return statement in function");
02606: }
02607:
02608: final public void methodLeg(Vector list) throws ParseException,
02609: SQLException {
02610: Token id;
02611: id = jj_consume_token(IDENTIFIER);
02612: list.addElement(id.image);
02613: }
02614:
02615: final public String[] staticMethodArgs() throws ParseException,
02616: SQLException {
02617: Vector list = new Vector();
02618: String[] args;
02619: jj_consume_token(LEFT_PAREN);
02620: if (jj_2_119(2)) {
02621: oneStaticArg(list);
02622: label_3: while (true) {
02623: if (jj_2_118(2)) {
02624: ;
02625: } else {
02626: break label_3;
02627: }
02628: jj_consume_token(COMMA);
02629: oneStaticArg(list);
02630: }
02631: } else {
02632: ;
02633: }
02634: jj_consume_token(RIGHT_PAREN);
02635: args = new String[list.size()];
02636: list.copyInto(args);
02637:
02638: {
02639: if (true)
02640: return args;
02641: }
02642: throw new Error("Missing return statement in function");
02643: }
02644:
02645: final public void oneStaticArg(Vector list) throws ParseException,
02646: SQLException {
02647: Token tok;
02648: tok = jj_consume_token(STRING);
02649: list.addElement(stringValue(tok.image));
02650: }
02651:
02652: /*
02653: * <A NAME="sign">sign</A>
02654: */
02655: final public String sign() throws ParseException, SQLException {
02656: Token s;
02657: if (jj_2_120(2)) {
02658: s = jj_consume_token(PLUS_SIGN);
02659: {
02660: if (true)
02661: return s.image;
02662: }
02663: } else if (jj_2_121(2)) {
02664: s = jj_consume_token(MINUS_SIGN);
02665: {
02666: if (true)
02667: return s.image;
02668: }
02669: } else {
02670: jj_consume_token(-1);
02671: throw new ParseException();
02672: }
02673: throw new Error("Missing return statement in function");
02674: }
02675:
02676: /**
02677: Undocumented commands to help XA testing.
02678:
02679: This is the grammer for the XA commands
02680:
02681: <XA_DATASOURCE> 'dbname' ( <CREATE> | shutdown )
02682: - get a XADataSource whose database name is dbname and make that
02683: XADataSource the current XADataSource
02684:
02685: <XA_CONNECT> [ <USER> 'user' ]
02686: [ <PASSWORD> 'password' ]
02687: [ <AS> xaconnid ]
02688: - make an XAConnection using the current XADataSource and make
02689: that XAConnection the current XAConnection. If xaconnid is
02690: given, then associate xaconnid with the XAConnection.
02691: (xaconnid not implemeneted)
02692:
02693:
02694: <XA_COMMIT> ( <XA_1PHASE> | <XA_2PHASE> ) xid
02695: - commit a global transaction xid
02696:
02697:
02698: <XA_DISCONNECT> [ xaconnid = identifier() ]
02699: - disconnect an XAConnection. If xaconnid is given, then
02700: disconnect the XAConnection with the given xaconnid.
02701: (xaconnid not implemeneted)
02702:
02703:
02704: <XA_END> ( <XA_SUSPEND> | <XA_SUCCESS> | <XA_FAIL> ) xid
02705: - dissociate a transaction from the current XAConnection or end
02706: an already suspened one
02707:
02708: <XA_FORGET> xid - forget about a global transaction
02709:
02710: <XA_GETCONNECTION> [ <AS> connid ]
02711: - get a Connection object from the current XAConnection.
02712: If connid is given, then associate connid with the connection.
02713: (connid not implemented)
02714:
02715: <XA_PREPARE> xid - prepare a global transaction
02716:
02717: <XA_RECOVER> ( <XA_NOFLAGS> | <XA_STARTRSCAN> | <XA_ENDRSCAN> )
02718: - return the list of in-doubt transactions
02719:
02720: <XA_ROLLBACK> xid - rollback a global transaction
02721:
02722: <XA_START> ( <XA_NOFLAGS> | <XA_JOIN> | <XA_RESUME> ) xid
02723: - associate a transaction or start a new global
02724: transaction with the current XAConnection.
02725:
02726: The following is for testing other JDBC2.0 ext interface, DataSource
02727: and ConnectionPoolDataSource. Strictly speaking, these are not xa, but
02728: their functionality will be lumped into xaHelper because these are here
02729: only for testing purposes.
02730:
02731: <DATASOURCE> 'dbname' [ <PROTOCOL> 'protocol' ]
02732: [ <USER> 'user' ]
02733: [ <PASSWORD> 'password' ]
02734: [ <AS> n=identifier() ]
02735: - get a data source whose database name is dbname and make that
02736: DataSource the current DataSource. If <PROTOCOL> is specified,
02737: the DataSource may be remote. Get a connection from that
02738: dataSource and use the user/password if specified.
02739:
02740: <CP_DATASOURCE> 'dbname' [ <PROTOCOL> 'protocol' ]
02741: - get a connection pool data source whose database name is
02742: dbname and make that DataSource the current CPDataSource.
02743: If <PROTOCOL> is specified, the DataSource may be
02744: remote.
02745:
02746: <CP_CONNECT> [ <USER> 'user' ]
02747: [ <PASSWORD> 'password' ]
02748: [ <AS> cpconnid ]
02749: - make a PooledConnection using the current CPDataSource and
02750: make that PooledConnection the current PooledConnection.
02751: If cpconnid is given, then associate cpconnid with the
02752: PooledConnection. (cpconnid not implemented).
02753:
02754: <CP_GETCONNECTION> [ <AS> connid ]
02755: - get a Connection object from the current PooledConnection.
02756: If connid is given, the associate connid with the connection.
02757: (connid not implemented)
02758:
02759: <CP_DISCONNECT> [ cpconnid = identifier() ]
02760: - disconnect a PooledConnection. If cpconnid is given, then
02761: disconnect the PooledConnection with the given cpconnid.
02762: (cpconnid not implemented)
02763:
02764: */
02765:
02766: /**
02767: * XA_DataSourceStatement is XA_DataSource 'dbname' ( create | shutdown )
02768: * We new'ed an instance of XADataSource as the current DataSource and set its
02769: * database name to dbname.
02770: */
02771: final public ijResult XA_DataSourceStatement()
02772: throws ParseException, SQLException {
02773: Token dbname = null;
02774: Token shut = null;
02775: String create = null;
02776: jj_consume_token(XA_DATASOURCE);
02777: dbname = jj_consume_token(STRING);
02778: if (jj_2_124(2)) {
02779: if (jj_2_122(2)) {
02780: shut = jj_consume_token(SHUTDOWN);
02781: } else if (jj_2_123(2)) {
02782: create = identifier();
02783: } else {
02784: jj_consume_token(-1);
02785: throw new ParseException();
02786: }
02787: } else {
02788: ;
02789: }
02790: xahelper.XADataSourceStatement(this , dbname, shut, create);
02791:
02792: {
02793: if (true)
02794: return null;
02795: }
02796: throw new Error("Missing return statement in function");
02797: }
02798:
02799: /**
02800: * XA_ConnectStatement is XA_CONNECT (<AS> connid)
02801: * make a XAConnection using the currentXADataSource and make that XAConnection
02802: * the current XAConnection. If connid is given, then associate connid with
02803: * the XAConnection. This connid is not th xid.
02804: */
02805: final public ijResult XA_ConnectStatement() throws ParseException,
02806: SQLException {
02807: Token userT = null;
02808: Token passwordT = null;
02809: String n = null;
02810: jj_consume_token(XA_CONNECT);
02811: if (jj_2_125(2)) {
02812: jj_consume_token(USER);
02813: userT = jj_consume_token(STRING);
02814: } else {
02815: ;
02816: }
02817: if (jj_2_126(2)) {
02818: jj_consume_token(PASSWORD);
02819: passwordT = jj_consume_token(STRING);
02820: } else {
02821: ;
02822: }
02823: if (jj_2_127(2)) {
02824: jj_consume_token(AS);
02825: n = identifier();
02826: } else {
02827: ;
02828: }
02829: xahelper.XAConnectStatement(this , userT, passwordT, n);
02830: {
02831: if (true)
02832: return null;
02833: }
02834: throw new Error("Missing return statement in function");
02835: }
02836:
02837: /**
02838: * XA_DisconnectStatement is XA_DISCONNECT [xaconnid = identifier()]
02839: * disconnect the current XAConnection
02840: * If xaconnid is given, then disconnect XAConnection with xaconnid (xaconnid
02841: * not implemented).
02842: *
02843: */
02844: final public ijResult XA_DisconnectStatement()
02845: throws ParseException, SQLException {
02846: String n = null;
02847: jj_consume_token(XA_DISCONNECT);
02848: if (jj_2_128(2)) {
02849: n = identifier();
02850: } else {
02851: ;
02852: }
02853: xahelper.XADisconnectStatement(this , n);
02854: {
02855: if (true)
02856: return null;
02857: }
02858: throw new Error("Missing return statement in function");
02859: }
02860:
02861: /**
02862: * XA_CommitStatement is XA_COMMIT [ XA_1PHASE | XA_2PHASE ] xid
02863: * commits a global transaction xid
02864: */
02865: final public ijResult XA_CommitStatement() throws ParseException,
02866: SQLException {
02867: Token onePhase = null;
02868: Token twoPhase = null;
02869: int xid = 0;
02870: jj_consume_token(XA_COMMIT);
02871: if (jj_2_129(2)) {
02872: onePhase = jj_consume_token(XA_1PHASE);
02873: } else if (jj_2_130(2)) {
02874: twoPhase = jj_consume_token(XA_2PHASE);
02875: } else {
02876: jj_consume_token(-1);
02877: throw new ParseException();
02878: }
02879: xid = intValue();
02880: xahelper.CommitStatement(this , onePhase, twoPhase, xid);
02881: {
02882: if (true)
02883: return null;
02884: }
02885: throw new Error("Missing return statement in function");
02886: }
02887:
02888: /**
02889: * XA_EndStatement is XA_END [ XA_SUSPEND | XA_SUCCESS | XA_FAIL] xid
02890: * dissociates a transaction from the current XAConnection or end an already
02891: * suspended one
02892: */
02893: final public ijResult XA_EndStatement() throws ParseException,
02894: SQLException {
02895: int flag = 0;
02896: int xid = 0;
02897: jj_consume_token(XA_END);
02898: flag = xatmflag();
02899: xid = intValue();
02900: xahelper.EndStatement(this , flag, xid);
02901: {
02902: if (true)
02903: return null;
02904: }
02905: throw new Error("Missing return statement in function");
02906: }
02907:
02908: /**
02909: * XA_ForgetStatement is XA_FORGET xid
02910: * forgets about a heuristically completed transaction
02911: */
02912: final public ijResult XA_ForgetStatement() throws ParseException,
02913: SQLException {
02914: int xid = 0;
02915: jj_consume_token(XA_FORGET);
02916: xid = intValue();
02917: xahelper.ForgetStatement(this , xid);
02918: {
02919: if (true)
02920: return null;
02921: }
02922: throw new Error("Missing return statement in function");
02923: }
02924:
02925: /**
02926: * XA_GetConnectionStatement is XA_GETCONNECTION
02927: * it gets a Connection from the currentXAConnection and uses that as the
02928: * current connection
02929: */
02930: final public ijResult XA_GetConnectionStatement()
02931: throws ParseException, SQLException {
02932: String n = "XA";
02933: jj_consume_token(XA_GETCONNECTION);
02934: if (jj_2_131(2)) {
02935: jj_consume_token(AS);
02936: n = identifier();
02937: } else {
02938: ;
02939: }
02940: theConnection = xahelper.XAGetConnectionStatement(this , n);
02941: currentConnEnv.addSession(theConnection, n);
02942:
02943: {
02944: if (true)
02945: return new ijConnectionResult(theConnection);
02946: }
02947: throw new Error("Missing return statement in function");
02948: }
02949:
02950: /**
02951: * XA_PrepareStatement is XA_PREPARE xid
02952: * prepares a global transaction
02953: */
02954: final public ijResult XA_PrepareStatement() throws ParseException,
02955: SQLException {
02956: int xid = 0;
02957: jj_consume_token(XA_PREPARE);
02958: xid = intValue();
02959: xahelper.PrepareStatement(this , xid);
02960: {
02961: if (true)
02962: return null;
02963: }
02964: throw new Error("Missing return statement in function");
02965: }
02966:
02967: /**
02968: * XA_RecoverStatement is XA_RECOVER flag
02969: * displays the list of prepared transactions
02970: */
02971: final public ijResult XA_RecoverStatement() throws ParseException,
02972: SQLException {
02973: int flag = 0;
02974: jj_consume_token(XA_RECOVER);
02975: flag = xatmflag();
02976: {
02977: if (true)
02978: return xahelper.RecoverStatement(this , flag);
02979: }
02980: throw new Error("Missing return statement in function");
02981: }
02982:
02983: /**
02984: * XA_RollbackStatement is XA_Rollback xid
02985: * rolls back a global transaction
02986: */
02987: final public ijResult XA_RollbackStatement() throws ParseException,
02988: SQLException {
02989: int xid = 0;
02990: jj_consume_token(XA_ROLLBACK);
02991: xid = intValue();
02992: xahelper.RollbackStatement(this , xid);
02993: {
02994: if (true)
02995: return null;
02996: }
02997: throw new Error("Missing return statement in function");
02998: }
02999:
03000: /**
03001: * XA_StartStatement is XA_START [ XA_NOFLAGS | XA_JOIN | XA_RESUME ] xid
03002: * start or associates a transaction with the current XAConnection
03003: */
03004: final public ijResult XA_StartStatement() throws ParseException,
03005: SQLException {
03006: int flag = 0;
03007: int xid = 0;
03008: jj_consume_token(XA_START);
03009: flag = xatmflag();
03010: xid = intValue();
03011: xahelper.StartStatement(this , flag, xid);
03012: {
03013: if (true)
03014: return null;
03015: }
03016: throw new Error("Missing return statement in function");
03017: }
03018:
03019: final public int xatmflag() throws ParseException, SQLException {
03020: if (jj_2_132(2)) {
03021: jj_consume_token(XA_ENDRSCAN);
03022: {
03023: if (true)
03024: return JDBC20Translation.XA_ENDRSCAN;
03025: }
03026: } else if (jj_2_133(2)) {
03027: jj_consume_token(XA_FAIL);
03028: {
03029: if (true)
03030: return JDBC20Translation.XA_FAIL;
03031: }
03032: } else if (jj_2_134(2)) {
03033: jj_consume_token(XA_JOIN);
03034: {
03035: if (true)
03036: return JDBC20Translation.XA_JOIN;
03037: }
03038: } else if (jj_2_135(2)) {
03039: jj_consume_token(XA_NOFLAGS);
03040: {
03041: if (true)
03042: return JDBC20Translation.XA_NOFLAGS;
03043: }
03044: } else if (jj_2_136(2)) {
03045: jj_consume_token(XA_RESUME);
03046: {
03047: if (true)
03048: return JDBC20Translation.XA_RESUME;
03049: }
03050: } else if (jj_2_137(2)) {
03051: jj_consume_token(XA_STARTRSCAN);
03052: {
03053: if (true)
03054: return JDBC20Translation.XA_STARTRSCAN;
03055: }
03056: } else if (jj_2_138(2)) {
03057: jj_consume_token(XA_SUCCESS);
03058: {
03059: if (true)
03060: return JDBC20Translation.XA_SUCCESS;
03061: }
03062: } else if (jj_2_139(2)) {
03063: jj_consume_token(XA_SUSPEND);
03064: {
03065: if (true)
03066: return JDBC20Translation.XA_SUSPEND;
03067: }
03068: } else {
03069: jj_consume_token(-1);
03070: throw new ParseException();
03071: }
03072: throw new Error("Missing return statement in function");
03073: }
03074:
03075: /**
03076: * DataSourceStatement is
03077: * DataSource 'dbname'
03078: * [ <PROTCOL> 'protocol']
03079: * [ <USER> 'user' ]
03080: * [ <PASSWORD> 'password' ]
03081: * [ <AS> n=identifier() ]
03082: *
03083: * We new'ed an instance of DataSource as the current DataSource and set its
03084: * database name to dbname. Also get a connection
03085: */
03086: final public ijResult DataSourceStatement() throws ParseException,
03087: SQLException {
03088: Token dbname = null;
03089: Token protocol = null;
03090: Token userT = null;
03091: Token passwordT = null;
03092: String n = null;
03093: jj_consume_token(DATASOURCE);
03094: dbname = jj_consume_token(STRING);
03095: if (jj_2_140(2)) {
03096: jj_consume_token(PROTOCOL);
03097: protocol = jj_consume_token(STRING);
03098: } else {
03099: ;
03100: }
03101: if (jj_2_141(2)) {
03102: jj_consume_token(USER);
03103: userT = jj_consume_token(STRING);
03104: } else {
03105: ;
03106: }
03107: if (jj_2_142(2)) {
03108: jj_consume_token(PASSWORD);
03109: passwordT = jj_consume_token(STRING);
03110: } else {
03111: ;
03112: }
03113: if (jj_2_143(2)) {
03114: jj_consume_token(AS);
03115: n = identifier();
03116: } else {
03117: ;
03118: }
03119: theConnection = xahelper.DataSourceStatement(this , dbname,
03120: protocol, userT, passwordT, n);
03121:
03122: {
03123: if (true)
03124: return addSession(theConnection, n);
03125: }
03126: throw new Error("Missing return statement in function");
03127: }
03128:
03129: /**
03130: * CP_DataSourceStatement is
03131: * CP_DataSource 'dbname' [ <PROTOCOL> 'protocol' ]
03132: * - get a connection pool data source whose database name is
03133: * dbname and make that DataSource the current CPDataSource.
03134: * If <PROTOCOL> is specified, the DataSource may be
03135: * remote.
03136: */
03137: final public ijResult CP_DataSourceStatement()
03138: throws ParseException, SQLException {
03139: Token dbname = null;
03140: Token protocol = null;
03141: jj_consume_token(CP_DATASOURCE);
03142: dbname = jj_consume_token(STRING);
03143: if (jj_2_144(2)) {
03144: jj_consume_token(PROTOCOL);
03145: protocol = jj_consume_token(STRING);
03146: } else {
03147: ;
03148: }
03149: xahelper.CPDataSourceStatement(this , dbname, protocol);
03150: {
03151: if (true)
03152: return null;
03153: }
03154: throw new Error("Missing return statement in function");
03155: }
03156:
03157: /**
03158: * CP_ConnectStatement is
03159: * <CP_CONNECT> [ <USER> 'user' ]
03160: * [ <PASSWORD> 'password' ]
03161: * [ <AS> cpconnid ]
03162: * make a PooledConnection using the current CPDataSource and
03163: * make that PooledConnection the current PooledConnection.
03164: * If cpconnid is given, then associate cpconnid with the
03165: * PooledConnection. (cpconnid not implemented).
03166: */
03167: final public ijResult CP_ConnectStatement() throws ParseException,
03168: SQLException {
03169: Token userT = null;
03170: Token passwordT = null;
03171: String n = null;
03172: jj_consume_token(CP_CONNECT);
03173: if (jj_2_145(2)) {
03174: jj_consume_token(USER);
03175: userT = jj_consume_token(STRING);
03176: } else {
03177: ;
03178: }
03179: if (jj_2_146(2)) {
03180: jj_consume_token(PASSWORD);
03181: passwordT = jj_consume_token(STRING);
03182: } else {
03183: ;
03184: }
03185: if (jj_2_147(2)) {
03186: jj_consume_token(AS);
03187: n = identifier();
03188: } else {
03189: ;
03190: }
03191: xahelper.CPConnectStatement(this , userT, passwordT, n);
03192: {
03193: if (true)
03194: return null;
03195: }
03196: throw new Error("Missing return statement in function");
03197: }
03198:
03199: /**
03200: * CP_GetConnectionStatement is
03201: * <CP_GETCONNECTION> [ <AS> connid ]
03202: * get a Connection object from the current PooledConnection.
03203: * If connid is given, the associate connid with the connection.
03204: * (connid not implemented)
03205: */
03206: final public ijResult CP_GetConnectionStatement()
03207: throws ParseException, SQLException {
03208: String n = "Pooled";
03209: jj_consume_token(CP_GETCONNECTION);
03210: if (jj_2_148(2)) {
03211: jj_consume_token(AS);
03212: n = identifier();
03213: } else {
03214: ;
03215: }
03216: theConnection = xahelper.CPGetConnectionStatement(this , n);
03217: currentConnEnv.addSession(theConnection, n);
03218: {
03219: if (true)
03220: return new ijConnectionResult(theConnection);
03221: }
03222: throw new Error("Missing return statement in function");
03223: }
03224:
03225: /**
03226: * CP_DisconnectStatement is
03227: * <CP_DISCONNECT> [ cpconnid = identifier() ]
03228: * disconnect a PooledConnection. If cpconnid is given, then
03229: * disconnect the PooledConnection with the given cpconnid.
03230: * (cpconnid not implemented)
03231: */
03232: final public ijResult CP_DisconnectStatement()
03233: throws ParseException, SQLException {
03234: String n = null;
03235: jj_consume_token(CP_DISCONNECT);
03236: if (jj_2_149(2)) {
03237: n = identifier();
03238: } else {
03239: ;
03240: }
03241: xahelper.CPDisconnectStatement(this , n);
03242: {
03243: if (true)
03244: return null;
03245: }
03246: throw new Error("Missing return statement in function");
03247: }
03248:
03249: final public Properties attributeList() throws ParseException {
03250: Properties properties = new Properties();
03251: Token tok;
03252: String value;
03253: if (jj_2_151(2)) {
03254: property(properties);
03255: label_4: while (true) {
03256: if (jj_2_150(2)) {
03257: ;
03258: } else {
03259: break label_4;
03260: }
03261: jj_consume_token(COMMA);
03262: property(properties);
03263: }
03264: } else {
03265: ;
03266: }
03267: //properties.put(tok.image,value);
03268: {
03269: if (true)
03270: return properties;
03271: }
03272: throw new Error("Missing return statement in function");
03273: }
03274:
03275: final public void property(Properties properties)
03276: throws ParseException {
03277: String key;
03278: String value;
03279: key = caseSensitiveIdentifierOrKeyword();
03280: jj_consume_token(EQUALS_OPERATOR);
03281: value = caseSensitiveIdentifierOrKeyword();
03282: properties.put(key, value);
03283: }
03284:
03285: final public String caseSensitiveIdentifierOrKeyword()
03286: throws ParseException {
03287: String value = null;
03288: Token tok;
03289: if (jj_2_152(2)) {
03290: value = keyword();
03291: {
03292: if (true)
03293: return value;
03294: }
03295: } else if (jj_2_153(2)) {
03296: tok = jj_consume_token(IDENTIFIER);
03297: {
03298: if (true)
03299: return tok.image;
03300: }
03301: } else {
03302: jj_consume_token(-1);
03303: throw new ParseException();
03304: }
03305: throw new Error("Missing return statement in function");
03306: }
03307:
03308: final public String caseSensitiveIdentifier() throws ParseException {
03309: Token tok;
03310: tok = jj_consume_token(IDENTIFIER);
03311: {
03312: if (true)
03313: return tok.image;
03314: }
03315: throw new Error("Missing return statement in function");
03316: }
03317:
03318: final public String keyword() throws ParseException {
03319: Token tok;
03320: String value = null;
03321: if (jj_2_154(2)) {
03322: tok = jj_consume_token(ABSOLUTE);
03323: } else if (jj_2_155(2)) {
03324: tok = jj_consume_token(AFTER);
03325: } else if (jj_2_156(2)) {
03326: tok = jj_consume_token(ALIASES);
03327: } else if (jj_2_157(2)) {
03328: tok = jj_consume_token(ALL);
03329: } else if (jj_2_158(2)) {
03330: tok = jj_consume_token(AS);
03331: } else if (jj_2_159(2)) {
03332: tok = jj_consume_token(ASYNC);
03333: } else if (jj_2_160(2)) {
03334: tok = jj_consume_token(ATTRIBUTES);
03335: } else if (jj_2_161(2)) {
03336: tok = jj_consume_token(AUTOCOMMIT);
03337: } else if (jj_2_162(2)) {
03338: tok = jj_consume_token(BANG);
03339: } else if (jj_2_163(2)) {
03340: tok = jj_consume_token(BEFORE);
03341: } else if (jj_2_164(2)) {
03342: tok = jj_consume_token(CLOSE);
03343: } else if (jj_2_165(2)) {
03344: tok = jj_consume_token(COMMIT);
03345: } else if (jj_2_166(2)) {
03346: tok = jj_consume_token(CONNECT);
03347: } else if (jj_2_167(2)) {
03348: tok = jj_consume_token(CONNECTION);
03349: } else if (jj_2_168(2)) {
03350: tok = jj_consume_token(CONNECTIONS);
03351: } else if (jj_2_169(2)) {
03352: tok = jj_consume_token(CURRENT);
03353: } else if (jj_2_170(2)) {
03354: tok = jj_consume_token(CURSOR);
03355: } else if (jj_2_171(2)) {
03356: tok = jj_consume_token(DESCRIBE);
03357: } else if (jj_2_172(2)) {
03358: tok = jj_consume_token(DISCONNECT);
03359: } else if (jj_2_173(2)) {
03360: tok = jj_consume_token(DRIVER);
03361: } else if (jj_2_174(2)) {
03362: tok = jj_consume_token(ELAPSEDTIME);
03363: } else if (jj_2_175(2)) {
03364: tok = jj_consume_token(END);
03365: } else if (jj_2_176(2)) {
03366: tok = jj_consume_token(EXECUTE);
03367: } else if (jj_2_177(2)) {
03368: tok = jj_consume_token(EXIT);
03369: } else if (jj_2_178(2)) {
03370: tok = jj_consume_token(EXPECT);
03371: } else if (jj_2_179(2)) {
03372: tok = jj_consume_token(FAIL);
03373: } else if (jj_2_180(2)) {
03374: tok = jj_consume_token(FIRST);
03375: } else if (jj_2_181(2)) {
03376: tok = jj_consume_token(FOR);
03377: } else if (jj_2_182(2)) {
03378: tok = jj_consume_token(FROM);
03379: } else if (jj_2_183(2)) {
03380: tok = jj_consume_token(GET);
03381: } else if (jj_2_184(2)) {
03382: tok = jj_consume_token(GETCURRENTROWNUMBER);
03383: } else if (jj_2_185(2)) {
03384: tok = jj_consume_token(HOLD);
03385: } else if (jj_2_186(2)) {
03386: tok = jj_consume_token(HELP);
03387: } else if (jj_2_187(2)) {
03388: tok = jj_consume_token(IN);
03389: } else if (jj_2_188(2)) {
03390: tok = jj_consume_token(INDEXES);
03391: } else if (jj_2_189(2)) {
03392: tok = jj_consume_token(INSENSITIVE);
03393: } else if (jj_2_190(2)) {
03394: tok = jj_consume_token(INTO);
03395: } else if (jj_2_191(2)) {
03396: tok = jj_consume_token(LAST);
03397: } else if (jj_2_192(2)) {
03398: tok = jj_consume_token(LOCALIZEDDISPLAY);
03399: } else if (jj_2_193(2)) {
03400: tok = jj_consume_token(MAXIMUMDISPLAYWIDTH);
03401: } else if (jj_2_194(2)) {
03402: tok = jj_consume_token(NAME);
03403: } else if (jj_2_195(2)) {
03404: tok = jj_consume_token(NEXT);
03405: } else if (jj_2_196(2)) {
03406: tok = jj_consume_token(NOHOLD);
03407: } else if (jj_2_197(2)) {
03408: tok = jj_consume_token(NOHOLDFORCONNECTION);
03409: } else if (jj_2_198(2)) {
03410: tok = jj_consume_token(OFF);
03411: } else if (jj_2_199(2)) {
03412: tok = jj_consume_token(ON);
03413: } else if (jj_2_200(2)) {
03414: tok = jj_consume_token(PASSWORD);
03415: } else if (jj_2_201(2)) {
03416: tok = jj_consume_token(PERIOD);
03417: } else if (jj_2_202(2)) {
03418: tok = jj_consume_token(PREPARE);
03419: } else if (jj_2_203(2)) {
03420: tok = jj_consume_token(PREVIOUS);
03421: } else if (jj_2_204(2)) {
03422: tok = jj_consume_token(PROCEDURE);
03423: } else if (jj_2_205(2)) {
03424: tok = jj_consume_token(PROCEDURES);
03425: } else if (jj_2_206(2)) {
03426: tok = jj_consume_token(PROPERTIES);
03427: } else if (jj_2_207(2)) {
03428: tok = jj_consume_token(PROTOCOL);
03429: } else if (jj_2_208(2)) {
03430: tok = jj_consume_token(QUIT);
03431: } else if (jj_2_209(2)) {
03432: tok = jj_consume_token(READONLY);
03433: } else if (jj_2_210(2)) {
03434: tok = jj_consume_token(RELATIVE);
03435: } else if (jj_2_211(2)) {
03436: tok = jj_consume_token(REMOVE);
03437: } else if (jj_2_212(2)) {
03438: tok = jj_consume_token(RESOURCE);
03439: } else if (jj_2_213(2)) {
03440: tok = jj_consume_token(ROLLBACK);
03441: } else if (jj_2_214(2)) {
03442: tok = jj_consume_token(RUN);
03443: } else if (jj_2_215(2)) {
03444: tok = jj_consume_token(TO);
03445: } else if (jj_2_216(2)) {
03446: tok = jj_consume_token(SCHEMAS);
03447: } else if (jj_2_217(2)) {
03448: tok = jj_consume_token(SCROLL);
03449: } else if (jj_2_218(2)) {
03450: tok = jj_consume_token(SENSITIVE);
03451: } else if (jj_2_219(2)) {
03452: tok = jj_consume_token(SET);
03453: } else if (jj_2_220(2)) {
03454: tok = jj_consume_token(SHOW);
03455: } else if (jj_2_221(2)) {
03456: tok = jj_consume_token(SHUTDOWN);
03457: } else if (jj_2_222(2)) {
03458: tok = jj_consume_token(STATEMENT);
03459: } else if (jj_2_223(2)) {
03460: tok = jj_consume_token(SYNONYMS);
03461: } else if (jj_2_224(2)) {
03462: tok = jj_consume_token(TABLES);
03463: } else if (jj_2_225(2)) {
03464: tok = jj_consume_token(USER);
03465: } else if (jj_2_226(2)) {
03466: tok = jj_consume_token(USING);
03467: } else if (jj_2_227(2)) {
03468: tok = jj_consume_token(VIEWS);
03469: } else if (jj_2_228(2)) {
03470: tok = jj_consume_token(WAIT);
03471: } else if (jj_2_229(2)) {
03472: tok = jj_consume_token(WITH);
03473: } else if (jj_2_230(2)) {
03474: tok = jj_consume_token(XA_1PHASE);
03475: } else if (jj_2_231(2)) {
03476: tok = jj_consume_token(XA_2PHASE);
03477: } else if (jj_2_232(2)) {
03478: tok = jj_consume_token(XA_DATASOURCE);
03479: } else if (jj_2_233(2)) {
03480: tok = jj_consume_token(XA_CONNECT);
03481: } else if (jj_2_234(2)) {
03482: tok = jj_consume_token(XA_COMMIT);
03483: } else if (jj_2_235(2)) {
03484: tok = jj_consume_token(XA_DISCONNECT);
03485: } else if (jj_2_236(2)) {
03486: tok = jj_consume_token(XA_END);
03487: } else if (jj_2_237(2)) {
03488: tok = jj_consume_token(XA_ENDRSCAN);
03489: } else if (jj_2_238(2)) {
03490: tok = jj_consume_token(XA_FAIL);
03491: } else if (jj_2_239(2)) {
03492: tok = jj_consume_token(XA_FORGET);
03493: } else if (jj_2_240(2)) {
03494: tok = jj_consume_token(XA_GETCONNECTION);
03495: } else if (jj_2_241(2)) {
03496: tok = jj_consume_token(XA_JOIN);
03497: } else if (jj_2_242(2)) {
03498: tok = jj_consume_token(XA_NOFLAGS);
03499: } else if (jj_2_243(2)) {
03500: tok = jj_consume_token(XA_PREPARE);
03501: } else if (jj_2_244(2)) {
03502: tok = jj_consume_token(XA_RECOVER);
03503: } else if (jj_2_245(2)) {
03504: tok = jj_consume_token(XA_RESUME);
03505: } else if (jj_2_246(2)) {
03506: tok = jj_consume_token(XA_ROLLBACK);
03507: } else if (jj_2_247(2)) {
03508: tok = jj_consume_token(XA_START);
03509: } else if (jj_2_248(2)) {
03510: tok = jj_consume_token(XA_STARTRSCAN);
03511: } else if (jj_2_249(2)) {
03512: tok = jj_consume_token(XA_SUCCESS);
03513: } else if (jj_2_250(2)) {
03514: tok = jj_consume_token(XA_SUSPEND);
03515: } else if (jj_2_251(2)) {
03516: tok = jj_consume_token(DATASOURCE);
03517: } else if (jj_2_252(2)) {
03518: tok = jj_consume_token(CP_DATASOURCE);
03519: } else if (jj_2_253(2)) {
03520: tok = jj_consume_token(CP_CONNECT);
03521: } else if (jj_2_254(2)) {
03522: tok = jj_consume_token(CP_GETCONNECTION);
03523: } else if (jj_2_255(2)) {
03524: tok = jj_consume_token(CP_DISCONNECT);
03525: } else if (jj_2_256(2)) {
03526: tok = jj_consume_token(WORK);
03527: } else {
03528: jj_consume_token(-1);
03529: throw new ParseException();
03530: }
03531: {
03532: if (true)
03533: return tok.image;
03534: }
03535: throw new Error("Missing return statement in function");
03536: }
03537:
03538: final private boolean jj_2_1(int xla) {
03539: jj_la = xla;
03540: jj_lastpos = jj_scanpos = token;
03541: try {
03542: return !jj_3_1();
03543: } catch (LookaheadSuccess ls) {
03544: return true;
03545: } finally {
03546: jj_save(0, xla);
03547: }
03548: }
03549:
03550: final private boolean jj_2_2(int xla) {
03551: jj_la = xla;
03552: jj_lastpos = jj_scanpos = token;
03553: try {
03554: return !jj_3_2();
03555: } catch (LookaheadSuccess ls) {
03556: return true;
03557: } finally {
03558: jj_save(1, xla);
03559: }
03560: }
03561:
03562: final private boolean jj_2_3(int xla) {
03563: jj_la = xla;
03564: jj_lastpos = jj_scanpos = token;
03565: try {
03566: return !jj_3_3();
03567: } catch (LookaheadSuccess ls) {
03568: return true;
03569: } finally {
03570: jj_save(2, xla);
03571: }
03572: }
03573:
03574: final private boolean jj_2_4(int xla) {
03575: jj_la = xla;
03576: jj_lastpos = jj_scanpos = token;
03577: try {
03578: return !jj_3_4();
03579: } catch (LookaheadSuccess ls) {
03580: return true;
03581: } finally {
03582: jj_save(3, xla);
03583: }
03584: }
03585:
03586: final private boolean jj_2_5(int xla) {
03587: jj_la = xla;
03588: jj_lastpos = jj_scanpos = token;
03589: try {
03590: return !jj_3_5();
03591: } catch (LookaheadSuccess ls) {
03592: return true;
03593: } finally {
03594: jj_save(4, xla);
03595: }
03596: }
03597:
03598: final private boolean jj_2_6(int xla) {
03599: jj_la = xla;
03600: jj_lastpos = jj_scanpos = token;
03601: try {
03602: return !jj_3_6();
03603: } catch (LookaheadSuccess ls) {
03604: return true;
03605: } finally {
03606: jj_save(5, xla);
03607: }
03608: }
03609:
03610: final private boolean jj_2_7(int xla) {
03611: jj_la = xla;
03612: jj_lastpos = jj_scanpos = token;
03613: try {
03614: return !jj_3_7();
03615: } catch (LookaheadSuccess ls) {
03616: return true;
03617: } finally {
03618: jj_save(6, xla);
03619: }
03620: }
03621:
03622: final private boolean jj_2_8(int xla) {
03623: jj_la = xla;
03624: jj_lastpos = jj_scanpos = token;
03625: try {
03626: return !jj_3_8();
03627: } catch (LookaheadSuccess ls) {
03628: return true;
03629: } finally {
03630: jj_save(7, xla);
03631: }
03632: }
03633:
03634: final private boolean jj_2_9(int xla) {
03635: jj_la = xla;
03636: jj_lastpos = jj_scanpos = token;
03637: try {
03638: return !jj_3_9();
03639: } catch (LookaheadSuccess ls) {
03640: return true;
03641: } finally {
03642: jj_save(8, xla);
03643: }
03644: }
03645:
03646: final private boolean jj_2_10(int xla) {
03647: jj_la = xla;
03648: jj_lastpos = jj_scanpos = token;
03649: try {
03650: return !jj_3_10();
03651: } catch (LookaheadSuccess ls) {
03652: return true;
03653: } finally {
03654: jj_save(9, xla);
03655: }
03656: }
03657:
03658: final private boolean jj_2_11(int xla) {
03659: jj_la = xla;
03660: jj_lastpos = jj_scanpos = token;
03661: try {
03662: return !jj_3_11();
03663: } catch (LookaheadSuccess ls) {
03664: return true;
03665: } finally {
03666: jj_save(10, xla);
03667: }
03668: }
03669:
03670: final private boolean jj_2_12(int xla) {
03671: jj_la = xla;
03672: jj_lastpos = jj_scanpos = token;
03673: try {
03674: return !jj_3_12();
03675: } catch (LookaheadSuccess ls) {
03676: return true;
03677: } finally {
03678: jj_save(11, xla);
03679: }
03680: }
03681:
03682: final private boolean jj_2_13(int xla) {
03683: jj_la = xla;
03684: jj_lastpos = jj_scanpos = token;
03685: try {
03686: return !jj_3_13();
03687: } catch (LookaheadSuccess ls) {
03688: return true;
03689: } finally {
03690: jj_save(12, xla);
03691: }
03692: }
03693:
03694: final private boolean jj_2_14(int xla) {
03695: jj_la = xla;
03696: jj_lastpos = jj_scanpos = token;
03697: try {
03698: return !jj_3_14();
03699: } catch (LookaheadSuccess ls) {
03700: return true;
03701: } finally {
03702: jj_save(13, xla);
03703: }
03704: }
03705:
03706: final private boolean jj_2_15(int xla) {
03707: jj_la = xla;
03708: jj_lastpos = jj_scanpos = token;
03709: try {
03710: return !jj_3_15();
03711: } catch (LookaheadSuccess ls) {
03712: return true;
03713: } finally {
03714: jj_save(14, xla);
03715: }
03716: }
03717:
03718: final private boolean jj_2_16(int xla) {
03719: jj_la = xla;
03720: jj_lastpos = jj_scanpos = token;
03721: try {
03722: return !jj_3_16();
03723: } catch (LookaheadSuccess ls) {
03724: return true;
03725: } finally {
03726: jj_save(15, xla);
03727: }
03728: }
03729:
03730: final private boolean jj_2_17(int xla) {
03731: jj_la = xla;
03732: jj_lastpos = jj_scanpos = token;
03733: try {
03734: return !jj_3_17();
03735: } catch (LookaheadSuccess ls) {
03736: return true;
03737: } finally {
03738: jj_save(16, xla);
03739: }
03740: }
03741:
03742: final private boolean jj_2_18(int xla) {
03743: jj_la = xla;
03744: jj_lastpos = jj_scanpos = token;
03745: try {
03746: return !jj_3_18();
03747: } catch (LookaheadSuccess ls) {
03748: return true;
03749: } finally {
03750: jj_save(17, xla);
03751: }
03752: }
03753:
03754: final private boolean jj_2_19(int xla) {
03755: jj_la = xla;
03756: jj_lastpos = jj_scanpos = token;
03757: try {
03758: return !jj_3_19();
03759: } catch (LookaheadSuccess ls) {
03760: return true;
03761: } finally {
03762: jj_save(18, xla);
03763: }
03764: }
03765:
03766: final private boolean jj_2_20(int xla) {
03767: jj_la = xla;
03768: jj_lastpos = jj_scanpos = token;
03769: try {
03770: return !jj_3_20();
03771: } catch (LookaheadSuccess ls) {
03772: return true;
03773: } finally {
03774: jj_save(19, xla);
03775: }
03776: }
03777:
03778: final private boolean jj_2_21(int xla) {
03779: jj_la = xla;
03780: jj_lastpos = jj_scanpos = token;
03781: try {
03782: return !jj_3_21();
03783: } catch (LookaheadSuccess ls) {
03784: return true;
03785: } finally {
03786: jj_save(20, xla);
03787: }
03788: }
03789:
03790: final private boolean jj_2_22(int xla) {
03791: jj_la = xla;
03792: jj_lastpos = jj_scanpos = token;
03793: try {
03794: return !jj_3_22();
03795: } catch (LookaheadSuccess ls) {
03796: return true;
03797: } finally {
03798: jj_save(21, xla);
03799: }
03800: }
03801:
03802: final private boolean jj_2_23(int xla) {
03803: jj_la = xla;
03804: jj_lastpos = jj_scanpos = token;
03805: try {
03806: return !jj_3_23();
03807: } catch (LookaheadSuccess ls) {
03808: return true;
03809: } finally {
03810: jj_save(22, xla);
03811: }
03812: }
03813:
03814: final private boolean jj_2_24(int xla) {
03815: jj_la = xla;
03816: jj_lastpos = jj_scanpos = token;
03817: try {
03818: return !jj_3_24();
03819: } catch (LookaheadSuccess ls) {
03820: return true;
03821: } finally {
03822: jj_save(23, xla);
03823: }
03824: }
03825:
03826: final private boolean jj_2_25(int xla) {
03827: jj_la = xla;
03828: jj_lastpos = jj_scanpos = token;
03829: try {
03830: return !jj_3_25();
03831: } catch (LookaheadSuccess ls) {
03832: return true;
03833: } finally {
03834: jj_save(24, xla);
03835: }
03836: }
03837:
03838: final private boolean jj_2_26(int xla) {
03839: jj_la = xla;
03840: jj_lastpos = jj_scanpos = token;
03841: try {
03842: return !jj_3_26();
03843: } catch (LookaheadSuccess ls) {
03844: return true;
03845: } finally {
03846: jj_save(25, xla);
03847: }
03848: }
03849:
03850: final private boolean jj_2_27(int xla) {
03851: jj_la = xla;
03852: jj_lastpos = jj_scanpos = token;
03853: try {
03854: return !jj_3_27();
03855: } catch (LookaheadSuccess ls) {
03856: return true;
03857: } finally {
03858: jj_save(26, xla);
03859: }
03860: }
03861:
03862: final private boolean jj_2_28(int xla) {
03863: jj_la = xla;
03864: jj_lastpos = jj_scanpos = token;
03865: try {
03866: return !jj_3_28();
03867: } catch (LookaheadSuccess ls) {
03868: return true;
03869: } finally {
03870: jj_save(27, xla);
03871: }
03872: }
03873:
03874: final private boolean jj_2_29(int xla) {
03875: jj_la = xla;
03876: jj_lastpos = jj_scanpos = token;
03877: try {
03878: return !jj_3_29();
03879: } catch (LookaheadSuccess ls) {
03880: return true;
03881: } finally {
03882: jj_save(28, xla);
03883: }
03884: }
03885:
03886: final private boolean jj_2_30(int xla) {
03887: jj_la = xla;
03888: jj_lastpos = jj_scanpos = token;
03889: try {
03890: return !jj_3_30();
03891: } catch (LookaheadSuccess ls) {
03892: return true;
03893: } finally {
03894: jj_save(29, xla);
03895: }
03896: }
03897:
03898: final private boolean jj_2_31(int xla) {
03899: jj_la = xla;
03900: jj_lastpos = jj_scanpos = token;
03901: try {
03902: return !jj_3_31();
03903: } catch (LookaheadSuccess ls) {
03904: return true;
03905: } finally {
03906: jj_save(30, xla);
03907: }
03908: }
03909:
03910: final private boolean jj_2_32(int xla) {
03911: jj_la = xla;
03912: jj_lastpos = jj_scanpos = token;
03913: try {
03914: return !jj_3_32();
03915: } catch (LookaheadSuccess ls) {
03916: return true;
03917: } finally {
03918: jj_save(31, xla);
03919: }
03920: }
03921:
03922: final private boolean jj_2_33(int xla) {
03923: jj_la = xla;
03924: jj_lastpos = jj_scanpos = token;
03925: try {
03926: return !jj_3_33();
03927: } catch (LookaheadSuccess ls) {
03928: return true;
03929: } finally {
03930: jj_save(32, xla);
03931: }
03932: }
03933:
03934: final private boolean jj_2_34(int xla) {
03935: jj_la = xla;
03936: jj_lastpos = jj_scanpos = token;
03937: try {
03938: return !jj_3_34();
03939: } catch (LookaheadSuccess ls) {
03940: return true;
03941: } finally {
03942: jj_save(33, xla);
03943: }
03944: }
03945:
03946: final private boolean jj_2_35(int xla) {
03947: jj_la = xla;
03948: jj_lastpos = jj_scanpos = token;
03949: try {
03950: return !jj_3_35();
03951: } catch (LookaheadSuccess ls) {
03952: return true;
03953: } finally {
03954: jj_save(34, xla);
03955: }
03956: }
03957:
03958: final private boolean jj_2_36(int xla) {
03959: jj_la = xla;
03960: jj_lastpos = jj_scanpos = token;
03961: try {
03962: return !jj_3_36();
03963: } catch (LookaheadSuccess ls) {
03964: return true;
03965: } finally {
03966: jj_save(35, xla);
03967: }
03968: }
03969:
03970: final private boolean jj_2_37(int xla) {
03971: jj_la = xla;
03972: jj_lastpos = jj_scanpos = token;
03973: try {
03974: return !jj_3_37();
03975: } catch (LookaheadSuccess ls) {
03976: return true;
03977: } finally {
03978: jj_save(36, xla);
03979: }
03980: }
03981:
03982: final private boolean jj_2_38(int xla) {
03983: jj_la = xla;
03984: jj_lastpos = jj_scanpos = token;
03985: try {
03986: return !jj_3_38();
03987: } catch (LookaheadSuccess ls) {
03988: return true;
03989: } finally {
03990: jj_save(37, xla);
03991: }
03992: }
03993:
03994: final private boolean jj_2_39(int xla) {
03995: jj_la = xla;
03996: jj_lastpos = jj_scanpos = token;
03997: try {
03998: return !jj_3_39();
03999: } catch (LookaheadSuccess ls) {
04000: return true;
04001: } finally {
04002: jj_save(38, xla);
04003: }
04004: }
04005:
04006: final private boolean jj_2_40(int xla) {
04007: jj_la = xla;
04008: jj_lastpos = jj_scanpos = token;
04009: try {
04010: return !jj_3_40();
04011: } catch (LookaheadSuccess ls) {
04012: return true;
04013: } finally {
04014: jj_save(39, xla);
04015: }
04016: }
04017:
04018: final private boolean jj_2_41(int xla) {
04019: jj_la = xla;
04020: jj_lastpos = jj_scanpos = token;
04021: try {
04022: return !jj_3_41();
04023: } catch (LookaheadSuccess ls) {
04024: return true;
04025: } finally {
04026: jj_save(40, xla);
04027: }
04028: }
04029:
04030: final private boolean jj_2_42(int xla) {
04031: jj_la = xla;
04032: jj_lastpos = jj_scanpos = token;
04033: try {
04034: return !jj_3_42();
04035: } catch (LookaheadSuccess ls) {
04036: return true;
04037: } finally {
04038: jj_save(41, xla);
04039: }
04040: }
04041:
04042: final private boolean jj_2_43(int xla) {
04043: jj_la = xla;
04044: jj_lastpos = jj_scanpos = token;
04045: try {
04046: return !jj_3_43();
04047: } catch (LookaheadSuccess ls) {
04048: return true;
04049: } finally {
04050: jj_save(42, xla);
04051: }
04052: }
04053:
04054: final private boolean jj_2_44(int xla) {
04055: jj_la = xla;
04056: jj_lastpos = jj_scanpos = token;
04057: try {
04058: return !jj_3_44();
04059: } catch (LookaheadSuccess ls) {
04060: return true;
04061: } finally {
04062: jj_save(43, xla);
04063: }
04064: }
04065:
04066: final private boolean jj_2_45(int xla) {
04067: jj_la = xla;
04068: jj_lastpos = jj_scanpos = token;
04069: try {
04070: return !jj_3_45();
04071: } catch (LookaheadSuccess ls) {
04072: return true;
04073: } finally {
04074: jj_save(44, xla);
04075: }
04076: }
04077:
04078: final private boolean jj_2_46(int xla) {
04079: jj_la = xla;
04080: jj_lastpos = jj_scanpos = token;
04081: try {
04082: return !jj_3_46();
04083: } catch (LookaheadSuccess ls) {
04084: return true;
04085: } finally {
04086: jj_save(45, xla);
04087: }
04088: }
04089:
04090: final private boolean jj_2_47(int xla) {
04091: jj_la = xla;
04092: jj_lastpos = jj_scanpos = token;
04093: try {
04094: return !jj_3_47();
04095: } catch (LookaheadSuccess ls) {
04096: return true;
04097: } finally {
04098: jj_save(46, xla);
04099: }
04100: }
04101:
04102: final private boolean jj_2_48(int xla) {
04103: jj_la = xla;
04104: jj_lastpos = jj_scanpos = token;
04105: try {
04106: return !jj_3_48();
04107: } catch (LookaheadSuccess ls) {
04108: return true;
04109: } finally {
04110: jj_save(47, xla);
04111: }
04112: }
04113:
04114: final private boolean jj_2_49(int xla) {
04115: jj_la = xla;
04116: jj_lastpos = jj_scanpos = token;
04117: try {
04118: return !jj_3_49();
04119: } catch (LookaheadSuccess ls) {
04120: return true;
04121: } finally {
04122: jj_save(48, xla);
04123: }
04124: }
04125:
04126: final private boolean jj_2_50(int xla) {
04127: jj_la = xla;
04128: jj_lastpos = jj_scanpos = token;
04129: try {
04130: return !jj_3_50();
04131: } catch (LookaheadSuccess ls) {
04132: return true;
04133: } finally {
04134: jj_save(49, xla);
04135: }
04136: }
04137:
04138: final private boolean jj_2_51(int xla) {
04139: jj_la = xla;
04140: jj_lastpos = jj_scanpos = token;
04141: try {
04142: return !jj_3_51();
04143: } catch (LookaheadSuccess ls) {
04144: return true;
04145: } finally {
04146: jj_save(50, xla);
04147: }
04148: }
04149:
04150: final private boolean jj_2_52(int xla) {
04151: jj_la = xla;
04152: jj_lastpos = jj_scanpos = token;
04153: try {
04154: return !jj_3_52();
04155: } catch (LookaheadSuccess ls) {
04156: return true;
04157: } finally {
04158: jj_save(51, xla);
04159: }
04160: }
04161:
04162: final private boolean jj_2_53(int xla) {
04163: jj_la = xla;
04164: jj_lastpos = jj_scanpos = token;
04165: try {
04166: return !jj_3_53();
04167: } catch (LookaheadSuccess ls) {
04168: return true;
04169: } finally {
04170: jj_save(52, xla);
04171: }
04172: }
04173:
04174: final private boolean jj_2_54(int xla) {
04175: jj_la = xla;
04176: jj_lastpos = jj_scanpos = token;
04177: try {
04178: return !jj_3_54();
04179: } catch (LookaheadSuccess ls) {
04180: return true;
04181: } finally {
04182: jj_save(53, xla);
04183: }
04184: }
04185:
04186: final private boolean jj_2_55(int xla) {
04187: jj_la = xla;
04188: jj_lastpos = jj_scanpos = token;
04189: try {
04190: return !jj_3_55();
04191: } catch (LookaheadSuccess ls) {
04192: return true;
04193: } finally {
04194: jj_save(54, xla);
04195: }
04196: }
04197:
04198: final private boolean jj_2_56(int xla) {
04199: jj_la = xla;
04200: jj_lastpos = jj_scanpos = token;
04201: try {
04202: return !jj_3_56();
04203: } catch (LookaheadSuccess ls) {
04204: return true;
04205: } finally {
04206: jj_save(55, xla);
04207: }
04208: }
04209:
04210: final private boolean jj_2_57(int xla) {
04211: jj_la = xla;
04212: jj_lastpos = jj_scanpos = token;
04213: try {
04214: return !jj_3_57();
04215: } catch (LookaheadSuccess ls) {
04216: return true;
04217: } finally {
04218: jj_save(56, xla);
04219: }
04220: }
04221:
04222: final private boolean jj_2_58(int xla) {
04223: jj_la = xla;
04224: jj_lastpos = jj_scanpos = token;
04225: try {
04226: return !jj_3_58();
04227: } catch (LookaheadSuccess ls) {
04228: return true;
04229: } finally {
04230: jj_save(57, xla);
04231: }
04232: }
04233:
04234: final private boolean jj_2_59(int xla) {
04235: jj_la = xla;
04236: jj_lastpos = jj_scanpos = token;
04237: try {
04238: return !jj_3_59();
04239: } catch (LookaheadSuccess ls) {
04240: return true;
04241: } finally {
04242: jj_save(58, xla);
04243: }
04244: }
04245:
04246: final private boolean jj_2_60(int xla) {
04247: jj_la = xla;
04248: jj_lastpos = jj_scanpos = token;
04249: try {
04250: return !jj_3_60();
04251: } catch (LookaheadSuccess ls) {
04252: return true;
04253: } finally {
04254: jj_save(59, xla);
04255: }
04256: }
04257:
04258: final private boolean jj_2_61(int xla) {
04259: jj_la = xla;
04260: jj_lastpos = jj_scanpos = token;
04261: try {
04262: return !jj_3_61();
04263: } catch (LookaheadSuccess ls) {
04264: return true;
04265: } finally {
04266: jj_save(60, xla);
04267: }
04268: }
04269:
04270: final private boolean jj_2_62(int xla) {
04271: jj_la = xla;
04272: jj_lastpos = jj_scanpos = token;
04273: try {
04274: return !jj_3_62();
04275: } catch (LookaheadSuccess ls) {
04276: return true;
04277: } finally {
04278: jj_save(61, xla);
04279: }
04280: }
04281:
04282: final private boolean jj_2_63(int xla) {
04283: jj_la = xla;
04284: jj_lastpos = jj_scanpos = token;
04285: try {
04286: return !jj_3_63();
04287: } catch (LookaheadSuccess ls) {
04288: return true;
04289: } finally {
04290: jj_save(62, xla);
04291: }
04292: }
04293:
04294: final private boolean jj_2_64(int xla) {
04295: jj_la = xla;
04296: jj_lastpos = jj_scanpos = token;
04297: try {
04298: return !jj_3_64();
04299: } catch (LookaheadSuccess ls) {
04300: return true;
04301: } finally {
04302: jj_save(63, xla);
04303: }
04304: }
04305:
04306: final private boolean jj_2_65(int xla) {
04307: jj_la = xla;
04308: jj_lastpos = jj_scanpos = token;
04309: try {
04310: return !jj_3_65();
04311: } catch (LookaheadSuccess ls) {
04312: return true;
04313: } finally {
04314: jj_save(64, xla);
04315: }
04316: }
04317:
04318: final private boolean jj_2_66(int xla) {
04319: jj_la = xla;
04320: jj_lastpos = jj_scanpos = token;
04321: try {
04322: return !jj_3_66();
04323: } catch (LookaheadSuccess ls) {
04324: return true;
04325: } finally {
04326: jj_save(65, xla);
04327: }
04328: }
04329:
04330: final private boolean jj_2_67(int xla) {
04331: jj_la = xla;
04332: jj_lastpos = jj_scanpos = token;
04333: try {
04334: return !jj_3_67();
04335: } catch (LookaheadSuccess ls) {
04336: return true;
04337: } finally {
04338: jj_save(66, xla);
04339: }
04340: }
04341:
04342: final private boolean jj_2_68(int xla) {
04343: jj_la = xla;
04344: jj_lastpos = jj_scanpos = token;
04345: try {
04346: return !jj_3_68();
04347: } catch (LookaheadSuccess ls) {
04348: return true;
04349: } finally {
04350: jj_save(67, xla);
04351: }
04352: }
04353:
04354: final private boolean jj_2_69(int xla) {
04355: jj_la = xla;
04356: jj_lastpos = jj_scanpos = token;
04357: try {
04358: return !jj_3_69();
04359: } catch (LookaheadSuccess ls) {
04360: return true;
04361: } finally {
04362: jj_save(68, xla);
04363: }
04364: }
04365:
04366: final private boolean jj_2_70(int xla) {
04367: jj_la = xla;
04368: jj_lastpos = jj_scanpos = token;
04369: try {
04370: return !jj_3_70();
04371: } catch (LookaheadSuccess ls) {
04372: return true;
04373: } finally {
04374: jj_save(69, xla);
04375: }
04376: }
04377:
04378: final private boolean jj_2_71(int xla) {
04379: jj_la = xla;
04380: jj_lastpos = jj_scanpos = token;
04381: try {
04382: return !jj_3_71();
04383: } catch (LookaheadSuccess ls) {
04384: return true;
04385: } finally {
04386: jj_save(70, xla);
04387: }
04388: }
04389:
04390: final private boolean jj_2_72(int xla) {
04391: jj_la = xla;
04392: jj_lastpos = jj_scanpos = token;
04393: try {
04394: return !jj_3_72();
04395: } catch (LookaheadSuccess ls) {
04396: return true;
04397: } finally {
04398: jj_save(71, xla);
04399: }
04400: }
04401:
04402: final private boolean jj_2_73(int xla) {
04403: jj_la = xla;
04404: jj_lastpos = jj_scanpos = token;
04405: try {
04406: return !jj_3_73();
04407: } catch (LookaheadSuccess ls) {
04408: return true;
04409: } finally {
04410: jj_save(72, xla);
04411: }
04412: }
04413:
04414: final private boolean jj_2_74(int xla) {
04415: jj_la = xla;
04416: jj_lastpos = jj_scanpos = token;
04417: try {
04418: return !jj_3_74();
04419: } catch (LookaheadSuccess ls) {
04420: return true;
04421: } finally {
04422: jj_save(73, xla);
04423: }
04424: }
04425:
04426: final private boolean jj_2_75(int xla) {
04427: jj_la = xla;
04428: jj_lastpos = jj_scanpos = token;
04429: try {
04430: return !jj_3_75();
04431: } catch (LookaheadSuccess ls) {
04432: return true;
04433: } finally {
04434: jj_save(74, xla);
04435: }
04436: }
04437:
04438: final private boolean jj_2_76(int xla) {
04439: jj_la = xla;
04440: jj_lastpos = jj_scanpos = token;
04441: try {
04442: return !jj_3_76();
04443: } catch (LookaheadSuccess ls) {
04444: return true;
04445: } finally {
04446: jj_save(75, xla);
04447: }
04448: }
04449:
04450: final private boolean jj_2_77(int xla) {
04451: jj_la = xla;
04452: jj_lastpos = jj_scanpos = token;
04453: try {
04454: return !jj_3_77();
04455: } catch (LookaheadSuccess ls) {
04456: return true;
04457: } finally {
04458: jj_save(76, xla);
04459: }
04460: }
04461:
04462: final private boolean jj_2_78(int xla) {
04463: jj_la = xla;
04464: jj_lastpos = jj_scanpos = token;
04465: try {
04466: return !jj_3_78();
04467: } catch (LookaheadSuccess ls) {
04468: return true;
04469: } finally {
04470: jj_save(77, xla);
04471: }
04472: }
04473:
04474: final private boolean jj_2_79(int xla) {
04475: jj_la = xla;
04476: jj_lastpos = jj_scanpos = token;
04477: try {
04478: return !jj_3_79();
04479: } catch (LookaheadSuccess ls) {
04480: return true;
04481: } finally {
04482: jj_save(78, xla);
04483: }
04484: }
04485:
04486: final private boolean jj_2_80(int xla) {
04487: jj_la = xla;
04488: jj_lastpos = jj_scanpos = token;
04489: try {
04490: return !jj_3_80();
04491: } catch (LookaheadSuccess ls) {
04492: return true;
04493: } finally {
04494: jj_save(79, xla);
04495: }
04496: }
04497:
04498: final private boolean jj_2_81(int xla) {
04499: jj_la = xla;
04500: jj_lastpos = jj_scanpos = token;
04501: try {
04502: return !jj_3_81();
04503: } catch (LookaheadSuccess ls) {
04504: return true;
04505: } finally {
04506: jj_save(80, xla);
04507: }
04508: }
04509:
04510: final private boolean jj_2_82(int xla) {
04511: jj_la = xla;
04512: jj_lastpos = jj_scanpos = token;
04513: try {
04514: return !jj_3_82();
04515: } catch (LookaheadSuccess ls) {
04516: return true;
04517: } finally {
04518: jj_save(81, xla);
04519: }
04520: }
04521:
04522: final private boolean jj_2_83(int xla) {
04523: jj_la = xla;
04524: jj_lastpos = jj_scanpos = token;
04525: try {
04526: return !jj_3_83();
04527: } catch (LookaheadSuccess ls) {
04528: return true;
04529: } finally {
04530: jj_save(82, xla);
04531: }
04532: }
04533:
04534: final private boolean jj_2_84(int xla) {
04535: jj_la = xla;
04536: jj_lastpos = jj_scanpos = token;
04537: try {
04538: return !jj_3_84();
04539: } catch (LookaheadSuccess ls) {
04540: return true;
04541: } finally {
04542: jj_save(83, xla);
04543: }
04544: }
04545:
04546: final private boolean jj_2_85(int xla) {
04547: jj_la = xla;
04548: jj_lastpos = jj_scanpos = token;
04549: try {
04550: return !jj_3_85();
04551: } catch (LookaheadSuccess ls) {
04552: return true;
04553: } finally {
04554: jj_save(84, xla);
04555: }
04556: }
04557:
04558: final private boolean jj_2_86(int xla) {
04559: jj_la = xla;
04560: jj_lastpos = jj_scanpos = token;
04561: try {
04562: return !jj_3_86();
04563: } catch (LookaheadSuccess ls) {
04564: return true;
04565: } finally {
04566: jj_save(85, xla);
04567: }
04568: }
04569:
04570: final private boolean jj_2_87(int xla) {
04571: jj_la = xla;
04572: jj_lastpos = jj_scanpos = token;
04573: try {
04574: return !jj_3_87();
04575: } catch (LookaheadSuccess ls) {
04576: return true;
04577: } finally {
04578: jj_save(86, xla);
04579: }
04580: }
04581:
04582: final private boolean jj_2_88(int xla) {
04583: jj_la = xla;
04584: jj_lastpos = jj_scanpos = token;
04585: try {
04586: return !jj_3_88();
04587: } catch (LookaheadSuccess ls) {
04588: return true;
04589: } finally {
04590: jj_save(87, xla);
04591: }
04592: }
04593:
04594: final private boolean jj_2_89(int xla) {
04595: jj_la = xla;
04596: jj_lastpos = jj_scanpos = token;
04597: try {
04598: return !jj_3_89();
04599: } catch (LookaheadSuccess ls) {
04600: return true;
04601: } finally {
04602: jj_save(88, xla);
04603: }
04604: }
04605:
04606: final private boolean jj_2_90(int xla) {
04607: jj_la = xla;
04608: jj_lastpos = jj_scanpos = token;
04609: try {
04610: return !jj_3_90();
04611: } catch (LookaheadSuccess ls) {
04612: return true;
04613: } finally {
04614: jj_save(89, xla);
04615: }
04616: }
04617:
04618: final private boolean jj_2_91(int xla) {
04619: jj_la = xla;
04620: jj_lastpos = jj_scanpos = token;
04621: try {
04622: return !jj_3_91();
04623: } catch (LookaheadSuccess ls) {
04624: return true;
04625: } finally {
04626: jj_save(90, xla);
04627: }
04628: }
04629:
04630: final private boolean jj_2_92(int xla) {
04631: jj_la = xla;
04632: jj_lastpos = jj_scanpos = token;
04633: try {
04634: return !jj_3_92();
04635: } catch (LookaheadSuccess ls) {
04636: return true;
04637: } finally {
04638: jj_save(91, xla);
04639: }
04640: }
04641:
04642: final private boolean jj_2_93(int xla) {
04643: jj_la = xla;
04644: jj_lastpos = jj_scanpos = token;
04645: try {
04646: return !jj_3_93();
04647: } catch (LookaheadSuccess ls) {
04648: return true;
04649: } finally {
04650: jj_save(92, xla);
04651: }
04652: }
04653:
04654: final private boolean jj_2_94(int xla) {
04655: jj_la = xla;
04656: jj_lastpos = jj_scanpos = token;
04657: try {
04658: return !jj_3_94();
04659: } catch (LookaheadSuccess ls) {
04660: return true;
04661: } finally {
04662: jj_save(93, xla);
04663: }
04664: }
04665:
04666: final private boolean jj_2_95(int xla) {
04667: jj_la = xla;
04668: jj_lastpos = jj_scanpos = token;
04669: try {
04670: return !jj_3_95();
04671: } catch (LookaheadSuccess ls) {
04672: return true;
04673: } finally {
04674: jj_save(94, xla);
04675: }
04676: }
04677:
04678: final private boolean jj_2_96(int xla) {
04679: jj_la = xla;
04680: jj_lastpos = jj_scanpos = token;
04681: try {
04682: return !jj_3_96();
04683: } catch (LookaheadSuccess ls) {
04684: return true;
04685: } finally {
04686: jj_save(95, xla);
04687: }
04688: }
04689:
04690: final private boolean jj_2_97(int xla) {
04691: jj_la = xla;
04692: jj_lastpos = jj_scanpos = token;
04693: try {
04694: return !jj_3_97();
04695: } catch (LookaheadSuccess ls) {
04696: return true;
04697: } finally {
04698: jj_save(96, xla);
04699: }
04700: }
04701:
04702: final private boolean jj_2_98(int xla) {
04703: jj_la = xla;
04704: jj_lastpos = jj_scanpos = token;
04705: try {
04706: return !jj_3_98();
04707: } catch (LookaheadSuccess ls) {
04708: return true;
04709: } finally {
04710: jj_save(97, xla);
04711: }
04712: }
04713:
04714: final private boolean jj_2_99(int xla) {
04715: jj_la = xla;
04716: jj_lastpos = jj_scanpos = token;
04717: try {
04718: return !jj_3_99();
04719: } catch (LookaheadSuccess ls) {
04720: return true;
04721: } finally {
04722: jj_save(98, xla);
04723: }
04724: }
04725:
04726: final private boolean jj_2_100(int xla) {
04727: jj_la = xla;
04728: jj_lastpos = jj_scanpos = token;
04729: try {
04730: return !jj_3_100();
04731: } catch (LookaheadSuccess ls) {
04732: return true;
04733: } finally {
04734: jj_save(99, xla);
04735: }
04736: }
04737:
04738: final private boolean jj_2_101(int xla) {
04739: jj_la = xla;
04740: jj_lastpos = jj_scanpos = token;
04741: try {
04742: return !jj_3_101();
04743: } catch (LookaheadSuccess ls) {
04744: return true;
04745: } finally {
04746: jj_save(100, xla);
04747: }
04748: }
04749:
04750: final private boolean jj_2_102(int xla) {
04751: jj_la = xla;
04752: jj_lastpos = jj_scanpos = token;
04753: try {
04754: return !jj_3_102();
04755: } catch (LookaheadSuccess ls) {
04756: return true;
04757: } finally {
04758: jj_save(101, xla);
04759: }
04760: }
04761:
04762: final private boolean jj_2_103(int xla) {
04763: jj_la = xla;
04764: jj_lastpos = jj_scanpos = token;
04765: try {
04766: return !jj_3_103();
04767: } catch (LookaheadSuccess ls) {
04768: return true;
04769: } finally {
04770: jj_save(102, xla);
04771: }
04772: }
04773:
04774: final private boolean jj_2_104(int xla) {
04775: jj_la = xla;
04776: jj_lastpos = jj_scanpos = token;
04777: try {
04778: return !jj_3_104();
04779: } catch (LookaheadSuccess ls) {
04780: return true;
04781: } finally {
04782: jj_save(103, xla);
04783: }
04784: }
04785:
04786: final private boolean jj_2_105(int xla) {
04787: jj_la = xla;
04788: jj_lastpos = jj_scanpos = token;
04789: try {
04790: return !jj_3_105();
04791: } catch (LookaheadSuccess ls) {
04792: return true;
04793: } finally {
04794: jj_save(104, xla);
04795: }
04796: }
04797:
04798: final private boolean jj_2_106(int xla) {
04799: jj_la = xla;
04800: jj_lastpos = jj_scanpos = token;
04801: try {
04802: return !jj_3_106();
04803: } catch (LookaheadSuccess ls) {
04804: return true;
04805: } finally {
04806: jj_save(105, xla);
04807: }
04808: }
04809:
04810: final private boolean jj_2_107(int xla) {
04811: jj_la = xla;
04812: jj_lastpos = jj_scanpos = token;
04813: try {
04814: return !jj_3_107();
04815: } catch (LookaheadSuccess ls) {
04816: return true;
04817: } finally {
04818: jj_save(106, xla);
04819: }
04820: }
04821:
04822: final private boolean jj_2_108(int xla) {
04823: jj_la = xla;
04824: jj_lastpos = jj_scanpos = token;
04825: try {
04826: return !jj_3_108();
04827: } catch (LookaheadSuccess ls) {
04828: return true;
04829: } finally {
04830: jj_save(107, xla);
04831: }
04832: }
04833:
04834: final private boolean jj_2_109(int xla) {
04835: jj_la = xla;
04836: jj_lastpos = jj_scanpos = token;
04837: try {
04838: return !jj_3_109();
04839: } catch (LookaheadSuccess ls) {
04840: return true;
04841: } finally {
04842: jj_save(108, xla);
04843: }
04844: }
04845:
04846: final private boolean jj_2_110(int xla) {
04847: jj_la = xla;
04848: jj_lastpos = jj_scanpos = token;
04849: try {
04850: return !jj_3_110();
04851: } catch (LookaheadSuccess ls) {
04852: return true;
04853: } finally {
04854: jj_save(109, xla);
04855: }
04856: }
04857:
04858: final private boolean jj_2_111(int xla) {
04859: jj_la = xla;
04860: jj_lastpos = jj_scanpos = token;
04861: try {
04862: return !jj_3_111();
04863: } catch (LookaheadSuccess ls) {
04864: return true;
04865: } finally {
04866: jj_save(110, xla);
04867: }
04868: }
04869:
04870: final private boolean jj_2_112(int xla) {
04871: jj_la = xla;
04872: jj_lastpos = jj_scanpos = token;
04873: try {
04874: return !jj_3_112();
04875: } catch (LookaheadSuccess ls) {
04876: return true;
04877: } finally {
04878: jj_save(111, xla);
04879: }
04880: }
04881:
04882: final private boolean jj_2_113(int xla) {
04883: jj_la = xla;
04884: jj_lastpos = jj_scanpos = token;
04885: try {
04886: return !jj_3_113();
04887: } catch (LookaheadSuccess ls) {
04888: return true;
04889: } finally {
04890: jj_save(112, xla);
04891: }
04892: }
04893:
04894: final private boolean jj_2_114(int xla) {
04895: jj_la = xla;
04896: jj_lastpos = jj_scanpos = token;
04897: try {
04898: return !jj_3_114();
04899: } catch (LookaheadSuccess ls) {
04900: return true;
04901: } finally {
04902: jj_save(113, xla);
04903: }
04904: }
04905:
04906: final private boolean jj_2_115(int xla) {
04907: jj_la = xla;
04908: jj_lastpos = jj_scanpos = token;
04909: try {
04910: return !jj_3_115();
04911: } catch (LookaheadSuccess ls) {
04912: return true;
04913: } finally {
04914: jj_save(114, xla);
04915: }
04916: }
04917:
04918: final private boolean jj_2_116(int xla) {
04919: jj_la = xla;
04920: jj_lastpos = jj_scanpos = token;
04921: try {
04922: return !jj_3_116();
04923: } catch (LookaheadSuccess ls) {
04924: return true;
04925: } finally {
04926: jj_save(115, xla);
04927: }
04928: }
04929:
04930: final private boolean jj_2_117(int xla) {
04931: jj_la = xla;
04932: jj_lastpos = jj_scanpos = token;
04933: try {
04934: return !jj_3_117();
04935: } catch (LookaheadSuccess ls) {
04936: return true;
04937: } finally {
04938: jj_save(116, xla);
04939: }
04940: }
04941:
04942: final private boolean jj_2_118(int xla) {
04943: jj_la = xla;
04944: jj_lastpos = jj_scanpos = token;
04945: try {
04946: return !jj_3_118();
04947: } catch (LookaheadSuccess ls) {
04948: return true;
04949: } finally {
04950: jj_save(117, xla);
04951: }
04952: }
04953:
04954: final private boolean jj_2_119(int xla) {
04955: jj_la = xla;
04956: jj_lastpos = jj_scanpos = token;
04957: try {
04958: return !jj_3_119();
04959: } catch (LookaheadSuccess ls) {
04960: return true;
04961: } finally {
04962: jj_save(118, xla);
04963: }
04964: }
04965:
04966: final private boolean jj_2_120(int xla) {
04967: jj_la = xla;
04968: jj_lastpos = jj_scanpos = token;
04969: try {
04970: return !jj_3_120();
04971: } catch (LookaheadSuccess ls) {
04972: return true;
04973: } finally {
04974: jj_save(119, xla);
04975: }
04976: }
04977:
04978: final private boolean jj_2_121(int xla) {
04979: jj_la = xla;
04980: jj_lastpos = jj_scanpos = token;
04981: try {
04982: return !jj_3_121();
04983: } catch (LookaheadSuccess ls) {
04984: return true;
04985: } finally {
04986: jj_save(120, xla);
04987: }
04988: }
04989:
04990: final private boolean jj_2_122(int xla) {
04991: jj_la = xla;
04992: jj_lastpos = jj_scanpos = token;
04993: try {
04994: return !jj_3_122();
04995: } catch (LookaheadSuccess ls) {
04996: return true;
04997: } finally {
04998: jj_save(121, xla);
04999: }
05000: }
05001:
05002: final private boolean jj_2_123(int xla) {
05003: jj_la = xla;
05004: jj_lastpos = jj_scanpos = token;
05005: try {
05006: return !jj_3_123();
05007: } catch (LookaheadSuccess ls) {
05008: return true;
05009: } finally {
05010: jj_save(122, xla);
05011: }
05012: }
05013:
05014: final private boolean jj_2_124(int xla) {
05015: jj_la = xla;
05016: jj_lastpos = jj_scanpos = token;
05017: try {
05018: return !jj_3_124();
05019: } catch (LookaheadSuccess ls) {
05020: return true;
05021: } finally {
05022: jj_save(123, xla);
05023: }
05024: }
05025:
05026: final private boolean jj_2_125(int xla) {
05027: jj_la = xla;
05028: jj_lastpos = jj_scanpos = token;
05029: try {
05030: return !jj_3_125();
05031: } catch (LookaheadSuccess ls) {
05032: return true;
05033: } finally {
05034: jj_save(124, xla);
05035: }
05036: }
05037:
05038: final private boolean jj_2_126(int xla) {
05039: jj_la = xla;
05040: jj_lastpos = jj_scanpos = token;
05041: try {
05042: return !jj_3_126();
05043: } catch (LookaheadSuccess ls) {
05044: return true;
05045: } finally {
05046: jj_save(125, xla);
05047: }
05048: }
05049:
05050: final private boolean jj_2_127(int xla) {
05051: jj_la = xla;
05052: jj_lastpos = jj_scanpos = token;
05053: try {
05054: return !jj_3_127();
05055: } catch (LookaheadSuccess ls) {
05056: return true;
05057: } finally {
05058: jj_save(126, xla);
05059: }
05060: }
05061:
05062: final private boolean jj_2_128(int xla) {
05063: jj_la = xla;
05064: jj_lastpos = jj_scanpos = token;
05065: try {
05066: return !jj_3_128();
05067: } catch (LookaheadSuccess ls) {
05068: return true;
05069: } finally {
05070: jj_save(127, xla);
05071: }
05072: }
05073:
05074: final private boolean jj_2_129(int xla) {
05075: jj_la = xla;
05076: jj_lastpos = jj_scanpos = token;
05077: try {
05078: return !jj_3_129();
05079: } catch (LookaheadSuccess ls) {
05080: return true;
05081: } finally {
05082: jj_save(128, xla);
05083: }
05084: }
05085:
05086: final private boolean jj_2_130(int xla) {
05087: jj_la = xla;
05088: jj_lastpos = jj_scanpos = token;
05089: try {
05090: return !jj_3_130();
05091: } catch (LookaheadSuccess ls) {
05092: return true;
05093: } finally {
05094: jj_save(129, xla);
05095: }
05096: }
05097:
05098: final private boolean jj_2_131(int xla) {
05099: jj_la = xla;
05100: jj_lastpos = jj_scanpos = token;
05101: try {
05102: return !jj_3_131();
05103: } catch (LookaheadSuccess ls) {
05104: return true;
05105: } finally {
05106: jj_save(130, xla);
05107: }
05108: }
05109:
05110: final private boolean jj_2_132(int xla) {
05111: jj_la = xla;
05112: jj_lastpos = jj_scanpos = token;
05113: try {
05114: return !jj_3_132();
05115: } catch (LookaheadSuccess ls) {
05116: return true;
05117: } finally {
05118: jj_save(131, xla);
05119: }
05120: }
05121:
05122: final private boolean jj_2_133(int xla) {
05123: jj_la = xla;
05124: jj_lastpos = jj_scanpos = token;
05125: try {
05126: return !jj_3_133();
05127: } catch (LookaheadSuccess ls) {
05128: return true;
05129: } finally {
05130: jj_save(132, xla);
05131: }
05132: }
05133:
05134: final private boolean jj_2_134(int xla) {
05135: jj_la = xla;
05136: jj_lastpos = jj_scanpos = token;
05137: try {
05138: return !jj_3_134();
05139: } catch (LookaheadSuccess ls) {
05140: return true;
05141: } finally {
05142: jj_save(133, xla);
05143: }
05144: }
05145:
05146: final private boolean jj_2_135(int xla) {
05147: jj_la = xla;
05148: jj_lastpos = jj_scanpos = token;
05149: try {
05150: return !jj_3_135();
05151: } catch (LookaheadSuccess ls) {
05152: return true;
05153: } finally {
05154: jj_save(134, xla);
05155: }
05156: }
05157:
05158: final private boolean jj_2_136(int xla) {
05159: jj_la = xla;
05160: jj_lastpos = jj_scanpos = token;
05161: try {
05162: return !jj_3_136();
05163: } catch (LookaheadSuccess ls) {
05164: return true;
05165: } finally {
05166: jj_save(135, xla);
05167: }
05168: }
05169:
05170: final private boolean jj_2_137(int xla) {
05171: jj_la = xla;
05172: jj_lastpos = jj_scanpos = token;
05173: try {
05174: return !jj_3_137();
05175: } catch (LookaheadSuccess ls) {
05176: return true;
05177: } finally {
05178: jj_save(136, xla);
05179: }
05180: }
05181:
05182: final private boolean jj_2_138(int xla) {
05183: jj_la = xla;
05184: jj_lastpos = jj_scanpos = token;
05185: try {
05186: return !jj_3_138();
05187: } catch (LookaheadSuccess ls) {
05188: return true;
05189: } finally {
05190: jj_save(137, xla);
05191: }
05192: }
05193:
05194: final private boolean jj_2_139(int xla) {
05195: jj_la = xla;
05196: jj_lastpos = jj_scanpos = token;
05197: try {
05198: return !jj_3_139();
05199: } catch (LookaheadSuccess ls) {
05200: return true;
05201: } finally {
05202: jj_save(138, xla);
05203: }
05204: }
05205:
05206: final private boolean jj_2_140(int xla) {
05207: jj_la = xla;
05208: jj_lastpos = jj_scanpos = token;
05209: try {
05210: return !jj_3_140();
05211: } catch (LookaheadSuccess ls) {
05212: return true;
05213: } finally {
05214: jj_save(139, xla);
05215: }
05216: }
05217:
05218: final private boolean jj_2_141(int xla) {
05219: jj_la = xla;
05220: jj_lastpos = jj_scanpos = token;
05221: try {
05222: return !jj_3_141();
05223: } catch (LookaheadSuccess ls) {
05224: return true;
05225: } finally {
05226: jj_save(140, xla);
05227: }
05228: }
05229:
05230: final private boolean jj_2_142(int xla) {
05231: jj_la = xla;
05232: jj_lastpos = jj_scanpos = token;
05233: try {
05234: return !jj_3_142();
05235: } catch (LookaheadSuccess ls) {
05236: return true;
05237: } finally {
05238: jj_save(141, xla);
05239: }
05240: }
05241:
05242: final private boolean jj_2_143(int xla) {
05243: jj_la = xla;
05244: jj_lastpos = jj_scanpos = token;
05245: try {
05246: return !jj_3_143();
05247: } catch (LookaheadSuccess ls) {
05248: return true;
05249: } finally {
05250: jj_save(142, xla);
05251: }
05252: }
05253:
05254: final private boolean jj_2_144(int xla) {
05255: jj_la = xla;
05256: jj_lastpos = jj_scanpos = token;
05257: try {
05258: return !jj_3_144();
05259: } catch (LookaheadSuccess ls) {
05260: return true;
05261: } finally {
05262: jj_save(143, xla);
05263: }
05264: }
05265:
05266: final private boolean jj_2_145(int xla) {
05267: jj_la = xla;
05268: jj_lastpos = jj_scanpos = token;
05269: try {
05270: return !jj_3_145();
05271: } catch (LookaheadSuccess ls) {
05272: return true;
05273: } finally {
05274: jj_save(144, xla);
05275: }
05276: }
05277:
05278: final private boolean jj_2_146(int xla) {
05279: jj_la = xla;
05280: jj_lastpos = jj_scanpos = token;
05281: try {
05282: return !jj_3_146();
05283: } catch (LookaheadSuccess ls) {
05284: return true;
05285: } finally {
05286: jj_save(145, xla);
05287: }
05288: }
05289:
05290: final private boolean jj_2_147(int xla) {
05291: jj_la = xla;
05292: jj_lastpos = jj_scanpos = token;
05293: try {
05294: return !jj_3_147();
05295: } catch (LookaheadSuccess ls) {
05296: return true;
05297: } finally {
05298: jj_save(146, xla);
05299: }
05300: }
05301:
05302: final private boolean jj_2_148(int xla) {
05303: jj_la = xla;
05304: jj_lastpos = jj_scanpos = token;
05305: try {
05306: return !jj_3_148();
05307: } catch (LookaheadSuccess ls) {
05308: return true;
05309: } finally {
05310: jj_save(147, xla);
05311: }
05312: }
05313:
05314: final private boolean jj_2_149(int xla) {
05315: jj_la = xla;
05316: jj_lastpos = jj_scanpos = token;
05317: try {
05318: return !jj_3_149();
05319: } catch (LookaheadSuccess ls) {
05320: return true;
05321: } finally {
05322: jj_save(148, xla);
05323: }
05324: }
05325:
05326: final private boolean jj_2_150(int xla) {
05327: jj_la = xla;
05328: jj_lastpos = jj_scanpos = token;
05329: try {
05330: return !jj_3_150();
05331: } catch (LookaheadSuccess ls) {
05332: return true;
05333: } finally {
05334: jj_save(149, xla);
05335: }
05336: }
05337:
05338: final private boolean jj_2_151(int xla) {
05339: jj_la = xla;
05340: jj_lastpos = jj_scanpos = token;
05341: try {
05342: return !jj_3_151();
05343: } catch (LookaheadSuccess ls) {
05344: return true;
05345: } finally {
05346: jj_save(150, xla);
05347: }
05348: }
05349:
05350: final private boolean jj_2_152(int xla) {
05351: jj_la = xla;
05352: jj_lastpos = jj_scanpos = token;
05353: try {
05354: return !jj_3_152();
05355: } catch (LookaheadSuccess ls) {
05356: return true;
05357: } finally {
05358: jj_save(151, xla);
05359: }
05360: }
05361:
05362: final private boolean jj_2_153(int xla) {
05363: jj_la = xla;
05364: jj_lastpos = jj_scanpos = token;
05365: try {
05366: return !jj_3_153();
05367: } catch (LookaheadSuccess ls) {
05368: return true;
05369: } finally {
05370: jj_save(152, xla);
05371: }
05372: }
05373:
05374: final private boolean jj_2_154(int xla) {
05375: jj_la = xla;
05376: jj_lastpos = jj_scanpos = token;
05377: try {
05378: return !jj_3_154();
05379: } catch (LookaheadSuccess ls) {
05380: return true;
05381: } finally {
05382: jj_save(153, xla);
05383: }
05384: }
05385:
05386: final private boolean jj_2_155(int xla) {
05387: jj_la = xla;
05388: jj_lastpos = jj_scanpos = token;
05389: try {
05390: return !jj_3_155();
05391: } catch (LookaheadSuccess ls) {
05392: return true;
05393: } finally {
05394: jj_save(154, xla);
05395: }
05396: }
05397:
05398: final private boolean jj_2_156(int xla) {
05399: jj_la = xla;
05400: jj_lastpos = jj_scanpos = token;
05401: try {
05402: return !jj_3_156();
05403: } catch (LookaheadSuccess ls) {
05404: return true;
05405: } finally {
05406: jj_save(155, xla);
05407: }
05408: }
05409:
05410: final private boolean jj_2_157(int xla) {
05411: jj_la = xla;
05412: jj_lastpos = jj_scanpos = token;
05413: try {
05414: return !jj_3_157();
05415: } catch (LookaheadSuccess ls) {
05416: return true;
05417: } finally {
05418: jj_save(156, xla);
05419: }
05420: }
05421:
05422: final private boolean jj_2_158(int xla) {
05423: jj_la = xla;
05424: jj_lastpos = jj_scanpos = token;
05425: try {
05426: return !jj_3_158();
05427: } catch (LookaheadSuccess ls) {
05428: return true;
05429: } finally {
05430: jj_save(157, xla);
05431: }
05432: }
05433:
05434: final private boolean jj_2_159(int xla) {
05435: jj_la = xla;
05436: jj_lastpos = jj_scanpos = token;
05437: try {
05438: return !jj_3_159();
05439: } catch (LookaheadSuccess ls) {
05440: return true;
05441: } finally {
05442: jj_save(158, xla);
05443: }
05444: }
05445:
05446: final private boolean jj_2_160(int xla) {
05447: jj_la = xla;
05448: jj_lastpos = jj_scanpos = token;
05449: try {
05450: return !jj_3_160();
05451: } catch (LookaheadSuccess ls) {
05452: return true;
05453: } finally {
05454: jj_save(159, xla);
05455: }
05456: }
05457:
05458: final private boolean jj_2_161(int xla) {
05459: jj_la = xla;
05460: jj_lastpos = jj_scanpos = token;
05461: try {
05462: return !jj_3_161();
05463: } catch (LookaheadSuccess ls) {
05464: return true;
05465: } finally {
05466: jj_save(160, xla);
05467: }
05468: }
05469:
05470: final private boolean jj_2_162(int xla) {
05471: jj_la = xla;
05472: jj_lastpos = jj_scanpos = token;
05473: try {
05474: return !jj_3_162();
05475: } catch (LookaheadSuccess ls) {
05476: return true;
05477: } finally {
05478: jj_save(161, xla);
05479: }
05480: }
05481:
05482: final private boolean jj_2_163(int xla) {
05483: jj_la = xla;
05484: jj_lastpos = jj_scanpos = token;
05485: try {
05486: return !jj_3_163();
05487: } catch (LookaheadSuccess ls) {
05488: return true;
05489: } finally {
05490: jj_save(162, xla);
05491: }
05492: }
05493:
05494: final private boolean jj_2_164(int xla) {
05495: jj_la = xla;
05496: jj_lastpos = jj_scanpos = token;
05497: try {
05498: return !jj_3_164();
05499: } catch (LookaheadSuccess ls) {
05500: return true;
05501: } finally {
05502: jj_save(163, xla);
05503: }
05504: }
05505:
05506: final private boolean jj_2_165(int xla) {
05507: jj_la = xla;
05508: jj_lastpos = jj_scanpos = token;
05509: try {
05510: return !jj_3_165();
05511: } catch (LookaheadSuccess ls) {
05512: return true;
05513: } finally {
05514: jj_save(164, xla);
05515: }
05516: }
05517:
05518: final private boolean jj_2_166(int xla) {
05519: jj_la = xla;
05520: jj_lastpos = jj_scanpos = token;
05521: try {
05522: return !jj_3_166();
05523: } catch (LookaheadSuccess ls) {
05524: return true;
05525: } finally {
05526: jj_save(165, xla);
05527: }
05528: }
05529:
05530: final private boolean jj_2_167(int xla) {
05531: jj_la = xla;
05532: jj_lastpos = jj_scanpos = token;
05533: try {
05534: return !jj_3_167();
05535: } catch (LookaheadSuccess ls) {
05536: return true;
05537: } finally {
05538: jj_save(166, xla);
05539: }
05540: }
05541:
05542: final private boolean jj_2_168(int xla) {
05543: jj_la = xla;
05544: jj_lastpos = jj_scanpos = token;
05545: try {
05546: return !jj_3_168();
05547: } catch (LookaheadSuccess ls) {
05548: return true;
05549: } finally {
05550: jj_save(167, xla);
05551: }
05552: }
05553:
05554: final private boolean jj_2_169(int xla) {
05555: jj_la = xla;
05556: jj_lastpos = jj_scanpos = token;
05557: try {
05558: return !jj_3_169();
05559: } catch (LookaheadSuccess ls) {
05560: return true;
05561: } finally {
05562: jj_save(168, xla);
05563: }
05564: }
05565:
05566: final private boolean jj_2_170(int xla) {
05567: jj_la = xla;
05568: jj_lastpos = jj_scanpos = token;
05569: try {
05570: return !jj_3_170();
05571: } catch (LookaheadSuccess ls) {
05572: return true;
05573: } finally {
05574: jj_save(169, xla);
05575: }
05576: }
05577:
05578: final private boolean jj_2_171(int xla) {
05579: jj_la = xla;
05580: jj_lastpos = jj_scanpos = token;
05581: try {
05582: return !jj_3_171();
05583: } catch (LookaheadSuccess ls) {
05584: return true;
05585: } finally {
05586: jj_save(170, xla);
05587: }
05588: }
05589:
05590: final private boolean jj_2_172(int xla) {
05591: jj_la = xla;
05592: jj_lastpos = jj_scanpos = token;
05593: try {
05594: return !jj_3_172();
05595: } catch (LookaheadSuccess ls) {
05596: return true;
05597: } finally {
05598: jj_save(171, xla);
05599: }
05600: }
05601:
05602: final private boolean jj_2_173(int xla) {
05603: jj_la = xla;
05604: jj_lastpos = jj_scanpos = token;
05605: try {
05606: return !jj_3_173();
05607: } catch (LookaheadSuccess ls) {
05608: return true;
05609: } finally {
05610: jj_save(172, xla);
05611: }
05612: }
05613:
05614: final private boolean jj_2_174(int xla) {
05615: jj_la = xla;
05616: jj_lastpos = jj_scanpos = token;
05617: try {
05618: return !jj_3_174();
05619: } catch (LookaheadSuccess ls) {
05620: return true;
05621: } finally {
05622: jj_save(173, xla);
05623: }
05624: }
05625:
05626: final private boolean jj_2_175(int xla) {
05627: jj_la = xla;
05628: jj_lastpos = jj_scanpos = token;
05629: try {
05630: return !jj_3_175();
05631: } catch (LookaheadSuccess ls) {
05632: return true;
05633: } finally {
05634: jj_save(174, xla);
05635: }
05636: }
05637:
05638: final private boolean jj_2_176(int xla) {
05639: jj_la = xla;
05640: jj_lastpos = jj_scanpos = token;
05641: try {
05642: return !jj_3_176();
05643: } catch (LookaheadSuccess ls) {
05644: return true;
05645: } finally {
05646: jj_save(175, xla);
05647: }
05648: }
05649:
05650: final private boolean jj_2_177(int xla) {
05651: jj_la = xla;
05652: jj_lastpos = jj_scanpos = token;
05653: try {
05654: return !jj_3_177();
05655: } catch (LookaheadSuccess ls) {
05656: return true;
05657: } finally {
05658: jj_save(176, xla);
05659: }
05660: }
05661:
05662: final private boolean jj_2_178(int xla) {
05663: jj_la = xla;
05664: jj_lastpos = jj_scanpos = token;
05665: try {
05666: return !jj_3_178();
05667: } catch (LookaheadSuccess ls) {
05668: return true;
05669: } finally {
05670: jj_save(177, xla);
05671: }
05672: }
05673:
05674: final private boolean jj_2_179(int xla) {
05675: jj_la = xla;
05676: jj_lastpos = jj_scanpos = token;
05677: try {
05678: return !jj_3_179();
05679: } catch (LookaheadSuccess ls) {
05680: return true;
05681: } finally {
05682: jj_save(178, xla);
05683: }
05684: }
05685:
05686: final private boolean jj_2_180(int xla) {
05687: jj_la = xla;
05688: jj_lastpos = jj_scanpos = token;
05689: try {
05690: return !jj_3_180();
05691: } catch (LookaheadSuccess ls) {
05692: return true;
05693: } finally {
05694: jj_save(179, xla);
05695: }
05696: }
05697:
05698: final private boolean jj_2_181(int xla) {
05699: jj_la = xla;
05700: jj_lastpos = jj_scanpos = token;
05701: try {
05702: return !jj_3_181();
05703: } catch (LookaheadSuccess ls) {
05704: return true;
05705: } finally {
05706: jj_save(180, xla);
05707: }
05708: }
05709:
05710: final private boolean jj_2_182(int xla) {
05711: jj_la = xla;
05712: jj_lastpos = jj_scanpos = token;
05713: try {
05714: return !jj_3_182();
05715: } catch (LookaheadSuccess ls) {
05716: return true;
05717: } finally {
05718: jj_save(181, xla);
05719: }
05720: }
05721:
05722: final private boolean jj_2_183(int xla) {
05723: jj_la = xla;
05724: jj_lastpos = jj_scanpos = token;
05725: try {
05726: return !jj_3_183();
05727: } catch (LookaheadSuccess ls) {
05728: return true;
05729: } finally {
05730: jj_save(182, xla);
05731: }
05732: }
05733:
05734: final private boolean jj_2_184(int xla) {
05735: jj_la = xla;
05736: jj_lastpos = jj_scanpos = token;
05737: try {
05738: return !jj_3_184();
05739: } catch (LookaheadSuccess ls) {
05740: return true;
05741: } finally {
05742: jj_save(183, xla);
05743: }
05744: }
05745:
05746: final private boolean jj_2_185(int xla) {
05747: jj_la = xla;
05748: jj_lastpos = jj_scanpos = token;
05749: try {
05750: return !jj_3_185();
05751: } catch (LookaheadSuccess ls) {
05752: return true;
05753: } finally {
05754: jj_save(184, xla);
05755: }
05756: }
05757:
05758: final private boolean jj_2_186(int xla) {
05759: jj_la = xla;
05760: jj_lastpos = jj_scanpos = token;
05761: try {
05762: return !jj_3_186();
05763: } catch (LookaheadSuccess ls) {
05764: return true;
05765: } finally {
05766: jj_save(185, xla);
05767: }
05768: }
05769:
05770: final private boolean jj_2_187(int xla) {
05771: jj_la = xla;
05772: jj_lastpos = jj_scanpos = token;
05773: try {
05774: return !jj_3_187();
05775: } catch (LookaheadSuccess ls) {
05776: return true;
05777: } finally {
05778: jj_save(186, xla);
05779: }
05780: }
05781:
05782: final private boolean jj_2_188(int xla) {
05783: jj_la = xla;
05784: jj_lastpos = jj_scanpos = token;
05785: try {
05786: return !jj_3_188();
05787: } catch (LookaheadSuccess ls) {
05788: return true;
05789: } finally {
05790: jj_save(187, xla);
05791: }
05792: }
05793:
05794: final private boolean jj_2_189(int xla) {
05795: jj_la = xla;
05796: jj_lastpos = jj_scanpos = token;
05797: try {
05798: return !jj_3_189();
05799: } catch (LookaheadSuccess ls) {
05800: return true;
05801: } finally {
05802: jj_save(188, xla);
05803: }
05804: }
05805:
05806: final private boolean jj_2_190(int xla) {
05807: jj_la = xla;
05808: jj_lastpos = jj_scanpos = token;
05809: try {
05810: return !jj_3_190();
05811: } catch (LookaheadSuccess ls) {
05812: return true;
05813: } finally {
05814: jj_save(189, xla);
05815: }
05816: }
05817:
05818: final private boolean jj_2_191(int xla) {
05819: jj_la = xla;
05820: jj_lastpos = jj_scanpos = token;
05821: try {
05822: return !jj_3_191();
05823: } catch (LookaheadSuccess ls) {
05824: return true;
05825: } finally {
05826: jj_save(190, xla);
05827: }
05828: }
05829:
05830: final private boolean jj_2_192(int xla) {
05831: jj_la = xla;
05832: jj_lastpos = jj_scanpos = token;
05833: try {
05834: return !jj_3_192();
05835: } catch (LookaheadSuccess ls) {
05836: return true;
05837: } finally {
05838: jj_save(191, xla);
05839: }
05840: }
05841:
05842: final private boolean jj_2_193(int xla) {
05843: jj_la = xla;
05844: jj_lastpos = jj_scanpos = token;
05845: try {
05846: return !jj_3_193();
05847: } catch (LookaheadSuccess ls) {
05848: return true;
05849: } finally {
05850: jj_save(192, xla);
05851: }
05852: }
05853:
05854: final private boolean jj_2_194(int xla) {
05855: jj_la = xla;
05856: jj_lastpos = jj_scanpos = token;
05857: try {
05858: return !jj_3_194();
05859: } catch (LookaheadSuccess ls) {
05860: return true;
05861: } finally {
05862: jj_save(193, xla);
05863: }
05864: }
05865:
05866: final private boolean jj_2_195(int xla) {
05867: jj_la = xla;
05868: jj_lastpos = jj_scanpos = token;
05869: try {
05870: return !jj_3_195();
05871: } catch (LookaheadSuccess ls) {
05872: return true;
05873: } finally {
05874: jj_save(194, xla);
05875: }
05876: }
05877:
05878: final private boolean jj_2_196(int xla) {
05879: jj_la = xla;
05880: jj_lastpos = jj_scanpos = token;
05881: try {
05882: return !jj_3_196();
05883: } catch (LookaheadSuccess ls) {
05884: return true;
05885: } finally {
05886: jj_save(195, xla);
05887: }
05888: }
05889:
05890: final private boolean jj_2_197(int xla) {
05891: jj_la = xla;
05892: jj_lastpos = jj_scanpos = token;
05893: try {
05894: return !jj_3_197();
05895: } catch (LookaheadSuccess ls) {
05896: return true;
05897: } finally {
05898: jj_save(196, xla);
05899: }
05900: }
05901:
05902: final private boolean jj_2_198(int xla) {
05903: jj_la = xla;
05904: jj_lastpos = jj_scanpos = token;
05905: try {
05906: return !jj_3_198();
05907: } catch (LookaheadSuccess ls) {
05908: return true;
05909: } finally {
05910: jj_save(197, xla);
05911: }
05912: }
05913:
05914: final private boolean jj_2_199(int xla) {
05915: jj_la = xla;
05916: jj_lastpos = jj_scanpos = token;
05917: try {
05918: return !jj_3_199();
05919: } catch (LookaheadSuccess ls) {
05920: return true;
05921: } finally {
05922: jj_save(198, xla);
05923: }
05924: }
05925:
05926: final private boolean jj_2_200(int xla) {
05927: jj_la = xla;
05928: jj_lastpos = jj_scanpos = token;
05929: try {
05930: return !jj_3_200();
05931: } catch (LookaheadSuccess ls) {
05932: return true;
05933: } finally {
05934: jj_save(199, xla);
05935: }
05936: }
05937:
05938: final private boolean jj_2_201(int xla) {
05939: jj_la = xla;
05940: jj_lastpos = jj_scanpos = token;
05941: try {
05942: return !jj_3_201();
05943: } catch (LookaheadSuccess ls) {
05944: return true;
05945: } finally {
05946: jj_save(200, xla);
05947: }
05948: }
05949:
05950: final private boolean jj_2_202(int xla) {
05951: jj_la = xla;
05952: jj_lastpos = jj_scanpos = token;
05953: try {
05954: return !jj_3_202();
05955: } catch (LookaheadSuccess ls) {
05956: return true;
05957: } finally {
05958: jj_save(201, xla);
05959: }
05960: }
05961:
05962: final private boolean jj_2_203(int xla) {
05963: jj_la = xla;
05964: jj_lastpos = jj_scanpos = token;
05965: try {
05966: return !jj_3_203();
05967: } catch (LookaheadSuccess ls) {
05968: return true;
05969: } finally {
05970: jj_save(202, xla);
05971: }
05972: }
05973:
05974: final private boolean jj_2_204(int xla) {
05975: jj_la = xla;
05976: jj_lastpos = jj_scanpos = token;
05977: try {
05978: return !jj_3_204();
05979: } catch (LookaheadSuccess ls) {
05980: return true;
05981: } finally {
05982: jj_save(203, xla);
05983: }
05984: }
05985:
05986: final private boolean jj_2_205(int xla) {
05987: jj_la = xla;
05988: jj_lastpos = jj_scanpos = token;
05989: try {
05990: return !jj_3_205();
05991: } catch (LookaheadSuccess ls) {
05992: return true;
05993: } finally {
05994: jj_save(204, xla);
05995: }
05996: }
05997:
05998: final private boolean jj_2_206(int xla) {
05999: jj_la = xla;
06000: jj_lastpos = jj_scanpos = token;
06001: try {
06002: return !jj_3_206();
06003: } catch (LookaheadSuccess ls) {
06004: return true;
06005: } finally {
06006: jj_save(205, xla);
06007: }
06008: }
06009:
06010: final private boolean jj_2_207(int xla) {
06011: jj_la = xla;
06012: jj_lastpos = jj_scanpos = token;
06013: try {
06014: return !jj_3_207();
06015: } catch (LookaheadSuccess ls) {
06016: return true;
06017: } finally {
06018: jj_save(206, xla);
06019: }
06020: }
06021:
06022: final private boolean jj_2_208(int xla) {
06023: jj_la = xla;
06024: jj_lastpos = jj_scanpos = token;
06025: try {
06026: return !jj_3_208();
06027: } catch (LookaheadSuccess ls) {
06028: return true;
06029: } finally {
06030: jj_save(207, xla);
06031: }
06032: }
06033:
06034: final private boolean jj_2_209(int xla) {
06035: jj_la = xla;
06036: jj_lastpos = jj_scanpos = token;
06037: try {
06038: return !jj_3_209();
06039: } catch (LookaheadSuccess ls) {
06040: return true;
06041: } finally {
06042: jj_save(208, xla);
06043: }
06044: }
06045:
06046: final private boolean jj_2_210(int xla) {
06047: jj_la = xla;
06048: jj_lastpos = jj_scanpos = token;
06049: try {
06050: return !jj_3_210();
06051: } catch (LookaheadSuccess ls) {
06052: return true;
06053: } finally {
06054: jj_save(209, xla);
06055: }
06056: }
06057:
06058: final private boolean jj_2_211(int xla) {
06059: jj_la = xla;
06060: jj_lastpos = jj_scanpos = token;
06061: try {
06062: return !jj_3_211();
06063: } catch (LookaheadSuccess ls) {
06064: return true;
06065: } finally {
06066: jj_save(210, xla);
06067: }
06068: }
06069:
06070: final private boolean jj_2_212(int xla) {
06071: jj_la = xla;
06072: jj_lastpos = jj_scanpos = token;
06073: try {
06074: return !jj_3_212();
06075: } catch (LookaheadSuccess ls) {
06076: return true;
06077: } finally {
06078: jj_save(211, xla);
06079: }
06080: }
06081:
06082: final private boolean jj_2_213(int xla) {
06083: jj_la = xla;
06084: jj_lastpos = jj_scanpos = token;
06085: try {
06086: return !jj_3_213();
06087: } catch (LookaheadSuccess ls) {
06088: return true;
06089: } finally {
06090: jj_save(212, xla);
06091: }
06092: }
06093:
06094: final private boolean jj_2_214(int xla) {
06095: jj_la = xla;
06096: jj_lastpos = jj_scanpos = token;
06097: try {
06098: return !jj_3_214();
06099: } catch (LookaheadSuccess ls) {
06100: return true;
06101: } finally {
06102: jj_save(213, xla);
06103: }
06104: }
06105:
06106: final private boolean jj_2_215(int xla) {
06107: jj_la = xla;
06108: jj_lastpos = jj_scanpos = token;
06109: try {
06110: return !jj_3_215();
06111: } catch (LookaheadSuccess ls) {
06112: return true;
06113: } finally {
06114: jj_save(214, xla);
06115: }
06116: }
06117:
06118: final private boolean jj_2_216(int xla) {
06119: jj_la = xla;
06120: jj_lastpos = jj_scanpos = token;
06121: try {
06122: return !jj_3_216();
06123: } catch (LookaheadSuccess ls) {
06124: return true;
06125: } finally {
06126: jj_save(215, xla);
06127: }
06128: }
06129:
06130: final private boolean jj_2_217(int xla) {
06131: jj_la = xla;
06132: jj_lastpos = jj_scanpos = token;
06133: try {
06134: return !jj_3_217();
06135: } catch (LookaheadSuccess ls) {
06136: return true;
06137: } finally {
06138: jj_save(216, xla);
06139: }
06140: }
06141:
06142: final private boolean jj_2_218(int xla) {
06143: jj_la = xla;
06144: jj_lastpos = jj_scanpos = token;
06145: try {
06146: return !jj_3_218();
06147: } catch (LookaheadSuccess ls) {
06148: return true;
06149: } finally {
06150: jj_save(217, xla);
06151: }
06152: }
06153:
06154: final private boolean jj_2_219(int xla) {
06155: jj_la = xla;
06156: jj_lastpos = jj_scanpos = token;
06157: try {
06158: return !jj_3_219();
06159: } catch (LookaheadSuccess ls) {
06160: return true;
06161: } finally {
06162: jj_save(218, xla);
06163: }
06164: }
06165:
06166: final private boolean jj_2_220(int xla) {
06167: jj_la = xla;
06168: jj_lastpos = jj_scanpos = token;
06169: try {
06170: return !jj_3_220();
06171: } catch (LookaheadSuccess ls) {
06172: return true;
06173: } finally {
06174: jj_save(219, xla);
06175: }
06176: }
06177:
06178: final private boolean jj_2_221(int xla) {
06179: jj_la = xla;
06180: jj_lastpos = jj_scanpos = token;
06181: try {
06182: return !jj_3_221();
06183: } catch (LookaheadSuccess ls) {
06184: return true;
06185: } finally {
06186: jj_save(220, xla);
06187: }
06188: }
06189:
06190: final private boolean jj_2_222(int xla) {
06191: jj_la = xla;
06192: jj_lastpos = jj_scanpos = token;
06193: try {
06194: return !jj_3_222();
06195: } catch (LookaheadSuccess ls) {
06196: return true;
06197: } finally {
06198: jj_save(221, xla);
06199: }
06200: }
06201:
06202: final private boolean jj_2_223(int xla) {
06203: jj_la = xla;
06204: jj_lastpos = jj_scanpos = token;
06205: try {
06206: return !jj_3_223();
06207: } catch (LookaheadSuccess ls) {
06208: return true;
06209: } finally {
06210: jj_save(222, xla);
06211: }
06212: }
06213:
06214: final private boolean jj_2_224(int xla) {
06215: jj_la = xla;
06216: jj_lastpos = jj_scanpos = token;
06217: try {
06218: return !jj_3_224();
06219: } catch (LookaheadSuccess ls) {
06220: return true;
06221: } finally {
06222: jj_save(223, xla);
06223: }
06224: }
06225:
06226: final private boolean jj_2_225(int xla) {
06227: jj_la = xla;
06228: jj_lastpos = jj_scanpos = token;
06229: try {
06230: return !jj_3_225();
06231: } catch (LookaheadSuccess ls) {
06232: return true;
06233: } finally {
06234: jj_save(224, xla);
06235: }
06236: }
06237:
06238: final private boolean jj_2_226(int xla) {
06239: jj_la = xla;
06240: jj_lastpos = jj_scanpos = token;
06241: try {
06242: return !jj_3_226();
06243: } catch (LookaheadSuccess ls) {
06244: return true;
06245: } finally {
06246: jj_save(225, xla);
06247: }
06248: }
06249:
06250: final private boolean jj_2_227(int xla) {
06251: jj_la = xla;
06252: jj_lastpos = jj_scanpos = token;
06253: try {
06254: return !jj_3_227();
06255: } catch (LookaheadSuccess ls) {
06256: return true;
06257: } finally {
06258: jj_save(226, xla);
06259: }
06260: }
06261:
06262: final private boolean jj_2_228(int xla) {
06263: jj_la = xla;
06264: jj_lastpos = jj_scanpos = token;
06265: try {
06266: return !jj_3_228();
06267: } catch (LookaheadSuccess ls) {
06268: return true;
06269: } finally {
06270: jj_save(227, xla);
06271: }
06272: }
06273:
06274: final private boolean jj_2_229(int xla) {
06275: jj_la = xla;
06276: jj_lastpos = jj_scanpos = token;
06277: try {
06278: return !jj_3_229();
06279: } catch (LookaheadSuccess ls) {
06280: return true;
06281: } finally {
06282: jj_save(228, xla);
06283: }
06284: }
06285:
06286: final private boolean jj_2_230(int xla) {
06287: jj_la = xla;
06288: jj_lastpos = jj_scanpos = token;
06289: try {
06290: return !jj_3_230();
06291: } catch (LookaheadSuccess ls) {
06292: return true;
06293: } finally {
06294: jj_save(229, xla);
06295: }
06296: }
06297:
06298: final private boolean jj_2_231(int xla) {
06299: jj_la = xla;
06300: jj_lastpos = jj_scanpos = token;
06301: try {
06302: return !jj_3_231();
06303: } catch (LookaheadSuccess ls) {
06304: return true;
06305: } finally {
06306: jj_save(230, xla);
06307: }
06308: }
06309:
06310: final private boolean jj_2_232(int xla) {
06311: jj_la = xla;
06312: jj_lastpos = jj_scanpos = token;
06313: try {
06314: return !jj_3_232();
06315: } catch (LookaheadSuccess ls) {
06316: return true;
06317: } finally {
06318: jj_save(231, xla);
06319: }
06320: }
06321:
06322: final private boolean jj_2_233(int xla) {
06323: jj_la = xla;
06324: jj_lastpos = jj_scanpos = token;
06325: try {
06326: return !jj_3_233();
06327: } catch (LookaheadSuccess ls) {
06328: return true;
06329: } finally {
06330: jj_save(232, xla);
06331: }
06332: }
06333:
06334: final private boolean jj_2_234(int xla) {
06335: jj_la = xla;
06336: jj_lastpos = jj_scanpos = token;
06337: try {
06338: return !jj_3_234();
06339: } catch (LookaheadSuccess ls) {
06340: return true;
06341: } finally {
06342: jj_save(233, xla);
06343: }
06344: }
06345:
06346: final private boolean jj_2_235(int xla) {
06347: jj_la = xla;
06348: jj_lastpos = jj_scanpos = token;
06349: try {
06350: return !jj_3_235();
06351: } catch (LookaheadSuccess ls) {
06352: return true;
06353: } finally {
06354: jj_save(234, xla);
06355: }
06356: }
06357:
06358: final private boolean jj_2_236(int xla) {
06359: jj_la = xla;
06360: jj_lastpos = jj_scanpos = token;
06361: try {
06362: return !jj_3_236();
06363: } catch (LookaheadSuccess ls) {
06364: return true;
06365: } finally {
06366: jj_save(235, xla);
06367: }
06368: }
06369:
06370: final private boolean jj_2_237(int xla) {
06371: jj_la = xla;
06372: jj_lastpos = jj_scanpos = token;
06373: try {
06374: return !jj_3_237();
06375: } catch (LookaheadSuccess ls) {
06376: return true;
06377: } finally {
06378: jj_save(236, xla);
06379: }
06380: }
06381:
06382: final private boolean jj_2_238(int xla) {
06383: jj_la = xla;
06384: jj_lastpos = jj_scanpos = token;
06385: try {
06386: return !jj_3_238();
06387: } catch (LookaheadSuccess ls) {
06388: return true;
06389: } finally {
06390: jj_save(237, xla);
06391: }
06392: }
06393:
06394: final private boolean jj_2_239(int xla) {
06395: jj_la = xla;
06396: jj_lastpos = jj_scanpos = token;
06397: try {
06398: return !jj_3_239();
06399: } catch (LookaheadSuccess ls) {
06400: return true;
06401: } finally {
06402: jj_save(238, xla);
06403: }
06404: }
06405:
06406: final private boolean jj_2_240(int xla) {
06407: jj_la = xla;
06408: jj_lastpos = jj_scanpos = token;
06409: try {
06410: return !jj_3_240();
06411: } catch (LookaheadSuccess ls) {
06412: return true;
06413: } finally {
06414: jj_save(239, xla);
06415: }
06416: }
06417:
06418: final private boolean jj_2_241(int xla) {
06419: jj_la = xla;
06420: jj_lastpos = jj_scanpos = token;
06421: try {
06422: return !jj_3_241();
06423: } catch (LookaheadSuccess ls) {
06424: return true;
06425: } finally {
06426: jj_save(240, xla);
06427: }
06428: }
06429:
06430: final private boolean jj_2_242(int xla) {
06431: jj_la = xla;
06432: jj_lastpos = jj_scanpos = token;
06433: try {
06434: return !jj_3_242();
06435: } catch (LookaheadSuccess ls) {
06436: return true;
06437: } finally {
06438: jj_save(241, xla);
06439: }
06440: }
06441:
06442: final private boolean jj_2_243(int xla) {
06443: jj_la = xla;
06444: jj_lastpos = jj_scanpos = token;
06445: try {
06446: return !jj_3_243();
06447: } catch (LookaheadSuccess ls) {
06448: return true;
06449: } finally {
06450: jj_save(242, xla);
06451: }
06452: }
06453:
06454: final private boolean jj_2_244(int xla) {
06455: jj_la = xla;
06456: jj_lastpos = jj_scanpos = token;
06457: try {
06458: return !jj_3_244();
06459: } catch (LookaheadSuccess ls) {
06460: return true;
06461: } finally {
06462: jj_save(243, xla);
06463: }
06464: }
06465:
06466: final private boolean jj_2_245(int xla) {
06467: jj_la = xla;
06468: jj_lastpos = jj_scanpos = token;
06469: try {
06470: return !jj_3_245();
06471: } catch (LookaheadSuccess ls) {
06472: return true;
06473: } finally {
06474: jj_save(244, xla);
06475: }
06476: }
06477:
06478: final private boolean jj_2_246(int xla) {
06479: jj_la = xla;
06480: jj_lastpos = jj_scanpos = token;
06481: try {
06482: return !jj_3_246();
06483: } catch (LookaheadSuccess ls) {
06484: return true;
06485: } finally {
06486: jj_save(245, xla);
06487: }
06488: }
06489:
06490: final private boolean jj_2_247(int xla) {
06491: jj_la = xla;
06492: jj_lastpos = jj_scanpos = token;
06493: try {
06494: return !jj_3_247();
06495: } catch (LookaheadSuccess ls) {
06496: return true;
06497: } finally {
06498: jj_save(246, xla);
06499: }
06500: }
06501:
06502: final private boolean jj_2_248(int xla) {
06503: jj_la = xla;
06504: jj_lastpos = jj_scanpos = token;
06505: try {
06506: return !jj_3_248();
06507: } catch (LookaheadSuccess ls) {
06508: return true;
06509: } finally {
06510: jj_save(247, xla);
06511: }
06512: }
06513:
06514: final private boolean jj_2_249(int xla) {
06515: jj_la = xla;
06516: jj_lastpos = jj_scanpos = token;
06517: try {
06518: return !jj_3_249();
06519: } catch (LookaheadSuccess ls) {
06520: return true;
06521: } finally {
06522: jj_save(248, xla);
06523: }
06524: }
06525:
06526: final private boolean jj_2_250(int xla) {
06527: jj_la = xla;
06528: jj_lastpos = jj_scanpos = token;
06529: try {
06530: return !jj_3_250();
06531: } catch (LookaheadSuccess ls) {
06532: return true;
06533: } finally {
06534: jj_save(249, xla);
06535: }
06536: }
06537:
06538: final private boolean jj_2_251(int xla) {
06539: jj_la = xla;
06540: jj_lastpos = jj_scanpos = token;
06541: try {
06542: return !jj_3_251();
06543: } catch (LookaheadSuccess ls) {
06544: return true;
06545: } finally {
06546: jj_save(250, xla);
06547: }
06548: }
06549:
06550: final private boolean jj_2_252(int xla) {
06551: jj_la = xla;
06552: jj_lastpos = jj_scanpos = token;
06553: try {
06554: return !jj_3_252();
06555: } catch (LookaheadSuccess ls) {
06556: return true;
06557: } finally {
06558: jj_save(251, xla);
06559: }
06560: }
06561:
06562: final private boolean jj_2_253(int xla) {
06563: jj_la = xla;
06564: jj_lastpos = jj_scanpos = token;
06565: try {
06566: return !jj_3_253();
06567: } catch (LookaheadSuccess ls) {
06568: return true;
06569: } finally {
06570: jj_save(252, xla);
06571: }
06572: }
06573:
06574: final private boolean jj_2_254(int xla) {
06575: jj_la = xla;
06576: jj_lastpos = jj_scanpos = token;
06577: try {
06578: return !jj_3_254();
06579: } catch (LookaheadSuccess ls) {
06580: return true;
06581: } finally {
06582: jj_save(253, xla);
06583: }
06584: }
06585:
06586: final private boolean jj_2_255(int xla) {
06587: jj_la = xla;
06588: jj_lastpos = jj_scanpos = token;
06589: try {
06590: return !jj_3_255();
06591: } catch (LookaheadSuccess ls) {
06592: return true;
06593: } finally {
06594: jj_save(254, xla);
06595: }
06596: }
06597:
06598: final private boolean jj_2_256(int xla) {
06599: jj_la = xla;
06600: jj_lastpos = jj_scanpos = token;
06601: try {
06602: return !jj_3_256();
06603: } catch (LookaheadSuccess ls) {
06604: return true;
06605: } finally {
06606: jj_save(255, xla);
06607: }
06608: }
06609:
06610: final private boolean jj_3R_48() {
06611: if (jj_scan_token(XA_END))
06612: return true;
06613: if (jj_3R_75())
06614: return true;
06615: return false;
06616: }
06617:
06618: final private boolean jj_3_69() {
06619: if (jj_scan_token(STRING))
06620: return true;
06621: return false;
06622: }
06623:
06624: final private boolean jj_3_68() {
06625: if (jj_3R_60())
06626: return true;
06627: return false;
06628: }
06629:
06630: final private boolean jj_3_67() {
06631: if (jj_3R_60())
06632: return true;
06633: if (jj_scan_token(PERIOD))
06634: return true;
06635: return false;
06636: }
06637:
06638: final private boolean jj_3_129() {
06639: if (jj_scan_token(XA_1PHASE))
06640: return true;
06641: return false;
06642: }
06643:
06644: final private boolean jj_3R_14() {
06645: if (jj_scan_token(DESCRIBE))
06646: return true;
06647: Token xsp;
06648: xsp = jj_scanpos;
06649: if (jj_3_67()) {
06650: jj_scanpos = xsp;
06651: if (jj_3_68()) {
06652: jj_scanpos = xsp;
06653: if (jj_3_69())
06654: return true;
06655: }
06656: }
06657: return false;
06658: }
06659:
06660: final private boolean jj_3R_45() {
06661: if (jj_scan_token(XA_COMMIT))
06662: return true;
06663: Token xsp;
06664: xsp = jj_scanpos;
06665: if (jj_3_129()) {
06666: jj_scanpos = xsp;
06667: if (jj_3_130())
06668: return true;
06669: }
06670: return false;
06671: }
06672:
06673: final private boolean jj_3_128() {
06674: if (jj_3R_60())
06675: return true;
06676: return false;
06677: }
06678:
06679: final private boolean jj_3R_46() {
06680: if (jj_scan_token(XA_DISCONNECT))
06681: return true;
06682: Token xsp;
06683: xsp = jj_scanpos;
06684: if (jj_3_128())
06685: jj_scanpos = xsp;
06686: return false;
06687: }
06688:
06689: final private boolean jj_3_127() {
06690: if (jj_scan_token(AS))
06691: return true;
06692: if (jj_3R_60())
06693: return true;
06694: return false;
06695: }
06696:
06697: final private boolean jj_3_126() {
06698: if (jj_scan_token(PASSWORD))
06699: return true;
06700: if (jj_scan_token(STRING))
06701: return true;
06702: return false;
06703: }
06704:
06705: final private boolean jj_3_125() {
06706: if (jj_scan_token(USER))
06707: return true;
06708: if (jj_scan_token(STRING))
06709: return true;
06710: return false;
06711: }
06712:
06713: final private boolean jj_3_123() {
06714: if (jj_3R_60())
06715: return true;
06716: return false;
06717: }
06718:
06719: final private boolean jj_3_103() {
06720: if (jj_scan_token(STRING))
06721: return true;
06722: return false;
06723: }
06724:
06725: final private boolean jj_3R_44() {
06726: if (jj_scan_token(XA_CONNECT))
06727: return true;
06728: Token xsp;
06729: xsp = jj_scanpos;
06730: if (jj_3_125())
06731: jj_scanpos = xsp;
06732: xsp = jj_scanpos;
06733: if (jj_3_126())
06734: jj_scanpos = xsp;
06735: xsp = jj_scanpos;
06736: if (jj_3_127())
06737: jj_scanpos = xsp;
06738: return false;
06739: }
06740:
06741: final private boolean jj_3_102() {
06742: if (jj_3R_60())
06743: return true;
06744: return false;
06745: }
06746:
06747: final private boolean jj_3_122() {
06748: if (jj_scan_token(SHUTDOWN))
06749: return true;
06750: return false;
06751: }
06752:
06753: final private boolean jj_3_124() {
06754: Token xsp;
06755: xsp = jj_scanpos;
06756: if (jj_3_122()) {
06757: jj_scanpos = xsp;
06758: if (jj_3_123())
06759: return true;
06760: }
06761: return false;
06762: }
06763:
06764: final private boolean jj_3_66() {
06765: if (jj_scan_token(AS))
06766: return true;
06767: if (jj_3R_60())
06768: return true;
06769: return false;
06770: }
06771:
06772: final private boolean jj_3_104() {
06773: if (jj_scan_token(USING))
06774: return true;
06775: Token xsp;
06776: xsp = jj_scanpos;
06777: if (jj_3_102()) {
06778: jj_scanpos = xsp;
06779: if (jj_3_103())
06780: return true;
06781: }
06782: return false;
06783: }
06784:
06785: final private boolean jj_3_64() {
06786: if (jj_scan_token(PASSWORD))
06787: return true;
06788: if (jj_scan_token(STRING))
06789: return true;
06790: return false;
06791: }
06792:
06793: final private boolean jj_3_101() {
06794: if (jj_scan_token(STRING))
06795: return true;
06796: return false;
06797: }
06798:
06799: final private boolean jj_3_63() {
06800: if (jj_scan_token(USER))
06801: return true;
06802: if (jj_scan_token(STRING))
06803: return true;
06804: return false;
06805: }
06806:
06807: final private boolean jj_3_100() {
06808: if (jj_3R_60())
06809: return true;
06810: return false;
06811: }
06812:
06813: final private boolean jj_3R_18() {
06814: if (jj_scan_token(EXECUTE))
06815: return true;
06816: Token xsp;
06817: xsp = jj_scanpos;
06818: if (jj_3_100()) {
06819: jj_scanpos = xsp;
06820: if (jj_3_101())
06821: return true;
06822: }
06823: return false;
06824: }
06825:
06826: final private boolean jj_3_65() {
06827: if (jj_scan_token(ATTRIBUTES))
06828: return true;
06829: if (jj_3R_63())
06830: return true;
06831: return false;
06832: }
06833:
06834: final private boolean jj_3R_43() {
06835: if (jj_scan_token(XA_DATASOURCE))
06836: return true;
06837: if (jj_scan_token(STRING))
06838: return true;
06839: return false;
06840: }
06841:
06842: final private boolean jj_3_62() {
06843: if (jj_scan_token(PROTOCOL))
06844: return true;
06845: if (jj_3R_60())
06846: return true;
06847: return false;
06848: }
06849:
06850: final private boolean jj_3R_61() {
06851: if (jj_scan_token(STRING))
06852: return true;
06853: Token xsp;
06854: xsp = jj_scanpos;
06855: if (jj_3_62())
06856: jj_scanpos = xsp;
06857: xsp = jj_scanpos;
06858: if (jj_3_63())
06859: jj_scanpos = xsp;
06860: xsp = jj_scanpos;
06861: if (jj_3_64())
06862: jj_scanpos = xsp;
06863: xsp = jj_scanpos;
06864: if (jj_3_65())
06865: jj_scanpos = xsp;
06866: xsp = jj_scanpos;
06867: if (jj_3_66())
06868: jj_scanpos = xsp;
06869: return false;
06870: }
06871:
06872: final private boolean jj_3_59() {
06873: if (jj_3R_62())
06874: return true;
06875: return false;
06876: }
06877:
06878: final private boolean jj_3R_21() {
06879: if (jj_scan_token(EXECUTE))
06880: return true;
06881: if (jj_scan_token(PROCEDURE))
06882: return true;
06883: return false;
06884: }
06885:
06886: final private boolean jj_3R_20() {
06887: if (jj_scan_token(EXECUTE))
06888: return true;
06889: if (jj_scan_token(STATEMENT))
06890: return true;
06891: return false;
06892: }
06893:
06894: final private boolean jj_3_58() {
06895: if (jj_3R_61())
06896: return true;
06897: return false;
06898: }
06899:
06900: final private boolean jj_3_61() {
06901: if (jj_scan_token(CONNECT))
06902: return true;
06903: Token xsp;
06904: xsp = jj_scanpos;
06905: if (jj_3_58()) {
06906: jj_scanpos = xsp;
06907: if (jj_3_59())
06908: return true;
06909: }
06910: return false;
06911: }
06912:
06913: final private boolean jj_3_60() {
06914: if (jj_scan_token(CONNECT))
06915: return true;
06916: if (jj_scan_token(TO))
06917: return true;
06918: return false;
06919: }
06920:
06921: final private boolean jj_3R_13() {
06922: Token xsp;
06923: xsp = jj_scanpos;
06924: if (jj_3_60()) {
06925: jj_scanpos = xsp;
06926: if (jj_3_61())
06927: return true;
06928: }
06929: return false;
06930: }
06931:
06932: final private boolean jj_3R_11() {
06933: if (jj_scan_token(CLOSE))
06934: return true;
06935: if (jj_3R_60())
06936: return true;
06937: return false;
06938: }
06939:
06940: final private boolean jj_3R_16() {
06941: if (jj_scan_token(DRIVER))
06942: return true;
06943: if (jj_scan_token(STRING))
06944: return true;
06945: return false;
06946: }
06947:
06948: final private boolean jj_3_57() {
06949: if (jj_scan_token(AS))
06950: return true;
06951: if (jj_3R_60())
06952: return true;
06953: return false;
06954: }
06955:
06956: final private boolean jj_3R_25() {
06957: if (jj_scan_token(GETCURRENTROWNUMBER))
06958: return true;
06959: if (jj_3R_60())
06960: return true;
06961: return false;
06962: }
06963:
06964: final private boolean jj_3_121() {
06965: if (jj_scan_token(MINUS_SIGN))
06966: return true;
06967: return false;
06968: }
06969:
06970: final private boolean jj_3R_67() {
06971: Token xsp;
06972: xsp = jj_scanpos;
06973: if (jj_3_120()) {
06974: jj_scanpos = xsp;
06975: if (jj_3_121())
06976: return true;
06977: }
06978: return false;
06979: }
06980:
06981: final private boolean jj_3_120() {
06982: if (jj_scan_token(PLUS_SIGN))
06983: return true;
06984: return false;
06985: }
06986:
06987: final private boolean jj_3_118() {
06988: if (jj_scan_token(COMMA))
06989: return true;
06990: if (jj_3R_69())
06991: return true;
06992: return false;
06993: }
06994:
06995: final private boolean jj_3R_35() {
06996: if (jj_scan_token(PROTOCOL))
06997: return true;
06998: if (jj_scan_token(STRING))
06999: return true;
07000: return false;
07001: }
07002:
07003: final private boolean jj_3R_34() {
07004: if (jj_scan_token(PREVIOUS))
07005: return true;
07006: if (jj_3R_60())
07007: return true;
07008: return false;
07009: }
07010:
07011: final private boolean jj_3R_69() {
07012: if (jj_scan_token(STRING))
07013: return true;
07014: return false;
07015: }
07016:
07017: final private boolean jj_3_119() {
07018: if (jj_3R_69())
07019: return true;
07020: Token xsp;
07021: while (true) {
07022: xsp = jj_scanpos;
07023: if (jj_3_118()) {
07024: jj_scanpos = xsp;
07025: break;
07026: }
07027: }
07028: return false;
07029: }
07030:
07031: final private boolean jj_3_55() {
07032: if (jj_3R_58())
07033: return true;
07034: return false;
07035: }
07036:
07037: final private boolean jj_3_54() {
07038: if (jj_3R_57())
07039: return true;
07040: return false;
07041: }
07042:
07043: final private boolean jj_3_53() {
07044: if (jj_3R_56())
07045: return true;
07046: return false;
07047: }
07048:
07049: final private boolean jj_3_52() {
07050: if (jj_3R_55())
07051: return true;
07052: return false;
07053: }
07054:
07055: final private boolean jj_3_51() {
07056: if (jj_3R_54())
07057: return true;
07058: return false;
07059: }
07060:
07061: final private boolean jj_3R_28() {
07062: if (jj_scan_token(LAST))
07063: return true;
07064: if (jj_3R_60())
07065: return true;
07066: return false;
07067: }
07068:
07069: final private boolean jj_3_50() {
07070: if (jj_3R_53())
07071: return true;
07072: return false;
07073: }
07074:
07075: final private boolean jj_3_49() {
07076: if (jj_3R_52())
07077: return true;
07078: return false;
07079: }
07080:
07081: final private boolean jj_3_48() {
07082: if (jj_3R_51())
07083: return true;
07084: return false;
07085: }
07086:
07087: final private boolean jj_3_47() {
07088: if (jj_3R_50())
07089: return true;
07090: return false;
07091: }
07092:
07093: final private boolean jj_3_46() {
07094: if (jj_3R_49())
07095: return true;
07096: return false;
07097: }
07098:
07099: final private boolean jj_3_45() {
07100: if (jj_3R_48())
07101: return true;
07102: return false;
07103: }
07104:
07105: final private boolean jj_3_117() {
07106: if (jj_scan_token(PERIOD))
07107: return true;
07108: if (jj_3R_68())
07109: return true;
07110: return false;
07111: }
07112:
07113: final private boolean jj_3_44() {
07114: if (jj_3R_47())
07115: return true;
07116: return false;
07117: }
07118:
07119: final private boolean jj_3_43() {
07120: if (jj_3R_46())
07121: return true;
07122: return false;
07123: }
07124:
07125: final private boolean jj_3_42() {
07126: if (jj_3R_45())
07127: return true;
07128: return false;
07129: }
07130:
07131: final private boolean jj_3_41() {
07132: if (jj_3R_44())
07133: return true;
07134: return false;
07135: }
07136:
07137: final private boolean jj_3_40() {
07138: if (jj_3R_43())
07139: return true;
07140: return false;
07141: }
07142:
07143: final private boolean jj_3_39() {
07144: if (jj_3R_42())
07145: return true;
07146: return false;
07147: }
07148:
07149: final private boolean jj_3_38() {
07150: if (jj_3R_41())
07151: return true;
07152: return false;
07153: }
07154:
07155: final private boolean jj_3R_68() {
07156: if (jj_scan_token(IDENTIFIER))
07157: return true;
07158: return false;
07159: }
07160:
07161: final private boolean jj_3_37() {
07162: if (jj_3R_40())
07163: return true;
07164: return false;
07165: }
07166:
07167: final private boolean jj_3_36() {
07168: if (jj_3R_39())
07169: return true;
07170: return false;
07171: }
07172:
07173: final private boolean jj_3_35() {
07174: if (jj_3R_38())
07175: return true;
07176: return false;
07177: }
07178:
07179: final private boolean jj_3_34() {
07180: if (jj_3R_37())
07181: return true;
07182: return false;
07183: }
07184:
07185: final private boolean jj_3_33() {
07186: if (jj_3R_36())
07187: return true;
07188: return false;
07189: }
07190:
07191: final private boolean jj_3_32() {
07192: if (jj_3R_35())
07193: return true;
07194: return false;
07195: }
07196:
07197: final private boolean jj_3_31() {
07198: if (jj_3R_34())
07199: return true;
07200: return false;
07201: }
07202:
07203: final private boolean jj_3_30() {
07204: if (jj_3R_33())
07205: return true;
07206: return false;
07207: }
07208:
07209: final private boolean jj_3R_6() {
07210: if (jj_scan_token(AFTER))
07211: return true;
07212: if (jj_scan_token(LAST))
07213: return true;
07214: return false;
07215: }
07216:
07217: final private boolean jj_3_29() {
07218: if (jj_3R_32())
07219: return true;
07220: return false;
07221: }
07222:
07223: final private boolean jj_3_28() {
07224: if (jj_3R_31())
07225: return true;
07226: return false;
07227: }
07228:
07229: final private boolean jj_3_27() {
07230: if (jj_3R_30())
07231: return true;
07232: return false;
07233: }
07234:
07235: final private boolean jj_3_26() {
07236: if (jj_3R_29())
07237: return true;
07238: return false;
07239: }
07240:
07241: final private boolean jj_3R_77() {
07242: if (jj_3R_68())
07243: return true;
07244: Token xsp;
07245: if (jj_3_117())
07246: return true;
07247: while (true) {
07248: xsp = jj_scanpos;
07249: if (jj_3_117()) {
07250: jj_scanpos = xsp;
07251: break;
07252: }
07253: }
07254: return false;
07255: }
07256:
07257: final private boolean jj_3_25() {
07258: if (jj_3R_28())
07259: return true;
07260: return false;
07261: }
07262:
07263: final private boolean jj_3_24() {
07264: if (jj_3R_27())
07265: return true;
07266: return false;
07267: }
07268:
07269: final private boolean jj_3_23() {
07270: if (jj_3R_26())
07271: return true;
07272: return false;
07273: }
07274:
07275: final private boolean jj_3_22() {
07276: if (jj_3R_25())
07277: return true;
07278: return false;
07279: }
07280:
07281: final private boolean jj_3_21() {
07282: if (jj_3R_24())
07283: return true;
07284: return false;
07285: }
07286:
07287: final private boolean jj_3_20() {
07288: if (jj_3R_23())
07289: return true;
07290: return false;
07291: }
07292:
07293: final private boolean jj_3_19() {
07294: if (jj_3R_22())
07295: return true;
07296: return false;
07297: }
07298:
07299: final private boolean jj_3_18() {
07300: if (jj_3R_21())
07301: return true;
07302: return false;
07303: }
07304:
07305: final private boolean jj_3_17() {
07306: if (jj_3R_20())
07307: return true;
07308: return false;
07309: }
07310:
07311: final private boolean jj_3_16() {
07312: if (jj_3R_19())
07313: return true;
07314: return false;
07315: }
07316:
07317: final private boolean jj_3_15() {
07318: if (jj_3R_19())
07319: return true;
07320: return false;
07321: }
07322:
07323: final private boolean jj_3_14() {
07324: if (jj_3R_18())
07325: return true;
07326: return false;
07327: }
07328:
07329: final private boolean jj_3_13() {
07330: if (jj_3R_17())
07331: return true;
07332: return false;
07333: }
07334:
07335: final private boolean jj_3_12() {
07336: if (jj_3R_16())
07337: return true;
07338: return false;
07339: }
07340:
07341: final private boolean jj_3_11() {
07342: if (jj_3R_15())
07343: return true;
07344: return false;
07345: }
07346:
07347: final private boolean jj_3_10() {
07348: if (jj_3R_14())
07349: return true;
07350: return false;
07351: }
07352:
07353: final private boolean jj_3R_31() {
07354: if (jj_scan_token(NEXT))
07355: return true;
07356: if (jj_3R_60())
07357: return true;
07358: return false;
07359: }
07360:
07361: final private boolean jj_3_9() {
07362: if (jj_3R_13())
07363: return true;
07364: return false;
07365: }
07366:
07367: final private boolean jj_3_8() {
07368: if (jj_3R_12())
07369: return true;
07370: return false;
07371: }
07372:
07373: final private boolean jj_3_7() {
07374: if (jj_3R_11())
07375: return true;
07376: return false;
07377: }
07378:
07379: final private boolean jj_3_6() {
07380: if (jj_3R_10())
07381: return true;
07382: return false;
07383: }
07384:
07385: final private boolean jj_3_5() {
07386: if (jj_3R_9())
07387: return true;
07388: return false;
07389: }
07390:
07391: final private boolean jj_3_4() {
07392: if (jj_3R_8())
07393: return true;
07394: return false;
07395: }
07396:
07397: final private boolean jj_3_256() {
07398: if (jj_scan_token(WORK))
07399: return true;
07400: return false;
07401: }
07402:
07403: final private boolean jj_3_3() {
07404: if (jj_3R_7())
07405: return true;
07406: return false;
07407: }
07408:
07409: final private boolean jj_3_116() {
07410: if (jj_3R_67())
07411: return true;
07412: return false;
07413: }
07414:
07415: final private boolean jj_3_255() {
07416: if (jj_scan_token(CP_DISCONNECT))
07417: return true;
07418: return false;
07419: }
07420:
07421: final private boolean jj_3_2() {
07422: if (jj_3R_6())
07423: return true;
07424: return false;
07425: }
07426:
07427: final private boolean jj_3_254() {
07428: if (jj_scan_token(CP_GETCONNECTION))
07429: return true;
07430: return false;
07431: }
07432:
07433: final private boolean jj_3R_72() {
07434: Token xsp;
07435: xsp = jj_scanpos;
07436: if (jj_3_116())
07437: jj_scanpos = xsp;
07438: if (jj_scan_token(INTEGER))
07439: return true;
07440: return false;
07441: }
07442:
07443: final private boolean jj_3_1() {
07444: if (jj_3R_5())
07445: return true;
07446: return false;
07447: }
07448:
07449: final private boolean jj_3_253() {
07450: if (jj_scan_token(CP_CONNECT))
07451: return true;
07452: return false;
07453: }
07454:
07455: final private boolean jj_3_252() {
07456: if (jj_scan_token(CP_DATASOURCE))
07457: return true;
07458: return false;
07459: }
07460:
07461: final private boolean jj_3_251() {
07462: if (jj_scan_token(DATASOURCE))
07463: return true;
07464: return false;
07465: }
07466:
07467: final private boolean jj_3_250() {
07468: if (jj_scan_token(XA_SUSPEND))
07469: return true;
07470: return false;
07471: }
07472:
07473: final private boolean jj_3_249() {
07474: if (jj_scan_token(XA_SUCCESS))
07475: return true;
07476: return false;
07477: }
07478:
07479: final private boolean jj_3_248() {
07480: if (jj_scan_token(XA_STARTRSCAN))
07481: return true;
07482: return false;
07483: }
07484:
07485: final private boolean jj_3R_59() {
07486: if (jj_3R_76())
07487: return true;
07488: return false;
07489: }
07490:
07491: final private boolean jj_3_56() {
07492: Token xsp;
07493: xsp = jj_scanpos;
07494: lookingAhead = true;
07495: jj_semLA = getToken(1).kind == ROLLBACK
07496: && (!(getToken(3).kind == TO || getToken(3).kind == SAVEPOINT));
07497: lookingAhead = false;
07498: if (!jj_semLA || jj_3R_59()) {
07499: jj_scanpos = xsp;
07500: if (jj_3_1()) {
07501: jj_scanpos = xsp;
07502: if (jj_3_2()) {
07503: jj_scanpos = xsp;
07504: if (jj_3_3()) {
07505: jj_scanpos = xsp;
07506: if (jj_3_4()) {
07507: jj_scanpos = xsp;
07508: if (jj_3_5()) {
07509: jj_scanpos = xsp;
07510: if (jj_3_6()) {
07511: jj_scanpos = xsp;
07512: if (jj_3_7()) {
07513: jj_scanpos = xsp;
07514: if (jj_3_8()) {
07515: jj_scanpos = xsp;
07516: if (jj_3_9()) {
07517: jj_scanpos = xsp;
07518: if (jj_3_10()) {
07519: jj_scanpos = xsp;
07520: if (jj_3_11()) {
07521: jj_scanpos = xsp;
07522: if (jj_3_12()) {
07523: jj_scanpos = xsp;
07524: if (jj_3_13()) {
07525: jj_scanpos = xsp;
07526: if (jj_3_14()) {
07527: jj_scanpos = xsp;
07528: if (jj_3_15()) {
07529: jj_scanpos = xsp;
07530: if (jj_3_16()) {
07531: jj_scanpos = xsp;
07532: if (jj_3_17()) {
07533: jj_scanpos = xsp;
07534: if (jj_3_18()) {
07535: jj_scanpos = xsp;
07536: if (jj_3_19()) {
07537: jj_scanpos = xsp;
07538: if (jj_3_20()) {
07539: jj_scanpos = xsp;
07540: if (jj_3_21()) {
07541: jj_scanpos = xsp;
07542: if (jj_3_22()) {
07543: jj_scanpos = xsp;
07544: if (jj_3_23()) {
07545: jj_scanpos = xsp;
07546: if (jj_3_24()) {
07547: jj_scanpos = xsp;
07548: if (jj_3_25()) {
07549: jj_scanpos = xsp;
07550: if (jj_3_26()) {
07551: jj_scanpos = xsp;
07552: if (jj_3_27()) {
07553: jj_scanpos = xsp;
07554: if (jj_3_28()) {
07555: jj_scanpos = xsp;
07556: if (jj_3_29()) {
07557: jj_scanpos = xsp;
07558: if (jj_3_30()) {
07559: jj_scanpos = xsp;
07560: if (jj_3_31()) {
07561: jj_scanpos = xsp;
07562: if (jj_3_32()) {
07563: jj_scanpos = xsp;
07564: if (jj_3_33()) {
07565: jj_scanpos = xsp;
07566: if (jj_3_34()) {
07567: jj_scanpos = xsp;
07568: if (jj_3_35()) {
07569: jj_scanpos = xsp;
07570: if (jj_3_36()) {
07571: jj_scanpos = xsp;
07572: if (jj_3_37()) {
07573: jj_scanpos = xsp;
07574: if (jj_3_38()) {
07575: jj_scanpos = xsp;
07576: if (jj_3_39()) {
07577: jj_scanpos = xsp;
07578: if (jj_3_40()) {
07579: jj_scanpos = xsp;
07580: if (jj_3_41()) {
07581: jj_scanpos = xsp;
07582: if (jj_3_42()) {
07583: jj_scanpos = xsp;
07584: if (jj_3_43()) {
07585: jj_scanpos = xsp;
07586: if (jj_3_44()) {
07587: jj_scanpos = xsp;
07588: if (jj_3_45()) {
07589: jj_scanpos = xsp;
07590: if (jj_3_46()) {
07591: jj_scanpos = xsp;
07592: if (jj_3_47()) {
07593: jj_scanpos = xsp;
07594: if (jj_3_48()) {
07595: jj_scanpos = xsp;
07596: if (jj_3_49()) {
07597: jj_scanpos = xsp;
07598: if (jj_3_50()) {
07599: jj_scanpos = xsp;
07600: if (jj_3_51()) {
07601: jj_scanpos = xsp;
07602: if (jj_3_52()) {
07603: jj_scanpos = xsp;
07604: if (jj_3_53()) {
07605: jj_scanpos = xsp;
07606: if (jj_3_54()) {
07607: jj_scanpos = xsp;
07608: if (jj_3_55())
07609: return true;
07610: }
07611: }
07612: }
07613: }
07614: }
07615: }
07616: }
07617: }
07618: }
07619: }
07620: }
07621: }
07622: }
07623: }
07624: }
07625: }
07626: }
07627: }
07628: }
07629: }
07630: }
07631: }
07632: }
07633: }
07634: }
07635: }
07636: }
07637: }
07638: }
07639: }
07640: }
07641: }
07642: }
07643: }
07644: }
07645: }
07646: }
07647: }
07648: }
07649: }
07650: }
07651: }
07652: }
07653: }
07654: }
07655: }
07656: }
07657: }
07658: }
07659: }
07660: }
07661: }
07662: }
07663: }
07664: }
07665: return false;
07666: }
07667:
07668: final private boolean jj_3_247() {
07669: if (jj_scan_token(XA_START))
07670: return true;
07671: return false;
07672: }
07673:
07674: final private boolean jj_3_246() {
07675: if (jj_scan_token(XA_ROLLBACK))
07676: return true;
07677: return false;
07678: }
07679:
07680: final private boolean jj_3_245() {
07681: if (jj_scan_token(XA_RESUME))
07682: return true;
07683: return false;
07684: }
07685:
07686: final private boolean jj_3_244() {
07687: if (jj_scan_token(XA_RECOVER))
07688: return true;
07689: return false;
07690: }
07691:
07692: final private boolean jj_3_243() {
07693: if (jj_scan_token(XA_PREPARE))
07694: return true;
07695: return false;
07696: }
07697:
07698: final private boolean jj_3_242() {
07699: if (jj_scan_token(XA_NOFLAGS))
07700: return true;
07701: return false;
07702: }
07703:
07704: final private boolean jj_3R_19() {
07705: if (jj_scan_token(FIRST))
07706: return true;
07707: if (jj_3R_60())
07708: return true;
07709: return false;
07710: }
07711:
07712: final private boolean jj_3_241() {
07713: if (jj_scan_token(XA_JOIN))
07714: return true;
07715: return false;
07716: }
07717:
07718: final private boolean jj_3_240() {
07719: if (jj_scan_token(XA_GETCONNECTION))
07720: return true;
07721: return false;
07722: }
07723:
07724: final private boolean jj_3_239() {
07725: if (jj_scan_token(XA_FORGET))
07726: return true;
07727: return false;
07728: }
07729:
07730: final private boolean jj_3R_60() {
07731: if (jj_scan_token(IDENTIFIER))
07732: return true;
07733: return false;
07734: }
07735:
07736: final private boolean jj_3_238() {
07737: if (jj_scan_token(XA_FAIL))
07738: return true;
07739: return false;
07740: }
07741:
07742: final private boolean jj_3_237() {
07743: if (jj_scan_token(XA_ENDRSCAN))
07744: return true;
07745: return false;
07746: }
07747:
07748: final private boolean jj_3_236() {
07749: if (jj_scan_token(XA_END))
07750: return true;
07751: return false;
07752: }
07753:
07754: final private boolean jj_3_235() {
07755: if (jj_scan_token(XA_DISCONNECT))
07756: return true;
07757: return false;
07758: }
07759:
07760: final private boolean jj_3_234() {
07761: if (jj_scan_token(XA_COMMIT))
07762: return true;
07763: return false;
07764: }
07765:
07766: final private boolean jj_3_233() {
07767: if (jj_scan_token(XA_CONNECT))
07768: return true;
07769: return false;
07770: }
07771:
07772: final private boolean jj_3_232() {
07773: if (jj_scan_token(XA_DATASOURCE))
07774: return true;
07775: return false;
07776: }
07777:
07778: final private boolean jj_3_231() {
07779: if (jj_scan_token(XA_2PHASE))
07780: return true;
07781: return false;
07782: }
07783:
07784: final private boolean jj_3_230() {
07785: if (jj_scan_token(XA_1PHASE))
07786: return true;
07787: return false;
07788: }
07789:
07790: final private boolean jj_3_229() {
07791: if (jj_scan_token(WITH))
07792: return true;
07793: return false;
07794: }
07795:
07796: final private boolean jj_3_228() {
07797: if (jj_scan_token(WAIT))
07798: return true;
07799: return false;
07800: }
07801:
07802: final private boolean jj_3_227() {
07803: if (jj_scan_token(VIEWS))
07804: return true;
07805: return false;
07806: }
07807:
07808: final private boolean jj_3_226() {
07809: if (jj_scan_token(USING))
07810: return true;
07811: return false;
07812: }
07813:
07814: final private boolean jj_3_225() {
07815: if (jj_scan_token(USER))
07816: return true;
07817: return false;
07818: }
07819:
07820: final private boolean jj_3_224() {
07821: if (jj_scan_token(TABLES))
07822: return true;
07823: return false;
07824: }
07825:
07826: final private boolean jj_3_223() {
07827: if (jj_scan_token(SYNONYMS))
07828: return true;
07829: return false;
07830: }
07831:
07832: final private boolean jj_3_222() {
07833: if (jj_scan_token(STATEMENT))
07834: return true;
07835: return false;
07836: }
07837:
07838: final private boolean jj_3_221() {
07839: if (jj_scan_token(SHUTDOWN))
07840: return true;
07841: return false;
07842: }
07843:
07844: final private boolean jj_3R_10() {
07845: if (jj_scan_token(BEFORE))
07846: return true;
07847: if (jj_scan_token(FIRST))
07848: return true;
07849: return false;
07850: }
07851:
07852: final private boolean jj_3_220() {
07853: if (jj_scan_token(SHOW))
07854: return true;
07855: return false;
07856: }
07857:
07858: final private boolean jj_3R_26() {
07859: if (jj_scan_token(HELP))
07860: return true;
07861: return false;
07862: }
07863:
07864: final private boolean jj_3_219() {
07865: if (jj_scan_token(SET))
07866: return true;
07867: return false;
07868: }
07869:
07870: final private boolean jj_3_218() {
07871: if (jj_scan_token(SENSITIVE))
07872: return true;
07873: return false;
07874: }
07875:
07876: final private boolean jj_3_217() {
07877: if (jj_scan_token(SCROLL))
07878: return true;
07879: return false;
07880: }
07881:
07882: final private boolean jj_3_216() {
07883: if (jj_scan_token(SCHEMAS))
07884: return true;
07885: return false;
07886: }
07887:
07888: final private boolean jj_3_215() {
07889: if (jj_scan_token(TO))
07890: return true;
07891: return false;
07892: }
07893:
07894: final private boolean jj_3_214() {
07895: if (jj_scan_token(RUN))
07896: return true;
07897: return false;
07898: }
07899:
07900: final private boolean jj_3_213() {
07901: if (jj_scan_token(ROLLBACK))
07902: return true;
07903: return false;
07904: }
07905:
07906: final private boolean jj_3_212() {
07907: if (jj_scan_token(RESOURCE))
07908: return true;
07909: return false;
07910: }
07911:
07912: final private boolean jj_3_115() {
07913: if (jj_3R_66())
07914: return true;
07915: return false;
07916: }
07917:
07918: final private boolean jj_3_211() {
07919: if (jj_scan_token(REMOVE))
07920: return true;
07921: return false;
07922: }
07923:
07924: final private boolean jj_3_210() {
07925: if (jj_scan_token(RELATIVE))
07926: return true;
07927: return false;
07928: }
07929:
07930: final private boolean jj_3_209() {
07931: if (jj_scan_token(READONLY))
07932: return true;
07933: return false;
07934: }
07935:
07936: final private boolean jj_3_208() {
07937: if (jj_scan_token(QUIT))
07938: return true;
07939: return false;
07940: }
07941:
07942: final private boolean jj_3_207() {
07943: if (jj_scan_token(PROTOCOL))
07944: return true;
07945: return false;
07946: }
07947:
07948: final private boolean jj_3_206() {
07949: if (jj_scan_token(PROPERTIES))
07950: return true;
07951: return false;
07952: }
07953:
07954: final private boolean jj_3_205() {
07955: if (jj_scan_token(PROCEDURES))
07956: return true;
07957: return false;
07958: }
07959:
07960: final private boolean jj_3R_66() {
07961: if (jj_scan_token(STRING))
07962: return true;
07963: return false;
07964: }
07965:
07966: final private boolean jj_3_204() {
07967: if (jj_scan_token(PROCEDURE))
07968: return true;
07969: return false;
07970: }
07971:
07972: final private boolean jj_3_203() {
07973: if (jj_scan_token(PREVIOUS))
07974: return true;
07975: return false;
07976: }
07977:
07978: final private boolean jj_3_202() {
07979: if (jj_scan_token(PREPARE))
07980: return true;
07981: return false;
07982: }
07983:
07984: final private boolean jj_3_201() {
07985: if (jj_scan_token(PERIOD))
07986: return true;
07987: return false;
07988: }
07989:
07990: final private boolean jj_3_200() {
07991: if (jj_scan_token(PASSWORD))
07992: return true;
07993: return false;
07994: }
07995:
07996: final private boolean jj_3R_37() {
07997: if (jj_scan_token(RELATIVE))
07998: return true;
07999: if (jj_3R_72())
08000: return true;
08001: return false;
08002: }
08003:
08004: final private boolean jj_3_199() {
08005: if (jj_scan_token(ON))
08006: return true;
08007: return false;
08008: }
08009:
08010: final private boolean jj_3_198() {
08011: if (jj_scan_token(OFF))
08012: return true;
08013: return false;
08014: }
08015:
08016: final private boolean jj_3_197() {
08017: if (jj_scan_token(NOHOLDFORCONNECTION))
08018: return true;
08019: return false;
08020: }
08021:
08022: final private boolean jj_3_196() {
08023: if (jj_scan_token(NOHOLD))
08024: return true;
08025: return false;
08026: }
08027:
08028: final private boolean jj_3R_73() {
08029: if (jj_3R_66())
08030: return true;
08031: return false;
08032: }
08033:
08034: final private boolean jj_3_195() {
08035: if (jj_scan_token(NEXT))
08036: return true;
08037: return false;
08038: }
08039:
08040: final private boolean jj_3_194() {
08041: if (jj_scan_token(NAME))
08042: return true;
08043: return false;
08044: }
08045:
08046: final private boolean jj_3_193() {
08047: if (jj_scan_token(MAXIMUMDISPLAYWIDTH))
08048: return true;
08049: return false;
08050: }
08051:
08052: final private boolean jj_3_192() {
08053: if (jj_scan_token(LOCALIZEDDISPLAY))
08054: return true;
08055: return false;
08056: }
08057:
08058: final private boolean jj_3_191() {
08059: if (jj_scan_token(LAST))
08060: return true;
08061: return false;
08062: }
08063:
08064: final private boolean jj_3_190() {
08065: if (jj_scan_token(INTO))
08066: return true;
08067: return false;
08068: }
08069:
08070: final private boolean jj_3_189() {
08071: if (jj_scan_token(INSENSITIVE))
08072: return true;
08073: return false;
08074: }
08075:
08076: final private boolean jj_3_188() {
08077: if (jj_scan_token(INDEXES))
08078: return true;
08079: return false;
08080: }
08081:
08082: final private boolean jj_3_187() {
08083: if (jj_scan_token(IN))
08084: return true;
08085: return false;
08086: }
08087:
08088: final private boolean jj_3_186() {
08089: if (jj_scan_token(HELP))
08090: return true;
08091: return false;
08092: }
08093:
08094: final private boolean jj_3_185() {
08095: if (jj_scan_token(HOLD))
08096: return true;
08097: return false;
08098: }
08099:
08100: final private boolean jj_3_184() {
08101: if (jj_scan_token(GETCURRENTROWNUMBER))
08102: return true;
08103: return false;
08104: }
08105:
08106: final private boolean jj_3_114() {
08107: if (jj_scan_token(FAIL))
08108: return true;
08109: return false;
08110: }
08111:
08112: final private boolean jj_3_183() {
08113: if (jj_scan_token(GET))
08114: return true;
08115: return false;
08116: }
08117:
08118: final private boolean jj_3_182() {
08119: if (jj_scan_token(FROM))
08120: return true;
08121: return false;
08122: }
08123:
08124: final private boolean jj_3_181() {
08125: if (jj_scan_token(FOR))
08126: return true;
08127: return false;
08128: }
08129:
08130: final private boolean jj_3_180() {
08131: if (jj_scan_token(FIRST))
08132: return true;
08133: return false;
08134: }
08135:
08136: final private boolean jj_3_179() {
08137: if (jj_scan_token(FAIL))
08138: return true;
08139: return false;
08140: }
08141:
08142: final private boolean jj_3_178() {
08143: if (jj_scan_token(EXPECT))
08144: return true;
08145: return false;
08146: }
08147:
08148: final private boolean jj_3R_5() {
08149: if (jj_scan_token(ABSOLUTE))
08150: return true;
08151: if (jj_3R_72())
08152: return true;
08153: return false;
08154: }
08155:
08156: final private boolean jj_3_177() {
08157: if (jj_scan_token(EXIT))
08158: return true;
08159: return false;
08160: }
08161:
08162: final private boolean jj_3_176() {
08163: if (jj_scan_token(EXECUTE))
08164: return true;
08165: return false;
08166: }
08167:
08168: final private boolean jj_3_175() {
08169: if (jj_scan_token(END))
08170: return true;
08171: return false;
08172: }
08173:
08174: final private boolean jj_3_174() {
08175: if (jj_scan_token(ELAPSEDTIME))
08176: return true;
08177: return false;
08178: }
08179:
08180: final private boolean jj_3_173() {
08181: if (jj_scan_token(DRIVER))
08182: return true;
08183: return false;
08184: }
08185:
08186: final private boolean jj_3R_23() {
08187: if (jj_scan_token(EXPECT))
08188: return true;
08189: Token xsp;
08190: xsp = jj_scanpos;
08191: if (jj_3_114())
08192: jj_scanpos = xsp;
08193: if (jj_3R_73())
08194: return true;
08195: return false;
08196: }
08197:
08198: final private boolean jj_3_172() {
08199: if (jj_scan_token(DISCONNECT))
08200: return true;
08201: return false;
08202: }
08203:
08204: final private boolean jj_3_171() {
08205: if (jj_scan_token(DESCRIBE))
08206: return true;
08207: return false;
08208: }
08209:
08210: final private boolean jj_3_170() {
08211: if (jj_scan_token(CURSOR))
08212: return true;
08213: return false;
08214: }
08215:
08216: final private boolean jj_3_169() {
08217: if (jj_scan_token(CURRENT))
08218: return true;
08219: return false;
08220: }
08221:
08222: final private boolean jj_3_168() {
08223: if (jj_scan_token(CONNECTIONS))
08224: return true;
08225: return false;
08226: }
08227:
08228: final private boolean jj_3_167() {
08229: if (jj_scan_token(CONNECTION))
08230: return true;
08231: return false;
08232: }
08233:
08234: final private boolean jj_3_166() {
08235: if (jj_scan_token(CONNECT))
08236: return true;
08237: return false;
08238: }
08239:
08240: final private boolean jj_3_165() {
08241: if (jj_scan_token(COMMIT))
08242: return true;
08243: return false;
08244: }
08245:
08246: final private boolean jj_3_164() {
08247: if (jj_scan_token(CLOSE))
08248: return true;
08249: return false;
08250: }
08251:
08252: final private boolean jj_3_163() {
08253: if (jj_scan_token(BEFORE))
08254: return true;
08255: return false;
08256: }
08257:
08258: final private boolean jj_3_162() {
08259: if (jj_scan_token(BANG))
08260: return true;
08261: return false;
08262: }
08263:
08264: final private boolean jj_3_99() {
08265: if (jj_scan_token(NOHOLD))
08266: return true;
08267: return false;
08268: }
08269:
08270: final private boolean jj_3_161() {
08271: if (jj_scan_token(AUTOCOMMIT))
08272: return true;
08273: return false;
08274: }
08275:
08276: final private boolean jj_3_160() {
08277: if (jj_scan_token(ATTRIBUTES))
08278: return true;
08279: return false;
08280: }
08281:
08282: final private boolean jj_3_159() {
08283: if (jj_scan_token(ASYNC))
08284: return true;
08285: return false;
08286: }
08287:
08288: final private boolean jj_3_158() {
08289: if (jj_scan_token(AS))
08290: return true;
08291: return false;
08292: }
08293:
08294: final private boolean jj_3_157() {
08295: if (jj_scan_token(ALL))
08296: return true;
08297: return false;
08298: }
08299:
08300: final private boolean jj_3R_65() {
08301: Token xsp;
08302: xsp = jj_scanpos;
08303: if (jj_3_98()) {
08304: jj_scanpos = xsp;
08305: if (jj_3_99())
08306: return true;
08307: }
08308: return false;
08309: }
08310:
08311: final private boolean jj_3_98() {
08312: if (jj_scan_token(HOLD))
08313: return true;
08314: return false;
08315: }
08316:
08317: final private boolean jj_3_156() {
08318: if (jj_scan_token(ALIASES))
08319: return true;
08320: return false;
08321: }
08322:
08323: final private boolean jj_3_155() {
08324: if (jj_scan_token(AFTER))
08325: return true;
08326: return false;
08327: }
08328:
08329: final private boolean jj_3_154() {
08330: if (jj_scan_token(ABSOLUTE))
08331: return true;
08332: return false;
08333: }
08334:
08335: final private boolean jj_3R_71() {
08336: Token xsp;
08337: xsp = jj_scanpos;
08338: if (jj_3_154()) {
08339: jj_scanpos = xsp;
08340: if (jj_3_155()) {
08341: jj_scanpos = xsp;
08342: if (jj_3_156()) {
08343: jj_scanpos = xsp;
08344: if (jj_3_157()) {
08345: jj_scanpos = xsp;
08346: if (jj_3_158()) {
08347: jj_scanpos = xsp;
08348: if (jj_3_159()) {
08349: jj_scanpos = xsp;
08350: if (jj_3_160()) {
08351: jj_scanpos = xsp;
08352: if (jj_3_161()) {
08353: jj_scanpos = xsp;
08354: if (jj_3_162()) {
08355: jj_scanpos = xsp;
08356: if (jj_3_163()) {
08357: jj_scanpos = xsp;
08358: if (jj_3_164()) {
08359: jj_scanpos = xsp;
08360: if (jj_3_165()) {
08361: jj_scanpos = xsp;
08362: if (jj_3_166()) {
08363: jj_scanpos = xsp;
08364: if (jj_3_167()) {
08365: jj_scanpos = xsp;
08366: if (jj_3_168()) {
08367: jj_scanpos = xsp;
08368: if (jj_3_169()) {
08369: jj_scanpos = xsp;
08370: if (jj_3_170()) {
08371: jj_scanpos = xsp;
08372: if (jj_3_171()) {
08373: jj_scanpos = xsp;
08374: if (jj_3_172()) {
08375: jj_scanpos = xsp;
08376: if (jj_3_173()) {
08377: jj_scanpos = xsp;
08378: if (jj_3_174()) {
08379: jj_scanpos = xsp;
08380: if (jj_3_175()) {
08381: jj_scanpos = xsp;
08382: if (jj_3_176()) {
08383: jj_scanpos = xsp;
08384: if (jj_3_177()) {
08385: jj_scanpos = xsp;
08386: if (jj_3_178()) {
08387: jj_scanpos = xsp;
08388: if (jj_3_179()) {
08389: jj_scanpos = xsp;
08390: if (jj_3_180()) {
08391: jj_scanpos = xsp;
08392: if (jj_3_181()) {
08393: jj_scanpos = xsp;
08394: if (jj_3_182()) {
08395: jj_scanpos = xsp;
08396: if (jj_3_183()) {
08397: jj_scanpos = xsp;
08398: if (jj_3_184()) {
08399: jj_scanpos = xsp;
08400: if (jj_3_185()) {
08401: jj_scanpos = xsp;
08402: if (jj_3_186()) {
08403: jj_scanpos = xsp;
08404: if (jj_3_187()) {
08405: jj_scanpos = xsp;
08406: if (jj_3_188()) {
08407: jj_scanpos = xsp;
08408: if (jj_3_189()) {
08409: jj_scanpos = xsp;
08410: if (jj_3_190()) {
08411: jj_scanpos = xsp;
08412: if (jj_3_191()) {
08413: jj_scanpos = xsp;
08414: if (jj_3_192()) {
08415: jj_scanpos = xsp;
08416: if (jj_3_193()) {
08417: jj_scanpos = xsp;
08418: if (jj_3_194()) {
08419: jj_scanpos = xsp;
08420: if (jj_3_195()) {
08421: jj_scanpos = xsp;
08422: if (jj_3_196()) {
08423: jj_scanpos = xsp;
08424: if (jj_3_197()) {
08425: jj_scanpos = xsp;
08426: if (jj_3_198()) {
08427: jj_scanpos = xsp;
08428: if (jj_3_199()) {
08429: jj_scanpos = xsp;
08430: if (jj_3_200()) {
08431: jj_scanpos = xsp;
08432: if (jj_3_201()) {
08433: jj_scanpos = xsp;
08434: if (jj_3_202()) {
08435: jj_scanpos = xsp;
08436: if (jj_3_203()) {
08437: jj_scanpos = xsp;
08438: if (jj_3_204()) {
08439: jj_scanpos = xsp;
08440: if (jj_3_205()) {
08441: jj_scanpos = xsp;
08442: if (jj_3_206()) {
08443: jj_scanpos = xsp;
08444: if (jj_3_207()) {
08445: jj_scanpos = xsp;
08446: if (jj_3_208()) {
08447: jj_scanpos = xsp;
08448: if (jj_3_209()) {
08449: jj_scanpos = xsp;
08450: if (jj_3_210()) {
08451: jj_scanpos = xsp;
08452: if (jj_3_211()) {
08453: jj_scanpos = xsp;
08454: if (jj_3_212()) {
08455: jj_scanpos = xsp;
08456: if (jj_3_213()) {
08457: jj_scanpos = xsp;
08458: if (jj_3_214()) {
08459: jj_scanpos = xsp;
08460: if (jj_3_215()) {
08461: jj_scanpos = xsp;
08462: if (jj_3_216()) {
08463: jj_scanpos = xsp;
08464: if (jj_3_217()) {
08465: jj_scanpos = xsp;
08466: if (jj_3_218()) {
08467: jj_scanpos = xsp;
08468: if (jj_3_219()) {
08469: jj_scanpos = xsp;
08470: if (jj_3_220()) {
08471: jj_scanpos = xsp;
08472: if (jj_3_221()) {
08473: jj_scanpos = xsp;
08474: if (jj_3_222()) {
08475: jj_scanpos = xsp;
08476: if (jj_3_223()) {
08477: jj_scanpos = xsp;
08478: if (jj_3_224()) {
08479: jj_scanpos = xsp;
08480: if (jj_3_225()) {
08481: jj_scanpos = xsp;
08482: if (jj_3_226()) {
08483: jj_scanpos = xsp;
08484: if (jj_3_227()) {
08485: jj_scanpos = xsp;
08486: if (jj_3_228()) {
08487: jj_scanpos = xsp;
08488: if (jj_3_229()) {
08489: jj_scanpos = xsp;
08490: if (jj_3_230()) {
08491: jj_scanpos = xsp;
08492: if (jj_3_231()) {
08493: jj_scanpos = xsp;
08494: if (jj_3_232()) {
08495: jj_scanpos = xsp;
08496: if (jj_3_233()) {
08497: jj_scanpos = xsp;
08498: if (jj_3_234()) {
08499: jj_scanpos = xsp;
08500: if (jj_3_235()) {
08501: jj_scanpos = xsp;
08502: if (jj_3_236()) {
08503: jj_scanpos = xsp;
08504: if (jj_3_237()) {
08505: jj_scanpos = xsp;
08506: if (jj_3_238()) {
08507: jj_scanpos = xsp;
08508: if (jj_3_239()) {
08509: jj_scanpos = xsp;
08510: if (jj_3_240()) {
08511: jj_scanpos = xsp;
08512: if (jj_3_241()) {
08513: jj_scanpos = xsp;
08514: if (jj_3_242()) {
08515: jj_scanpos = xsp;
08516: if (jj_3_243()) {
08517: jj_scanpos = xsp;
08518: if (jj_3_244()) {
08519: jj_scanpos = xsp;
08520: if (jj_3_245()) {
08521: jj_scanpos = xsp;
08522: if (jj_3_246()) {
08523: jj_scanpos = xsp;
08524: if (jj_3_247()) {
08525: jj_scanpos = xsp;
08526: if (jj_3_248()) {
08527: jj_scanpos = xsp;
08528: if (jj_3_249()) {
08529: jj_scanpos = xsp;
08530: if (jj_3_250()) {
08531: jj_scanpos = xsp;
08532: if (jj_3_251()) {
08533: jj_scanpos = xsp;
08534: if (jj_3_252()) {
08535: jj_scanpos = xsp;
08536: if (jj_3_253()) {
08537: jj_scanpos = xsp;
08538: if (jj_3_254()) {
08539: jj_scanpos = xsp;
08540: if (jj_3_255()) {
08541: jj_scanpos = xsp;
08542: if (jj_3_256())
08543: return true;
08544: }
08545: }
08546: }
08547: }
08548: }
08549: }
08550: }
08551: }
08552: }
08553: }
08554: }
08555: }
08556: }
08557: }
08558: }
08559: }
08560: }
08561: }
08562: }
08563: }
08564: }
08565: }
08566: }
08567: }
08568: }
08569: }
08570: }
08571: }
08572: }
08573: }
08574: }
08575: }
08576: }
08577: }
08578: }
08579: }
08580: }
08581: }
08582: }
08583: }
08584: }
08585: }
08586: }
08587: }
08588: }
08589: }
08590: }
08591: }
08592: }
08593: }
08594: }
08595: }
08596: }
08597: }
08598: }
08599: }
08600: }
08601: }
08602: }
08603: }
08604: }
08605: }
08606: }
08607: }
08608: }
08609: }
08610: }
08611: }
08612: }
08613: }
08614: }
08615: }
08616: }
08617: }
08618: }
08619: }
08620: }
08621: }
08622: }
08623: }
08624: }
08625: }
08626: }
08627: }
08628: }
08629: }
08630: }
08631: }
08632: }
08633: }
08634: }
08635: }
08636: }
08637: }
08638: }
08639: }
08640: }
08641: }
08642: }
08643: }
08644: }
08645: }
08646: return false;
08647: }
08648:
08649: final private boolean jj_3_97() {
08650: if (jj_scan_token(SENSITIVE))
08651: return true;
08652: return false;
08653: }
08654:
08655: final private boolean jj_3R_64() {
08656: Token xsp;
08657: xsp = jj_scanpos;
08658: if (jj_3_96()) {
08659: jj_scanpos = xsp;
08660: if (jj_3_97())
08661: return true;
08662: }
08663: return false;
08664: }
08665:
08666: final private boolean jj_3_96() {
08667: if (jj_scan_token(INSENSITIVE))
08668: return true;
08669: return false;
08670: }
08671:
08672: final private boolean jj_3_153() {
08673: if (jj_scan_token(IDENTIFIER))
08674: return true;
08675: return false;
08676: }
08677:
08678: final private boolean jj_3R_78() {
08679: Token xsp;
08680: xsp = jj_scanpos;
08681: if (jj_3_152()) {
08682: jj_scanpos = xsp;
08683: if (jj_3_153())
08684: return true;
08685: }
08686: return false;
08687: }
08688:
08689: final private boolean jj_3_152() {
08690: if (jj_3R_71())
08691: return true;
08692: return false;
08693: }
08694:
08695: final private boolean jj_3R_9() {
08696: if (jj_scan_token(BANG))
08697: return true;
08698: if (jj_scan_token(STRING))
08699: return true;
08700: return false;
08701: }
08702:
08703: final private boolean jj_3_150() {
08704: if (jj_scan_token(COMMA))
08705: return true;
08706: if (jj_3R_70())
08707: return true;
08708: return false;
08709: }
08710:
08711: final private boolean jj_3_94() {
08712: if (jj_scan_token(SCROLL))
08713: return true;
08714: if (jj_3R_64())
08715: return true;
08716: return false;
08717: }
08718:
08719: final private boolean jj_3R_70() {
08720: if (jj_3R_78())
08721: return true;
08722: if (jj_scan_token(EQUALS_OPERATOR))
08723: return true;
08724: return false;
08725: }
08726:
08727: final private boolean jj_3_95() {
08728: if (jj_scan_token(WITH))
08729: return true;
08730: if (jj_3R_65())
08731: return true;
08732: return false;
08733: }
08734:
08735: final private boolean jj_3R_24() {
08736: if (jj_scan_token(GET))
08737: return true;
08738: Token xsp;
08739: xsp = jj_scanpos;
08740: if (jj_3_94())
08741: jj_scanpos = xsp;
08742: xsp = jj_scanpos;
08743: if (jj_3_95())
08744: jj_scanpos = xsp;
08745: if (jj_scan_token(CURSOR))
08746: return true;
08747: return false;
08748: }
08749:
08750: final private boolean jj_3R_74() {
08751: if (jj_scan_token(INTEGER))
08752: return true;
08753: return false;
08754: }
08755:
08756: final private boolean jj_3_151() {
08757: if (jj_3R_70())
08758: return true;
08759: return false;
08760: }
08761:
08762: final private boolean jj_3R_63() {
08763: Token xsp;
08764: xsp = jj_scanpos;
08765: if (jj_3_151())
08766: jj_scanpos = xsp;
08767: return false;
08768: }
08769:
08770: final private boolean jj_3_149() {
08771: if (jj_3R_60())
08772: return true;
08773: return false;
08774: }
08775:
08776: final private boolean jj_3R_30() {
08777: if (jj_scan_token(MAXIMUMDISPLAYWIDTH))
08778: return true;
08779: if (jj_3R_74())
08780: return true;
08781: return false;
08782: }
08783:
08784: final private boolean jj_3R_58() {
08785: if (jj_scan_token(CP_DISCONNECT))
08786: return true;
08787: Token xsp;
08788: xsp = jj_scanpos;
08789: if (jj_3_149())
08790: jj_scanpos = xsp;
08791: return false;
08792: }
08793:
08794: final private boolean jj_3_148() {
08795: if (jj_scan_token(AS))
08796: return true;
08797: if (jj_3R_60())
08798: return true;
08799: return false;
08800: }
08801:
08802: final private boolean jj_3R_33() {
08803: if (jj_scan_token(PREPARE))
08804: return true;
08805: if (jj_3R_60())
08806: return true;
08807: return false;
08808: }
08809:
08810: final private boolean jj_3_113() {
08811: if (jj_scan_token(OFF))
08812: return true;
08813: return false;
08814: }
08815:
08816: final private boolean jj_3_112() {
08817: if (jj_scan_token(ON))
08818: return true;
08819: return false;
08820: }
08821:
08822: final private boolean jj_3R_17() {
08823: if (jj_scan_token(ELAPSEDTIME))
08824: return true;
08825: Token xsp;
08826: xsp = jj_scanpos;
08827: if (jj_3_112()) {
08828: jj_scanpos = xsp;
08829: if (jj_3_113())
08830: return true;
08831: }
08832: return false;
08833: }
08834:
08835: final private boolean jj_3R_57() {
08836: if (jj_scan_token(CP_GETCONNECTION))
08837: return true;
08838: Token xsp;
08839: xsp = jj_scanpos;
08840: if (jj_3_148())
08841: jj_scanpos = xsp;
08842: return false;
08843: }
08844:
08845: final private boolean jj_3R_27() {
08846: if (jj_scan_token(PREPARE))
08847: return true;
08848: if (jj_scan_token(PROCEDURE))
08849: return true;
08850: return false;
08851: }
08852:
08853: final private boolean jj_3_147() {
08854: if (jj_scan_token(AS))
08855: return true;
08856: if (jj_3R_60())
08857: return true;
08858: return false;
08859: }
08860:
08861: final private boolean jj_3_146() {
08862: if (jj_scan_token(PASSWORD))
08863: return true;
08864: if (jj_scan_token(STRING))
08865: return true;
08866: return false;
08867: }
08868:
08869: final private boolean jj_3_145() {
08870: if (jj_scan_token(USER))
08871: return true;
08872: if (jj_scan_token(STRING))
08873: return true;
08874: return false;
08875: }
08876:
08877: final private boolean jj_3_111() {
08878: if (jj_scan_token(OFF))
08879: return true;
08880: return false;
08881: }
08882:
08883: final private boolean jj_3_110() {
08884: if (jj_scan_token(ON))
08885: return true;
08886: return false;
08887: }
08888:
08889: final private boolean jj_3R_36() {
08890: if (jj_scan_token(READONLY))
08891: return true;
08892: Token xsp;
08893: xsp = jj_scanpos;
08894: if (jj_3_110()) {
08895: jj_scanpos = xsp;
08896: if (jj_3_111())
08897: return true;
08898: }
08899: return false;
08900: }
08901:
08902: final private boolean jj_3_90() {
08903: if (jj_3R_60())
08904: return true;
08905: return false;
08906: }
08907:
08908: final private boolean jj_3_144() {
08909: if (jj_scan_token(PROTOCOL))
08910: return true;
08911: if (jj_scan_token(STRING))
08912: return true;
08913: return false;
08914: }
08915:
08916: final private boolean jj_3_93() {
08917: if (jj_scan_token(QUIT))
08918: return true;
08919: return false;
08920: }
08921:
08922: final private boolean jj_3_92() {
08923: if (jj_scan_token(EXIT))
08924: return true;
08925: return false;
08926: }
08927:
08928: final private boolean jj_3R_22() {
08929: Token xsp;
08930: xsp = jj_scanpos;
08931: if (jj_3_92()) {
08932: jj_scanpos = xsp;
08933: if (jj_3_93())
08934: return true;
08935: }
08936: return false;
08937: }
08938:
08939: final private boolean jj_3R_56() {
08940: if (jj_scan_token(CP_CONNECT))
08941: return true;
08942: Token xsp;
08943: xsp = jj_scanpos;
08944: if (jj_3_145())
08945: jj_scanpos = xsp;
08946: xsp = jj_scanpos;
08947: if (jj_3_146())
08948: jj_scanpos = xsp;
08949: xsp = jj_scanpos;
08950: if (jj_3_147())
08951: jj_scanpos = xsp;
08952: return false;
08953: }
08954:
08955: final private boolean jj_3_89() {
08956: if (jj_scan_token(ALL))
08957: return true;
08958: return false;
08959: }
08960:
08961: final private boolean jj_3_109() {
08962: if (jj_scan_token(OFF))
08963: return true;
08964: return false;
08965: }
08966:
08967: final private boolean jj_3_108() {
08968: if (jj_scan_token(ON))
08969: return true;
08970: return false;
08971: }
08972:
08973: final private boolean jj_3_88() {
08974: if (jj_scan_token(CURRENT))
08975: return true;
08976: return false;
08977: }
08978:
08979: final private boolean jj_3_91() {
08980: Token xsp;
08981: xsp = jj_scanpos;
08982: if (jj_3_88()) {
08983: jj_scanpos = xsp;
08984: if (jj_3_89()) {
08985: jj_scanpos = xsp;
08986: if (jj_3_90())
08987: return true;
08988: }
08989: }
08990: return false;
08991: }
08992:
08993: final private boolean jj_3R_29() {
08994: if (jj_scan_token(LOCALIZEDDISPLAY))
08995: return true;
08996: Token xsp;
08997: xsp = jj_scanpos;
08998: if (jj_3_108()) {
08999: jj_scanpos = xsp;
09000: if (jj_3_109())
09001: return true;
09002: }
09003: return false;
09004: }
09005:
09006: final private boolean jj_3_143() {
09007: if (jj_scan_token(AS))
09008: return true;
09009: if (jj_3R_60())
09010: return true;
09011: return false;
09012: }
09013:
09014: final private boolean jj_3_142() {
09015: if (jj_scan_token(PASSWORD))
09016: return true;
09017: if (jj_scan_token(STRING))
09018: return true;
09019: return false;
09020: }
09021:
09022: final private boolean jj_3_141() {
09023: if (jj_scan_token(USER))
09024: return true;
09025: if (jj_scan_token(STRING))
09026: return true;
09027: return false;
09028: }
09029:
09030: final private boolean jj_3_140() {
09031: if (jj_scan_token(PROTOCOL))
09032: return true;
09033: if (jj_scan_token(STRING))
09034: return true;
09035: return false;
09036: }
09037:
09038: final private boolean jj_3R_55() {
09039: if (jj_scan_token(CP_DATASOURCE))
09040: return true;
09041: if (jj_scan_token(STRING))
09042: return true;
09043: return false;
09044: }
09045:
09046: final private boolean jj_3R_15() {
09047: if (jj_scan_token(DISCONNECT))
09048: return true;
09049: Token xsp;
09050: xsp = jj_scanpos;
09051: if (jj_3_91())
09052: jj_scanpos = xsp;
09053: return false;
09054: }
09055:
09056: final private boolean jj_3R_32() {
09057: if (jj_scan_token(NOHOLDFORCONNECTION))
09058: return true;
09059: return false;
09060: }
09061:
09062: final private boolean jj_3_87() {
09063: if (jj_scan_token(WORK))
09064: return true;
09065: return false;
09066: }
09067:
09068: final private boolean jj_3R_54() {
09069: if (jj_scan_token(DATASOURCE))
09070: return true;
09071: if (jj_scan_token(STRING))
09072: return true;
09073: return false;
09074: }
09075:
09076: final private boolean jj_3R_76() {
09077: if (jj_scan_token(ROLLBACK))
09078: return true;
09079: Token xsp;
09080: xsp = jj_scanpos;
09081: if (jj_3_87())
09082: jj_scanpos = xsp;
09083: return false;
09084: }
09085:
09086: final private boolean jj_3_107() {
09087: if (jj_scan_token(OFF))
09088: return true;
09089: return false;
09090: }
09091:
09092: final private boolean jj_3_106() {
09093: if (jj_scan_token(ON))
09094: return true;
09095: return false;
09096: }
09097:
09098: final private boolean jj_3R_7() {
09099: if (jj_scan_token(AUTOCOMMIT))
09100: return true;
09101: Token xsp;
09102: xsp = jj_scanpos;
09103: if (jj_3_106()) {
09104: jj_scanpos = xsp;
09105: if (jj_3_107())
09106: return true;
09107: }
09108: return false;
09109: }
09110:
09111: final private boolean jj_3_86() {
09112: if (jj_scan_token(WORK))
09113: return true;
09114: return false;
09115: }
09116:
09117: final private boolean jj_3_76() {
09118: if (jj_scan_token(PERIOD))
09119: return true;
09120: if (jj_3R_60())
09121: return true;
09122: return false;
09123: }
09124:
09125: final private boolean jj_3R_12() {
09126: if (jj_scan_token(COMMIT))
09127: return true;
09128: Token xsp;
09129: xsp = jj_scanpos;
09130: if (jj_3_86())
09131: jj_scanpos = xsp;
09132: return false;
09133: }
09134:
09135: final private boolean jj_3_105() {
09136: if (jj_scan_token(RESOURCE))
09137: return true;
09138: return false;
09139: }
09140:
09141: final private boolean jj_3_74() {
09142: if (jj_scan_token(ALIASES))
09143: return true;
09144: return false;
09145: }
09146:
09147: final private boolean jj_3_139() {
09148: if (jj_scan_token(XA_SUSPEND))
09149: return true;
09150: return false;
09151: }
09152:
09153: final private boolean jj_3_80() {
09154: if (jj_scan_token(IN))
09155: return true;
09156: if (jj_3R_60())
09157: return true;
09158: return false;
09159: }
09160:
09161: final private boolean jj_3_138() {
09162: if (jj_scan_token(XA_SUCCESS))
09163: return true;
09164: return false;
09165: }
09166:
09167: final private boolean jj_3R_39() {
09168: if (jj_scan_token(RUN))
09169: return true;
09170: Token xsp;
09171: xsp = jj_scanpos;
09172: if (jj_3_105())
09173: jj_scanpos = xsp;
09174: if (jj_scan_token(STRING))
09175: return true;
09176: return false;
09177: }
09178:
09179: final private boolean jj_3_85() {
09180: if (jj_scan_token(SHOW))
09181: return true;
09182: if (jj_scan_token(SCHEMAS))
09183: return true;
09184: return false;
09185: }
09186:
09187: final private boolean jj_3_137() {
09188: if (jj_scan_token(XA_STARTRSCAN))
09189: return true;
09190: return false;
09191: }
09192:
09193: final private boolean jj_3_84() {
09194: if (jj_scan_token(SHOW))
09195: return true;
09196: if (jj_scan_token(PROCEDURES))
09197: return true;
09198: return false;
09199: }
09200:
09201: final private boolean jj_3_73() {
09202: if (jj_scan_token(SYNONYMS))
09203: return true;
09204: return false;
09205: }
09206:
09207: final private boolean jj_3_136() {
09208: if (jj_scan_token(XA_RESUME))
09209: return true;
09210: return false;
09211: }
09212:
09213: final private boolean jj_3_78() {
09214: if (jj_scan_token(FROM))
09215: return true;
09216: if (jj_3R_60())
09217: return true;
09218: return false;
09219: }
09220:
09221: final private boolean jj_3_79() {
09222: Token xsp;
09223: xsp = jj_scanpos;
09224: if (jj_3_77()) {
09225: jj_scanpos = xsp;
09226: if (jj_3_78())
09227: return true;
09228: }
09229: return false;
09230: }
09231:
09232: final private boolean jj_3_77() {
09233: if (jj_scan_token(IN))
09234: return true;
09235: if (jj_3R_60())
09236: return true;
09237: return false;
09238: }
09239:
09240: final private boolean jj_3_135() {
09241: if (jj_scan_token(XA_NOFLAGS))
09242: return true;
09243: return false;
09244: }
09245:
09246: final private boolean jj_3_72() {
09247: if (jj_scan_token(VIEWS))
09248: return true;
09249: return false;
09250: }
09251:
09252: final private boolean jj_3_134() {
09253: if (jj_scan_token(XA_JOIN))
09254: return true;
09255: return false;
09256: }
09257:
09258: final private boolean jj_3R_38() {
09259: if (jj_scan_token(REMOVE))
09260: return true;
09261: if (jj_3R_60())
09262: return true;
09263: return false;
09264: }
09265:
09266: final private boolean jj_3_83() {
09267: if (jj_scan_token(SHOW))
09268: return true;
09269: if (jj_scan_token(INDEXES))
09270: return true;
09271: return false;
09272: }
09273:
09274: final private boolean jj_3_133() {
09275: if (jj_scan_token(XA_FAIL))
09276: return true;
09277: return false;
09278: }
09279:
09280: final private boolean jj_3_75() {
09281: if (jj_scan_token(IN))
09282: return true;
09283: if (jj_3R_60())
09284: return true;
09285: return false;
09286: }
09287:
09288: final private boolean jj_3R_75() {
09289: Token xsp;
09290: xsp = jj_scanpos;
09291: if (jj_3_132()) {
09292: jj_scanpos = xsp;
09293: if (jj_3_133()) {
09294: jj_scanpos = xsp;
09295: if (jj_3_134()) {
09296: jj_scanpos = xsp;
09297: if (jj_3_135()) {
09298: jj_scanpos = xsp;
09299: if (jj_3_136()) {
09300: jj_scanpos = xsp;
09301: if (jj_3_137()) {
09302: jj_scanpos = xsp;
09303: if (jj_3_138()) {
09304: jj_scanpos = xsp;
09305: if (jj_3_139())
09306: return true;
09307: }
09308: }
09309: }
09310: }
09311: }
09312: }
09313: }
09314: return false;
09315: }
09316:
09317: final private boolean jj_3_132() {
09318: if (jj_scan_token(XA_ENDRSCAN))
09319: return true;
09320: return false;
09321: }
09322:
09323: final private boolean jj_3_71() {
09324: if (jj_scan_token(TABLES))
09325: return true;
09326: return false;
09327: }
09328:
09329: final private boolean jj_3R_41() {
09330: Token xsp;
09331: xsp = jj_scanpos;
09332: if (jj_3_81()) {
09333: jj_scanpos = xsp;
09334: if (jj_3_82()) {
09335: jj_scanpos = xsp;
09336: if (jj_3_83()) {
09337: jj_scanpos = xsp;
09338: if (jj_3_84()) {
09339: jj_scanpos = xsp;
09340: if (jj_3_85())
09341: return true;
09342: }
09343: }
09344: }
09345: }
09346: return false;
09347: }
09348:
09349: final private boolean jj_3_82() {
09350: if (jj_scan_token(SHOW))
09351: return true;
09352: Token xsp;
09353: xsp = jj_scanpos;
09354: if (jj_3_71()) {
09355: jj_scanpos = xsp;
09356: if (jj_3_72()) {
09357: jj_scanpos = xsp;
09358: if (jj_3_73()) {
09359: jj_scanpos = xsp;
09360: if (jj_3_74())
09361: return true;
09362: }
09363: }
09364: }
09365: return false;
09366: }
09367:
09368: final private boolean jj_3_81() {
09369: if (jj_scan_token(SHOW))
09370: return true;
09371: if (jj_scan_token(CONNECTIONS))
09372: return true;
09373: return false;
09374: }
09375:
09376: final private boolean jj_3R_53() {
09377: if (jj_scan_token(XA_START))
09378: return true;
09379: if (jj_3R_75())
09380: return true;
09381: return false;
09382: }
09383:
09384: final private boolean jj_3R_42() {
09385: if (jj_scan_token(WAIT))
09386: return true;
09387: if (jj_scan_token(FOR))
09388: return true;
09389: return false;
09390: }
09391:
09392: final private boolean jj_3R_52() {
09393: if (jj_scan_token(XA_ROLLBACK))
09394: return true;
09395: if (jj_3R_74())
09396: return true;
09397: return false;
09398: }
09399:
09400: final private boolean jj_3_70() {
09401: if (jj_scan_token(AS))
09402: return true;
09403: if (jj_3R_60())
09404: return true;
09405: return false;
09406: }
09407:
09408: final private boolean jj_3R_40() {
09409: if (jj_scan_token(SET))
09410: return true;
09411: if (jj_scan_token(CONNECTION))
09412: return true;
09413: return false;
09414: }
09415:
09416: final private boolean jj_3R_8() {
09417: if (jj_scan_token(ASYNC))
09418: return true;
09419: if (jj_3R_60())
09420: return true;
09421: return false;
09422: }
09423:
09424: final private boolean jj_3R_51() {
09425: if (jj_scan_token(XA_RECOVER))
09426: return true;
09427: if (jj_3R_75())
09428: return true;
09429: return false;
09430: }
09431:
09432: final private boolean jj_3_131() {
09433: if (jj_scan_token(AS))
09434: return true;
09435: if (jj_3R_60())
09436: return true;
09437: return false;
09438: }
09439:
09440: final private boolean jj_3R_50() {
09441: if (jj_scan_token(XA_PREPARE))
09442: return true;
09443: if (jj_3R_74())
09444: return true;
09445: return false;
09446: }
09447:
09448: final private boolean jj_3R_47() {
09449: if (jj_scan_token(XA_GETCONNECTION))
09450: return true;
09451: Token xsp;
09452: xsp = jj_scanpos;
09453: if (jj_3_131())
09454: jj_scanpos = xsp;
09455: return false;
09456: }
09457:
09458: final private boolean jj_3R_62() {
09459: if (jj_3R_77())
09460: return true;
09461: return false;
09462: }
09463:
09464: final private boolean jj_3R_49() {
09465: if (jj_scan_token(XA_FORGET))
09466: return true;
09467: if (jj_3R_74())
09468: return true;
09469: return false;
09470: }
09471:
09472: final private boolean jj_3_130() {
09473: if (jj_scan_token(XA_2PHASE))
09474: return true;
09475: return false;
09476: }
09477:
09478: public ijTokenManager token_source;
09479: public Token token, jj_nt;
09480: private Token jj_scanpos, jj_lastpos;
09481: private int jj_la;
09482: public boolean lookingAhead = false;
09483: private boolean jj_semLA;
09484: private int jj_gen;
09485: final private int[] jj_la1 = new int[0];
09486: static private int[] jj_la1_0;
09487: static private int[] jj_la1_1;
09488: static private int[] jj_la1_2;
09489: static private int[] jj_la1_3;
09490: static {
09491: jj_la1_0();
09492: jj_la1_1();
09493: jj_la1_2();
09494: jj_la1_3();
09495: }
09496:
09497: private static void jj_la1_0() {
09498: jj_la1_0 = new int[] {};
09499: }
09500:
09501: private static void jj_la1_1() {
09502: jj_la1_1 = new int[] {};
09503: }
09504:
09505: private static void jj_la1_2() {
09506: jj_la1_2 = new int[] {};
09507: }
09508:
09509: private static void jj_la1_3() {
09510: jj_la1_3 = new int[] {};
09511: }
09512:
09513: final private JJCalls[] jj_2_rtns = new JJCalls[256];
09514: private boolean jj_rescan = false;
09515: private int jj_gc = 0;
09516:
09517: public ij(CharStream stream) {
09518: token_source = new ijTokenManager(stream);
09519: token = new Token();
09520: token.next = jj_nt = token_source.getNextToken();
09521: jj_gen = 0;
09522: for (int i = 0; i < 0; i++)
09523: jj_la1[i] = -1;
09524: for (int i = 0; i < jj_2_rtns.length; i++)
09525: jj_2_rtns[i] = new JJCalls();
09526: }
09527:
09528: public void ReInit(CharStream stream) {
09529: token_source.ReInit(stream);
09530: token = new Token();
09531: token.next = jj_nt = token_source.getNextToken();
09532: jj_gen = 0;
09533: for (int i = 0; i < 0; i++)
09534: jj_la1[i] = -1;
09535: for (int i = 0; i < jj_2_rtns.length; i++)
09536: jj_2_rtns[i] = new JJCalls();
09537: }
09538:
09539: public ij(ijTokenManager tm) {
09540: token_source = tm;
09541: token = new Token();
09542: token.next = jj_nt = token_source.getNextToken();
09543: jj_gen = 0;
09544: for (int i = 0; i < 0; i++)
09545: jj_la1[i] = -1;
09546: for (int i = 0; i < jj_2_rtns.length; i++)
09547: jj_2_rtns[i] = new JJCalls();
09548: }
09549:
09550: public void ReInit(ijTokenManager tm) {
09551: token_source = tm;
09552: token = new Token();
09553: token.next = jj_nt = token_source.getNextToken();
09554: jj_gen = 0;
09555: for (int i = 0; i < 0; i++)
09556: jj_la1[i] = -1;
09557: for (int i = 0; i < jj_2_rtns.length; i++)
09558: jj_2_rtns[i] = new JJCalls();
09559: }
09560:
09561: final private Token jj_consume_token(int kind)
09562: throws ParseException {
09563: Token oldToken = token;
09564: if ((token = jj_nt).next != null)
09565: jj_nt = jj_nt.next;
09566: else
09567: jj_nt = jj_nt.next = token_source.getNextToken();
09568: if (token.kind == kind) {
09569: jj_gen++;
09570: if (++jj_gc > 100) {
09571: jj_gc = 0;
09572: for (int i = 0; i < jj_2_rtns.length; i++) {
09573: JJCalls c = jj_2_rtns[i];
09574: while (c != null) {
09575: if (c.gen < jj_gen)
09576: c.first = null;
09577: c = c.next;
09578: }
09579: }
09580: }
09581: return token;
09582: }
09583: jj_nt = token;
09584: token = oldToken;
09585: jj_kind = kind;
09586: throw generateParseException();
09587: }
09588:
09589: static private final class LookaheadSuccess extends java.lang.Error {
09590: }
09591:
09592: final private LookaheadSuccess jj_ls = new LookaheadSuccess();
09593:
09594: final private boolean jj_scan_token(int kind) {
09595: if (jj_scanpos == jj_lastpos) {
09596: jj_la--;
09597: if (jj_scanpos.next == null) {
09598: jj_lastpos = jj_scanpos = jj_scanpos.next = token_source
09599: .getNextToken();
09600: } else {
09601: jj_lastpos = jj_scanpos = jj_scanpos.next;
09602: }
09603: } else {
09604: jj_scanpos = jj_scanpos.next;
09605: }
09606: if (jj_rescan) {
09607: int i = 0;
09608: Token tok = token;
09609: while (tok != null && tok != jj_scanpos) {
09610: i++;
09611: tok = tok.next;
09612: }
09613: if (tok != null)
09614: jj_add_error_token(kind, i);
09615: }
09616: if (jj_scanpos.kind != kind)
09617: return true;
09618: if (jj_la == 0 && jj_scanpos == jj_lastpos)
09619: throw jj_ls;
09620: return false;
09621: }
09622:
09623: final public Token getNextToken() {
09624: if ((token = jj_nt).next != null)
09625: jj_nt = jj_nt.next;
09626: else
09627: jj_nt = jj_nt.next = token_source.getNextToken();
09628: jj_gen++;
09629: return token;
09630: }
09631:
09632: final public Token getToken(int index) {
09633: Token t = lookingAhead ? jj_scanpos : token;
09634: for (int i = 0; i < index; i++) {
09635: if (t.next != null)
09636: t = t.next;
09637: else
09638: t = t.next = token_source.getNextToken();
09639: }
09640: return t;
09641: }
09642:
09643: private java.util.Vector jj_expentries = new java.util.Vector();
09644: private int[] jj_expentry;
09645: private int jj_kind = -1;
09646: private int[] jj_lasttokens = new int[100];
09647: private int jj_endpos;
09648:
09649: private void jj_add_error_token(int kind, int pos) {
09650: if (pos >= 100)
09651: return;
09652: if (pos == jj_endpos + 1) {
09653: jj_lasttokens[jj_endpos++] = kind;
09654: } else if (jj_endpos != 0) {
09655: jj_expentry = new int[jj_endpos];
09656: for (int i = 0; i < jj_endpos; i++) {
09657: jj_expentry[i] = jj_lasttokens[i];
09658: }
09659: boolean exists = false;
09660: for (java.util.Enumeration e = jj_expentries.elements(); e
09661: .hasMoreElements();) {
09662: int[] oldentry = (int[]) (e.nextElement());
09663: if (oldentry.length == jj_expentry.length) {
09664: exists = true;
09665: for (int i = 0; i < jj_expentry.length; i++) {
09666: if (oldentry[i] != jj_expentry[i]) {
09667: exists = false;
09668: break;
09669: }
09670: }
09671: if (exists)
09672: break;
09673: }
09674: }
09675: if (!exists)
09676: jj_expentries.addElement(jj_expentry);
09677: if (pos != 0)
09678: jj_lasttokens[(jj_endpos = pos) - 1] = kind;
09679: }
09680: }
09681:
09682: public ParseException generateParseException() {
09683: jj_expentries.removeAllElements();
09684: boolean[] la1tokens = new boolean[125];
09685: for (int i = 0; i < 125; i++) {
09686: la1tokens[i] = false;
09687: }
09688: if (jj_kind >= 0) {
09689: la1tokens[jj_kind] = true;
09690: jj_kind = -1;
09691: }
09692: for (int i = 0; i < 0; i++) {
09693: if (jj_la1[i] == jj_gen) {
09694: for (int j = 0; j < 32; j++) {
09695: if ((jj_la1_0[i] & (1 << j)) != 0) {
09696: la1tokens[j] = true;
09697: }
09698: if ((jj_la1_1[i] & (1 << j)) != 0) {
09699: la1tokens[32 + j] = true;
09700: }
09701: if ((jj_la1_2[i] & (1 << j)) != 0) {
09702: la1tokens[64 + j] = true;
09703: }
09704: if ((jj_la1_3[i] & (1 << j)) != 0) {
09705: la1tokens[96 + j] = true;
09706: }
09707: }
09708: }
09709: }
09710: for (int i = 0; i < 125; i++) {
09711: if (la1tokens[i]) {
09712: jj_expentry = new int[1];
09713: jj_expentry[0] = i;
09714: jj_expentries.addElement(jj_expentry);
09715: }
09716: }
09717: jj_endpos = 0;
09718: jj_rescan_token();
09719: jj_add_error_token(0, 0);
09720: int[][] exptokseq = new int[jj_expentries.size()][];
09721: for (int i = 0; i < jj_expentries.size(); i++) {
09722: exptokseq[i] = (int[]) jj_expentries.elementAt(i);
09723: }
09724: return new ParseException(token, exptokseq,
09725: ijConstants.tokenImage);
09726: }
09727:
09728: final public void enable_tracing() {
09729: }
09730:
09731: final public void disable_tracing() {
09732: }
09733:
09734: final private void jj_rescan_token() {
09735: jj_rescan = true;
09736: for (int i = 0; i < 256; i++) {
09737: try {
09738: JJCalls p = jj_2_rtns[i];
09739: do {
09740: if (p.gen > jj_gen) {
09741: jj_la = p.arg;
09742: jj_lastpos = jj_scanpos = p.first;
09743: switch (i) {
09744: case 0:
09745: jj_3_1();
09746: break;
09747: case 1:
09748: jj_3_2();
09749: break;
09750: case 2:
09751: jj_3_3();
09752: break;
09753: case 3:
09754: jj_3_4();
09755: break;
09756: case 4:
09757: jj_3_5();
09758: break;
09759: case 5:
09760: jj_3_6();
09761: break;
09762: case 6:
09763: jj_3_7();
09764: break;
09765: case 7:
09766: jj_3_8();
09767: break;
09768: case 8:
09769: jj_3_9();
09770: break;
09771: case 9:
09772: jj_3_10();
09773: break;
09774: case 10:
09775: jj_3_11();
09776: break;
09777: case 11:
09778: jj_3_12();
09779: break;
09780: case 12:
09781: jj_3_13();
09782: break;
09783: case 13:
09784: jj_3_14();
09785: break;
09786: case 14:
09787: jj_3_15();
09788: break;
09789: case 15:
09790: jj_3_16();
09791: break;
09792: case 16:
09793: jj_3_17();
09794: break;
09795: case 17:
09796: jj_3_18();
09797: break;
09798: case 18:
09799: jj_3_19();
09800: break;
09801: case 19:
09802: jj_3_20();
09803: break;
09804: case 20:
09805: jj_3_21();
09806: break;
09807: case 21:
09808: jj_3_22();
09809: break;
09810: case 22:
09811: jj_3_23();
09812: break;
09813: case 23:
09814: jj_3_24();
09815: break;
09816: case 24:
09817: jj_3_25();
09818: break;
09819: case 25:
09820: jj_3_26();
09821: break;
09822: case 26:
09823: jj_3_27();
09824: break;
09825: case 27:
09826: jj_3_28();
09827: break;
09828: case 28:
09829: jj_3_29();
09830: break;
09831: case 29:
09832: jj_3_30();
09833: break;
09834: case 30:
09835: jj_3_31();
09836: break;
09837: case 31:
09838: jj_3_32();
09839: break;
09840: case 32:
09841: jj_3_33();
09842: break;
09843: case 33:
09844: jj_3_34();
09845: break;
09846: case 34:
09847: jj_3_35();
09848: break;
09849: case 35:
09850: jj_3_36();
09851: break;
09852: case 36:
09853: jj_3_37();
09854: break;
09855: case 37:
09856: jj_3_38();
09857: break;
09858: case 38:
09859: jj_3_39();
09860: break;
09861: case 39:
09862: jj_3_40();
09863: break;
09864: case 40:
09865: jj_3_41();
09866: break;
09867: case 41:
09868: jj_3_42();
09869: break;
09870: case 42:
09871: jj_3_43();
09872: break;
09873: case 43:
09874: jj_3_44();
09875: break;
09876: case 44:
09877: jj_3_45();
09878: break;
09879: case 45:
09880: jj_3_46();
09881: break;
09882: case 46:
09883: jj_3_47();
09884: break;
09885: case 47:
09886: jj_3_48();
09887: break;
09888: case 48:
09889: jj_3_49();
09890: break;
09891: case 49:
09892: jj_3_50();
09893: break;
09894: case 50:
09895: jj_3_51();
09896: break;
09897: case 51:
09898: jj_3_52();
09899: break;
09900: case 52:
09901: jj_3_53();
09902: break;
09903: case 53:
09904: jj_3_54();
09905: break;
09906: case 54:
09907: jj_3_55();
09908: break;
09909: case 55:
09910: jj_3_56();
09911: break;
09912: case 56:
09913: jj_3_57();
09914: break;
09915: case 57:
09916: jj_3_58();
09917: break;
09918: case 58:
09919: jj_3_59();
09920: break;
09921: case 59:
09922: jj_3_60();
09923: break;
09924: case 60:
09925: jj_3_61();
09926: break;
09927: case 61:
09928: jj_3_62();
09929: break;
09930: case 62:
09931: jj_3_63();
09932: break;
09933: case 63:
09934: jj_3_64();
09935: break;
09936: case 64:
09937: jj_3_65();
09938: break;
09939: case 65:
09940: jj_3_66();
09941: break;
09942: case 66:
09943: jj_3_67();
09944: break;
09945: case 67:
09946: jj_3_68();
09947: break;
09948: case 68:
09949: jj_3_69();
09950: break;
09951: case 69:
09952: jj_3_70();
09953: break;
09954: case 70:
09955: jj_3_71();
09956: break;
09957: case 71:
09958: jj_3_72();
09959: break;
09960: case 72:
09961: jj_3_73();
09962: break;
09963: case 73:
09964: jj_3_74();
09965: break;
09966: case 74:
09967: jj_3_75();
09968: break;
09969: case 75:
09970: jj_3_76();
09971: break;
09972: case 76:
09973: jj_3_77();
09974: break;
09975: case 77:
09976: jj_3_78();
09977: break;
09978: case 78:
09979: jj_3_79();
09980: break;
09981: case 79:
09982: jj_3_80();
09983: break;
09984: case 80:
09985: jj_3_81();
09986: break;
09987: case 81:
09988: jj_3_82();
09989: break;
09990: case 82:
09991: jj_3_83();
09992: break;
09993: case 83:
09994: jj_3_84();
09995: break;
09996: case 84:
09997: jj_3_85();
09998: break;
09999: case 85:
10000: jj_3_86();
10001: break;
10002: case 86:
10003: jj_3_87();
10004: break;
10005: case 87:
10006: jj_3_88();
10007: break;
10008: case 88:
10009: jj_3_89();
10010: break;
10011: case 89:
10012: jj_3_90();
10013: break;
10014: case 90:
10015: jj_3_91();
10016: break;
10017: case 91:
10018: jj_3_92();
10019: break;
10020: case 92:
10021: jj_3_93();
10022: break;
10023: case 93:
10024: jj_3_94();
10025: break;
10026: case 94:
10027: jj_3_95();
10028: break;
10029: case 95:
10030: jj_3_96();
10031: break;
10032: case 96:
10033: jj_3_97();
10034: break;
10035: case 97:
10036: jj_3_98();
10037: break;
10038: case 98:
10039: jj_3_99();
10040: break;
10041: case 99:
10042: jj_3_100();
10043: break;
10044: case 100:
10045: jj_3_101();
10046: break;
10047: case 101:
10048: jj_3_102();
10049: break;
10050: case 102:
10051: jj_3_103();
10052: break;
10053: case 103:
10054: jj_3_104();
10055: break;
10056: case 104:
10057: jj_3_105();
10058: break;
10059: case 105:
10060: jj_3_106();
10061: break;
10062: case 106:
10063: jj_3_107();
10064: break;
10065: case 107:
10066: jj_3_108();
10067: break;
10068: case 108:
10069: jj_3_109();
10070: break;
10071: case 109:
10072: jj_3_110();
10073: break;
10074: case 110:
10075: jj_3_111();
10076: break;
10077: case 111:
10078: jj_3_112();
10079: break;
10080: case 112:
10081: jj_3_113();
10082: break;
10083: case 113:
10084: jj_3_114();
10085: break;
10086: case 114:
10087: jj_3_115();
10088: break;
10089: case 115:
10090: jj_3_116();
10091: break;
10092: case 116:
10093: jj_3_117();
10094: break;
10095: case 117:
10096: jj_3_118();
10097: break;
10098: case 118:
10099: jj_3_119();
10100: break;
10101: case 119:
10102: jj_3_120();
10103: break;
10104: case 120:
10105: jj_3_121();
10106: break;
10107: case 121:
10108: jj_3_122();
10109: break;
10110: case 122:
10111: jj_3_123();
10112: break;
10113: case 123:
10114: jj_3_124();
10115: break;
10116: case 124:
10117: jj_3_125();
10118: break;
10119: case 125:
10120: jj_3_126();
10121: break;
10122: case 126:
10123: jj_3_127();
10124: break;
10125: case 127:
10126: jj_3_128();
10127: break;
10128: case 128:
10129: jj_3_129();
10130: break;
10131: case 129:
10132: jj_3_130();
10133: break;
10134: case 130:
10135: jj_3_131();
10136: break;
10137: case 131:
10138: jj_3_132();
10139: break;
10140: case 132:
10141: jj_3_133();
10142: break;
10143: case 133:
10144: jj_3_134();
10145: break;
10146: case 134:
10147: jj_3_135();
10148: break;
10149: case 135:
10150: jj_3_136();
10151: break;
10152: case 136:
10153: jj_3_137();
10154: break;
10155: case 137:
10156: jj_3_138();
10157: break;
10158: case 138:
10159: jj_3_139();
10160: break;
10161: case 139:
10162: jj_3_140();
10163: break;
10164: case 140:
10165: jj_3_141();
10166: break;
10167: case 141:
10168: jj_3_142();
10169: break;
10170: case 142:
10171: jj_3_143();
10172: break;
10173: case 143:
10174: jj_3_144();
10175: break;
10176: case 144:
10177: jj_3_145();
10178: break;
10179: case 145:
10180: jj_3_146();
10181: break;
10182: case 146:
10183: jj_3_147();
10184: break;
10185: case 147:
10186: jj_3_148();
10187: break;
10188: case 148:
10189: jj_3_149();
10190: break;
10191: case 149:
10192: jj_3_150();
10193: break;
10194: case 150:
10195: jj_3_151();
10196: break;
10197: case 151:
10198: jj_3_152();
10199: break;
10200: case 152:
10201: jj_3_153();
10202: break;
10203: case 153:
10204: jj_3_154();
10205: break;
10206: case 154:
10207: jj_3_155();
10208: break;
10209: case 155:
10210: jj_3_156();
10211: break;
10212: case 156:
10213: jj_3_157();
10214: break;
10215: case 157:
10216: jj_3_158();
10217: break;
10218: case 158:
10219: jj_3_159();
10220: break;
10221: case 159:
10222: jj_3_160();
10223: break;
10224: case 160:
10225: jj_3_161();
10226: break;
10227: case 161:
10228: jj_3_162();
10229: break;
10230: case 162:
10231: jj_3_163();
10232: break;
10233: case 163:
10234: jj_3_164();
10235: break;
10236: case 164:
10237: jj_3_165();
10238: break;
10239: case 165:
10240: jj_3_166();
10241: break;
10242: case 166:
10243: jj_3_167();
10244: break;
10245: case 167:
10246: jj_3_168();
10247: break;
10248: case 168:
10249: jj_3_169();
10250: break;
10251: case 169:
10252: jj_3_170();
10253: break;
10254: case 170:
10255: jj_3_171();
10256: break;
10257: case 171:
10258: jj_3_172();
10259: break;
10260: case 172:
10261: jj_3_173();
10262: break;
10263: case 173:
10264: jj_3_174();
10265: break;
10266: case 174:
10267: jj_3_175();
10268: break;
10269: case 175:
10270: jj_3_176();
10271: break;
10272: case 176:
10273: jj_3_177();
10274: break;
10275: case 177:
10276: jj_3_178();
10277: break;
10278: case 178:
10279: jj_3_179();
10280: break;
10281: case 179:
10282: jj_3_180();
10283: break;
10284: case 180:
10285: jj_3_181();
10286: break;
10287: case 181:
10288: jj_3_182();
10289: break;
10290: case 182:
10291: jj_3_183();
10292: break;
10293: case 183:
10294: jj_3_184();
10295: break;
10296: case 184:
10297: jj_3_185();
10298: break;
10299: case 185:
10300: jj_3_186();
10301: break;
10302: case 186:
10303: jj_3_187();
10304: break;
10305: case 187:
10306: jj_3_188();
10307: break;
10308: case 188:
10309: jj_3_189();
10310: break;
10311: case 189:
10312: jj_3_190();
10313: break;
10314: case 190:
10315: jj_3_191();
10316: break;
10317: case 191:
10318: jj_3_192();
10319: break;
10320: case 192:
10321: jj_3_193();
10322: break;
10323: case 193:
10324: jj_3_194();
10325: break;
10326: case 194:
10327: jj_3_195();
10328: break;
10329: case 195:
10330: jj_3_196();
10331: break;
10332: case 196:
10333: jj_3_197();
10334: break;
10335: case 197:
10336: jj_3_198();
10337: break;
10338: case 198:
10339: jj_3_199();
10340: break;
10341: case 199:
10342: jj_3_200();
10343: break;
10344: case 200:
10345: jj_3_201();
10346: break;
10347: case 201:
10348: jj_3_202();
10349: break;
10350: case 202:
10351: jj_3_203();
10352: break;
10353: case 203:
10354: jj_3_204();
10355: break;
10356: case 204:
10357: jj_3_205();
10358: break;
10359: case 205:
10360: jj_3_206();
10361: break;
10362: case 206:
10363: jj_3_207();
10364: break;
10365: case 207:
10366: jj_3_208();
10367: break;
10368: case 208:
10369: jj_3_209();
10370: break;
10371: case 209:
10372: jj_3_210();
10373: break;
10374: case 210:
10375: jj_3_211();
10376: break;
10377: case 211:
10378: jj_3_212();
10379: break;
10380: case 212:
10381: jj_3_213();
10382: break;
10383: case 213:
10384: jj_3_214();
10385: break;
10386: case 214:
10387: jj_3_215();
10388: break;
10389: case 215:
10390: jj_3_216();
10391: break;
10392: case 216:
10393: jj_3_217();
10394: break;
10395: case 217:
10396: jj_3_218();
10397: break;
10398: case 218:
10399: jj_3_219();
10400: break;
10401: case 219:
10402: jj_3_220();
10403: break;
10404: case 220:
10405: jj_3_221();
10406: break;
10407: case 221:
10408: jj_3_222();
10409: break;
10410: case 222:
10411: jj_3_223();
10412: break;
10413: case 223:
10414: jj_3_224();
10415: break;
10416: case 224:
10417: jj_3_225();
10418: break;
10419: case 225:
10420: jj_3_226();
10421: break;
10422: case 226:
10423: jj_3_227();
10424: break;
10425: case 227:
10426: jj_3_228();
10427: break;
10428: case 228:
10429: jj_3_229();
10430: break;
10431: case 229:
10432: jj_3_230();
10433: break;
10434: case 230:
10435: jj_3_231();
10436: break;
10437: case 231:
10438: jj_3_232();
10439: break;
10440: case 232:
10441: jj_3_233();
10442: break;
10443: case 233:
10444: jj_3_234();
10445: break;
10446: case 234:
10447: jj_3_235();
10448: break;
10449: case 235:
10450: jj_3_236();
10451: break;
10452: case 236:
10453: jj_3_237();
10454: break;
10455: case 237:
10456: jj_3_238();
10457: break;
10458: case 238:
10459: jj_3_239();
10460: break;
10461: case 239:
10462: jj_3_240();
10463: break;
10464: case 240:
10465: jj_3_241();
10466: break;
10467: case 241:
10468: jj_3_242();
10469: break;
10470: case 242:
10471: jj_3_243();
10472: break;
10473: case 243:
10474: jj_3_244();
10475: break;
10476: case 244:
10477: jj_3_245();
10478: break;
10479: case 245:
10480: jj_3_246();
10481: break;
10482: case 246:
10483: jj_3_247();
10484: break;
10485: case 247:
10486: jj_3_248();
10487: break;
10488: case 248:
10489: jj_3_249();
10490: break;
10491: case 249:
10492: jj_3_250();
10493: break;
10494: case 250:
10495: jj_3_251();
10496: break;
10497: case 251:
10498: jj_3_252();
10499: break;
10500: case 252:
10501: jj_3_253();
10502: break;
10503: case 253:
10504: jj_3_254();
10505: break;
10506: case 254:
10507: jj_3_255();
10508: break;
10509: case 255:
10510: jj_3_256();
10511: break;
10512: }
10513: }
10514: p = p.next;
10515: } while (p != null);
10516: } catch (LookaheadSuccess ls) {
10517: }
10518: }
10519: jj_rescan = false;
10520: }
10521:
10522: final private void jj_save(int index, int xla) {
10523: JJCalls p = jj_2_rtns[index];
10524: while (p.gen > jj_gen) {
10525: if (p.next == null) {
10526: p = p.next = new JJCalls();
10527: break;
10528: }
10529: p = p.next;
10530: }
10531: p.gen = jj_gen + xla - jj_la;
10532: p.first = token;
10533: p.arg = xla;
10534: }
10535:
10536: static final class JJCalls {
10537: int gen;
10538: Token first;
10539: int arg;
10540: JJCalls next;
10541: }
10542:
10543: }
|