Application: gvSIG desktop

/***********************************************************************

 * 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; }

}