| /* Generated By:JJTree&JavaCC: Do not edit this line. DDLParser.java */ |
| /*******************************************************************************
|
| * Copyright (c) 2011 Oracle. All rights reserved.
|
| * This program and the accompanying materials are made available under the
|
| * terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
|
| * which accompanies this distribution.
|
| * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
|
| * and the Eclipse Distribution License is available at
|
| * http://www.eclipse.org/org/documents/edl-v10.php.
|
| *
|
| * Contributors:
|
| * Mike Norman - June 10 2011, created DDL parser package
|
| ******************************************************************************/ |
| package org.eclipse.persistence.tools.oracleddl.parser; |
| |
| //javase imports
|
| import java.io.InputStream; |
| import java.util.List; |
| import java.util.HashMap; |
| import java.util.Map; |
| |
| //metadata imports
|
| import org.eclipse.persistence.tools.oracleddl.metadata.ArgumentType; |
| import org.eclipse.persistence.tools.oracleddl.metadata.ArgumentTypeDirection; |
| import org.eclipse.persistence.tools.oracleddl.metadata.BlobType; |
| import org.eclipse.persistence.tools.oracleddl.metadata.CharType; |
| import org.eclipse.persistence.tools.oracleddl.metadata.ClobType; |
| import org.eclipse.persistence.tools.oracleddl.metadata.CompositeDatabaseType; |
| import org.eclipse.persistence.tools.oracleddl.metadata.DatabaseType; |
| import org.eclipse.persistence.tools.oracleddl.metadata.DecimalType; |
| import org.eclipse.persistence.tools.oracleddl.metadata.DoubleType; |
| import org.eclipse.persistence.tools.oracleddl.metadata.FieldType; |
| import org.eclipse.persistence.tools.oracleddl.metadata.FloatType; |
| import org.eclipse.persistence.tools.oracleddl.metadata.FunctionType; |
| import org.eclipse.persistence.tools.oracleddl.metadata.IntervalDayToSecond; |
| import org.eclipse.persistence.tools.oracleddl.metadata.IntervalYearToMonth; |
| import org.eclipse.persistence.tools.oracleddl.metadata.LongType; |
| import org.eclipse.persistence.tools.oracleddl.metadata.LongRawType; |
| import org.eclipse.persistence.tools.oracleddl.metadata.NCharType; |
| import org.eclipse.persistence.tools.oracleddl.metadata.NClobType; |
| import org.eclipse.persistence.tools.oracleddl.metadata.NumericType; |
| import org.eclipse.persistence.tools.oracleddl.metadata.NVarChar2Type; |
| import org.eclipse.persistence.tools.oracleddl.metadata.ObjectType; |
| import org.eclipse.persistence.tools.oracleddl.metadata.ObjectTableType; |
| import org.eclipse.persistence.tools.oracleddl.metadata.PLSQLCollectionType; |
| import org.eclipse.persistence.tools.oracleddl.metadata.PLSQLCursorType; |
| import org.eclipse.persistence.tools.oracleddl.metadata.PLSQLPackageType; |
| import org.eclipse.persistence.tools.oracleddl.metadata.PLSQLRecordType; |
| import org.eclipse.persistence.tools.oracleddl.metadata.PLSQLType; |
| import org.eclipse.persistence.tools.oracleddl.metadata.PLSQLSubType; |
| import org.eclipse.persistence.tools.oracleddl.metadata.ProcedureType; |
| import org.eclipse.persistence.tools.oracleddl.metadata.RawType; |
| import org.eclipse.persistence.tools.oracleddl.metadata.RealType; |
| import org.eclipse.persistence.tools.oracleddl.metadata.ROWTYPEType; |
| import org.eclipse.persistence.tools.oracleddl.metadata.TableType; |
| import org.eclipse.persistence.tools.oracleddl.metadata.TimeStampType; |
| import org.eclipse.persistence.tools.oracleddl.metadata.TYPEType; |
| import org.eclipse.persistence.tools.oracleddl.metadata.URowIdType; |
| import org.eclipse.persistence.tools.oracleddl.metadata.UnresolvedSizedType; |
| import org.eclipse.persistence.tools.oracleddl.metadata.UnresolvedType; |
| import org.eclipse.persistence.tools.oracleddl.metadata.VarCharType; |
| import org.eclipse.persistence.tools.oracleddl.metadata.VarChar2Type; |
| import org.eclipse.persistence.tools.oracleddl.metadata.VArrayType; |
| import org.eclipse.persistence.tools.oracleddl.util.DatabaseTypesRepository; |
| import static org.eclipse.persistence.tools.oracleddl.metadata.ScalarDatabaseTypeEnum.BFILE_TYPE; |
| import static org.eclipse.persistence.tools.oracleddl.metadata.ScalarDatabaseTypeEnum.BINARY_INTEGER_TYPE; |
| import static org.eclipse.persistence.tools.oracleddl.metadata.ScalarDatabaseTypeEnum.BINARY_FLOAT_TYPE; |
| import static org.eclipse.persistence.tools.oracleddl.metadata.ScalarDatabaseTypeEnum.BINARY_DOUBLE_TYPE; |
| import static org.eclipse.persistence.tools.oracleddl.metadata.ScalarDatabaseTypeEnum.BOOLEAN_TYPE; |
| import static org.eclipse.persistence.tools.oracleddl.metadata.ScalarDatabaseTypeEnum.DATE_TYPE; |
| import static org.eclipse.persistence.tools.oracleddl.metadata.ScalarDatabaseTypeEnum.INTEGER_TYPE; |
| import static org.eclipse.persistence.tools.oracleddl.metadata.ScalarDatabaseTypeEnum.MLSLABEL_TYPE; |
| import static org.eclipse.persistence.tools.oracleddl.metadata.ScalarDatabaseTypeEnum.NATURAL_TYPE; |
| import static org.eclipse.persistence.tools.oracleddl.metadata.ScalarDatabaseTypeEnum.PLS_INTEGER_TYPE; |
| import static org.eclipse.persistence.tools.oracleddl.metadata.ScalarDatabaseTypeEnum.POSITIVE_TYPE; |
| import static org.eclipse.persistence.tools.oracleddl.metadata.ScalarDatabaseTypeEnum.ROWID_TYPE; |
| import static org.eclipse.persistence.tools.oracleddl.metadata.ScalarDatabaseTypeEnum.SIGN_TYPE; |
| import static org.eclipse.persistence.tools.oracleddl.metadata.ScalarDatabaseTypeEnum.SIMPLE_INTEGER_TYPE; |
| import static org.eclipse.persistence.tools.oracleddl.metadata.ScalarDatabaseTypeEnum.SIMPLE_DOUBLE_TYPE; |
| import static org.eclipse.persistence.tools.oracleddl.metadata.ScalarDatabaseTypeEnum.SIMPLE_FLOAT_TYPE; |
| import static org.eclipse.persistence.tools.oracleddl.metadata.ScalarDatabaseTypeEnum.SMALLINT_TYPE; |
| import static org.eclipse.persistence.tools.oracleddl.metadata.ScalarDatabaseTypeEnum.SYS_REFCURSOR_TYPE; |
| import static org.eclipse.persistence.tools.oracleddl.metadata.ScalarDatabaseTypeEnum.TIME_TYPE; |
| |
| @SuppressWarnings("all") |
| public class DDLParser/*@bgen(jjtree)*/implements DDLParserTreeConstants, DDLParserConstants {/*@bgen(jjtree)*/ |
| protected JJTDDLParserState jjtree = new JJTDDLParserState(); |
| protected Map<String, DatabaseType> localTypes = new HashMap<String, DatabaseType>(); |
| |
| protected DatabaseTypesRepository typesRepository = new DatabaseTypesRepository(); |
| |
| public DDLParser() { |
| super(); |
| } |
| |
| public void setTypesRepository(DatabaseTypesRepository typesRepository) { |
| this.typesRepository = typesRepository; |
| } |
| public DatabaseTypesRepository getTypesRepository() { |
| return typesRepository; |
| } |
| |
| protected String removeQuotes(String quotedString) { |
| return quotedString.substring(1, quotedString.length() - 1); |
| } |
| |
| // stripped-down version of PLSQL grammar: only parses package/top-level DDL specifications
|
| |
| // PLSQLPackage at 'top-level'
|
| final public PLSQLPackageType parsePLSQLPackage() throws ParseException { |
| PLSQLPackageType packageType = new PLSQLPackageType(); |
| String dottedName = null; |
| String schema = null; |
| String packageName = null; |
| jj_consume_token(R_CREATE); |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case R_OR: |
| orReplace(); |
| break; |
| default: |
| ; |
| } |
| jj_consume_token(K_PACKAGE); |
| dottedName = OracleObjectNamePossiblyDotted(); |
| packageName = dottedName; |
| if (dottedName.contains(".")) { |
| int idx = dottedName.indexOf("."); |
| schema = dottedName.substring(0, idx); |
| packageName = dottedName.substring(idx+1, dottedName.length()); |
| } |
| if (schema != null) { |
| packageType.setSchema(schema); |
| } |
| packageType.setPackageName(packageName); |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case K_AUTHID: |
| invokerRights(); |
| break; |
| default: |
| ; |
| } |
| as(); |
| label_1: |
| while (true) { |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case R_CURSOR: |
| case R_FUNCTION: |
| case R_PROCEDURE: |
| case R_SUBTYPE: |
| case R_TYPE: |
| case K_PRAGMA: |
| case S_IDENTIFIER: |
| ; |
| break; |
| default: |
| break label_1; |
| } |
| packageDeclaration(packageType); |
| } |
| jj_consume_token(R_END); |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case S_IDENTIFIER: |
| case S_QUOTED_IDENTIFIER: |
| OracleObjectName(); |
| break; |
| default: |
| ; |
| } |
| jj_consume_token(O_SEMICOLON); |
| jj_consume_token(0); |
| typesRepository.setDatabaseType(packageName, packageType); |
| {if (true) return packageType;} |
| throw new Error("Missing return statement in function"); |
| } |
| |
| // procedure at 'top-level'
|
| final public ProcedureType parseTopLevelProcedure() throws ParseException { |
| ProcedureType procedureType = null; |
| String dottedName = null; |
| String schema = null; |
| String procedureName = null; |
| jj_consume_token(R_CREATE); |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case R_OR: |
| orReplace(); |
| break; |
| default: |
| ; |
| } |
| jj_consume_token(R_PROCEDURE); |
| dottedName = OracleObjectNamePossiblyDotted(); |
| procedureName = dottedName; |
| if (dottedName.contains(".")) { |
| int idx = dottedName.indexOf("."); |
| schema = dottedName.substring(0, idx); |
| procedureName = dottedName.substring(idx+1, dottedName.length()); |
| } |
| procedureType = new ProcedureType(procedureName); |
| if (schema != null) { |
| procedureType.setSchema(schema); |
| } |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case O_OPENPAREN: |
| jj_consume_token(O_OPENPAREN); |
| argumentList(procedureType); |
| jj_consume_token(O_CLOSEPAREN); |
| break; |
| default: |
| ; |
| } |
| as(); |
| skipToEnd(); |
| typesRepository.setDatabaseType(procedureName, procedureType); |
| {if (true) return procedureType;} |
| throw new Error("Missing return statement in function"); |
| } |
| |
| // function at 'top-level'
|
| final public FunctionType parseTopLevelFunction() throws ParseException { |
| FunctionType functionType = null; |
| String dottedName = null; |
| String schema = null; |
| String functionName = null; |
| ArgumentType returnType = null; |
| jj_consume_token(R_CREATE); |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case R_OR: |
| orReplace(); |
| break; |
| default: |
| ; |
| } |
| jj_consume_token(R_FUNCTION); |
| dottedName = OracleObjectNamePossiblyDotted(); |
| functionName = dottedName; |
| if (dottedName.contains(".")) { |
| int idx = dottedName.indexOf("."); |
| schema = dottedName.substring(0, idx); |
| functionName = dottedName.substring(idx+1, dottedName.length()); |
| } |
| functionType = new FunctionType(functionName); |
| if (schema != null) { |
| functionType.setSchema(schema); |
| } |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case O_OPENPAREN: |
| jj_consume_token(O_OPENPAREN); |
| argumentList(functionType); |
| jj_consume_token(O_CLOSEPAREN); |
| break; |
| default: |
| ; |
| } |
| returnType = functionReturnSpec(); |
| as(); |
| skipToEnd(); |
| functionType.setReturnArgument(returnType); |
| typesRepository.setDatabaseType(functionName, functionType); |
| {if (true) return functionType;} |
| throw new Error("Missing return statement in function"); |
| } |
| |
| // table at 'top-level'
|
| final public TableType parseTable() throws ParseException { |
| TableType tableType = null; |
| String dottedName = null; |
| String schema = null; |
| String tableName = null; |
| Token iot = null; |
| jj_consume_token(R_CREATE); |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case K_GLOBAL: |
| jj_consume_token(K_GLOBAL); |
| jj_consume_token(K_TEMPORARY); |
| break; |
| default: |
| ; |
| } |
| jj_consume_token(R_TABLE); |
| dottedName = OracleObjectNamePossiblyDotted(); |
| tableName = dottedName; |
| if (dottedName.contains(".")) { |
| int idx = dottedName.indexOf("."); |
| schema = dottedName.substring(0, idx); |
| tableName = dottedName.substring(idx+1, dottedName.length()); |
| } |
| tableType = new TableType(tableName); |
| if (schema != null) { |
| tableType.setSchema(schema); |
| } |
| jj_consume_token(O_OPENPAREN); |
| columnDeclarations(tableType); |
| jj_consume_token(O_CLOSEPAREN); |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case K_ORGANIZATION: |
| jj_consume_token(K_ORGANIZATION); |
| break; |
| default: |
| ; |
| } |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case R_INDEX: |
| iot = jj_consume_token(R_INDEX); |
| break; |
| default: |
| ; |
| } |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case R_NOCOMPRESS: |
| jj_consume_token(R_NOCOMPRESS); |
| break; |
| default: |
| ; |
| } |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case K_OVERFLOW: |
| jj_consume_token(K_OVERFLOW); |
| break; |
| default: |
| ; |
| } |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case R_ON: |
| onCommit(); |
| break; |
| default: |
| ; |
| } |
| jj_consume_token(O_SEMICOLON); |
| jj_consume_token(0); |
| if (iot != null) { |
| tableType.setIOT(true); |
| } |
| typesRepository.setDatabaseType(tableName, tableType); |
| {if (true) return tableType;} |
| throw new Error("Missing return statement in function"); |
| } |
| |
| // type at 'top-level'
|
| final public CompositeDatabaseType parseType() throws ParseException { |
| CompositeDatabaseType databaseType = null; |
| DatabaseType enclosedType = null; |
| String dottedName = null; |
| String schema = null; |
| String typeName = null; |
| Token vsize = null; |
| boolean varray = false; |
| boolean nestedTable = false; |
| jj_consume_token(R_CREATE); |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case R_OR: |
| orReplace(); |
| break; |
| default: |
| ; |
| } |
| jj_consume_token(R_TYPE); |
| dottedName = OracleObjectNamePossiblyDotted(); |
| typeName = dottedName; |
| if (dottedName.contains(".")) { |
| int idx = dottedName.indexOf("."); |
| schema = dottedName.substring(0, idx); |
| typeName = dottedName.substring(idx+1, dottedName.length()); |
| } |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case K_FORCE: |
| jj_consume_token(K_FORCE); |
| break; |
| default: |
| ; |
| } |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case K_OID: |
| jj_consume_token(K_OID); |
| jj_consume_token(S_CHAR_LITERAL); |
| break; |
| default: |
| ; |
| } |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case K_AUTHID: |
| invokerRights(); |
| break; |
| default: |
| ; |
| } |
| as(); |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case R_TABLE: |
| case K_OBJECT: |
| case K_VARRAY: |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case K_OBJECT: |
| jj_consume_token(K_OBJECT); |
| jj_consume_token(O_OPENPAREN); |
| databaseType = new ObjectType(typeName); |
| if (schema != null) { |
| ((ObjectType)databaseType).setSchema(schema); |
| } |
| columnDeclarations(databaseType); |
| jj_consume_token(O_CLOSEPAREN); |
| break; |
| case K_VARRAY: |
| jj_consume_token(K_VARRAY); |
| jj_consume_token(O_OPENPAREN); |
| vsize = jj_consume_token(S_NUMBER); |
| jj_consume_token(O_CLOSEPAREN); |
| jj_consume_token(R_OF); |
| databaseType = new VArrayType(typeName); |
| if (schema != null) { |
| ((VArrayType)databaseType).setSchema(schema); |
| } |
| if (vsize != null) { |
| Long size = Long.decode(vsize.image); |
| ((VArrayType)databaseType).setSize(size); |
| } |
| enclosedType = columnTypeSpec(databaseType); |
| break; |
| case R_TABLE: |
| jj_consume_token(R_TABLE); |
| jj_consume_token(R_OF); |
| databaseType = new ObjectTableType(typeName); |
| if (schema != null) { |
| ((ObjectTableType)databaseType).setSchema(schema); |
| } |
| enclosedType = columnTypeSpec(databaseType); |
| break; |
| default: |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| break; |
| default: |
| ; |
| } |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case R_NOT: |
| case K_FINAL: |
| case K_INSTANTIABLE: |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case R_NOT: |
| jj_consume_token(R_NOT); |
| break; |
| default: |
| ; |
| } |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case K_FINAL: |
| jj_consume_token(K_FINAL); |
| break; |
| case K_INSTANTIABLE: |
| jj_consume_token(K_INSTANTIABLE); |
| break; |
| default: |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| break; |
| default: |
| ; |
| } |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case O_SEMICOLON: |
| jj_consume_token(O_SEMICOLON); |
| break; |
| default: |
| ; |
| } |
| jj_consume_token(0); |
| if (enclosedType != null) { |
| ((CompositeDatabaseType)databaseType).setEnclosedType(enclosedType); |
| } |
| typesRepository.setDatabaseType(typeName, databaseType); |
| {if (true) return databaseType;} |
| throw new Error("Missing return statement in function"); |
| } |
| |
| final public void columnDeclarations(CompositeDatabaseType enclosingType) throws ParseException { |
| columnDeclaration(enclosingType); |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case O_COMMA: |
| jj_consume_token(O_COMMA); |
| columnDeclarations(enclosingType); |
| break; |
| default: |
| ; |
| } |
| } |
| |
| final public void columnDeclaration(CompositeDatabaseType enclosingType) throws ParseException { |
| String s = null; |
| String pk = null; |
| boolean notNull = false; |
| DatabaseType columnType = null; |
| FieldType column = null; |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case S_IDENTIFIER: |
| case S_QUOTED_IDENTIFIER: |
| s = OracleObjectName(); |
| column = new FieldType(s); |
| if (enclosingType != null) { |
| if (enclosingType.isPLSQLRecordType()) { |
| ((PLSQLRecordType)enclosingType).addField(column); |
| } |
| else if (enclosingType.isTableType()) { |
| ((TableType)enclosingType).addColumn(column); |
| } |
| else if (enclosingType.isObjectType()) { |
| ((ObjectType)enclosingType).addField(column); |
| } |
| } |
| columnType = columnTypeSpec(enclosingType); |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case R_NOT: |
| jj_consume_token(R_NOT); |
| jj_consume_token(R_NULL); |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case K_ENABLE: |
| jj_consume_token(K_ENABLE); |
| break; |
| default: |
| ; |
| } |
| notNull = true; |
| break; |
| default: |
| ; |
| } |
| break; |
| case R_CHECK: |
| case R_UNIQUE: |
| case K_CONSTRAINT: |
| case K_PRIMARY: |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case K_CONSTRAINT: |
| jj_consume_token(K_CONSTRAINT); |
| break; |
| default: |
| ; |
| } |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case S_IDENTIFIER: |
| case S_QUOTED_IDENTIFIER: |
| OracleObjectName(); |
| break; |
| default: |
| ; |
| } |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case K_PRIMARY: |
| jj_consume_token(K_PRIMARY); |
| jj_consume_token(K_KEY); |
| jj_consume_token(O_OPENPAREN); |
| pkList((TableType)enclosingType); |
| jj_consume_token(O_CLOSEPAREN); |
| break; |
| case R_CHECK: |
| jj_consume_token(R_CHECK); |
| jj_consume_token(O_OPENPAREN); |
| skipToClosingParen(); |
| jj_consume_token(O_CLOSEPAREN); |
| break; |
| case R_UNIQUE: |
| jj_consume_token(R_UNIQUE); |
| jj_consume_token(O_OPENPAREN); |
| uniqList(); |
| jj_consume_token(O_CLOSEPAREN); |
| break; |
| default: |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| jj_consume_token(K_ENABLE); |
| break; |
| default: |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| if (column != null) { |
| column.setEnclosedType(columnType); |
| if (columnType instanceof UnresolvedType) { |
| ((UnresolvedType)columnType).setOwningType(column); |
| } |
| if (notNull) { |
| column.setNotNull(); |
| } |
| } |
| } |
| |
| final public DatabaseType columnTypeSpec(CompositeDatabaseType enclosingType) throws ParseException { |
| String s = null; |
| Token t = null; |
| DatabaseType dt = null; |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case K_BFILE: |
| case K_BINARY_DOUBLE: |
| case K_BINARY_FLOAT: |
| case K_BINARY_INTEGER: |
| case K_BLOB: |
| case K_BOOLEAN: |
| case K_CHAR: |
| case K_CHARACTER: |
| case K_CLOB: |
| case K_DATE: |
| case K_DEC: |
| case K_DECIMAL: |
| case K_DOUBLE: |
| case K_FLOAT: |
| case K_INT: |
| case K_INTEGER: |
| case K_INTERVAL: |
| case K_LONG: |
| case K_MLSLABEL: |
| case K_NATIONAL: |
| case K_NATURAL: |
| case K_NCHAR: |
| case K_NCLOB: |
| case K_NUMBER: |
| case K_NUMERIC: |
| case K_NVARCHAR2: |
| case K_NVARCHAR: |
| case K_PLS_INTEGER: |
| case K_POSITIVE: |
| case K_RAW: |
| case K_REAL: |
| case K_ROWID: |
| case K_SIGNTYPE: |
| case K_SIMPLE_DOUBLE: |
| case K_SIMPLE_FLOAT: |
| case K_SIMPLE_INTEGER: |
| case K_SMALLINT: |
| case K_SYS_REFCURSOR: |
| case K_TIME: |
| case K_TIMESTAMP: |
| case K_UROWID: |
| case K_VARCHAR2: |
| case K_VARCHAR: |
| dt = datatype(); |
| break; |
| case S_IDENTIFIER: |
| case S_QUOTED_IDENTIFIER: |
| s = columnSpec(); |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case O_OPENPAREN: |
| jj_consume_token(O_OPENPAREN); |
| t = jj_consume_token(S_NUMBER); |
| jj_consume_token(O_CLOSEPAREN); |
| break; |
| default: |
| ; |
| } |
| break; |
| default: |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case K_CONSTRAINT: |
| jj_consume_token(K_CONSTRAINT); |
| jj_consume_token(S_QUOTED_IDENTIFIER); |
| break; |
| default: |
| ; |
| } |
| if (s != null) { |
| for (String typeName : localTypes.keySet()) { |
| if (typeName.equals(s)) { |
| dt = localTypes.get(s); |
| break; |
| } |
| } |
| if (dt == null) { |
| if (t != null) { |
| Long size = Long.decode(t.image); |
| dt = new UnresolvedSizedType(s, size); |
| } |
| else { |
| dt = new UnresolvedType(s); |
| } |
| ((UnresolvedType)dt).setOwningType(enclosingType); |
| } |
| } |
| {if (true) return dt;} |
| throw new Error("Missing return statement in function"); |
| } |
| |
| final public void uniqList() throws ParseException { |
| OracleObjectName(); |
| label_2: |
| while (true) { |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case O_COMMA: |
| ; |
| break; |
| default: |
| break label_2; |
| } |
| jj_consume_token(O_COMMA); |
| OracleObjectName(); |
| } |
| } |
| |
| final public void pkList(TableType tableType) throws ParseException { |
| pk(tableType); |
| label_3: |
| while (true) { |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case O_COMMA: |
| ; |
| break; |
| default: |
| break label_3; |
| } |
| jj_consume_token(O_COMMA); |
| pk(tableType); |
| } |
| } |
| |
| final public void pk(TableType tableType) throws ParseException { |
| String s = null; |
| s = OracleObjectName(); |
| List<FieldType> columns = tableType.getColumns(); |
| for (FieldType column : columns) { |
| if (column.getFieldName().equals(s)) { |
| column.setPk(); |
| break; |
| } |
| } |
| } |
| |
| final public void packageDeclaration(PLSQLPackageType packageType) throws ParseException { |
| if (jj_2_1(2)) { |
| variableDeclaration(packageType); |
| } else { |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case R_SUBTYPE: |
| case R_TYPE: |
| typeOrSubTypeDeclaration(packageType); |
| break; |
| case R_CURSOR: |
| cursorDeclaration(packageType); |
| break; |
| case R_PROCEDURE: |
| procedureSpec(packageType); |
| break; |
| case R_FUNCTION: |
| functionSpec(packageType); |
| break; |
| case S_IDENTIFIER: |
| exceptionDeclaration(); |
| break; |
| case K_PRAGMA: |
| pragmaDeclaration(); |
| break; |
| default: |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| } |
| } |
| |
| final public void variableDeclaration(PLSQLPackageType packageType) throws ParseException { |
| Token varName = null; |
| DatabaseType varType; |
| varName = jj_consume_token(S_IDENTIFIER); |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case K_CONSTANT: |
| jj_consume_token(K_CONSTANT); |
| break; |
| default: |
| ; |
| } |
| varType = typeSpec(); |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case R_NOT: |
| jj_consume_token(R_NOT); |
| jj_consume_token(R_NULL); |
| break; |
| default: |
| ; |
| } |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case O_ASSIGN: |
| case R_DEFAULT: |
| variableDefaultAssignment(); |
| break; |
| default: |
| ; |
| } |
| jj_consume_token(O_SEMICOLON); |
| FieldType variable = new FieldType(varName.image); |
| variable.setEnclosedType(varType); |
| packageType.addLocalVariable(variable); |
| } |
| |
| final public void variableDefaultAssignment() throws ParseException { |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case O_ASSIGN: |
| jj_consume_token(O_ASSIGN); |
| break; |
| case R_DEFAULT: |
| jj_consume_token(R_DEFAULT); |
| break; |
| default: |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| skipToSemiColon(); |
| } |
| |
| final public DatabaseType datatype() throws ParseException { |
| Token t = null; |
| DatabaseType dt = null; |
| Token precision = null; |
| Long sl; |
| Long pl; |
| Token scale = null; |
| Token withTimeZone = null; |
| Token withLocalTimeZone = null; |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case K_BINARY_INTEGER: |
| jj_consume_token(K_BINARY_INTEGER); |
| {if (true) return BINARY_INTEGER_TYPE;} |
| break; |
| case K_BINARY_FLOAT: |
| jj_consume_token(K_BINARY_FLOAT); |
| {if (true) return BINARY_FLOAT_TYPE;} |
| break; |
| case K_BINARY_DOUBLE: |
| jj_consume_token(K_BINARY_DOUBLE); |
| {if (true) return BINARY_DOUBLE_TYPE;} |
| break; |
| case K_NATURAL: |
| jj_consume_token(K_NATURAL); |
| {if (true) return NATURAL_TYPE;} |
| break; |
| case K_POSITIVE: |
| jj_consume_token(K_POSITIVE); |
| {if (true) return POSITIVE_TYPE;} |
| break; |
| case K_SIGNTYPE: |
| jj_consume_token(K_SIGNTYPE); |
| {if (true) return SIGN_TYPE;} |
| break; |
| case K_DEC: |
| case K_DECIMAL: |
| case K_NUMBER: |
| case K_NUMERIC: |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case K_NUMBER: |
| t = jj_consume_token(K_NUMBER); |
| break; |
| case K_NUMERIC: |
| t = jj_consume_token(K_NUMERIC); |
| break; |
| case K_DECIMAL: |
| t = jj_consume_token(K_DECIMAL); |
| break; |
| case K_DEC: |
| t = jj_consume_token(K_DEC); |
| break; |
| default: |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case O_OPENPAREN: |
| jj_consume_token(O_OPENPAREN); |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case O_ASTERISK: |
| case S_NUMBER: |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case O_ASTERISK: |
| precision = jj_consume_token(O_ASTERISK); |
| break; |
| case S_NUMBER: |
| precision = jj_consume_token(S_NUMBER); |
| break; |
| default: |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| break; |
| default: |
| ; |
| } |
| label_4: |
| while (true) { |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case O_COMMA: |
| ; |
| break; |
| default: |
| break label_4; |
| } |
| jj_consume_token(O_COMMA); |
| scale = jj_consume_token(S_NUMBER); |
| } |
| jj_consume_token(O_CLOSEPAREN); |
| break; |
| default: |
| ; |
| } |
| if (t.kind == K_NUMBER || t.kind == K_NUMERIC) { |
| if (precision != null && precision.image.equals("*")) { |
| precision = null; |
| } |
| if (precision == null) { |
| if (scale != null && scale.image.equals("0")) { |
| dt = INTEGER_TYPE; |
| } |
| else { |
| dt = new NumericType(); |
| } |
| } |
| else { |
| pl = Long.decode(precision.image); |
| if (scale == null) { |
| dt = new NumericType(pl); |
| } |
| else { |
| sl = Long.decode(scale.image); |
| dt = new NumericType(pl, sl); |
| } |
| } |
| //sometimes need to know difference between NUMERIC and NUMBER |
| if (dt != INTEGER_TYPE && t.kind == K_NUMBER) { |
| ((NumericType)dt).setNumberSynonym(true); |
| } |
| } |
| else if (t.kind == K_DECIMAL || t.kind == K_DEC) { |
| if (precision != null && precision.image.equals("*")) { |
| precision = null; |
| } |
| if (precision == null) { |
| dt = new DecimalType(); |
| } |
| else { |
| pl = Long.decode(precision.image); |
| if (scale == null) { |
| dt = new DecimalType(pl); |
| } |
| else { |
| sl = Long.decode(scale.image); |
| dt = new DecimalType(pl, sl); |
| } |
| } |
| } |
| {if (true) return dt;} |
| break; |
| case K_LONG: |
| jj_consume_token(K_LONG); |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case K_RAW: |
| t = jj_consume_token(K_RAW); |
| break; |
| default: |
| ; |
| } |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case O_OPENPAREN: |
| jj_consume_token(O_OPENPAREN); |
| precision = jj_consume_token(S_NUMBER); |
| jj_consume_token(O_CLOSEPAREN); |
| break; |
| default: |
| ; |
| } |
| if (t == null) { |
| if (precision == null) { |
| dt = new LongType(); |
| } |
| else { |
| pl = Long.decode(precision.image); |
| dt = new LongType(pl); |
| } |
| } |
| else { |
| if (precision == null) { |
| dt = new LongRawType(); |
| } |
| else { |
| pl = Long.decode(precision.image); |
| dt = new LongRawType(pl); |
| } |
| } |
| {if (true) return dt;} |
| break; |
| case K_RAW: |
| jj_consume_token(K_RAW); |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case O_OPENPAREN: |
| jj_consume_token(O_OPENPAREN); |
| precision = jj_consume_token(S_NUMBER); |
| jj_consume_token(O_CLOSEPAREN); |
| break; |
| default: |
| ; |
| } |
| if (precision == null) { |
| dt = new RawType(); |
| } |
| else { |
| pl = Long.decode(precision.image); |
| dt = new RawType(pl); |
| } |
| {if (true) return dt;} |
| break; |
| case K_BOOLEAN: |
| jj_consume_token(K_BOOLEAN); |
| {if (true) return BOOLEAN_TYPE;} |
| break; |
| case K_DATE: |
| jj_consume_token(K_DATE); |
| {if (true) return DATE_TYPE;} |
| break; |
| case K_INTERVAL: |
| jj_consume_token(K_INTERVAL); |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case K_DAY: |
| jj_consume_token(K_DAY); |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case O_OPENPAREN: |
| jj_consume_token(O_OPENPAREN); |
| precision = jj_consume_token(S_NUMBER); |
| jj_consume_token(O_CLOSEPAREN); |
| break; |
| default: |
| ; |
| } |
| jj_consume_token(R_TO); |
| jj_consume_token(K_SECOND); |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case O_OPENPAREN: |
| jj_consume_token(O_OPENPAREN); |
| scale = jj_consume_token(S_NUMBER); |
| jj_consume_token(O_CLOSEPAREN); |
| break; |
| default: |
| ; |
| } |
| if (precision == null) { |
| dt = new IntervalDayToSecond(); |
| } |
| else { |
| pl = Long.decode(precision.image); |
| if (scale == null) { |
| dt = new IntervalDayToSecond(pl); |
| } |
| else { |
| sl = Long.decode(scale.image); |
| dt = new IntervalDayToSecond(pl, sl); |
| } |
| } |
| {if (true) return dt;} |
| break; |
| case K_YEAR: |
| jj_consume_token(K_YEAR); |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case O_OPENPAREN: |
| jj_consume_token(O_OPENPAREN); |
| jj_consume_token(S_NUMBER); |
| jj_consume_token(O_CLOSEPAREN); |
| break; |
| default: |
| ; |
| } |
| jj_consume_token(R_TO); |
| jj_consume_token(K_MONTH); |
| if (precision == null) { |
| dt = new IntervalYearToMonth(); |
| } |
| else { |
| pl = Long.decode(precision.image); |
| dt = new IntervalYearToMonth(pl); |
| } |
| {if (true) return dt;} |
| break; |
| default: |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| break; |
| case K_TIME: |
| jj_consume_token(K_TIME); |
| {if (true) return TIME_TYPE;} |
| break; |
| case K_TIMESTAMP: |
| jj_consume_token(K_TIMESTAMP); |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case O_OPENPAREN: |
| jj_consume_token(O_OPENPAREN); |
| precision = jj_consume_token(S_NUMBER); |
| jj_consume_token(O_CLOSEPAREN); |
| break; |
| default: |
| ; |
| } |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case R_WITH: |
| jj_consume_token(R_WITH); |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case K_LOCAL: |
| withLocalTimeZone = jj_consume_token(K_LOCAL); |
| break; |
| default: |
| ; |
| } |
| withTimeZone = jj_consume_token(K_TIME); |
| jj_consume_token(K_ZONE); |
| break; |
| default: |
| ; |
| } |
| if (precision == null) { |
| dt = new TimeStampType(); |
| } |
| else { |
| pl = Long.decode(precision.image); |
| dt = new TimeStampType(pl); |
| } |
| if (withLocalTimeZone != null) { |
| ((TimeStampType)dt).setWithLocalTimeZone(); |
| } |
| else if (withTimeZone != null) { |
| ((TimeStampType)dt).setWithTimeZone(); |
| } |
| {if (true) return dt;} |
| break; |
| case K_INTEGER: |
| jj_consume_token(K_INTEGER); |
| {if (true) return INTEGER_TYPE;} |
| break; |
| case K_INT: |
| jj_consume_token(K_INT); |
| {if (true) return INTEGER_TYPE;} |
| break; |
| case K_SMALLINT: |
| jj_consume_token(K_SMALLINT); |
| {if (true) return SMALLINT_TYPE;} |
| break; |
| case K_FLOAT: |
| jj_consume_token(K_FLOAT); |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case O_OPENPAREN: |
| jj_consume_token(O_OPENPAREN); |
| precision = jj_consume_token(S_NUMBER); |
| jj_consume_token(O_CLOSEPAREN); |
| break; |
| default: |
| ; |
| } |
| if (precision == null) { |
| {if (true) return new FloatType();} |
| } |
| else { |
| pl = Long.decode(precision.image); |
| FloatType ft = new FloatType(pl); |
| {if (true) return ft;} |
| } |
| break; |
| case K_REAL: |
| jj_consume_token(K_REAL); |
| {if (true) return new RealType();} |
| break; |
| case K_MLSLABEL: |
| jj_consume_token(K_MLSLABEL); |
| {if (true) return MLSLABEL_TYPE;} |
| break; |
| case K_PLS_INTEGER: |
| jj_consume_token(K_PLS_INTEGER); |
| {if (true) return PLS_INTEGER_TYPE;} |
| break; |
| case K_SIMPLE_INTEGER: |
| jj_consume_token(K_SIMPLE_INTEGER); |
| {if (true) return SIMPLE_INTEGER_TYPE;} |
| break; |
| case K_SIMPLE_FLOAT: |
| jj_consume_token(K_SIMPLE_FLOAT); |
| {if (true) return SIMPLE_FLOAT_TYPE;} |
| break; |
| case K_SIMPLE_DOUBLE: |
| jj_consume_token(K_SIMPLE_DOUBLE); |
| {if (true) return SIMPLE_DOUBLE_TYPE;} |
| break; |
| case K_SYS_REFCURSOR: |
| jj_consume_token(K_SYS_REFCURSOR); |
| {if (true) return SYS_REFCURSOR_TYPE;} |
| break; |
| case K_BLOB: |
| jj_consume_token(K_BLOB); |
| {if (true) return new BlobType();} |
| break; |
| case K_NCLOB: |
| jj_consume_token(K_NCLOB); |
| {if (true) return new NClobType();} |
| break; |
| case K_BFILE: |
| jj_consume_token(K_BFILE); |
| {if (true) return BFILE_TYPE;} |
| break; |
| case K_ROWID: |
| jj_consume_token(K_ROWID); |
| {if (true) return ROWID_TYPE;} |
| break; |
| case K_UROWID: |
| jj_consume_token(K_UROWID); |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case O_OPENPAREN: |
| jj_consume_token(O_OPENPAREN); |
| precision = jj_consume_token(S_NUMBER); |
| jj_consume_token(O_CLOSEPAREN); |
| break; |
| default: |
| ; |
| } |
| if (precision == null) { |
| {if (true) return new URowIdType();} |
| } |
| else { |
| pl = Long.decode(precision.image); |
| {if (true) return new URowIdType(pl);} |
| } |
| break; |
| case K_DOUBLE: |
| jj_consume_token(K_DOUBLE); |
| jj_consume_token(K_PRECISION); |
| {if (true) return new DoubleType();} |
| break; |
| case K_CHAR: |
| jj_consume_token(K_CHAR); |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case K_VARYING: |
| t = jj_consume_token(K_VARYING); |
| break; |
| default: |
| ; |
| } |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case O_OPENPAREN: |
| jj_consume_token(O_OPENPAREN); |
| precision = jj_consume_token(S_NUMBER); |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case K_BYTE: |
| case K_CHAR: |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case K_BYTE: |
| jj_consume_token(K_BYTE); |
| break; |
| case K_CHAR: |
| jj_consume_token(K_CHAR); |
| break; |
| default: |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| break; |
| default: |
| ; |
| } |
| jj_consume_token(O_CLOSEPAREN); |
| break; |
| default: |
| ; |
| } |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case K_CHARACTER: |
| jj_consume_token(K_CHARACTER); |
| jj_consume_token(K_SET); |
| jj_consume_token(S_IDENTIFIER); |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case K_CHARSET: |
| jj_consume_token(K_CHARSET); |
| break; |
| default: |
| ; |
| } |
| break; |
| default: |
| ; |
| } |
| if (t == null) { |
| if (precision == null) { |
| {if (true) return new CharType();} |
| } |
| else { |
| pl = Long.decode(precision.image); |
| {if (true) return new CharType(pl);} |
| } |
| } |
| else { |
| // ANSI syntax for VARCHAR2 |
| if (precision == null) { |
| {if (true) return new VarChar2Type();} |
| } |
| else { |
| pl = Long.decode(precision.image); |
| {if (true) return new VarChar2Type(pl);} |
| } |
| } |
| break; |
| case K_VARCHAR: |
| jj_consume_token(K_VARCHAR); |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case K_VARYING: |
| jj_consume_token(K_VARYING); |
| break; |
| default: |
| ; |
| } |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case O_OPENPAREN: |
| jj_consume_token(O_OPENPAREN); |
| precision = jj_consume_token(S_NUMBER); |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case K_BYTE: |
| case K_CHAR: |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case K_BYTE: |
| jj_consume_token(K_BYTE); |
| break; |
| case K_CHAR: |
| jj_consume_token(K_CHAR); |
| break; |
| default: |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| break; |
| default: |
| ; |
| } |
| jj_consume_token(O_CLOSEPAREN); |
| break; |
| default: |
| ; |
| } |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case K_CHARACTER: |
| jj_consume_token(K_CHARACTER); |
| jj_consume_token(K_SET); |
| jj_consume_token(S_IDENTIFIER); |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case K_CHARSET: |
| jj_consume_token(K_CHARSET); |
| break; |
| default: |
| ; |
| } |
| break; |
| default: |
| ; |
| } |
| if (precision == null) { |
| {if (true) return new VarCharType();} |
| } |
| else { |
| pl = Long.decode(precision.image); |
| {if (true) return new VarCharType(pl);} |
| } |
| break; |
| case K_VARCHAR2: |
| jj_consume_token(K_VARCHAR2); |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case K_VARYING: |
| jj_consume_token(K_VARYING); |
| break; |
| default: |
| ; |
| } |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case O_OPENPAREN: |
| jj_consume_token(O_OPENPAREN); |
| precision = jj_consume_token(S_NUMBER); |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case K_BYTE: |
| case K_CHAR: |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case K_BYTE: |
| jj_consume_token(K_BYTE); |
| break; |
| case K_CHAR: |
| jj_consume_token(K_CHAR); |
| break; |
| default: |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| break; |
| default: |
| ; |
| } |
| jj_consume_token(O_CLOSEPAREN); |
| break; |
| default: |
| ; |
| } |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case K_CHARACTER: |
| jj_consume_token(K_CHARACTER); |
| jj_consume_token(K_SET); |
| jj_consume_token(S_IDENTIFIER); |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case K_CHARSET: |
| jj_consume_token(K_CHARSET); |
| break; |
| default: |
| ; |
| } |
| break; |
| default: |
| ; |
| } |
| if (precision == null) { |
| {if (true) return new VarChar2Type();} |
| } |
| else { |
| pl = Long.decode(precision.image); |
| {if (true) return new VarChar2Type(pl);} |
| } |
| break; |
| case K_CHARACTER: |
| jj_consume_token(K_CHARACTER); |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case K_VARYING: |
| t = jj_consume_token(K_VARYING); |
| break; |
| default: |
| ; |
| } |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case O_OPENPAREN: |
| jj_consume_token(O_OPENPAREN); |
| precision = jj_consume_token(S_NUMBER); |
| jj_consume_token(O_CLOSEPAREN); |
| break; |
| default: |
| ; |
| } |
| if (t == null) { |
| if (precision == null) { |
| {if (true) return new CharType();} |
| } |
| else { |
| pl = Long.decode(precision.image); |
| {if (true) return new CharType(pl);} |
| } |
| } |
| else { |
| // ANSI syntax for VARCHAR |
| if (precision == null) { |
| {if (true) return new VarCharType();} |
| } |
| else { |
| pl = Long.decode(precision.image); |
| {if (true) return new VarCharType(pl);} |
| } |
| } |
| break; |
| case K_NCHAR: |
| jj_consume_token(K_NCHAR); |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case K_VARYING: |
| t = jj_consume_token(K_VARYING); |
| break; |
| default: |
| ; |
| } |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case O_OPENPAREN: |
| jj_consume_token(O_OPENPAREN); |
| precision = jj_consume_token(S_NUMBER); |
| jj_consume_token(O_CLOSEPAREN); |
| break; |
| default: |
| ; |
| } |
| if (t == null) { |
| if (precision == null) { |
| {if (true) return new NCharType();} |
| } |
| else { |
| pl = Long.decode(precision.image); |
| {if (true) return new NCharType(pl);} |
| } |
| } |
| else { |
| // ANSI syntax for NVARCHAR2 |
| if (precision == null) { |
| {if (true) return new NVarChar2Type();} |
| } |
| else { |
| pl = Long.decode(precision.image); |
| {if (true) return new NVarChar2Type(pl);} |
| } |
| } |
| break; |
| case K_NVARCHAR: |
| jj_consume_token(K_NVARCHAR); |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case O_OPENPAREN: |
| jj_consume_token(O_OPENPAREN); |
| precision = jj_consume_token(S_NUMBER); |
| jj_consume_token(O_CLOSEPAREN); |
| break; |
| default: |
| ; |
| } |
| if (precision == null) { |
| {if (true) return new NVarChar2Type();} |
| } |
| else { |
| pl = Long.decode(precision.image); |
| {if (true) return new NVarChar2Type(pl);} |
| } |
| break; |
| case K_NVARCHAR2: |
| jj_consume_token(K_NVARCHAR2); |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case O_OPENPAREN: |
| jj_consume_token(O_OPENPAREN); |
| precision = jj_consume_token(S_NUMBER); |
| jj_consume_token(O_CLOSEPAREN); |
| break; |
| default: |
| ; |
| } |
| if (precision == null) { |
| {if (true) return new NVarChar2Type();} |
| } |
| else { |
| pl = Long.decode(precision.image); |
| {if (true) return new NVarChar2Type(pl);} |
| } |
| break; |
| case K_NATIONAL: |
| jj_consume_token(K_NATIONAL); |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case K_CHARACTER: |
| jj_consume_token(K_CHARACTER); |
| break; |
| case K_CHAR: |
| jj_consume_token(K_CHAR); |
| break; |
| default: |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case K_VARYING: |
| t = jj_consume_token(K_VARYING); |
| break; |
| default: |
| ; |
| } |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case O_OPENPAREN: |
| jj_consume_token(O_OPENPAREN); |
| precision = jj_consume_token(S_NUMBER); |
| jj_consume_token(O_CLOSEPAREN); |
| break; |
| default: |
| ; |
| } |
| if (t == null) { |
| if (precision == null) { |
| {if (true) return new NCharType();} |
| } |
| else { |
| pl = Long.decode(precision.image); |
| {if (true) return new NCharType(pl);} |
| } |
| } |
| else { |
| // ANSI syntax for NVARCHAR2 |
| if (precision == null) { |
| {if (true) return new NVarChar2Type();} |
| } |
| else { |
| pl = Long.decode(precision.image); |
| {if (true) return new NVarChar2Type(pl);} |
| } |
| } |
| break; |
| case K_CLOB: |
| jj_consume_token(K_CLOB); |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case K_CHARACTER: |
| jj_consume_token(K_CHARACTER); |
| jj_consume_token(K_SET); |
| jj_consume_token(S_IDENTIFIER); |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case K_CHARSET: |
| jj_consume_token(K_CHARSET); |
| break; |
| default: |
| ; |
| } |
| break; |
| default: |
| ; |
| } |
| {if (true) return new ClobType();} |
| break; |
| default: |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| throw new Error("Missing return statement in function"); |
| } |
| |
| final public DatabaseType typeSpec() throws ParseException { |
| boolean isTYPEType = false; |
| boolean isROWTYPEType = false; |
| DatabaseType dataType = null; |
| String spec = null; |
| String s = null; |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case K_BFILE: |
| case K_BINARY_DOUBLE: |
| case K_BINARY_FLOAT: |
| case K_BINARY_INTEGER: |
| case K_BLOB: |
| case K_BOOLEAN: |
| case K_CHAR: |
| case K_CHARACTER: |
| case K_CLOB: |
| case K_DATE: |
| case K_DEC: |
| case K_DECIMAL: |
| case K_DOUBLE: |
| case K_FLOAT: |
| case K_INT: |
| case K_INTEGER: |
| case K_INTERVAL: |
| case K_LONG: |
| case K_MLSLABEL: |
| case K_NATIONAL: |
| case K_NATURAL: |
| case K_NCHAR: |
| case K_NCLOB: |
| case K_NUMBER: |
| case K_NUMERIC: |
| case K_NVARCHAR2: |
| case K_NVARCHAR: |
| case K_PLS_INTEGER: |
| case K_POSITIVE: |
| case K_RAW: |
| case K_REAL: |
| case K_ROWID: |
| case K_SIGNTYPE: |
| case K_SIMPLE_DOUBLE: |
| case K_SIMPLE_FLOAT: |
| case K_SIMPLE_INTEGER: |
| case K_SMALLINT: |
| case K_SYS_REFCURSOR: |
| case K_TIME: |
| case K_TIMESTAMP: |
| case K_UROWID: |
| case K_VARCHAR2: |
| case K_VARCHAR: |
| dataType = datatype(); |
| break; |
| case S_IDENTIFIER: |
| case S_QUOTED_IDENTIFIER: |
| spec = columnSpec(); |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case O_OPENPAREN: |
| case R_ANCHORED_ROWTYPE: |
| case R_ANCHORED_TYPE: |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case O_OPENPAREN: |
| jj_consume_token(O_OPENPAREN); |
| jj_consume_token(S_NUMBER); |
| jj_consume_token(O_CLOSEPAREN); |
| break; |
| case R_ANCHORED_TYPE: |
| jj_consume_token(R_ANCHORED_TYPE); |
| isTYPEType=true; |
| s = spec + removeQuotes(tokenImage[R_ANCHORED_TYPE]); |
| break; |
| case R_ANCHORED_ROWTYPE: |
| jj_consume_token(R_ANCHORED_ROWTYPE); |
| isROWTYPEType =true; |
| s = spec + removeQuotes(tokenImage[R_ANCHORED_ROWTYPE]); |
| break; |
| default: |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| break; |
| default: |
| ; |
| } |
| break; |
| default: |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| if (dataType == null && localTypes != null) { |
| for (String typeName : localTypes.keySet()) { |
| if (typeName.equals(spec)) { |
| dataType = localTypes.get(spec); |
| break; |
| } |
| } |
| } |
| if (dataType == null) { |
| UnresolvedType uType = new UnresolvedType(spec); |
| if (isTYPEType) { |
| TYPEType tType = new TYPEType(s); |
| tType.setEnclosedType(uType); |
| uType.setOwningType(tType); |
| dataType = tType; |
| localTypes.put(spec, dataType); |
| } |
| else if (isROWTYPEType) { |
| ROWTYPEType rType = new ROWTYPEType(s); |
| rType.setEnclosedType(uType); |
| uType.setOwningType(rType); |
| dataType = rType; |
| localTypes.put(spec, dataType); |
| } |
| else { |
| dataType = uType; |
| } |
| } |
| {if (true) return dataType;} |
| throw new Error("Missing return statement in function"); |
| } |
| |
| final public String columnSpec() throws ParseException { |
| String s1 = null; |
| String s2 = null; |
| String s3 = null; |
| s1 = OracleObjectName(); |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case O_DOT: |
| jj_consume_token(O_DOT); |
| s2 = OracleObjectName(); |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case O_DOT: |
| jj_consume_token(O_DOT); |
| s3 = OracleObjectName(); |
| break; |
| default: |
| ; |
| } |
| break; |
| default: |
| ; |
| } |
| StringBuilder sb = new StringBuilder(s1); |
| if (s2 != null) { |
| sb.append('.'); |
| sb.append(s2); |
| if (s3 != null) { |
| sb.append('.'); |
| sb.append(s3); |
| } |
| } |
| {if (true) return sb.toString();} |
| throw new Error("Missing return statement in function"); |
| } |
| |
| final public String tableSpec() throws ParseException { |
| OracleObjectName(); |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case O_DOT: |
| jj_consume_token(O_DOT); |
| OracleObjectName(); |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case O_ATSIGN: |
| jj_consume_token(O_ATSIGN); |
| jj_consume_token(S_IDENTIFIER); |
| break; |
| default: |
| ; |
| } |
| break; |
| default: |
| ; |
| } |
| {if (true) return token.image;} |
| throw new Error("Missing return statement in function"); |
| } |
| |
| final public String typeName() throws ParseException { |
| OracleObjectName(); |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case O_DOT: |
| jj_consume_token(O_DOT); |
| OracleObjectName(); |
| break; |
| default: |
| ; |
| } |
| {if (true) return token.image;} |
| throw new Error("Missing return statement in function"); |
| } |
| |
| final public void typeOrSubTypeDeclaration(PLSQLPackageType packageType) throws ParseException { |
| String s = null; |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case R_TYPE: |
| typeDeclaration(packageType); |
| break; |
| case R_SUBTYPE: |
| subtypeDeclaration(packageType); |
| break; |
| default: |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| } |
| |
| final public void typeDeclaration(PLSQLPackageType packageType) throws ParseException { |
| String s = null; |
| jj_consume_token(R_TYPE); |
| s = typeName(); |
| jj_consume_token(R_IS); |
| aTypeDeclaration(packageType, s); |
| jj_consume_token(O_SEMICOLON); |
| } |
| |
| final public void aTypeDeclaration(PLSQLPackageType packageType, String typeName) throws ParseException { |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case K_RECORD: |
| recordDeclaration(packageType, typeName); |
| break; |
| case R_TABLE: |
| plsqlTableDeclaration(packageType, typeName); |
| break; |
| case K_VARRAY: |
| case K_VARYING: |
| varrayDeclaration(packageType); |
| break; |
| case K_REF: |
| refCursorDeclaration(packageType, typeName); |
| break; |
| default: |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| } |
| |
| final public void recordDeclaration(PLSQLPackageType packageType, String typeName) throws ParseException { |
| PLSQLRecordType plsqlRecordType = new PLSQLRecordType(typeName); |
| plsqlRecordType.setParentType(packageType); |
| jj_consume_token(K_RECORD); |
| jj_consume_token(O_OPENPAREN); |
| fieldDeclarations(plsqlRecordType); |
| jj_consume_token(O_CLOSEPAREN); |
| packageType.addType(plsqlRecordType); |
| localTypes.put(typeName, plsqlRecordType); |
| } |
| |
| final public void fieldDeclarations(PLSQLRecordType plsqlRecordType) throws ParseException { |
| fieldDeclaration(plsqlRecordType); |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case O_COMMA: |
| jj_consume_token(O_COMMA); |
| fieldDeclarations(plsqlRecordType); |
| break; |
| default: |
| ; |
| } |
| } |
| |
| final public void fieldDeclaration(PLSQLRecordType plsqlRecordType) throws ParseException { |
| String s = null; |
| DatabaseType dataType = null; |
| FieldType fieldType = null; |
| s = typeName(); |
| dataType = typeSpec(); |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case R_NOT: |
| jj_consume_token(R_NOT); |
| jj_consume_token(R_NULL); |
| break; |
| default: |
| ; |
| } |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case O_ASSIGN: |
| case R_DEFAULT: |
| fieldDefaultAssignment(); |
| break; |
| default: |
| ; |
| } |
| fieldType = new FieldType(s); |
| fieldType.setEnclosedType(dataType); |
| plsqlRecordType.addField(fieldType); |
| if (dataType instanceof UnresolvedType) { |
| ((UnresolvedType)dataType).setOwningType(plsqlRecordType); |
| } |
| } |
| |
| final public void fieldDefaultAssignment() throws ParseException { |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case O_ASSIGN: |
| jj_consume_token(O_ASSIGN); |
| break; |
| case R_DEFAULT: |
| jj_consume_token(R_DEFAULT); |
| break; |
| default: |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| skipToNextArg(); |
| } |
| |
| final public void subtypeDeclaration(PLSQLPackageType packageType) throws ParseException { |
| String subtypeName; |
| DatabaseType subtype; |
| Token notNull = null; |
| Token rangeStart = null; |
| Token rangeEnd = null; |
| jj_consume_token(R_SUBTYPE); |
| subtypeName = OracleObjectName(); |
| jj_consume_token(R_IS); |
| subtype = typeSpec(); |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case K_RANGE: |
| jj_consume_token(K_RANGE); |
| rangeStart = jj_consume_token(S_NUMBER); |
| jj_consume_token(O_DOUBLEDOT); |
| rangeEnd = jj_consume_token(S_NUMBER); |
| break; |
| default: |
| ; |
| } |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case R_NOT: |
| jj_consume_token(R_NOT); |
| notNull = jj_consume_token(R_NULL); |
| break; |
| default: |
| ; |
| } |
| jj_consume_token(O_SEMICOLON); |
| PLSQLSubType newPLSQLSubType = new PLSQLSubType(subtypeName); |
| newPLSQLSubType.setEnclosedType(subtype); |
| if (subtype instanceof UnresolvedType) { |
| ((UnresolvedType)subtype).setOwningType(newPLSQLSubType); |
| } |
| packageType.addType(newPLSQLSubType); |
| if (notNull != null) { |
| newPLSQLSubType.setNotNull(true); |
| } |
| if (rangeStart != null) { |
| long rStart = Long.decode(rangeStart.image).longValue(); |
| long rEnd = Long.decode(rangeEnd.image).longValue(); |
| newPLSQLSubType.setHasRange(true); |
| newPLSQLSubType.setRangeStart(rStart); |
| newPLSQLSubType.setRangeEnd(rEnd); |
| } |
| localTypes.put(subtypeName, newPLSQLSubType); |
| } |
| |
| final public void plsqlTableDeclaration(PLSQLPackageType packageType, String typeName) throws ParseException { |
| PLSQLCollectionType plsqlTable = new PLSQLCollectionType(typeName); |
| plsqlTable.setParentType(packageType); |
| DatabaseType nestedType; |
| jj_consume_token(R_TABLE); |
| jj_consume_token(R_OF); |
| nestedType = typeSpec(); |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case R_NOT: |
| jj_consume_token(R_NOT); |
| jj_consume_token(R_NULL); |
| break; |
| default: |
| ; |
| } |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case R_INDEX: |
| jj_consume_token(R_INDEX); |
| jj_consume_token(R_BY); |
| plsqlTableIndexByDeclaration(plsqlTable); |
| break; |
| default: |
| ; |
| } |
| if (nestedType instanceof UnresolvedType) { |
| ((UnresolvedType)nestedType).setOwningType(plsqlTable); |
| } |
| plsqlTable.setEnclosedType(nestedType); |
| packageType.addType(plsqlTable); |
| localTypes.put(typeName, plsqlTable); |
| } |
| |
| final public void plsqlTableIndexByDeclaration(PLSQLCollectionType plsqlTable) throws ParseException { |
| DatabaseType indexType = null; |
| Token precision = null; |
| Token otherIndexByType = null; |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case K_PLS_INTEGER: |
| jj_consume_token(K_PLS_INTEGER); |
| indexType = PLS_INTEGER_TYPE; |
| break; |
| case K_BINARY_INTEGER: |
| jj_consume_token(K_BINARY_INTEGER); |
| indexType = BINARY_INTEGER_TYPE; |
| break; |
| case K_VARCHAR2: |
| jj_consume_token(K_VARCHAR2); |
| jj_consume_token(O_OPENPAREN); |
| precision = jj_consume_token(S_NUMBER); |
| jj_consume_token(O_CLOSEPAREN); |
| if (precision == null) { |
| indexType = new VarChar2Type(); |
| } |
| else { |
| Long pl = Long.decode(precision.image); |
| indexType = new VarChar2Type(pl); |
| } |
| break; |
| case K_STRING: |
| otherIndexByType = jj_consume_token(K_STRING); |
| jj_consume_token(O_OPENPAREN); |
| jj_consume_token(S_NUMBER); |
| jj_consume_token(O_CLOSEPAREN); |
| String indexTypename = otherIndexByType.image; |
| for (String typeName : localTypes.keySet()) { |
| if (typeName.equals(indexTypename)) { |
| indexType = localTypes.get(indexTypename); |
| break; |
| } |
| } |
| //what else can INDEX BY be? Unresolved for now ... |
| if (indexType == null) { |
| indexType = new UnresolvedType(indexTypename); |
| ((UnresolvedType)indexType).setOwningType(plsqlTable); |
| } |
| break; |
| default: |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| plsqlTable.setIndexed(true); |
| plsqlTable.setIndexType(indexType); |
| } |
| |
| final public void varrayDeclaration(PLSQLPackageType packageType) throws ParseException { |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case K_VARRAY: |
| jj_consume_token(K_VARRAY); |
| break; |
| case K_VARYING: |
| jj_consume_token(K_VARYING); |
| jj_consume_token(K_ARRAY); |
| break; |
| default: |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| jj_consume_token(O_OPENPAREN); |
| jj_consume_token(S_NUMBER); |
| jj_consume_token(O_CLOSEPAREN); |
| jj_consume_token(R_OF); |
| datatype(); |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case R_NOT: |
| jj_consume_token(R_NOT); |
| jj_consume_token(R_NULL); |
| break; |
| default: |
| ; |
| } |
| } |
| |
| final public void refCursorDeclaration(PLSQLPackageType packageType, String cursorTypeName) throws ParseException { |
| PLSQLCursorType cursorType = null; |
| jj_consume_token(K_REF); |
| jj_consume_token(R_CURSOR); |
| cursorType = new PLSQLCursorType(cursorTypeName); |
| packageType.addCursor(cursorType); |
| localTypes.put(cursorTypeName, cursorType); |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case K_RETURN: |
| refCursorTypeSpec(cursorType, packageType); |
| break; |
| default: |
| ; |
| } |
| } |
| |
| final public void refCursorTypeSpec(PLSQLCursorType cursorType, PLSQLPackageType packageType) throws ParseException { |
| String s = null; |
| Token spec = null; |
| boolean isTYPEType = false; |
| boolean isROWTYPEType = false; |
| DatabaseType localType = null; |
| jj_consume_token(K_RETURN); |
| spec = jj_consume_token(S_IDENTIFIER); |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case R_ANCHORED_ROWTYPE: |
| case R_ANCHORED_TYPE: |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case R_ANCHORED_TYPE: |
| jj_consume_token(R_ANCHORED_TYPE); |
| isTYPEType = true; |
| s = spec.image + removeQuotes(tokenImage[R_ANCHORED_TYPE]); |
| break; |
| case R_ANCHORED_ROWTYPE: |
| jj_consume_token(R_ANCHORED_ROWTYPE); |
| isROWTYPEType = true; |
| s = spec.image + removeQuotes(tokenImage[R_ANCHORED_ROWTYPE]); |
| break; |
| default: |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| break; |
| default: |
| ; |
| } |
| //check local variables first |
| for (FieldType varField : packageType.getLocalVariables()) { |
| if (spec.image.equals(varField.getFieldName())) { |
| if (isTYPEType) { |
| TYPEType tType = new TYPEType(s); |
| UnresolvedType uType = new UnresolvedType(s); |
| tType.setEnclosedType(uType); |
| uType.setOwningType(tType); |
| localType = tType; |
| } |
| else if (isROWTYPEType) { |
| ROWTYPEType rType = new ROWTYPEType(s); |
| UnresolvedType uType = new UnresolvedType(s); |
| rType.setEnclosedType(uType); |
| uType.setOwningType(rType); |
| localType = rType; |
| } |
| else { |
| localType = varField.getEnclosedType(); |
| } |
| cursorType.setEnclosedType(localType); |
| break; |
| } |
| } |
| if (localType == null) { |
| localType = localTypes.get(spec.image); |
| if (localType == null) { |
| UnresolvedType uType = new UnresolvedType(spec.image); |
| if (isTYPEType) { |
| TYPEType tType = new TYPEType(s); |
| tType.setEnclosedType(uType); |
| uType.setOwningType(tType); |
| cursorType.setEnclosedType(tType); |
| } |
| else if (isROWTYPEType) { |
| ROWTYPEType rType = new ROWTYPEType(s); |
| rType.setEnclosedType(uType); |
| uType.setOwningType(rType); |
| cursorType.setEnclosedType(rType); |
| } |
| else { |
| uType.setOwningType(cursorType); |
| cursorType.setEnclosedType(uType); |
| } |
| } |
| else { |
| cursorType.setEnclosedType(localType); |
| } |
| } |
| } |
| |
| final public void cursorDeclaration(PLSQLPackageType packageType) throws ParseException { |
| Token t = null; |
| jj_consume_token(R_CURSOR); |
| t = jj_consume_token(S_IDENTIFIER); |
| jj_consume_token(O_SEMICOLON); |
| } |
| |
| // Procedure Specification
|
| final public void procedureSpec(PLSQLPackageType packageType) throws ParseException { |
| Token t = null; |
| ProcedureType procedureType = null; |
| jj_consume_token(R_PROCEDURE); |
| t = jj_consume_token(S_IDENTIFIER); |
| procedureType = new ProcedureType(t.image); |
| procedureType.setCatalogName(packageType.getPackageName()); |
| procedureType.setSchema(packageType.getSchema()); |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case O_OPENPAREN: |
| jj_consume_token(O_OPENPAREN); |
| argumentList(procedureType); |
| jj_consume_token(O_CLOSEPAREN); |
| break; |
| default: |
| ; |
| } |
| jj_consume_token(O_SEMICOLON); |
| packageType.addProcedure(procedureType); |
| } |
| |
| final public void argumentList(ProcedureType procedureType) throws ParseException { |
| argument(procedureType); |
| label_5: |
| while (true) { |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case O_COMMA: |
| ; |
| break; |
| default: |
| break label_5; |
| } |
| jj_consume_token(O_COMMA); |
| argument(procedureType); |
| } |
| } |
| |
| // Function Specification
|
| final public void functionSpec(PLSQLPackageType packageType) throws ParseException { |
| Token t = null; |
| FunctionType functionType = null; |
| ArgumentType returnDataType = null; |
| jj_consume_token(R_FUNCTION); |
| t = jj_consume_token(S_IDENTIFIER); |
| functionType = new FunctionType(t.image); |
| functionType.setCatalogName(packageType.getPackageName()); |
| functionType.setSchema(packageType.getSchema()); |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case O_OPENPAREN: |
| jj_consume_token(O_OPENPAREN); |
| argumentList(functionType); |
| jj_consume_token(O_CLOSEPAREN); |
| break; |
| default: |
| ; |
| } |
| returnDataType = functionReturnSpec(); |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case K_DETERMINISTIC: |
| case K_PARALLEL_ENABLE: |
| case K_PIPELINED: |
| case K_RESULT_CACHE: |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case K_DETERMINISTIC: |
| jj_consume_token(K_DETERMINISTIC); |
| break; |
| case K_PIPELINED: |
| jj_consume_token(K_PIPELINED); |
| break; |
| case K_PARALLEL_ENABLE: |
| jj_consume_token(K_PARALLEL_ENABLE); |
| break; |
| case K_RESULT_CACHE: |
| jj_consume_token(K_RESULT_CACHE); |
| break; |
| default: |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| break; |
| default: |
| ; |
| } |
| jj_consume_token(O_SEMICOLON); |
| functionType.setReturnArgument(returnDataType); |
| packageType.addProcedure(functionType); |
| } |
| |
| final public ArgumentType functionReturnSpec() throws ParseException { |
| DatabaseType dataType = null; |
| jj_consume_token(K_RETURN); |
| dataType = typeSpec(); |
| ArgumentType returnType = new ArgumentType(null); |
| returnType.setDirection(ArgumentTypeDirection.RETURN); |
| returnType.setEnclosedType(dataType); |
| if (dataType instanceof UnresolvedType) { |
| ((UnresolvedType)dataType).setOwningType(returnType); |
| } |
| {if (true) return returnType;} |
| throw new Error("Missing return statement in function"); |
| } |
| |
| final public void argument(ProcedureType procedureType) throws ParseException { |
| Token t = null; |
| ArgumentType argumentType = null; |
| DatabaseType argumentDataType = null; |
| ArgumentTypeDirection argDirection = ArgumentTypeDirection.IN; // by default, arguments are IN
|
| String direction = null; |
| boolean defaultAssignment = false; |
| t = jj_consume_token(S_IDENTIFIER); |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case R_IN: |
| case K_OUT: |
| direction = direction(); |
| break; |
| default: |
| ; |
| } |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case K_NOCOPY: |
| jj_consume_token(K_NOCOPY); |
| break; |
| default: |
| ; |
| } |
| argumentDataType = typeSpec(); |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case O_ASSIGN: |
| case R_DEFAULT: |
| defaultAssignment = argumentDefaultAssignment(); |
| break; |
| default: |
| ; |
| } |
| argumentType = new ArgumentType(t.image); |
| argumentType.setEnclosedType(argumentDataType); |
| if (argumentDataType instanceof UnresolvedType) { |
| ((UnresolvedType)argumentDataType).setOwningType(argumentType); |
| } |
| if (direction != null) { |
| if ("OUT".equals(direction)) { |
| argDirection = ArgumentTypeDirection.OUT; |
| } |
| else if ("IN OUT".equals(direction)) { |
| argDirection = ArgumentTypeDirection.INOUT; |
| } |
| argumentType.setDirection(argDirection); |
| } |
| if (defaultAssignment) { |
| argumentType.setOptional(); |
| } |
| procedureType.addArgument(argumentType); |
| } |
| |
| final public boolean argumentDefaultAssignment() throws ParseException { |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case O_ASSIGN: |
| jj_consume_token(O_ASSIGN); |
| break; |
| case R_DEFAULT: |
| jj_consume_token(R_DEFAULT); |
| break; |
| default: |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| skipToNextArg(); |
| {if (true) return true;} |
| throw new Error("Missing return statement in function"); |
| } |
| |
| final public void exceptionDeclaration() throws ParseException { |
| jj_consume_token(S_IDENTIFIER); |
| jj_consume_token(R_EXCEPTION); |
| jj_consume_token(O_SEMICOLON); |
| } |
| |
| final public void pragmaDeclaration() throws ParseException { |
| jj_consume_token(K_PRAGMA); |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case K_AUTONOMOUS_TRANSACTION: |
| case K_EXCEPTION_INIT: |
| case K_INLINE: |
| case K_RESTRICT_REFERENCES: |
| case K_SERIALLY_REUSABLE: |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case K_AUTONOMOUS_TRANSACTION: |
| jj_consume_token(K_AUTONOMOUS_TRANSACTION); |
| break; |
| case K_EXCEPTION_INIT: |
| jj_consume_token(K_EXCEPTION_INIT); |
| jj_consume_token(O_OPENPAREN); |
| jj_consume_token(S_IDENTIFIER); |
| jj_consume_token(O_COMMA); |
| jj_consume_token(S_NUMBER); |
| jj_consume_token(O_CLOSEPAREN); |
| break; |
| case K_SERIALLY_REUSABLE: |
| jj_consume_token(K_SERIALLY_REUSABLE); |
| break; |
| case K_INLINE: |
| jj_consume_token(K_INLINE); |
| jj_consume_token(O_OPENPAREN); |
| jj_consume_token(S_IDENTIFIER); |
| jj_consume_token(O_COMMA); |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case R_NO: |
| case R_YES: |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case R_YES: |
| jj_consume_token(R_YES); |
| break; |
| case R_NO: |
| jj_consume_token(R_NO); |
| break; |
| default: |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| break; |
| default: |
| ; |
| } |
| jj_consume_token(O_CLOSEPAREN); |
| break; |
| case K_RESTRICT_REFERENCES: |
| jj_consume_token(K_RESTRICT_REFERENCES); |
| jj_consume_token(O_OPENPAREN); |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case R_DEFAULT: |
| case S_IDENTIFIER: |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case S_IDENTIFIER: |
| jj_consume_token(S_IDENTIFIER); |
| break; |
| case R_DEFAULT: |
| jj_consume_token(R_DEFAULT); |
| break; |
| default: |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| break; |
| default: |
| ; |
| } |
| label_6: |
| while (true) { |
| jj_consume_token(O_COMMA); |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case K_RNDS: |
| case K_RNPS: |
| case K_TRUST: |
| case K_WNDS: |
| case K_WNPS: |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case K_RNDS: |
| jj_consume_token(K_RNDS); |
| break; |
| case K_WNDS: |
| jj_consume_token(K_WNDS); |
| break; |
| case K_RNPS: |
| jj_consume_token(K_RNPS); |
| break; |
| case K_WNPS: |
| jj_consume_token(K_WNPS); |
| break; |
| case K_TRUST: |
| jj_consume_token(K_TRUST); |
| break; |
| default: |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| break; |
| default: |
| ; |
| } |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case O_COMMA: |
| ; |
| break; |
| default: |
| break label_6; |
| } |
| } |
| jj_consume_token(O_CLOSEPAREN); |
| break; |
| default: |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| break; |
| default: |
| ; |
| } |
| jj_consume_token(O_SEMICOLON); |
| } |
| |
| final public void orReplace() throws ParseException { |
| jj_consume_token(R_OR); |
| jj_consume_token(K_REPLACE); |
| } |
| |
| final public void invokerRights() throws ParseException { |
| jj_consume_token(K_AUTHID); |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case K_CURRENT_USER: |
| jj_consume_token(K_CURRENT_USER); |
| break; |
| case K_DEFINER: |
| jj_consume_token(K_DEFINER); |
| break; |
| default: |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| } |
| |
| final public void as() throws ParseException { |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case R_AS: |
| jj_consume_token(R_AS); |
| break; |
| case R_IS: |
| jj_consume_token(R_IS); |
| break; |
| default: |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| } |
| |
| final public void onCommit() throws ParseException { |
| jj_consume_token(R_ON); |
| jj_consume_token(K_COMMIT); |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case K_DELETE: |
| jj_consume_token(K_DELETE); |
| break; |
| case K_PRESERVE: |
| jj_consume_token(K_PRESERVE); |
| break; |
| default: |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| jj_consume_token(K_ROWS); |
| } |
| |
| final public String direction() throws ParseException { |
| String dir = ""; |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case R_IN: |
| jj_consume_token(R_IN); |
| dir = "IN"; |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case K_OUT: |
| jj_consume_token(K_OUT); |
| dir += " OUT"; |
| break; |
| default: |
| ; |
| } |
| break; |
| case K_OUT: |
| jj_consume_token(K_OUT); |
| dir = "OUT"; |
| break; |
| default: |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| {if (true) return dir;} |
| throw new Error("Missing return statement in function"); |
| } |
| |
| final public String OracleObjectName() throws ParseException { |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case S_IDENTIFIER: |
| jj_consume_token(S_IDENTIFIER); |
| {if (true) return token.image;} |
| break; |
| case S_QUOTED_IDENTIFIER: |
| jj_consume_token(S_QUOTED_IDENTIFIER); |
| {if (true) return removeQuotes(token.image);} |
| break; |
| default: |
| jj_consume_token(-1); |
| throw new ParseException(); |
| } |
| throw new Error("Missing return statement in function"); |
| } |
| |
| final public String OracleObjectNamePossiblyDotted() throws ParseException { |
| String possiblyDottedName = ""; |
| String afterDot = null; |
| possiblyDottedName = OracleObjectName(); |
| switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { |
| case O_DOT: |
| jj_consume_token(O_DOT); |
| afterDot = OracleObjectName(); |
| break; |
| default: |
| ; |
| } |
| if (afterDot != null) { |
| possiblyDottedName += "." + afterDot; |
| } |
| {if (true) return possiblyDottedName;} |
| throw new Error("Missing return statement in function"); |
| } |
| |
| final public void skipToSemiColon() throws ParseException { |
| Token t = getNextToken(); |
| while (t.kind != O_SEMICOLON) { |
| t = getNextToken(); |
| } |
| token_source.input_stream.backup(1); |
| } |
| |
| final public void skipToClosingParen() throws ParseException { |
| Token t = getNextToken(); |
| while (t.kind != O_CLOSEPAREN) { |
| t = getNextToken(); |
| } |
| token_source.input_stream.backup(1); |
| } |
| |
| final public void skipToNextArg() throws ParseException { |
| Token t = getNextToken(); |
| while (t.kind != O_COMMA && t.kind != O_CLOSEPAREN) { |
| t = getNextToken(); |
| } |
| token_source.input_stream.backup(1); |
| } |
| |
| final public void skipToEnd() throws ParseException { |
| /** skip through all the tokens. */ |
| Token t = getNextToken(); |
| while (t.kind != EOF) { |
| t = getNextToken(); |
| } |
| } |
| |
| private boolean jj_2_1(int xla) { |
| jj_la = xla; jj_lastpos = jj_scanpos = token; |
| try { return !jj_3_1(); } |
| catch(LookaheadSuccess ls) { return true; } |
| } |
| |
| private boolean jj_3R_16() { |
| if (jj_scan_token(K_NATURAL)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_15() { |
| if (jj_scan_token(K_BINARY_DOUBLE)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_14() { |
| if (jj_scan_token(K_BINARY_FLOAT)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_24() { |
| if (jj_scan_token(K_INTERVAL)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_11() { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_13()) { |
| jj_scanpos = xsp; |
| if (jj_3R_14()) { |
| jj_scanpos = xsp; |
| if (jj_3R_15()) { |
| jj_scanpos = xsp; |
| if (jj_3R_16()) { |
| jj_scanpos = xsp; |
| if (jj_3R_17()) { |
| jj_scanpos = xsp; |
| if (jj_3R_18()) { |
| jj_scanpos = xsp; |
| if (jj_3R_19()) { |
| jj_scanpos = xsp; |
| if (jj_3R_20()) { |
| jj_scanpos = xsp; |
| if (jj_3R_21()) { |
| jj_scanpos = xsp; |
| if (jj_3R_22()) { |
| jj_scanpos = xsp; |
| if (jj_3R_23()) { |
| jj_scanpos = xsp; |
| if (jj_3R_24()) { |
| jj_scanpos = xsp; |
| if (jj_3R_25()) { |
| jj_scanpos = xsp; |
| if (jj_3R_26()) { |
| jj_scanpos = xsp; |
| if (jj_3R_27()) { |
| jj_scanpos = xsp; |
| if (jj_3R_28()) { |
| jj_scanpos = xsp; |
| if (jj_3R_29()) { |
| jj_scanpos = xsp; |
| if (jj_3R_30()) { |
| jj_scanpos = xsp; |
| if (jj_3R_31()) { |
| jj_scanpos = xsp; |
| if (jj_3R_32()) { |
| jj_scanpos = xsp; |
| if (jj_3R_33()) { |
| jj_scanpos = xsp; |
| if (jj_3R_34()) { |
| jj_scanpos = xsp; |
| if (jj_3R_35()) { |
| jj_scanpos = xsp; |
| if (jj_3R_36()) { |
| jj_scanpos = xsp; |
| if (jj_3R_37()) { |
| jj_scanpos = xsp; |
| if (jj_3R_38()) { |
| jj_scanpos = xsp; |
| if (jj_3R_39()) { |
| jj_scanpos = xsp; |
| if (jj_3R_40()) { |
| jj_scanpos = xsp; |
| if (jj_3R_41()) { |
| jj_scanpos = xsp; |
| if (jj_3R_42()) { |
| jj_scanpos = xsp; |
| if (jj_3R_43()) { |
| jj_scanpos = xsp; |
| if (jj_3R_44()) { |
| jj_scanpos = xsp; |
| if (jj_3R_45()) { |
| jj_scanpos = xsp; |
| if (jj_3R_46()) { |
| jj_scanpos = xsp; |
| if (jj_3R_47()) { |
| jj_scanpos = xsp; |
| if (jj_3R_48()) { |
| jj_scanpos = xsp; |
| if (jj_3R_49()) { |
| jj_scanpos = xsp; |
| if (jj_3R_50()) { |
| jj_scanpos = xsp; |
| if (jj_3R_51()) { |
| jj_scanpos = xsp; |
| if (jj_3R_52()) return true; |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_13() { |
| if (jj_scan_token(K_BINARY_INTEGER)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_23() { |
| if (jj_scan_token(K_DATE)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_22() { |
| if (jj_scan_token(K_BOOLEAN)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_12() { |
| if (jj_3R_53()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_50() { |
| if (jj_scan_token(K_NVARCHAR2)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_44() { |
| if (jj_scan_token(K_CHAR)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_43() { |
| if (jj_scan_token(K_DOUBLE)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_21() { |
| if (jj_scan_token(K_RAW)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_49() { |
| if (jj_scan_token(K_NVARCHAR)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_55() { |
| if (jj_scan_token(S_QUOTED_IDENTIFIER)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_54() { |
| if (jj_scan_token(S_IDENTIFIER)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_53() { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_54()) { |
| jj_scanpos = xsp; |
| if (jj_3R_55()) return true; |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_42() { |
| if (jj_scan_token(K_UROWID)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_41() { |
| if (jj_scan_token(K_ROWID)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_40() { |
| if (jj_scan_token(K_BFILE)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_39() { |
| if (jj_scan_token(K_NCLOB)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_38() { |
| if (jj_scan_token(K_BLOB)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_37() { |
| if (jj_scan_token(K_SYS_REFCURSOR)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_36() { |
| if (jj_scan_token(K_SIMPLE_DOUBLE)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_35() { |
| if (jj_scan_token(K_SIMPLE_FLOAT)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_7() { |
| if (jj_scan_token(S_IDENTIFIER)) return true; |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_scan_token(142)) jj_scanpos = xsp; |
| if (jj_3R_8()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_34() { |
| if (jj_scan_token(K_SIMPLE_INTEGER)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_33() { |
| if (jj_scan_token(K_PLS_INTEGER)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_32() { |
| if (jj_scan_token(K_MLSLABEL)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_31() { |
| if (jj_scan_token(K_REAL)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_20() { |
| if (jj_scan_token(K_LONG)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_48() { |
| if (jj_scan_token(K_NCHAR)) return true; |
| return false; |
| } |
| |
| private boolean jj_3_1() { |
| if (jj_3R_7()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_30() { |
| if (jj_scan_token(K_FLOAT)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_29() { |
| if (jj_scan_token(K_SMALLINT)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_28() { |
| if (jj_scan_token(K_INT)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_27() { |
| if (jj_scan_token(K_INTEGER)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_10() { |
| if (jj_3R_12()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_9() { |
| if (jj_3R_11()) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_47() { |
| if (jj_scan_token(K_CHARACTER)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_8() { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_3R_9()) { |
| jj_scanpos = xsp; |
| if (jj_3R_10()) return true; |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_26() { |
| if (jj_scan_token(K_TIMESTAMP)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_25() { |
| if (jj_scan_token(K_TIME)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_52() { |
| if (jj_scan_token(K_CLOB)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_46() { |
| if (jj_scan_token(K_VARCHAR2)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_45() { |
| if (jj_scan_token(K_VARCHAR)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_19() { |
| Token xsp; |
| xsp = jj_scanpos; |
| if (jj_scan_token(174)) { |
| jj_scanpos = xsp; |
| if (jj_scan_token(175)) { |
| jj_scanpos = xsp; |
| if (jj_scan_token(148)) { |
| jj_scanpos = xsp; |
| if (jj_scan_token(147)) return true; |
| } |
| } |
| } |
| return false; |
| } |
| |
| private boolean jj_3R_18() { |
| if (jj_scan_token(K_SIGNTYPE)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_51() { |
| if (jj_scan_token(K_NATIONAL)) return true; |
| return false; |
| } |
| |
| private boolean jj_3R_17() { |
| if (jj_scan_token(K_POSITIVE)) return true; |
| return false; |
| } |
| |
| /** Generated Token Manager. */ |
| public DDLParserTokenManager token_source; |
| JavaCharStream jj_input_stream; |
| /** Current token. */ |
| public Token token; |
| /** Next token. */ |
| public Token jj_nt; |
| private int jj_ntk; |
| private Token jj_scanpos, jj_lastpos; |
| private int jj_la; |
| |
| /** Constructor with InputStream. */ |
| public DDLParser(java.io.InputStream stream) { |
| this(stream, null); |
| } |
| /** Constructor with InputStream and supplied encoding */ |
| public DDLParser(java.io.InputStream stream, String encoding) { |
| try { jj_input_stream = new JavaCharStream(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); } |
| token_source = new DDLParserTokenManager(jj_input_stream); |
| token = new Token(); |
| jj_ntk = -1; |
| } |
| |
| /** Reinitialise. */ |
| public void ReInit(java.io.InputStream stream) { |
| ReInit(stream, null); |
| } |
| /** Reinitialise. */ |
| public void ReInit(java.io.InputStream stream, String encoding) { |
| try { jj_input_stream.ReInit(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); } |
| token_source.ReInit(jj_input_stream); |
| token = new Token(); |
| jj_ntk = -1; |
| jjtree.reset(); |
| } |
| |
| /** Constructor. */ |
| public DDLParser(java.io.Reader stream) { |
| jj_input_stream = new JavaCharStream(stream, 1, 1); |
| token_source = new DDLParserTokenManager(jj_input_stream); |
| token = new Token(); |
| jj_ntk = -1; |
| } |
| |
| /** Reinitialise. */ |
| public void ReInit(java.io.Reader stream) { |
| jj_input_stream.ReInit(stream, 1, 1); |
| token_source.ReInit(jj_input_stream); |
| token = new Token(); |
| jj_ntk = -1; |
| jjtree.reset(); |
| } |
| |
| /** Constructor with generated Token Manager. */ |
| public DDLParser(DDLParserTokenManager tm) { |
| token_source = tm; |
| token = new Token(); |
| jj_ntk = -1; |
| } |
| |
| /** Reinitialise. */ |
| public void ReInit(DDLParserTokenManager tm) { |
| token_source = tm; |
| token = new Token(); |
| jj_ntk = -1; |
| jjtree.reset(); |
| } |
| |
| private Token jj_consume_token(int kind) throws ParseException { |
| Token oldToken; |
| if ((oldToken = token).next != null) token = token.next; |
| else token = token.next = token_source.getNextToken(); |
| jj_ntk = -1; |
| if (token.kind == kind) { |
| return token; |
| } |
| token = oldToken; |
| throw generateParseException(); |
| } |
| |
| static private final class LookaheadSuccess extends java.lang.Error { } |
| final private LookaheadSuccess jj_ls = new LookaheadSuccess(); |
| private boolean jj_scan_token(int kind) { |
| if (jj_scanpos == jj_lastpos) { |
| jj_la--; |
| if (jj_scanpos.next == null) { |
| jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken(); |
| } else { |
| jj_lastpos = jj_scanpos = jj_scanpos.next; |
| } |
| } else { |
| jj_scanpos = jj_scanpos.next; |
| } |
| if (jj_scanpos.kind != kind) return true; |
| if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls; |
| return false; |
| } |
| |
| |
| /** Get the next Token. */ |
| final public Token getNextToken() { |
| if (token.next != null) token = token.next; |
| else token = token.next = token_source.getNextToken(); |
| jj_ntk = -1; |
| return token; |
| } |
| |
| /** Get the specific Token. */ |
| final public Token getToken(int index) { |
| Token t = token; |
| for (int i = 0; i < index; i++) { |
| if (t.next != null) t = t.next; |
| else t = t.next = token_source.getNextToken(); |
| } |
| return t; |
| } |
| |
| private int jj_ntk() { |
| if ((jj_nt=token.next) == null) |
| return (jj_ntk = (token.next=token_source.getNextToken()).kind); |
| else |
| return (jj_ntk = jj_nt.kind); |
| } |
| |
| /** Generate ParseException. */ |
| public ParseException generateParseException() { |
| Token errortok = token.next; |
| int line = errortok.beginLine, column = errortok.beginColumn; |
| String mess = (errortok.kind == 0) ? tokenImage[0] : errortok.image; |
| return new ParseException("Parse error at line " + line + ", column " + column + ". Encountered: " + mess); |
| } |
| |
| /** Enable tracing. */ |
| final public void enable_tracing() { |
| } |
| |
| /** Disable tracing. */ |
| final public void disable_tracing() { |
| } |
| |
| } |