/*******************************************************************************
 * 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
 ******************************************************************************/
options {
      STATIC = false;
      SUPPORT_CLASS_VISIBILITY_PUBLIC = true;
      ERROR_REPORTING = false;
      JAVA_UNICODE_ESCAPE = true;
      UNICODE_INPUT = true;
      NODE_USES_PARSER = true;
      TRACK_TOKENS = true;
      VISITOR = true;
}

PARSER_BEGIN(DDLParser)
/*******************************************************************************
 * 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;

//metadata imports
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.NestedTableType;
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.PLSQLPackageType;
import org.eclipse.persistence.tools.oracleddl.metadata.PLSQLType;
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.TableType;
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.SIMPLE_INTEGER_TYPE;
import static org.eclipse.persistence.tools.oracleddl.metadata.ScalarDatabaseTypeEnum.SMALLINT_TYPE;
import static org.eclipse.persistence.tools.oracleddl.metadata.ScalarDatabaseTypeEnum.TIME_TYPE;
import static org.eclipse.persistence.tools.oracleddl.metadata.ScalarDatabaseTypeEnum.TIMESTAMP_TYPE;

public class DDLParser {

    protected DatabaseTypesRepository typesRepository = new DatabaseTypesRepository();

    public DDLParser() {
        super();
    }

    public void setTypesRepository(DatabaseTypesRepository typesRepository) {
        this.typesRepository = typesRepository;
    }
}

PARSER_END(DDLParser)

// white-space
SKIP: {
  " "
| "\t"
| "\n"
| "\r"
| "\f"
}
// comments
SKIP: {
    <COMMENT_LINE: "--" (~["\n","\r"])* ("\n"|"\r"|"\r\n") >
}
SKIP:{
    <COMMENT_BLOCK: "/*" (~["*"])* "*" ("*" | (~["*","/"] (~["*"])* "*"))* "/">
}

// PLSQL reserved keywords (prefix with K_ to avoid naming conflicts) - NB: incomplete list
TOKEN: {  
          <K_A: "A">
        | <K_ADD: "ADD">
        | <K_ALTER: "ALTER">
        | <K_ARRAY: "ARRAY">
        | <K_AS: "AS">
        | <K_AUTHID: "AUTHID">
        | <K_AUTOMATIC: "AUTOMATIC">
        | <K_AUTONOMOUS_TRANSACTION: "AUTONOMOUS_TRANSACTION">
        | <K_BEGIN: "BEGIN">
        | <K_BFILE: "BFILE">
        | <K_BINARY_DOUBLE: "BINARY_DOUBLE">
        | <K_BINARY_FLOAT: "BINARY_FLOAT">
        | <K_BINARY_INTEGER: "BINARY_INTEGER">
        | <K_BLOB: "BLOB">
        | <K_BODY: "BODY">
        | <K_BOOLEAN: "BOOLEAN">
        | <K_BUILTIN: "BUILTIN">
        | <K_BULK: "BULK">
        | <K_BY: "BY">
        | <K_BYTE: "BYTE">
        | <K_CHAR: "CHAR">
        | <K_CHARACTER: "CHARACTER">
        | <K_CHARSET: "%CHARSET">
        | <K_CLOB: "CLOB">
        | <K_CLOSE: "CLOSE">
        | <K_COLLECT: "COLLECT">
        | <K_COMMIT: "COMMIT">
        | <K_CONSTANT: "CONSTANT">
        | <K_CONSTRAINT: "CONSTRAINT">
        | <K_COUNT: "COUNT">
        | <K_CREATE: "CREATE">
        | <K_CROSS: "CROSS">
        | <K_CUBE: "CUBE">
        | <K_CURRENT_OF: "CURRENT_OF">
        | <K_CURRENT_USER: "CURRENT_USER">
        | <K_CURSOR: "CURSOR">
        | <K_DATE: "DATE">
        | <K_DAY: "DAY">
        | <K_DBTIMEZONE: "DBTIMEZONE">
        | <K_DEC: "DEC">
        | <K_DECIMAL: "DECIMAL">
        | <K_DECREMENT: "DECREMENT">
        | <K_DEFAULT: "DEFAULT">
        | <K_DEFINER: "DEFINER">
        | <K_DELETE: "DELETE">
        | <K_DETERMINISTIC: "DETERMINISTIC">
        | <K_DIMENSION: "DIMENSION">
        | <K_DOUBLE: "DOUBLE">
        | <K_ELSIF: "ELSIF">
        | <K_EMPTY: "EMPTY">
        | <K_ENABLE: "ENABLE">
        | <K_END: "END">
        | <K_EQUALS_PATH: "EQUALS_PATH">
        | <K_ESCAPE: "ESCAPE">
        | <K_EXCEPTION: "EXCEPTION">
        | <K_EXCEPTION_INIT: "EXCEPTION_INIT">
        | <K_EXIT: "EXIT">
        | <K_FALSE: "FALSE">
        | <K_FIPSFLAG: "FIPSFLAG">
        | <K_FIRST: "FIRST">
        | <K_FLOAT: "FLOAT">
        | <K_FULL: "FULL">
        | <K_FUNCTION: "FUNCTION">
        | <K_GLOBAL: "GLOBAL">
        | <K_GROUPING: "GROUPING">
        | <K_IGNORE: "IGNORE">
        | <K_IN: "IN">
        | <K_INCREMENT: "INCREMENT">
        | <K_INDEX: "INDEX">
        | <K_INFINITE: "INFINITE">
        | <K_INLINE: "INLINE">
        | <K_INNER: "INNER">
        | <K_INT: "INT">
        | <K_INTEGER: "INTEGER">
        | <K_INTERFACE: "INTERFACE">
        | <K_INTERVAL: "INTERVAL">
        | <K_IS: "IS">
        | <K_ITERATE: "ITERATE">
        | <K_JOIN: "JOIN">
        | <K_KEY: "KEY">
        | <K_KEEP: "KEEP">
        | <K_LAST: "LAST">
        | <K_LEFT: "LEFT">
        | <K_LIKE2: "LIKE2">
        | <K_LIKE4: "LIKE4">
        | <K_LIKEC: "LIKEC">
        | <K_LOCAL: "LOCAL">
        | <K_LONG: "LONG">
        | <K_LOOP: "LOOP">
        | <K_MAIN: "MAIN">
        | <K_MEASURES: "MEASURES">
        | <K_MEMBER: "MEMBER">
        | <K_MLSLABEL: "MLSLABEL">
        | <K_MODEL: "MODEL">
        | <K_MONTH: "MONTH">
        | <K_NAN: "NAN">
        | <K_NATIONAL: "NATIONAL">
        | <K_NATURAL: "NATURAL">
        | <K_NAV: "NAV">
        | <K_NCHAR: "NCHAR">
        | <K_NCLOB: "NCLOB">
        | <K_NEW_NAMES: "NEW_NAMES">
        | <K_NO: "'NO'">
        | <K_NOCOMPRESS: "NOCOMPRESS">
        | <K_NOCOPY: "NOCOPY">
        | <K_NOCYCLE: "NOCYCLE">
        | <K_NOT: "NOT">
        | <K_NULL: "NULL">
        | <K_NULLS: "NULLS">
        | <K_NUMBER: "NUMBER">
        | <K_NUMERIC: "NUMERIC">
        | <K_NVARCHAR2: "NVARCHAR2">
        | <K_NVARCHAR: "NVARCHAR">
        | <K_OBJECT: "OBJECT">
        | <K_OF: "OF">
        | <K_ON: "ON">
        | <K_ONLY: "ONLY">
        | <K_OPEN: "OPEN">
        | <K_OR: "OR">
        | <K_ORGANIZATION: "ORGANIZATION">
        | <K_OUT: "OUT">
        | <K_OUTER: "OUTER">
        | <K_OVERFLOW: "OVERFLOW">
        | <K_PACKAGE: "PACKAGE">
        | <K_PARALLEL_ENABLE: "PARALLEL_ENABLE">
        | <K_PARTITION: "PARTITION">
        | <K_PIPELINED: "PIPELINED">
        | <K_PLS_INTEGER: "PLS_INTEGER">
        | <K_POSITIVE: "POSITIVE">
        | <K_PRAGMA: "PRAGMA">
        | <K_PRECISION: "PRECISION">
        | <K_PRESENT: "PRESENT">
        | <K_PRESERVE: "PRESERVE">
        | <K_PRIMARY: "PRIMARY">
        | <K_PROCEDURE: "PROCEDURE">
        | <K_RAISE: "RAISE">
        | <K_RANGE: "RANGE">
        | <K_RAW: "RAW">
        | <K_READ: "READ">
        | <K_REAL: "REAL">
        | <K_RECORD: "RECORD">
        | <K_REF: "REF">
        | <K_REFERENCE: "REFERENCE">
        | <K_REGEXP_LIKE: "REGEXP_LIKE">
        | <K_REPLACE: "REPLACE">
        | <K_RESTRICT_REFERENCES: "RESTRICT_REFERENCES">
        | <K_RESULT_CACHE: "RESULT_CACHE">
        | <K_RETURN: "RETURN">
        | <K_RETURNING: "RETURNING">
        | <K_REVERSE: "REVERSE">
        | <K_RIGHT: "RIGHT">
        | <K_RNDS: "RNDS">
        | <K_RNPS: "RNPS">
        | <K_ROLLBACK: "ROLLBACK">
        | <K_ROLLUP: "ROLLUP">
        | <K_ROWID: "ROWID">
        | <K_ROWS: "ROWS">
        | <K_ROWTYPE: "%ROWTYPE">
        | <K_RULES: "RULES">
        | <K_SECOND: "SECOND">
        | <K_SEQUENTIAL: "SEQUENTIAL">
        | <K_SERIALLY_REUSABLE: "SERIALLY_REUSABLE">
        | <K_SESSIONTIMEZONE: "SESSIONTIMEZONE">
        | <K_SET: "SET">
        | <K_SETS: "SETS">
        | <K_SIBLINGS: "SIBLINGS">
        | <K_SINGLE: "SINGLE">
        | <K_SIMPLE_INTEGER: "SIMPLE_INTEGER">
        | <K_SMALLINT: "SMALLINT">
        | <K_SOME: "SOME">
        | <K_STRING: "STRING">
        | <K_SUBMUlookISET: "SUBMUlookISET">
        | <K_SUBTYPE: "SUBTYPE">
        | <K_TABLE: "TABLE">
        | <K_TEMPORARY: "TEMPORARY">
        | <K_THE: "THE">
        | <K_TIME: "TIME">
        | <K_TIMESTAMP: "TIMESTAMP">
        | <K_TO: "TO">
        | <K_TRANSACTION: "TRANSACTION">
        | <K_TRUE: "TRUE">
        | <K_TRUST: "TRUST">
        | <K_TYPE: "TYPE">
        | <K_TYPE2: "%TYPE">
        | <K_UNDER_PATH: "UNDER_PATH">
        | <K_UNTIL: "UNTIL">
        | <K_UPDATED: "UPDATED">
        | <K_UPSERT: "UPSERT">
        | <K_UROWID: "UROWID">
        | <K_USING: "USING">
        | <K_VARCHAR2: "VARCHAR2">
        | <K_VARCHAR: "VARCHAR">
        | <K_VARRAY: "VARRAY">
        | <K_VARYING: "VARYING">
        | <K_WITH: "WITH">
        | <K_WHILE: "WHILE">
        | <K_WNDS: "WNDS">
        | <K_WNPS: "WNPS">
        | <K_WORK: "WORK">
        | <K_YEAR: "YEAR">
        | <K_YES: "'YES'">
        | <K_ZONE: "ZONE">
}

// separators and operators (prefix with O_ to avoid naming conflicts)
TOKEN: {
          <O_ASSIGN: ":=">
        | <O_ASTERISK: "*">
        | <O_ATSIGN: "@">
        | <O_CLOSEPAREN: ")">
        | <O_CONCAT: "||">
        | <O_COLON: ":">
        | <O_COMMA: ",">
        | <O_DOT: ".">
        | <O_DOUBLEDOT: "..">
        | <O_DOLLAR: "$">
        | <O_PERCENT: "%">
        | <O_EQUAL: "=">
        | <O_GREATER: ">">
        | <O_GREATEREQUAL: ">=">
        | <O_JOINPLUS: "(+)">
        | <O_LESS: "<">
        | <O_LESSEQUAL: "<=">
        | <O_MINUS: "-">
        | <O_NOTEQUAL2: "<>">
        | <O_NOTEQUAL: "!=">
        | <O_OPENPAREN: "(">
        | <O_PLUS: "+">
        | <O_POUND: "#">
        | <O_QUESTIONMARK: "?">
        | <O_SEMICOLON: ";">
        | <O_SLASH: "/">
        | <O_TILDE: "~">
}

// numeric literals
TOKEN : {
    <S_NUMBER: <FLOAT>
        | <FLOAT> ( ["e","E"] ([ "-","+"])? <FLOAT> )?
      >
    | <#FLOAT: <INTEGER>
            | <INTEGER> ( "." <INTEGER> )?
            | "." <INTEGER>
      >
    | <#INTEGER: ( <DIGIT> )+ >
    | <#DIGIT: ["0" - "9"] >
}

// identifiers
TOKEN:
{
    <S_IDENTIFIER: (<LETTER>)+ (<DIGIT> | <LETTER> | <SPECIAL_CHARS>)* >
  | <#LETTER: ["a"-"z", "A"-"Z"] >
  | <#SPECIAL_CHARS: "$" | "_" | "#" | "@" >
  | <S_BIND: ":" ( <S_NUMBER> | <S_IDENTIFIER> ("." <S_IDENTIFIER>)?) >
  | <S_CHAR_LITERAL: "'" (~["'"])* "'" ("'" (~["'"])* "'")*>
  | <S_QUOTED_IDENTIFIER: "\"" (~["\n","\r","\""])* "\"" >
}

// stripped-down version of PLSQL grammar: only parses package/top-level DDL specifications

// PLSQLPackage at 'top-level'
PLSQLPackageType parsePLSQLPackage():
{String schema = null;
 String packageName = null;
 PLSQLPackageType packageType = new PLSQLPackageType();}
{
    <K_CREATE> [ <K_OR> <K_REPLACE> ] <K_PACKAGE>
        [LOOKAHEAD(2) schema=OracleObjectName() <O_DOT> ] packageName=OracleObjectName()
        {
          if (schema != null) {
            packageType.setPackageName(schema + "." + packageName);
          }
          else {
            packageType.setPackageName(packageName);
          }
        }
        [ <K_AUTHID> [ <K_CURRENT_USER> | <K_DEFINER> ] ]
        [ <K_AS> | <K_IS> ]
         ( packageDeclaration(packageType) )*
     <K_END> [ OracleObjectName() ] <O_SEMICOLON>
     <EOF>
    {
      typesRepository.setDatabaseType(packageName, packageType);
      return packageType;
    }
}

// procedure at 'top-level'
ProcedureType parseTopLevelProcedure():
{ProcedureType procedureType = null;
 String schema = null;
 String procedureName = null;}
{
  <K_CREATE> [ <K_OR> <K_REPLACE> ] <K_PROCEDURE>
    [LOOKAHEAD(2) schema=OracleObjectName() <O_DOT> ] procedureName=OracleObjectName()
    [ <O_OPENPAREN> argumentList() <O_CLOSEPAREN> ] [ <K_AS> | <K_IS> ]
        skipToEnd()
    {
      procedureType = new ProcedureType(procedureName);
      if (schema != null) {
          procedureType.setSchema(schema);
      }
      typesRepository.setDatabaseType(procedureName, procedureType);
      return procedureType;
    }
}

// function at 'top-level'
FunctionType parseTopLevelFunction():
{FunctionType functionType = null;
 String schema = null;
 String functionName = null;}
{
  <K_CREATE> [ <K_OR> <K_REPLACE> ] <K_FUNCTION>
    [LOOKAHEAD(2) schema=OracleObjectName() <O_DOT> ] functionName=OracleObjectName()
    [ <O_OPENPAREN> argumentList() <O_CLOSEPAREN> ] functionReturnSpec() [ <K_AS> | <K_IS> ]
        skipToEnd()
    {
      functionType = new FunctionType(functionName);
      if (schema != null) {
          functionType.setSchema(schema);
      }
      //TODO - figure out returnType
      typesRepository.setDatabaseType(functionName, functionType);
      return functionType;
    }
}

// table at 'top-level'
TableType parseTable():
{
TableType tableType = null;
String schema = null;
String tableName = null;
Token iot = null;
}
{
    <K_CREATE> [ <K_GLOBAL> <K_TEMPORARY> ] <K_TABLE> 
        [LOOKAHEAD(2) schema=OracleObjectName() <O_DOT> ] tableName=OracleObjectName()
        {
            tableType = new TableType(tableName);
		    if (schema != null) {
		         tableType.setSchema(schema);
		    }        }
        <O_OPENPAREN> columnDeclarations(tableType) <O_CLOSEPAREN>
         [ <K_ORGANIZATION> ] [ iot=<K_INDEX> ] [ <K_NOCOMPRESS> ] [ <K_OVERFLOW> ]
         [ <K_ON> <K_COMMIT > [<K_DELETE> | <K_PRESERVE> ] <K_ROWS> ] <O_SEMICOLON>
        
     <EOF>
     {
         if (iot != null) {
             tableType.setIOT(true);
         } 
         typesRepository.setDatabaseType(tableName, tableType);
         return tableType;
     }
}

// type at 'top-level'
CompositeDatabaseType parseType():
{CompositeDatabaseType databaseType = null;
 String schema = null;
 String typeName = null;
 boolean varray = false;
 boolean nestedTable = false;
}
{
    <K_CREATE> [ <K_OR> <K_REPLACE> ] <K_TYPE>
      [LOOKAHEAD(2) schema=OracleObjectName() <O_DOT> ] typeName=OracleObjectName() <K_AS>
        [ <K_OBJECT> <O_OPENPAREN>
            {
                databaseType = new ObjectType(typeName);
                if (schema != null) {
                    ((ObjectType)databaseType).setSchema(schema);                }
            } columnDeclarations(databaseType) <O_CLOSEPAREN>
          | <K_VARRAY> <O_OPENPAREN> <S_NUMBER> <O_CLOSEPAREN> <K_OF>
            {                databaseType = new VArrayType(typeName);
                if (schema != null) {
                    ((VArrayType)databaseType).setSchema(schema);
                }
            } columnTypeSpec(databaseType)
          | <K_TABLE> <K_OF>	        {
                databaseType = new NestedTableType(typeName);
                if (schema != null) {
                    ((NestedTableType)databaseType).setSchema(schema);
                }	        } columnTypeSpec(databaseType)
        ] 
     [ <O_SEMICOLON> ]
     <EOF>
    {        typesRepository.setDatabaseType(typeName, databaseType);
        return databaseType;
    }
}

void columnDeclarations(CompositeDatabaseType enclosingType) #void:
{}
{
    columnDeclaration(enclosingType) [ <O_COMMA> columnDeclarations(enclosingType) ]    
}

void columnDeclaration(CompositeDatabaseType enclosingType) #void:
{String s = null;
 String pk = null;
 boolean notNull = false;
 DatabaseType columnType = null;
 FieldType column = null;
}
{
    (  LOOKAHEAD(2)       s=OracleObjectName()
         {
           column = new FieldType(s);
           if (enclosingType != null) {
               enclosingType.addCompositeType(column);
           }         }
         columnType=columnTypeSpec(enclosingType) [ <K_NOT> <K_NULL> <K_ENABLE> {notNull = true;} ]
       | LOOKAHEAD(2)
         [ <K_CONSTRAINT> ] [ OracleObjectName() ] <K_PRIMARY> <K_KEY>
             <O_OPENPAREN>  pkList((TableType)enclosingType) <O_CLOSEPAREN> <K_ENABLE>
    )
    {
      if (column != null) {
	      column.setDataType(columnType);
	      if (notNull) {
	          column.setNotNull();
	      }
	  }
    }
}

DatabaseType columnTypeSpec(CompositeDatabaseType enclosingType):
{String s = null;
 Token t = null;
 DatabaseType dt = null;}
{
    (
      dt=datatype()
    | s=columnSpec() [ <O_OPENPAREN> t=<S_NUMBER> <O_CLOSEPAREN> ]
    )
    {
      if (s != null) {
          if (t != null) {
              Long size = Long.decode(t.image);
              dt = new UnresolvedSizedType(s, size);
          }
          else {
              dt = new UnresolvedType(s);
          }
      } 
      return dt;
    }
}

void pkList(TableType tableType) #void:
{}
{
    pk(tableType) ( <O_COMMA> pk(tableType) )*
}


void pk(TableType tableType) #void:
{
String s = null;
}
{
    s=OracleObjectName()
    {
       List<FieldType> columns = tableType.getColumns();
       for (FieldType column : columns) {
            if (column.getFieldName().equals(s)) {
                column.setPk();
                break;
            }
       }    }
}

void packageDeclaration(PLSQLPackageType packageType) #void:
{}
{
    LOOKAHEAD(2) variableDeclaration(packageType)
    | typeDeclaration(packageType)
    | cursorDeclaration(packageType)
    | procedureSpec(packageType)
    | functionSpec(packageType)
    | exceptionDeclaration(packageType)
    | pragmaDeclaration(packageType)
}

void variableDeclaration(PLSQLPackageType packageType):
{}
{
    <S_IDENTIFIER> [ <K_CONSTANT> ] typeSpec() [ <K_NOT> <K_NULL> ]
        [ variableDefaultAssignment() ]
    <O_SEMICOLON>}

void variableDefaultAssignment() #void:
{}
{
    ( <O_ASSIGN> | <K_DEFAULT> ) skipToSemiColon()
}

DatabaseType datatype():
{Token t = null;
 DatabaseType dt = null;
 Token precision = null;
 Long sl;
 Long pl;
 Token scale = null;}
{
    <K_BINARY_INTEGER>  { return BINARY_INTEGER_TYPE;}
    | <K_BINARY_FLOAT>  { return BINARY_FLOAT_TYPE;}
    | <K_BINARY_DOUBLE> { return BINARY_DOUBLE_TYPE;}
    | <K_NATURAL>       { return NATURAL_TYPE;}
    | <K_POSITIVE>      { return POSITIVE_TYPE;}
    | ( t=<K_NUMBER>
        | t=<K_NUMERIC>
        | t=<K_DECIMAL>
        | t=<K_DEC>
      ) [ <O_OPENPAREN> [ precision=<O_ASTERISK > | precision=<S_NUMBER> ] ( <O_COMMA> scale=<S_NUMBER> )* <O_CLOSEPAREN> ]
        {
            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);
	                }
	            }
            }
            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);
                    }
                }
            }            return dt;        }
    | <K_LONG> [ t=<K_RAW> ] [ <O_OPENPAREN> precision=<S_NUMBER> <O_CLOSEPAREN> ]	    {
	      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);
              }
            }
            return dt;	    }
    | <K_RAW> [ <O_OPENPAREN> precision=<S_NUMBER> <O_CLOSEPAREN> ]	    {
            if (precision == null) {
                dt = new RawType();
            }
            else {
                pl = Long.decode(precision.image);
                dt = new RawType(pl);
            }
            return dt;
	    }
    | <K_BOOLEAN> { return BOOLEAN_TYPE;}
    | <K_DATE> { return DATE_TYPE;}
    | LOOKAHEAD(2) <K_INTERVAL> <K_DAY> [ <O_OPENPAREN> precision=<S_NUMBER> <O_CLOSEPAREN> ] <K_TO> <K_SECOND> [ <O_OPENPAREN> scale=<S_NUMBER> <O_CLOSEPAREN> ]
	    {
	        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);
                }
            }
            return dt;	    }
    | <K_INTERVAL> <K_YEAR> [ <O_OPENPAREN> <S_NUMBER> <O_CLOSEPAREN> ] <K_TO> <K_MONTH>	    {
            if (precision == null) {
                dt = new IntervalYearToMonth();
            }
            else {
                pl = Long.decode(precision.image);
                dt = new IntervalYearToMonth(pl);
            }
            return dt;	    }
    | ( <K_TIME> { return TIME_TYPE;}
        | <K_TIMESTAMP> { return TIMESTAMP_TYPE;}
      ) [ <O_OPENPAREN> <S_NUMBER> <O_CLOSEPAREN> ] [ <K_WITH> [ <K_LOCAL> ] <K_TIME> <K_ZONE> ]
    | <K_INTEGER>  { return INTEGER_TYPE;}
    | <K_INT>      { return INTEGER_TYPE;}
    | <K_SMALLINT> { return SMALLINT_TYPE;}
    | <K_FLOAT> [ <O_OPENPAREN> precision=<S_NUMBER> <O_CLOSEPAREN> ]
        {
          if (precision == null) {
              return new FloatType();
          }
          else {
              pl = Long.decode(precision.image);
              FloatType ft = new FloatType(pl);
              return ft;          }
        }
    | <K_REAL> { return new RealType();}
    | <K_MLSLABEL> { return MLSLABEL_TYPE;}
    | <K_PLS_INTEGER> { return PLS_INTEGER_TYPE;}
    | <K_SIMPLE_INTEGER> { return SIMPLE_INTEGER_TYPE;}
    | <K_BLOB > { return new BlobType();}
    | <K_NCLOB> { return new NClobType();}
    | <K_BFILE>  { return BFILE_TYPE;}
    | <K_ROWID> { return ROWID_TYPE;}
    | <K_UROWID> [ <O_OPENPAREN> precision=<S_NUMBER> <O_CLOSEPAREN> ]
        {
          if (precision == null) {
              return new URowIdType();
          }
          else {
              pl = Long.decode(precision.image);
              return new URowIdType(pl);
          }        }
    | <K_DOUBLE> <K_PRECISION> { return new DoubleType();}
    | <K_CHAR> [ t=<K_VARYING> ] [ <O_OPENPAREN> precision=<S_NUMBER> [ <K_BYTE> | <K_CHAR> ] <O_CLOSEPAREN> ]
        [ LOOKAHEAD(2) <K_CHARACTER> <K_SET> [ LOOKAHEAD(2) <S_IDENTIFIER> | columnSpec() <K_CHARSET> ] ]        {
          if (t == null) {
              if (precision == null) {
                  return new CharType();
              }
              else {
                  pl = Long.decode(precision.image);
                  return new CharType(pl);              }
          }
          else {
              // ANSI syntax for VARCHAR2
              if (precision == null) {
                  return new VarChar2Type();
              }
              else {
                  pl = Long.decode(precision.image);
                  return new VarChar2Type(pl);
              }          }        }
    | <K_VARCHAR> [ <K_VARYING> ] [ <O_OPENPAREN> precision=<S_NUMBER> [ <K_BYTE> | <K_CHAR> ] <O_CLOSEPAREN> ]
        [ LOOKAHEAD(2) <K_CHARACTER> <K_SET> [ LOOKAHEAD(2) <S_IDENTIFIER> | columnSpec() <K_CHARSET> ] ]
        {
          if (precision == null) {
              return new VarCharType();
          }
          else {
              pl = Long.decode(precision.image);
              return new VarCharType(pl);
          }
        }
    | <K_VARCHAR2> [ <K_VARYING> ] [ <O_OPENPAREN> precision=<S_NUMBER> [ <K_BYTE> | <K_CHAR> ] <O_CLOSEPAREN> ]
        [ LOOKAHEAD(2) <K_CHARACTER> <K_SET> [ LOOKAHEAD(2) <S_IDENTIFIER> | columnSpec() <K_CHARSET> ] ]
        {
            if (precision == null) {
                return new VarChar2Type();
            }
            else {
                pl = Long.decode(precision.image);
                return new VarChar2Type(pl);            }        }
    | <K_CHARACTER> [ t=<K_VARYING> ] [ <O_OPENPAREN> precision=<S_NUMBER> <O_CLOSEPAREN> ]
        {
          if (t == null) {
              if (precision == null) {
                  return new CharType();
              }
              else {
                  pl = Long.decode(precision.image);
                  return new CharType(pl);
              }
          }
          else {
              // ANSI syntax for VARCHAR
              if (precision == null) {
                  return new VarCharType();
              }
              else {
                  pl = Long.decode(precision.image);
                  return new VarCharType(pl);
              }
          }
        }
    | <K_NCHAR> [ t=<K_VARYING> ] [ <O_OPENPAREN> precision=<S_NUMBER> <O_CLOSEPAREN> ]
        {
          if (t == null) {
              if (precision == null) {
                  return new NCharType();
              }
              else {
                  pl = Long.decode(precision.image);
                  return new NCharType(pl);
              }
          }
          else {
              // ANSI syntax for NVARCHAR2
              if (precision == null) {
                  return new NVarChar2Type();
              }
              else {
                  pl = Long.decode(precision.image);
                  return new NVarChar2Type(pl);
              }
          }
        }
    | <K_NVARCHAR> [ <O_OPENPAREN> precision=<S_NUMBER> <O_CLOSEPAREN> ]	    {
            if (precision == null) {
                return new NVarChar2Type();
            }
            else {
                pl = Long.decode(precision.image);
                return new NVarChar2Type(pl);
            }	    }
    | <K_NVARCHAR2> [ <O_OPENPAREN> precision=<S_NUMBER> <O_CLOSEPAREN> ]
        {
            if (precision == null) {
                return new NVarChar2Type();
            }
            else {
                pl = Long.decode(precision.image);
                return new NVarChar2Type(pl);
            }
        }
    | <K_NATIONAL> ( <K_CHARACTER> | <K_CHAR> ) [ t=<K_VARYING> ] [ <O_OPENPAREN> precision=<S_NUMBER> <O_CLOSEPAREN> ]
        {
          if (t == null) {
              if (precision == null) {
                  return new NCharType();
              }
              else {
                  pl = Long.decode(precision.image);
                  return new NCharType(pl);
              }
          }
          else {
              // ANSI syntax for NVARCHAR2
              if (precision == null) {
                  return new NVarChar2Type();
              }
              else {
                  pl = Long.decode(precision.image);
                  return new NVarChar2Type(pl);
              }
          }
        }
    | <K_CLOB> [ LOOKAHEAD(2) <K_CHARACTER> <K_SET> [ LOOKAHEAD(2) <S_IDENTIFIER> | columnSpec() <K_CHARSET> ] ] { return new ClobType();}
}

String typeSpec():
{String s = null;}
{
    (      datatype()
    | LOOKAHEAD(3) columnSpec() <K_TYPE2>
    | LOOKAHEAD(3) tableSpec() <K_ROWTYPE>
    | typeName() [ <O_OPENPAREN> <S_NUMBER> <O_CLOSEPAREN> ]
    )
    {
      Token first = jjtThis.jjtGetFirstToken();
      Token last = jjtThis.jjtGetLastToken();
      Token cur = first;
      StringBuilder sb = new StringBuilder();
      sb.append(first.image);
      while (cur != last) {
          cur = cur.next;
          sb.append(cur.image);      }
      jjtThis.jjtSetValue(sb.toString());
      return sb.toString();    }
}

String columnSpec() #void:
{String s1 = null;
 String s2 = null;
 String s3 = null;}
{
    s1=OracleObjectName() [ <O_DOT> s2=OracleObjectName() [ <O_DOT> s3=OracleObjectName() ] ]
    {
      StringBuilder sb = new StringBuilder(s1);
      if (s2 != null) {
          sb.append('.');
          sb.append(s2);
          if (s3 != null) {
              sb.append('.');
              sb.append(s3);
          }
      }
      return sb.toString();
    }
}

String tableSpec() #void:
{}
{
    OracleObjectName() [ <O_DOT> OracleObjectName() [ <O_ATSIGN> <S_IDENTIFIER> ] ]
    {return token.image;}
}

String typeName() #void:
{}
{
    OracleObjectName() [ <O_DOT> OracleObjectName() ]
    {return token.image;}
}

void typeDeclaration(PLSQLPackageType packageType) #void:
{String s = null;}
{
    <K_TYPE> s=typeName() <K_IS>
        aTypeDeclaration(packageType)
    <O_SEMICOLON>
}

void aTypeDeclaration(PLSQLPackageType packageType) #void:
{}
{
    recordDeclaration(packageType)
    | subtypeDeclaration(packageType)
    | plsqlTableDeclaration(packageType)
    | varrayDeclaration(packageType)
    | refCursorDeclaration(packageType)
}

void recordDeclaration(PLSQLPackageType packageType) #void:
{}
{
    <K_RECORD> <O_OPENPAREN>
        fieldDeclarations()
    <O_CLOSEPAREN>
}

void fieldDeclarations() #void:
{}
{
    fieldDeclaration() [ <O_COMMA> fieldDeclarations() ]
}

SimpleNode fieldDeclaration():
{String s = null;
}
{
    s=typeName() typeSpec() [ <K_NOT> <K_NULL> ] [ variableDefaultAssignment() ]
    {
      jjtThis.jjtSetValue(s);
      return jjtThis;
    }
}

void subtypeDeclaration(PLSQLPackageType packageType) #void:
{}
{
    <K_SUBTYPE> OracleObjectName() <K_IS> datatype()
        ( <K_RANGE> <S_NUMBER> <O_DOUBLEDOT> <S_NUMBER>
        | <S_NUMBER> [ <O_COMMA> <S_NUMBER> ]
        | <K_CHARACTER> <K_SET> <S_IDENTIFIER>
        ) [ <K_NOT> <K_NULL> ]

}

void plsqlTableDeclaration(PLSQLPackageType packageType) #void:
{}
{
    <K_TABLE> <K_OF> typeSpec() [ <K_NOT> <K_NULL> ] <K_INDEX> <K_BY>
        plsqlTableIndexByDeclaration(packageType)
}

void plsqlTableIndexByDeclaration(PLSQLPackageType packageType) #void:
{}
{
    ( <K_PLS_INTEGER >
    | <K_BINARY_INTEGER>
    | <K_VARCHAR2> <O_OPENPAREN> <S_NUMBER> <O_CLOSEPAREN>
    | <K_STRING> <O_OPENPAREN> <S_NUMBER> <O_CLOSEPAREN>
    )
}

void varrayDeclaration(PLSQLPackageType packageType) #void:
{}
{
    ( <K_VARRAY> | <K_VARYING> <K_ARRAY> ) <O_OPENPAREN> <S_NUMBER> <O_CLOSEPAREN>
        <K_OF> datatype() [ <K_NOT> <K_NULL> ]
}

void refCursorDeclaration(PLSQLPackageType packageType) #void:
{String s = null;}
{
    <K_REF> <K_CURSOR> [ refCursorTypeSpec(packageType) ]
}

void refCursorTypeSpec(PLSQLPackageType packageType) #void:
{String s = null;}
{
    <K_RETURN> [LOOKAHEAD(3) s=columnSpec() [ <K_TYPE2> ]
    | LOOKAHEAD(3) s=tableSpec() [ <K_ROWTYPE> ] ]
}

void cursorDeclaration(PLSQLPackageType packageType) #void:
{Token t = null;}
{
    <K_CURSOR> t=<S_IDENTIFIER>
    <O_SEMICOLON>
}

// Procedure Specification
void procedureSpec(PLSQLPackageType packageType) #void:
{Token t = null;}
{
    <K_PROCEDURE> t=<S_IDENTIFIER>
        [ <O_OPENPAREN> argumentList() <O_CLOSEPAREN> ]
    <O_SEMICOLON>
}

void argumentList() #void:
{}
{
   argument() ( <O_COMMA> argument() )*
}

// Function Specification
void functionSpec(PLSQLPackageType packageType) #void:
{Token t = null;}
{
    <K_FUNCTION> t=<S_IDENTIFIER>
        [ <O_OPENPAREN> argumentList() <O_CLOSEPAREN> ]
        functionReturnSpec()
        [ <K_DETERMINISTIC> | <K_PIPELINED> | <K_PARALLEL_ENABLE> | <K_RESULT_CACHE> ]
    <O_SEMICOLON>
}

SimpleNode functionReturnSpec():
{}{    (<K_RETURN> typeSpec())
    {
      jjtThis.jjtSetValue("RETURN");
      return jjtThis;
    }
}

SimpleNode argument():
{Token t = null;
 String direction = null;
}
{
    t=<S_IDENTIFIER> [(direction=direction())]
        [ <K_NOCOPY> ] typeSpec() [ argumentDefaultAssignment() ]
    {
      if (direction != null) {
          jjtThis.jjtSetValue(direction + " " + t.image);
      }
      else {
          // by default, arguments are IN
          jjtThis.jjtSetValue("IN " + t.image);
      }
      return jjtThis;
    }
}

String direction() #void:
{}
{
    LOOKAHEAD(2) <K_IN> <K_OUT> { return "IN OUT"; }
    | <K_IN> { return "IN"; }
    | <K_OUT>  { return "OUT"; }
}

SimpleNode argumentDefaultAssignment():
{}
{
    ( <O_ASSIGN> | <K_DEFAULT> ) skipToNextArg()
    {
      jjtThis.jjtSetValue(" (optional)");
      return jjtThis;
    }
}

void exceptionDeclaration(PLSQLPackageType packageType) #void:
{}
{
    <S_IDENTIFIER> <K_EXCEPTION> <O_SEMICOLON>
}

void pragmaDeclaration(PLSQLPackageType packageType) #void:
{}
{    <K_PRAGMA>
    [ <K_AUTONOMOUS_TRANSACTION>
    | <K_EXCEPTION_INIT> <O_OPENPAREN> <S_IDENTIFIER> <O_COMMA> <S_NUMBER> <O_CLOSEPAREN>
    | <K_SERIALLY_REUSABLE>
    | <K_INLINE> <O_OPENPAREN> <S_IDENTIFIER> <O_COMMA> [ <K_YES> | <K_NO> ] <O_CLOSEPAREN>
    | <K_RESTRICT_REFERENCES> <O_OPENPAREN> [ <S_IDENTIFIER> | <K_DEFAULT> ]
        ( <O_COMMA> [ <K_RNDS> | <K_WNDS> | <K_RNPS> | <K_WNPS> | <K_TRUST>] )+ <O_CLOSEPAREN>
    ]
    <O_SEMICOLON>
}

String OracleObjectName() #void:
{}
{
    <S_IDENTIFIER>
    {return token.image;}
  | <S_QUOTED_IDENTIFIER>
    {
      String s = token.image;
      return s.substring(1, s.length() - 1); // strip-off quotes
    }
}

void skipToSemiColon() #void:
{}
{
    {
        Token t = getNextToken();
        while (t.kind != O_SEMICOLON) {
	        t = getNextToken();
        }
        token_source.input_stream.backup(1);
    }
}

void skipToNextArg() #void:
{}
{
    {
        Token t = getNextToken();
        while (t.kind != O_COMMA && t.kind != O_CLOSEPAREN) {
            t = getNextToken();
        }
        token_source.input_stream.backup(1);
    }
}

void skipToEnd() #void:
{}
{
    {
      /** skip through all the tokens. */
      Token t = getNextToken();
      while (t.kind != EOF) {
          t = getNextToken();
      }
  }

}