/***********************************************************************
 * Token definitions
 ***********************************************************************/

/* There may be tokens here which don't relate to SQL, but we needed for
   the rest of our project [Kevin] */ 

SKIP:
{
    " "
  | "\n"
  | "\r"
  | "\t"
}


SKIP:
{
  <COMMENT_LINE: "--" (~["\n","\r"])* ("\n"|"\r"|"\r\n") >
        { 
          SC.addComment(SC.fout.printBlock("//" + image.toString().substring(2)));
        }
}


SKIP:
{
  <COMMENT_BLOCK: "/*" (~["*"])* "*" ("*" | (~["*","/"] (~["*"])* "*"))* "/">
        { 
	  SC.addComment(SC.fout.printBlock(image.toString()) + SC.fout.println()); 
	}
}


TOKEN:  /* Keywords */
{
    < ALL: "all" >
  | < AND: "and" >
  | < ASC: "asc" >
  | < BEGIN: "begin" >
  | < BETWEEN: "between" >
  | < BOOLEAN: "boolean" >
  | < BY: "by" >
  | < CHAR: "char" >
  | < CHARACTER: "character" >
  | < CONSTANT: "constant" >
  | < CURSOR: "cursor" >
  | < DESC: "desc" >
  | < DISTINCT: "distinct" >
  | < ELSE: "else" >
  | < ELSIF : "elsif" >
  | < END: "end" >
  | < FROM: "from" >
  | < GROUP: "group" >
  | < HAVING: "having" >
  | < IF: "if" >
  | < INTEGER: "integer" >
  | < IN: "in" >
  | < IS: "is" >
  | < LIKE: "like" >
  | < MAX: "max" >
  | < MIN: "min" >
  | < NOT: "not" >
  | < NULL: "null" >
  | < NUMBER: "number" >
  | < OR: "or" >
  | < ORDER: "order" >
  | < PROCEDURE: "procedure" >
  | < RECORD: "record" >
  | < SELECT: "select" >
  | < SMALLINT: "smallint" >
  | < SPACES: "spaces" >
  | < SUBSTR: "substr" >
  | < SUM: "sum" >
  | < THEN: "then" >
  | < TYPE: "type" >
  | < USER: "user" >
  | < UPPER: "upper" >
  | < VARCHAR2: "varchar2" >
  | < WHERE: "where" >
  | < ZERO: "zero" >
  | < ZEROS: "zeros" >

//***************************************************************************************
  | < COUNT: "count" >
  | < CLOSE: "close" >
  | < CONVERT_TIMESTAMP_TO_DATE: "ConvertTimeStampToDate" >
  | < DELETE: "delete" >
  | < EXISTS: "exists" >
  | < EXIT: "exit" >
  | < EXCEPTION: "exception" >
  | < FETCH: "fetch" >
  | < FOR: "for" >
  | < FORMAT_AUDIT_HEADER: "FormatAuditHeader" >
  | < FORMAT_ATTRIBUTE_SUBSTRING: "FormatAttributeSubString" >
  | < GET_CURRENT_TIMESTAMP: "GetCurrentTimeStamp" >
  | < INSERT: "insert" >
  | < INTO: "into" >
  | < INDEX_BY: "index by binary_integer" >
  | < IS_TABLE_OF: "is table of" >
  | < LENGTH: "length" >
  | < LOOP: "loop" >
  | < LPAD: "lpad" >
  | < LTRIM: "ltrim" >
  | < REPLACE: "replace" >
  | < RTRIM: "rtrim" >
  | < NODULE: "nodule" >
  | < NOTFOUND: "%notFound" >
  | < OPEN: "open" >
  | < OTHERS: "others" >
  | < ORIGINPLUS: "originplus" >
  | < REPLY: "reply" >
  | < REPLY_REPEATING_GROUP: "replyRepeatingGroup" >
  | < REQUEST: "request" >
  | < ROW_NOT_FOUND: "row_not_found" >
  | < SET: "set" >
  | < SQL_I_O_CORRECT: "sql_I_O_Correct" >
  | < TO_CHAR: "to_char" >
  | < TO_NUMBER: "to_number" >
  | < UPDATE: "update" >
  | < VALUES: "values" >
  | < WHEN: "when" >
  | < WHILE: "while" >
}     


TOKEN:
{
    < NO_DATA_FOUND: "NO_DATA_FOUND" >
  | < TABLE_STATUS: "TABLE_STATUS" >
  | < SQLCODE: "SQLCode" >
  | < SET_ROW_NOT_FOUND: "Set_Row_Not_Found" >
  | < FILE_NAME_OF_ERROR_AREA: "FILE_NAME_OF_ERROR_AREA" >
  | < KEY_IN_ERROR: "KEY_IN_ERROR" >
  | < ERROR_DETAIL_DESCRIPTION: "ERROR_DETAIL_DESCRIPTION" >
  | < SETUPFATALERROR: "SetupFatalError" >
}

<DESCRIPTION_START_STATE> TOKEN:
{
    < OPENDESCRIPTION: "\r\n" > : DESCRIPTION_STATE
}


<DESCRIPTION_STATE> TOKEN:  /* Line */
{
    < CLOSEDESCRIPTION: "~" > : DEFAULT
  | < DESCRIPTION: (~["~"])* "~" > : DEFAULT
}

 
TOKEN:  /* Literals */
{
    < INTEGER_LITERAL: (["0"-"9"])+ >
  | < FLOATING_POINT_LITERAL:
          (["0"-"9"])+ "." (["0"-"9"])+ (<EXPONENT>)?
        | "." (["0"-"9"])+ (<EXPONENT>)?
        | (["0"-"9"])+ <EXPONENT>
        | (["0"-"9"])+ (<EXPONENT>)?
    >
  | < #EXPONENT: ["e","E"] (["+","-"])? (["0"-"9"])+ >
  | < STRING_LITERAL: "'" (~["'"])* ( "''" (~["'"])* )* "'" >
}


TOKEN:  /* Identifiers */
{
    < ID: ( <LETTER> )+ ( "_" | "$" | "#" | <DIGIT> | <LETTER> )* >
  | < #LETTER: ["A"-"Z", "a"-"z"] >
  | < #DIGIT: ["0"-"9"] >
}


TOKEN:  /* Separators and operators */
{
    < ASSIGN: ":=" >
  | < CONCAT: "||" >
  | < SEMICOLON: ";" >
  | < DOT: "." >
  | < ROWTYPE: "%ROWTYPE" >
  | < TILDE: "~" >
  | < LESS: "<" >
  | < LESSEQUAL: "<=" >
  | < GREATER: ">" >
  | < GREATEREQUAL: ">=" >
  | < EQUAL: "=" >
  | < NOTEQUAL: "!=" >
  | < NOTEQUAL2: "<>" >
  | < JOINPLUS: "(+)" >
  | < OPENPAREN: "(" >
  | < CLOSEPAREN: ")" >
  | < ASTERISK: "*" >
  | < SLASH: "/" >
  | < PLUS: "+" >
  | < MINUS: "-" >
  | < QUESTIONMARK: "?" >
  | <COMPARISON: <LESS>
       | <LESSEQUAL>
       | <GREATER>
       | <GREATEREQUAL>
       | <EQUAL>
       | <NOTEQUAL>
       | <NOTEQUAL2>
    >
}



/*******************************************************************
 * The PL-SQL grammar starts here
 *******************************************************************/

String SQLAndExpr() :
{ String rs = new String(""), ts; }
{
  ts = SQLNotExpr() { rs = rs + ts; }
  ( <AND> 
	{ rs = rs + fout.println();
	  rs = rs + fout.printRj("AND ");
        }
    ts = SQLNotExpr() { rs = rs + ts; })*
	{ return rs; }
}

String SQLBetweenClause() :
{ String rs = new String(""), ts; }
{
  [ <NOT> { rs = rs + fout.print(" NOT"); } ]
  <BETWEEN> { rs = rs + fout.print(" BETWEEN "); }
  ts = SQLSumExpr() { rs = rs + ts; }
  <AND> { rs = rs + fout.print(" AND "); }
  ts = SQLSumExpr() { rs = rs + ts; }
  { return rs; }
}

String SQLColRef() :
{Token aliasName, columnName;
 String s, rs = new String("");
}
{
  s = SQLLvalue()
	{ rs = rs + fout.print(s); return rs; }
}

String SQLCompareExpr() :
{ 
  String rs = new String(""), ts;
}
{
  (
    LOOKAHEAD (SQLSelect()) ts = SQLSelect() { rs = rs + ts; }
  | LOOKAHEAD (SQLColRef() <IS>) ts = SQLIsClause() { rs = rs + ts; }
  | LOOKAHEAD (<EXISTS>) ts = SQLExistsClause() { rs = rs + ts; }
  | ts = SQLSumExpr() { rs = rs + ts; } [ ts = SQLCompareExprRight() { rs = rs + ts; } ] 
  )
  { return rs; }
}

String SQLCompareExprRight() :
{ String rs = new String(""), ts; }
{
  (
    LOOKAHEAD(2) ts = SQLLikeClause() { rs = rs + ts; }
  | LOOKAHEAD(2) ts = SQLInClause() { rs = rs + ts; }
  | ts = SQLLeftJoinClause() { rs = rs + ts; }
  | LOOKAHEAD(SQLCompareOp() SQLSumExpr() "(+)") ts = SQLRightJoinClause() { rs = rs + ts; }
  | LOOKAHEAD(2) ts = SQLBetweenClause() { rs = rs + ts; }
  | ts = SQLCompareOp() { rs = rs + ts; }
    ts = SQLSumExpr() { rs = rs + ts; }
  )
	{ return rs; }
}

String SQLCompareOp() :
{ String rs = new String("");}
{
  (
    <EQUAL>	   { rs = rs + fout.print(" = "); }
  | <NOTEQUAL>     { rs = rs + fout.print(" != "); }
  | <NOTEQUAL2>    { rs = rs + fout.print(" != "); }
  | <GREATER>      { rs = rs + fout.print(" > "); }
  | <GREATEREQUAL> { rs = rs + fout.print(" >= "); }
  | <LESS>         { rs = rs + fout.print(" < "); }
  | <LESSEQUAL>    { rs = rs + fout.print(" <= "); }
  )
  { return rs; }
}

String SQLCursorArgs() :
{ String rs = new String(""), ts; }
{
  "(" 
  [ ( SQLColRef() [ SQLDataType() ] | SQLFunction() )
    ( "," ( SQLColRef() [ SQLDataType() ] | SQLFunction() ) )*
  ]
  ")" { return rs; }
}

String SQLCursorClose() :
{ Token cursorName;
  String rs = new String("");
}
{
  <CLOSE> cursorName = <ID>  
	{
	  rs = rs + fout.print("Exec SQL Close ");
	  rs = rs + fout.print(TitleCaseString.fixCase(cursorName.image));
	}
  { return rs; }
}

void SQLCursorDeclare() :
{Token x, y;
 String rs = new String(""), ts;
}
{
  "cursor" x = <ID>
        { fout.indent();
          rs = rs + fout.println("EXEC SQL");
          fout.indent();
          rs = rs + fout.print("Declare ");
          String s = TitleCaseString.fixCase(x.image);
          rs = rs + fout.print(s);
          rs = rs + fout.println(" Cursor For");
          fout.indent();
        }
  [ ts = SQLCursorArgs() { rs = rs + fout.println(); } ]
//  [ ts = SQLFunctionArgs() { rs = rs + ts; } ]
  "is" ts = SQLSelect() ";"
        {
		  rs = rs + fout.print(ts); 
          rs = rs + fout.println(";");
          fout.outdent();
          fout.outdent();
          fout.outdent();
		  out.print(rs);
        }
}

String SQLCursorFetch() :
{ String rs = new String(""), ts;}
{
  <FETCH>
        {
	    rs = rs + fout.print("Exec SQL FETCH ");
	    fout.align();
	    inSelect = true;
        }
  ts = SQLSelectCols()
	{
	  rs = rs + ts;
	  inSelect = false; 
	}
  [ <INTO>
        {
	  inSQL = true;
	  rs = rs + fout.println();
          rs = rs + fout.printRj("INTO ");
        }
    ts = SQLSelectCols()
        {
	  rs = rs + ts;
	  fout.outalign();
        }
  ]
	{ inSQL = false ; return rs; }
}

String SQLCursorOpen() :
{ Token cursorName;
  String rs = new String(""), ts;
}
{
  <OPEN> cursorName = <ID>  
	{
	  rs = rs + fout.print("Exec SQL Open ");
	  rs = rs + fout.print(TitleCaseString.fixCase(cursorName.image));
	}
  [ ts = SQLCursorArgs() ]
  { return rs; }
}

DataType SQLDataType() :
{Token x;
 int size = 0;
}
{
    "integer"
        { return new IntegerDataType(); }
  | "smallint"
        { return new IntegerDataType(); }
  | "number" { size = 0; }
             [ "(" x = <INTEGER_LITERAL> ")" { size = Integer.valueOf(x.image).intValue(); } ]
        { return new NumberDataType(size); }
  | ("char" | "character") { size = 1; }
             [ "(" x = <INTEGER_LITERAL> ")" { size = Integer.valueOf(x.image).intValue(); } ]
        { return new CharDataType(size); }
  | "varchar2" { size = 1; }
             [ "(" x = <INTEGER_LITERAL> ")" { size = Integer.valueOf(x.image).intValue(); } ]
        { return new CharDataType(size); }
  | "boolean"
        { return new BooleanDataType(); }
}

String SQLDelete() :
{ String rs = new String(""), ts; }
{
  <DELETE> <FROM>
        { 
	  if (inProcedure) rs = rs + fout.print("Exec SQL ");
	  rs = rs + fout.print("DELETE FROM ");
          fout.align();
	  inSQL = true;
        }
  ts = SQLTableList() { rs = rs + ts; }
  [ ts = SQLWhere() { rs = rs + ts; } ]
        { fout.outalign();
	  inSQL = false;
	}
  { return rs; }
}

String SQLExistsClause() :
{ String rs = new String(""), ts; }
{
  <EXISTS> 
	{
	  rs = rs + fout.print("EXISTS (");
	  fout.align();
	}
  "(" ts = SQLSelect() { rs = rs + ts; } ")"
	{
	  rs = rs + fout.print(")");
	  fout.outalign();
	  return rs;
	}
}

String SQLFunction() :
{ Token otherFunction;
  String rs = new String(""), ts;
}
{
  ( <UPPER> { rs = rs + fout.print("UPPER"); }
    ts = SQLFunctionArgs() { rs = rs + ts; }
  | <MAX> { rs = rs + fout.print("MAX"); }
    ts = SQLFunctionArgs() { rs = rs + ts; }
  | <MIN> { rs = rs + fout.print("MIN"); }
    ts = SQLFunctionArgs() { rs = rs + ts; }
  | <SUM> { rs = rs + fout.print("SUM"); }
    ts = SQLFunctionArgs() { rs = rs + ts; }
  | <COUNT> { rs = rs + fout.print("COUNT"); }
    ts = SQLFunctionArgs() { rs = rs + ts; }
  | <LPAD> { rs = rs + fout.print("<<<LPAD>>>"); }
    ts = SQLFunctionArgs() { rs = rs + ts; }
  | <LTRIM> { rs = rs + fout.print("<<<LTRIM>>>"); }
    ts = SQLFunctionArgs() { rs = rs + ts; }
  | <RTRIM> { rs = rs + fout.print("<<<RTRIM>>>"); }
    ts = SQLFunctionArgs() { rs = rs + ts; }
  | <LENGTH> { rs = rs + fout.print("<<<LENGTH>>>"); }
    ts = SQLFunctionArgs() { rs = rs + ts; }
  | <REPLACE> { rs = rs + fout.print("<<<REPLACE>>>"); }
    ts = SQLFunctionArgs() { rs = rs + ts; }
  | <SUBSTR> { rs = rs + fout.print(" <<<SUBSTR>>> "); }
    ts = SQLFunctionArgs() { rs = rs + ts; }
  | <TO_CHAR> { rs = rs + fout.print(" <<<TO_CHAR>>> "); }
    ts = SQLFunctionArgs() { rs = rs + ts; }
  | <TO_NUMBER> { rs = rs + fout.print(" <<<TO_NUMBER>>> "); }
    ts = SQLFunctionArgs() { rs = rs + ts; }
  | LOOKAHEAD(3) <ORIGINPLUS> <DOT> <CONVERT_TIMESTAMP_TO_DATE> { rs = rs + fout.print(" <<<ORIGINPLUS.ConvertTimeStampToDate>>> "); }
    ts = SQLFunctionArgs() { rs = rs + ts; }
  | LOOKAHEAD(3) <ORIGINPLUS> <DOT> <FORMAT_AUDIT_HEADER> { rs = rs + fout.print(" <<<ORIGINPLUS.FormatAuditHeaderString>>> "); }
    ts = SQLFunctionArgs() { rs = rs + ts; }
  | LOOKAHEAD(3) <ORIGINPLUS> <DOT> <FORMAT_ATTRIBUTE_SUBSTRING> { rs = rs + fout.print(" <<<ORIGINPLUS.FormatAttributeSubString>>> "); }
    ts = SQLFunctionArgs() { rs = rs + ts; }
  | LOOKAHEAD(3) <ORIGINPLUS> <DOT> <GET_CURRENT_TIMESTAMP> { rs = rs + fout.print(" <<<ORIGINPLUS.GetCurrentTimeStamp>>> "); }
  | LOOKAHEAD (<ID> "(") otherFunction = <ID> 
	{ 
	  rs = rs + fout.print("<<<");
	  rs = rs + fout.print(otherFunction.image);
	  rs = rs + fout.print(">>>");
	}
    ts = SQLFunctionArgs() { rs = rs + ts; }
  )
  { return rs; }
}

String SQLFunctionArgs() :
{ String rs = new String(""), ts; }
{
  "(" { rs = rs + fout.print("("); }
  [ ts = SQLSumExpr() { rs = rs + ts; }
    ( "," { rs = rs + fout.print(", "); }
          ts = SQLSumExpr() { rs = rs + ts; } )*
  ]
  ")" { rs = rs + fout.print(")"); return rs; }
}

String SQLGroupBy() :
{ String rs = new String(""), ts; }
{
  <GROUP> <BY> { rs = rs + fout.println();
                 rs = rs + fout.printRj("GROUP ");
                 rs = rs + fout.print("BY ");
               }
  ts = SQLOrderByList() { rs = rs + ts; }
  { return rs; }
}

String SQLInClause() :
{ String rs = new String(""), ts; }
{
  [ <NOT> { rs = rs + fout.print(" NOT"); } ]
  <IN> { rs = rs + fout.print(" IN "); }
  "(" { rs = rs + fout.print("("); }
  ts = SQLLValueList() { rs = rs + ts; }
  ")" { rs = rs + fout.print(")"); }
  { return rs; }
}

String SQLInsert() :
{ String rs = new String(""), ts; }
{
  <INSERT> <INTO> 
        { 
	    if (inProcedure) rs = rs + fout.print("Exec SQL ");
	    rs = rs + fout.print("INSERT INTO ");
          fout.align();
        }
  ts = SQLTableList() { rs = rs + ts; }
  [
    "(" 
	{
	  rs = rs + fout.print("(");
	  inSelect = true;
	} 
    ts = SQLSelectCols() { rs = rs + ts; }
    ")" 
	{ 
	  rs = rs + fout.print(")");
	  inSelect = false;
	}
    <VALUES> 
	{ 
	  rs = rs + fout.print(") VALUES");
	}
  ]
  "("
	{ 
	  rs = rs + fout.print(" (");
	  inSQL = true;
	}
  ts = SQLSelectCols() { rs = rs + ts; }
  ")"
	{ 
	  rs = rs + fout.print(")");
	  inSelect = false;
        fout.outalign();
	  return rs;
	}
}

String SQLIsClause() :
{ String rs = new String(""), ts; }
{
  ts = SQLColRef() { rs = rs + ts; }
  <IS> { rs = rs + fout.print(" IS"); }
  [ <NOT> { rs = rs + fout.print(" NOT"); } ]
  <NULL> { rs = rs + fout.print(" NULL"); }
  { return rs; }
}

String SQLLeftJoinClause() :
{ Token theComparison; 
  String rs = new String(""), ts;
}
{
  "(+)" ts = SQLCompareOp() 
	{
	  rs = rs + ts;
	  rs = rs + fout.print("* "); 
	}
  ts = SQLSumExpr() { rs = rs + ts; }
  { return rs; }
}

String SQLLikeClause() :
{ String rs = new String(""), ts;}
{
  [ <NOT> { rs = rs + fout.print(" NOT"); } ]
  <LIKE> { rs = rs + fout.print(" LIKE "); }
  ts = SQLPattern() { rs = rs + ts; }
  { return rs; }
}

String SQLLiteral() :
{Token x;
 String rs = new String("");
}
{
  ( x = <STRING_LITERAL> { rs = rs + fout.print(x.image); }
  | x = <INTEGER_LITERAL> { rs = rs + fout.print(x.image); }
  | x = <FLOATING_POINT_LITERAL> { rs = rs + fout.print(x.image); }
  | (<ZEROS> | <ZERO>) { rs = rs + fout.print("0"); }
  | <SPACES> { rs = rs + fout.print("<<<SPACES>>>"); }
  | x = <ASTERISK> { rs = rs + fout.print(x.image); }
  )
  { return rs; }
}

String SQLLvalue() :
{ Token x, y;
  String s = new String(""), t;
}
{
  (
    <REQUEST> <DOT> 
	{
	  s = s + ":";
          s = s + "Request->";
        }
    t = SQLLvalueTerm()
	{
	  s = s + t;
	}
  | <REPLY_REPEATING_GROUP> <DOT>
	{
	  s = s + ":";
          s = s + "ReplyRepeatingGroup->";
        }
    t = SQLLvalueTerm()
	{
	  s = s + t;
	}
  | <REPLY> <DOT>
	{
	  s = s + ":";
          s = s + "Reply->";
        }
    t = SQLLvalueTerm()
	{
	  s = s + t;
	}
  | <SQL_I_O_CORRECT>
	{
          s = s + "SQL_I_O_CORRECT";
        }
  | <ROW_NOT_FOUND>
	{
          s = s + "ROW_NOT_FOUND";
        }
  |
    t = SQLLvalueTerm()
	{
	  s = s + t;
	}
  )
  	{ return s; }
}

String SQLLvalueTerm() :
{ Token x, y; 
  String s = new String("");
}
{
  x = <ID> 
	{
	  s = varList.nameOf(x.image);
// Change to :Pr_ and substring(4) after creating nameOfSql	  
	  if (s.startsWith("Pr_")) {
		s = ":Request->" + s.substring(3);
	  }
	}
  ( <DOT> y = <ID>
		{ 
		  s = s + ".";
		  s = s + TitleCaseString.fixCase(y.image);
		} 
  )*
	{ return s; }
}

String SQLNotExpr() :
{ String rs = new String(""), ts; }
{
  [ <NOT> 
	{ 
	  rs = rs + fout.print("NOT ");
	}
  ] 
  ts = SQLCompareExpr() 
	{
	  rs = rs + ts;
	  return rs; 
	}
}

String SQLOrderBy() :
{ String rs = new String(""), ts; }
{
  <ORDER> <BY> { rs = rs + fout.println();
                 rs = rs + fout.printRj("ORDER ");
                 rs = rs + fout.print("BY ");
               }
  ts = SQLOrderByList() { rs = rs + ts; }
  { return rs; }
}

String SQLOrderByElem() :
{ String rs = new String(""), ts; }
{
  ts = SQLColRef() { rs = rs + ts; }
  [ ts = SQLOrderDirection() { rs = rs + ts; } ]
  { return rs; }
}

String SQLOrderByList() :
{ String rs = new String(""), ts; }
{
  ts = SQLOrderByElem() { rs = rs + ts; }
  ( LOOKAHEAD(2)
    "," { rs = rs + fout.println(", "); }
    ts = SQLOrderByElem() { rs = rs + ts; })*
  { return rs; }
}

String SQLOrderDirection() :
{ String rs = new String(""); }
{
  (
    <ASC> { rs = rs + fout.print(" ASC"); }
  | <DESC> { rs = rs + fout.print(" DESC"); }
  )
  { return rs; }
}

String SQLOrExpr() :
{ String rs = new String(""), ts;}
{
  ts = SQLAndExpr() { rs = rs + ts; }
  ( <OR> 
	{
	  rs = rs + fout.println();
	  rs = rs + fout.printRj("OR "); 
        }
    ts = SQLAndExpr() { rs = rs + ts; })* 
  { return rs; }
}

String SQLPattern() :
{Token x;
 String rs = new String(""), ts;
}
{
  ( x = <STRING_LITERAL> { rs = rs + fout.print(x.image); }
  | "?" { rs = rs + fout.print("?"); }
  | <USER> { rs = rs + fout.print("USER"); }
  | ts = SQLLvalue() { rs = rs + ts; }
  )
  { return rs; }
}

String SQLProductExpr() :
{ String rs = new String(""), ts;}
{
  ts = SQLUnaryExpr() { rs = rs + ts; }
  ( ( "*" { rs = rs + fout.print(" * "); }
    | "/" { rs = rs + fout.print(" / "); }
    ) ts = SQLUnaryExpr() { rs = rs + ts; } )*
  { return rs; }
}

String SQLRightJoinClause() :
{ Token theComparison; 
  String rs = new String(""), ts;
}
{
  { rs = rs + fout.print("*"); }
  ts = SQLCompareOp() { rs = rs + ts; }
  ts = SQLSumExpr() { rs = rs + ts; }
  "(+)"
  { return rs; }
}

String SQLSelect() :
{ String rs = new String(""), ts; }
{
  <SELECT>
        { 
	  if (inProcedure) rs = rs + fout.print("Exec SQL ");
	  rs = rs + fout.print("SELECT ");
	  fout.align();
	  inSelect = true;
        }
  ts = SQLSelectCols()
	{ rs = rs + ts; inSelect = false; }
  [ <INTO>
        { rs = rs + fout.println();
          rs = rs + fout.printRj("INTO ");
	  inSQL = true;
        }
    ts = SQLSelectCols()
	{ rs = rs + ts; inSQL = false; }
  ]
  <FROM>
        { rs = rs + fout.println();
          rs = rs + fout.printRj("FROM ");
        }
  ts = SQLTableList() { rs = rs + ts; }
  [ ts = SQLWhere()   { rs = rs + ts; } ]
  [ ts = SQLGroupBy() { rs = rs + ts; } ]
  [ ts = SQLOrderBy() { rs = rs + ts; } ]
        { 
	  fout.outalign();
	  return rs;
	}
}

String SQLSelectCols() :
{ String rs = new String(""), ts;}
{
  ( <ALL> { rs = rs + fout.print("ALL "); }
  | <DISTINCT> { rs = rs + fout.print("DISTINCT "); }
  )* [ "*" { rs = rs + fout.print("*"); } | ts = SQLSelectList() { rs = rs + ts; } ]
  { return rs; }
}

String SQLSelectList() :
{ String rs = new String(""), ts; }
{
  ts = SQLSumExpr() { rs = rs + ts; }
  ( ","
        { rs = rs + fout.println();
          rs = rs + fout.printRj(", ");
        }
    ts = SQLSumExpr() { rs = rs + ts; })*
  { return rs; }
}

String SQLStatement() :
{ String rs = new String(""), ts; }
{
  ( 
    ts = SQLSelect() { rs = rs + ts; }
  | ts = SQLInsert() { rs = rs + ts; }
  | ts = SQLUpdate() { rs = rs + ts; }
  | ts = SQLDelete() { rs = rs + ts; }
  | ts = SQLCursorOpen() { rs = rs + ts; }
  | ts = SQLCursorFetch() { rs = rs + ts; }
  | ts = SQLCursorClose() { rs = rs + ts; }
  ) ";"
	{
	  rs = rs + fout.println(";") ;
	  return rs;
	}
}

String SQLSumExpr() :
{ String rs = new String(""), ts; }
{
    ts = SQLProductExpr() { rs = rs + ts; }
     ( LOOKAHEAD(2) ( "+" { rs = rs + fout.print(" + "); }
                    | "-" { rs = rs + fout.print(" - "); }
                    | "||" { rs = rs + fout.print(" + "); }
                    ) ts = SQLProductExpr() { rs = rs + ts; } )*
  { return rs; }
}

String SQLTableList() :
{ String rs = new String(""), ts; }
{
  ts = SQLTableRef() { rs = rs + ts; }
  ( LOOKAHEAD(2) "," { rs = rs + fout.println(", "); }
                                ts = SQLTableRef() { rs = rs + ts; } )*
  { return rs; }
}


String SQLTableRef() :
{Token tableName, aliasName;
 String rs = new String("");
}
{
  tableName = <ID>
        { rs = rs + fout.print(TitleCaseString.fixCase(tableName.image));
        }
  [ aliasName = <ID>
        { rs = rs + fout.print(" ");
          rs = rs + fout.print(TitleCaseString.fixCase(aliasName.image));
        }
  ]
  { return rs; }
}

String SQLTerm() :
{ Token other; 
  String rs = new String(""), ts;
}
{
  (
    "(" { rs = rs + fout.print("(");
          fout.align();
        }
    ts = SQLOrExpr() { rs = rs + ts; }
    ")" { rs = rs + fout.print(")");
          fout.outalign();
        }
  | ts = SQLColRef() { rs = rs + ts; }
  | ts = SQLLiteral() { rs = rs + ts; }
  | ts = SQLFunction() { rs = rs + ts; }
//  | (other = <ID> { rs = rs + fout.print("<<<" + other.image + ">>>"); })+
  )
  { return rs; }
}

String SQLUnaryExpr() :
{ String rs = new String(""), ts; }
{
  [ ( "+" { rs = rs + fout.print("+"); }
    | "-" { rs = rs + fout.print("-"); }
    )
  ] ts = SQLTerm() { rs = rs + ts; }
  { return rs; }
}

String SQLUpdate() :
{ String rs = new String(""), ts; }
{
  <UPDATE>
        { 
	  if (inProcedure) rs = rs + fout.print("Exec SQL ");
	  rs = rs + fout.print("UPDATE ");
          fout.align();
        }
  ts = SQLTableList() { rs = rs + ts; }
  <SET>
        { 
	  inSQL = true;
	  rs = rs + fout.println();
	  rs = rs + fout.printRj("SET ");
        }
  ( 
    LOOKAHEAD(SQLLvalue() "=") ts = SQLUpdateAssignment() { rs = rs + ts; } 
    [
      ","
	{ 
	  rs = rs + fout.println();
	  rs = rs + fout.printRj(", ");
        }
    ] 
  )+

  [ ts = SQLWhere() { rs = rs + ts; } ]
        { fout.outalign();
	  inSQL = false;
	}
  { return rs; }
}

String SQLUpdateAssignment() :
{ String s, rs = new String(""), ts; }
{
  s = SQLLvalue() "="
  {
    rs = rs + fout.print(s);
    rs = rs + fout.print(" = ");
  }
  (
      LOOKAHEAD(SQLTerm() <CONCAT> ) { rs = rs + fout.print(" <<<CONCAT>>> "); } 
      ts = SQLTerm() { rs = rs + ts; } 
      ( <CONCAT> { rs = rs + fout.print(", "); } 
        ts = SQLTerm() { rs = rs + ts; } )+
      | ts = SQLSumExpr() { rs = rs + ts; } )
  { return rs; }
}

String SQLLValueElement() :
{ String rs = new String(""), ts; }
{
  ( <NULL> { rs = rs + fout.print("NULL"); }
  | ts = SQLSumExpr() { rs = rs + ts; }
  | ts = SQLSelect() { rs = rs + ts; } )
  { return rs; }
}

String SQLLValueList() :
{ String rs = new String(""), ts; }
{
  ts = SQLLValueElement() { rs = rs + ts; } 
  ( "," 
	{
	  rs = rs + fout.println();
	  rs = rs + fout.print(", ");
	}
    ts = SQLLValueElement() { rs = rs + ts; } 
  )*
  { return rs; }
}

String SQLWhere() :
{ String rs = new String(""), ts; }
{
  <WHERE> { rs = rs + fout.println();
            rs = rs + fout.printRj("WHERE ");
	    inSQL = true;
          } ts = SQLOrExpr()
	{ rs = rs + ts; inSQL = false; return rs; }

}