/*@bgen(jjtree) Generated By:JJTree: Do not edit this line. ./Parser.jj */
/*@egen*//***************************************************************
                   OPTIONS
***************************************************************/

options 
{
                 
                             
    STATIC = false;

                        
    DEBUG_PARSER = false;
}

PARSER_BEGIN(Parser)
package ru.biosoft.oql.parser;

import java.io.StringReader;
import java.util.Vector;
import ru.biosoft.oql.model.*;

public class Parser/*@bgen(jjtree)*/implements ParserTreeConstants/*@egen*/
{/*@bgen(jjtree)*/
  protected JJTParserState jjtree = new JJTParserState();

/*@egen*/
    /** Default constructor. */
    public Parser()
    {    
        this(new StringReader("0"));
    }

    /**
   * Returns the root node of the AST.  
   * It only makes sense to call this after a successful parse. 
   * @return the root node
   */
	public Node rootNode()
	{
		return jjtree.rootNode();
	}
	
	protected boolean seeUnreservedKeyword(String keyword)
    {
    	return (getToken(1).kind == IDENTIFIER && keyword.equals(getToken(1).image.toUpperCase()));
    }
    
    protected boolean seeUnreservedKeyword(String... keywords)
    {
    	for(int index = 0; index < keywords.length; index++)
    	{
	    	if (getToken(index + 1).kind != IDENTIFIER
	    		|| !keywords[index].equals(getToken(index + 1).image.toUpperCase()))
	    		return false;
    	}
    	return true;
    }

    protected boolean seeExclude(String... keywords)
    {
    	if (getToken(1).kind != IDENTIFIER)
    		return false;
    	
    	String image = getToken(1).image.toUpperCase();
    	for(int index = 0; index < keywords.length; index++)
	    	if (keywords[index].equals(image))
	    		return false;

    	return true;
    }
    
    protected ParseException generateCustomParseException(String... keywords)
    {
    	Token currentToken = getToken(0);
    	
    	StringBuilder buf = new StringBuilder();
    	for(String keyword : keywords)
    		buf.append("\n\t\"").append(keyword).append('"');
    		
    	String msg = java.text.MessageFormat.format(
    		"Encountered \"{0}\" at line {1}, column {2}.\nWas expecting one of: {3}",
    		currentToken.next.image,
    		currentToken.next.beginLine,
    		currentToken.next.beginColumn,
    		buf.toString());
    	
    	ParseException e = new ParseException(msg);
    	e.currentToken = currentToken;
    	return e;
    }  
    
    protected String getStringValueFromImage(String image)
    {
    	return image.substring(1, image.length() - 1);
    }
}

PARSER_END(Parser)

/* WHITE SPACE */

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

/* COMMENTS */

MORE :
{
  "//" : IN_SINGLE_LINE_COMMENT
|
  <"/**" ~["/"]> { input_stream.backup(1); } : IN_FORMAL_COMMENT
|
  "/*" : IN_MULTI_LINE_COMMENT
}

<IN_SINGLE_LINE_COMMENT>
SPECIAL_TOKEN :
{
  <SINGLE_LINE_COMMENT: "\n" | "\r" | "\r\n" > : DEFAULT
}

<IN_FORMAL_COMMENT>
SPECIAL_TOKEN :
{
  <FORMAL_COMMENT: "*/" > : DEFAULT/* RESERVED WORDS AND LITERALS */
}

<IN_MULTI_LINE_COMMENT>
SPECIAL_TOKEN :
{
  <MULTI_LINE_COMMENT: "*/" > : DEFAULT
}

<IN_SINGLE_LINE_COMMENT,IN_FORMAL_COMMENT,IN_MULTI_LINE_COMMENT>
MORE :
{
  < ~[] >
}

/* LITERALS */

TOKEN :
{
  < INTEGER_LITERAL:
        <DECIMAL_LITERAL>
      | <OCTAL_LITERAL>
  >
|
  < LONG_LITERAL:
        <DECIMAL_LITERAL> ["l","L"]
      | <OCTAL_LITERAL> ["l","L"]
  >
|
  < #DECIMAL_LITERAL: ["1"-"9"] (["0"-"9"])* >
|
  <HEX_LITERAL: "0" ["x","X"] (["0"-"9","a"-"f","A"-"F"])+ >
|
  < #OCTAL_LITERAL: "0" (["0"-"7"])* >
|
  < FLOATING_POINT_LITERAL:
        (["0"-"9"])+ "." (["0"-"9"])* (<EXPONENT>)? (["f","F","d","D"])?
      | "." (["0"-"9"])+ (<EXPONENT>)? (["f","F","d","D"])?
      | (["0"-"9"])+ <EXPONENT> (["f","F","d","D"])?
      | (["0"-"9"])+ (<EXPONENT>)? ["f","F","d","D"]
  >
|
  < #EXPONENT: ["e","E"] (["+","-"])? (["0"-"9"])+ >
|
  < CHARACTER_LITERAL:
      "'"
      (   ~["'","\\","\n","\r"]
      )
      "'"
  >
|
  < STRING_LITERAL:
      "\""
      (   ~["\"","\n","\r"]
      )*
      "\""
  >
}

/* IDENTIFIERS */

TOKEN :
{
    <INSTANCEOF : "INSTANCEOF">
|   <TRUE: "true">
|   <FALSE: "false">
|   <OR: "or">
|   <AND: "and">
|   <NULL: "null">
|   <IMPLEMENTS: "implements">
|	<DOLLAR_SIGN: "$">		
|   <IDENTIFIER: ( <LETTER> | <DOLLAR_SIGN> ) ( <PART_LETTER> | <DOLLAR_SIGN> )* >
|
    < #LETTER:
      [  
         "A"-"Z", // "A"-"Z"
         "_",          // "_"
         "a"-"z", // "a"-"z"
         "\u00a2"-"\u00a5", "\u00aa", "\u00b5", "\u00ba", "\u00c0"-"\u00d6", "\u00d8"-"\u00f6",
         "\u00f8"-"\u0236", "\u0250"-"\u02c1", "\u02c6"-"\u02d1", "\u02e0"-"\u02e4", "\u02ee",
         "\u037a", "\u0386", "\u0388"-"\u038a", "\u038c", "\u038e"-"\u03a1", "\u03a3"-"\u03ce",
         "\u03d0"-"\u03f5",  "\u03f7"-"\u03fb", "\u0400"-"\u0481", "\u048a"-"\u04ce",
         "\u04d0"-"\u04f5", "\u04f8"-"\u04f9", "\u0500"-"\u050f", "\u0531"-"\u0556",
         "\u0559", "\u0561"-"\u0587", "\u05d0"-"\u05ea", "\u05f0"-"\u05f2", "\u0621"-"\u063a",
         "\u0640"-"\u064a", "\u066e"-"\u066f", "\u0671"-"\u06d3", "\u06d5", "\u06e5"-"\u06e6",
         "\u06ee"-"\u06ef", "\u06fa"-"\u06fc", "\u06ff", "\u0710", "\u0712"-"\u072f",
         "\u074d"-"\u074f", "\u0780"-"\u07a5", "\u07b1", "\u0904"-"\u0939", "\u093d", "\u0950",
         "\u0958"-"\u0961", "\u0985"-"\u098c", "\u098f"-"\u0990", "\u0993"-"\u09a8",
         "\u09aa"-"\u09b0", "\u09b2", "\u09b6"-"\u09b9", "\u09bd", "\u09dc"-"\u09dd",
         "\u09df"-"\u09e1", "\u09f0"-"\u09f3", "\u0a05"-"\u0a0a", "\u0a0f"-"\u0a10",
         "\u0a13"-"\u0a28", "\u0a2a"-"\u0a30", "\u0a32"-"\u0a33", "\u0a35"-"\u0a36",
         "\u0a38"-"\u0a39", "\u0a59"-"\u0a5c", "\u0a5e", "\u0a72"-"\u0a74", "\u0a85"-"\u0a8d",
         "\u0a8f"-"\u0a91", "\u0a93"-"\u0aa8", "\u0aaa"-"\u0ab0", "\u0ab2"-"\u0ab3",
         "\u0ab5"-"\u0ab9", "\u0abd", "\u0ad0", "\u0ae0"-"\u0ae1", "\u0af1", "\u0b05"-"\u0b0c",
         "\u0b0f"-"\u0b10", "\u0b13"-"\u0b28", "\u0b2a"-"\u0b30", "\u0b32"-"\u0b33", "\u0b35"-"\u0b39",
         "\u0b3d", "\u0b5c"-"\u0b5d", "\u0b5f"-"\u0b61", "\u0b71", "\u0b83", "\u0b85"-"\u0b8a",
         "\u0b8e"-"\u0b90", "\u0b92"-"\u0b95", "\u0b99"-"\u0b9a", "\u0b9c", "\u0b9e"-"\u0b9f",
         "\u0ba3"-"\u0ba4", "\u0ba8"-"\u0baa", "\u0bae"-"\u0bb5", "\u0bb7"-"\u0bb9", "\u0bf9",
         "\u0c05"-"\u0c0c", "\u0c0e"-"\u0c10", "\u0c12"-"\u0c28", "\u0c2a"-"\u0c33", 
         "\u0c35"-"\u0c39", "\u0c60"-"\u0c61", "\u0c85"-"\u0c8c", "\u0c8e"-"\u0c90", 
         "\u0c92"-"\u0ca8", "\u0caa"-"\u0cb3", "\u0cb5"-"\u0cb9", "\u0cbd", "\u0cde", 
         "\u0ce0"-"\u0ce1", "\u0d05"-"\u0d0c", "\u0d0e"-"\u0d10", "\u0d12"-"\u0d28", 
         "\u0d2a"-"\u0d39", "\u0d60"-"\u0d61", "\u0d85"-"\u0d96", "\u0d9a"-"\u0db1", 
         "\u0db3"-"\u0dbb", "\u0dbd", "\u0dc0"-"\u0dc6", "\u0e01"-"\u0e30", "\u0e32"-"\u0e33", 
         "\u0e3f"-"\u0e46", "\u0e81"-"\u0e82", "\u0e84", "\u0e87"-"\u0e88", "\u0e8a", "\u0e8d", 
         "\u0e94"-"\u0e97", "\u0e99"-"\u0e9f", "\u0ea1"-"\u0ea3", "\u0ea5", "\u0ea7", 
         "\u0eaa"-"\u0eab", "\u0ead"-"\u0eb0", "\u0eb2"-"\u0eb3", "\u0ebd", "\u0ec0"-"\u0ec4", 
         "\u0ec6", "\u0edc"-"\u0edd", "\u0f00", "\u0f40"-"\u0f47", "\u0f49"-"\u0f6a", 
         "\u0f88"-"\u0f8b", "\u1000"-"\u1021", "\u1023"-"\u1027", "\u1029"-"\u102a", 
         "\u1050"-"\u1055", "\u10a0"-"\u10c5", "\u10d0"-"\u10f8", "\u1100"-"\u1159", 
         "\u115f"-"\u11a2", "\u11a8"-"\u11f9", "\u1200"-"\u1206", "\u1208"-"\u1246", 
         "\u1248", "\u124a"-"\u124d", "\u1250"-"\u1256", "\u1258", "\u125a"-"\u125d",
         "\u1260"-"\u1286", "\u1288", "\u128a"-"\u128d", "\u1290"-"\u12ae", "\u12b0", 
         "\u12b2"-"\u12b5", "\u12b8"-"\u12be", "\u12c0", "\u12c2"-"\u12c5", "\u12c8"-"\u12ce", 
         "\u12d0"-"\u12d6", "\u12d8"-"\u12ee", "\u12f0"-"\u130e", "\u1310", "\u1312"-"\u1315", 
         "\u1318"-"\u131e", "\u1320"-"\u1346", "\u1348"-"\u135a", "\u13a0"-"\u13f4", 
         "\u1401"-"\u166c", "\u166f"-"\u1676", "\u1681"-"\u169a", "\u16a0"-"\u16ea", 
         "\u16ee"-"\u16f0", "\u1700"-"\u170c", "\u170e"-"\u1711", "\u1720"-"\u1731", 
         "\u1740"-"\u1751", "\u1760"-"\u176c", "\u176e"-"\u1770", "\u1780"-"\u17b3", 
         "\u17d7", "\u17db"-"\u17dc", "\u1820"-"\u1877", "\u1880"-"\u18a8", "\u1900"-"\u191c", 
         "\u1950"-"\u196d", "\u1970"-"\u1974", "\u1d00"-"\u1d6b", "\u1e00"-"\u1e9b", 
         "\u1ea0"-"\u1ef9", "\u1f00"-"\u1f15", "\u1f18"-"\u1f1d", "\u1f20"-"\u1f45", 
         "\u1f48"-"\u1f4d", "\u1f50"-"\u1f57", "\u1f59", "\u1f5b", "\u1f5d", "\u1f5f"-"\u1f7d", 
         "\u1f80"-"\u1fb4", "\u1fb6"-"\u1fbc", "\u1fbe", "\u1fc2"-"\u1fc4", "\u1fc6"-"\u1fcc", 
         "\u1fd0"-"\u1fd3", "\u1fd6"-"\u1fdb", "\u1fe0"-"\u1fec", "\u1ff2"-"\u1ff4", 
         "\u1ff6"-"\u1ffc", "\u203f"-"\u2040", "\u2054", "\u2071", "\u207f", "\u20a0"-"\u20b1", 
         "\u2102", "\u2107", "\u210a"-"\u2113", "\u2115", "\u2119"-"\u211d", "\u2124", "\u2126", 
         "\u2128", "\u212a"-"\u212d", "\u212f"-"\u2131", "\u2133"-"\u2139", "\u213d"-"\u213f", 
         "\u2145"-"\u2149", "\u2160"-"\u2183", "\u3005"-"\u3007", "\u3021"-"\u3029", 
         "\u3031"-"\u3035", "\u3038"-"\u303c", "\u3041"-"\u3096", "\u309d"-"\u309f", 
         "\u30a1"-"\u30ff", "\u3105"-"\u312c", "\u3131"-"\u318e", "\u31a0"-"\u31b7", 
         "\u31f0"-"\u31ff", "\u3400"-"\u4db5", "\u4e00"-"\u9fa5", "\ua000"-"\ua48c", 
         "\uac00"-"\ud7a3", "\ud801", "\ud802", "\uf900"-"\ufa2d", "\ufa30"-"\ufa6a", 
         "\ufb00"-"\ufb06", "\ufb13"-"\ufb17", "\ufb1d", "\ufb1f"-"\ufb28", "\ufb2a"-"\ufb36", 
         "\ufb38"-"\ufb3c", "\ufb3e", "\ufb40"-"\ufb41", "\ufb43"-"\ufb44", "\ufb46"-"\ufbb1", 
         "\ufbd3"-"\ufd3d", "\ufd50"-"\ufd8f", "\ufd92"-"\ufdc7", "\ufdf0"-"\ufdfc", 
         "\ufe33"-"\ufe34", "\ufe4d"-"\ufe4f", "\ufe69", "\ufe70"-"\ufe74", "\ufe76"-"\ufefc", 
         "\uff04", "\uff21"-"\uff3a", "\uff3f", "\uff41"-"\uff5a", "\uff65"-"\uffbe", 
         "\uffc2"-"\uffc7", "\uffca"-"\uffcf", "\uffd2"-"\uffd7", "\uffda"-"\uffdc", 
         "\uffe0"-"\uffe1", "\uffe5"-"\uffe6"
      ]
  >
|
  < #PART_LETTER:
      [  // all chars for which Character.isIdentifierPart is true
         "\u0000"-"\u0008",
         "\u000e"-"\u001b",
         "0"-"9", // "0"-"9"
         "A"-"Z", // "A"-"Z"
         "_",          // "_"
         "a"-"z", // "a"-"z"
         "\u007f"-"\u009f", "\u00a2"-"\u00a5", "\u00aa", "\u00ad", "\u00b5", "\u00ba", 
         "\u00c0"-"\u00d6", "\u00d8"-"\u00f6", "\u00f8"-"\u0236", "\u0250"-"\u02c1", 
         "\u02c6"-"\u02d1", "\u02e0"-"\u02e4", "\u02ee", "\u0300"-"\u0357", "\u035d"-"\u036f", 
         "\u037a", "\u0386", "\u0388"-"\u038a", "\u038c", "\u038e"-"\u03a1", "\u03a3"-"\u03ce", 
         "\u03d0"-"\u03f5", "\u03f7"-"\u03fb", "\u0400"-"\u0481", "\u0483"-"\u0486", 
         "\u048a"-"\u04ce", "\u04d0"-"\u04f5", "\u04f8"-"\u04f9", "\u0500"-"\u050f", 
         "\u0531"-"\u0556", "\u0559", "\u0561"-"\u0587", "\u0591"-"\u05a1", "\u05a3"-"\u05b9", 
         "\u05bb"-"\u05bd", "\u05bf", "\u05c1"-"\u05c2", "\u05c4", "\u05d0"-"\u05ea", 
         "\u05f0"-"\u05f2", "\u0600"-"\u0603", "\u0610"-"\u0615", "\u0621"-"\u063a", 
         "\u0640"-"\u0658", "\u0660"-"\u0669", "\u066e"-"\u06d3", "\u06d5"-"\u06dd", 
         "\u06df"-"\u06e8", "\u06ea"-"\u06fc", "\u06ff", "\u070f"-"\u074a", "\u074d"-"\u074f", 
         "\u0780"-"\u07b1", "\u0901"-"\u0939", "\u093c"-"\u094d", "\u0950"-"\u0954", 
         "\u0958"-"\u0963", "\u0966"-"\u096f", "\u0981"-"\u0983", "\u0985"-"\u098c", 
         "\u098f"-"\u0990", "\u0993"-"\u09a8", "\u09aa"-"\u09b0", "\u09b2", "\u09b6"-"\u09b9", 
         "\u09bc"-"\u09c4", "\u09c7"-"\u09c8", "\u09cb"-"\u09cd", "\u09d7", "\u09dc"-"\u09dd", 
         "\u09df"-"\u09e3", "\u09e6"-"\u09f3", "\u0a01"-"\u0a03", "\u0a05"-"\u0a0a", 
         "\u0a0f"-"\u0a10", "\u0a13"-"\u0a28", "\u0a2a"-"\u0a30", "\u0a32"-"\u0a33", 
         "\u0a35"-"\u0a36", "\u0a38"-"\u0a39", "\u0a3c", "\u0a3e"-"\u0a42", "\u0a47"-"\u0a48", 
         "\u0a4b"-"\u0a4d", "\u0a59"-"\u0a5c", "\u0a5e", "\u0a66"-"\u0a74", "\u0a81"-"\u0a83", 
         "\u0a85"-"\u0a8d", "\u0a8f"-"\u0a91", "\u0a93"-"\u0aa8", "\u0aaa"-"\u0ab0", 
         "\u0ab2"-"\u0ab3", "\u0ab5"-"\u0ab9", "\u0abc"-"\u0ac5", "\u0ac7"-"\u0ac9", 
         "\u0acb"-"\u0acd", "\u0ad0", "\u0ae0"-"\u0ae3", "\u0ae6"-"\u0aef", "\u0af1", 
         "\u0b01"-"\u0b03", "\u0b05"-"\u0b0c", "\u0b0f"-"\u0b10", "\u0b13"-"\u0b28", 
         "\u0b2a"-"\u0b30", "\u0b32"-"\u0b33", "\u0b35"-"\u0b39", "\u0b3c"-"\u0b43", 
         "\u0b47"-"\u0b48", "\u0b4b"-"\u0b4d", "\u0b56"-"\u0b57", "\u0b5c"-"\u0b5d", 
         "\u0b5f"-"\u0b61", "\u0b66"-"\u0b6f", "\u0b71", "\u0b82"-"\u0b83", "\u0b85"-"\u0b8a", 
         "\u0b8e"-"\u0b90", "\u0b92"-"\u0b95", "\u0b99"-"\u0b9a", "\u0b9c", "\u0b9e"-"\u0b9f", 
         "\u0ba3"-"\u0ba4", "\u0ba8"-"\u0baa", "\u0bae"-"\u0bb5", "\u0bb7"-"\u0bb9", 
         "\u0bbe"-"\u0bc2", "\u0bc6"-"\u0bc8", "\u0bca"-"\u0bcd", "\u0bd7", "\u0be7"-"\u0bef", 
         "\u0bf9", "\u0c01"-"\u0c03", "\u0c05"-"\u0c0c", "\u0c0e"-"\u0c10", "\u0c12"-"\u0c28", 
         "\u0c2a"-"\u0c33", "\u0c35"-"\u0c39", "\u0c3e"-"\u0c44", "\u0c46"-"\u0c48", 
         "\u0c4a"-"\u0c4d", "\u0c55"-"\u0c56", "\u0c60"-"\u0c61", "\u0c66"-"\u0c6f", 
         "\u0c82"-"\u0c83", "\u0c85"-"\u0c8c", "\u0c8e"-"\u0c90", "\u0c92"-"\u0ca8", 
         "\u0caa"-"\u0cb3", "\u0cb5"-"\u0cb9", "\u0cbc"-"\u0cc4", "\u0cc6"-"\u0cc8", 
         "\u0cca"-"\u0ccd", "\u0cd5"-"\u0cd6", "\u0cde", "\u0ce0"-"\u0ce1", "\u0ce6"-"\u0cef", 
         "\u0d02"-"\u0d03", "\u0d05"-"\u0d0c", "\u0d0e"-"\u0d10", "\u0d12"-"\u0d28", 
         "\u0d2a"-"\u0d39", "\u0d3e"-"\u0d43", "\u0d46"-"\u0d48", "\u0d4a"-"\u0d4d", 
         "\u0d57", "\u0d60"-"\u0d61", "\u0d66"-"\u0d6f", "\u0d82"-"\u0d83", "\u0d85"-"\u0d96", 
         "\u0d9a"-"\u0db1", "\u0db3"-"\u0dbb", "\u0dbd", "\u0dc0"-"\u0dc6", "\u0dca", 
         "\u0dcf"-"\u0dd4", "\u0dd6", "\u0dd8"-"\u0ddf", "\u0df2"-"\u0df3", "\u0e01"-"\u0e3a", 
         "\u0e3f"-"\u0e4e", "\u0e50"-"\u0e59", "\u0e81"-"\u0e82", "\u0e84", "\u0e87"-"\u0e88", 
         "\u0e8a", "\u0e8d", "\u0e94"-"\u0e97", "\u0e99"-"\u0e9f", "\u0ea1"-"\u0ea3", "\u0ea5", 
         "\u0ea7", "\u0eaa"-"\u0eab", "\u0ead"-"\u0eb9", "\u0ebb"-"\u0ebd", "\u0ec0"-"\u0ec4", 
         "\u0ec6", "\u0ec8"-"\u0ecd", "\u0ed0"-"\u0ed9", "\u0edc"-"\u0edd", "\u0f00", 
         "\u0f18"-"\u0f19", "\u0f20"-"\u0f29", "\u0f35", "\u0f37", "\u0f39", "\u0f3e"-"\u0f47", 
         "\u0f49"-"\u0f6a", "\u0f71"-"\u0f84", "\u0f86"-"\u0f8b", "\u0f90"-"\u0f97", 
         "\u0f99"-"\u0fbc", "\u0fc6", "\u1000"-"\u1021", "\u1023"-"\u1027", "\u1029"-"\u102a", 
         "\u102c"-"\u1032", "\u1036"-"\u1039", "\u1040"-"\u1049", "\u1050"-"\u1059", 
         "\u10a0"-"\u10c5", "\u10d0"-"\u10f8", "\u1100"-"\u1159", "\u115f"-"\u11a2", 
         "\u11a8"-"\u11f9", "\u1200"-"\u1206", "\u1208"-"\u1246", "\u1248", "\u124a"-"\u124d", 
         "\u1250"-"\u1256", "\u1258", "\u125a"-"\u125d", "\u1260"-"\u1286", "\u1288", 
         "\u128a"-"\u128d", "\u1290"-"\u12ae", "\u12b0", "\u12b2"-"\u12b5", "\u12b8"-"\u12be", 
         "\u12c0", "\u12c2"-"\u12c5", "\u12c8"-"\u12ce", "\u12d0"-"\u12d6", "\u12d8"-"\u12ee", 
         "\u12f0"-"\u130e", "\u1310", "\u1312"-"\u1315", "\u1318"-"\u131e", "\u1320"-"\u1346", 
         "\u1348"-"\u135a", "\u1369"-"\u1371", "\u13a0"-"\u13f4", "\u1401"-"\u166c", 
         "\u166f"-"\u1676", "\u1681"-"\u169a", "\u16a0"-"\u16ea", "\u16ee"-"\u16f0", 
         "\u1700"-"\u170c", "\u170e"-"\u1714", "\u1720"-"\u1734", "\u1740"-"\u1753", 
         "\u1760"-"\u176c", "\u176e"-"\u1770", "\u1772"-"\u1773", "\u1780"-"\u17d3", 
         "\u17d7", "\u17db"-"\u17dd", "\u17e0"-"\u17e9", "\u180b"-"\u180d", "\u1810"-"\u1819", 
         "\u1820"-"\u1877", "\u1880"-"\u18a9", "\u1900"-"\u191c", "\u1920"-"\u192b", 
         "\u1930"-"\u193b", "\u1946"-"\u196d", "\u1970"-"\u1974", "\u1d00"-"\u1d6b", 
         "\u1e00"-"\u1e9b", "\u1ea0"-"\u1ef9", "\u1f00"-"\u1f15", "\u1f18"-"\u1f1d", 
         "\u1f20"-"\u1f45", "\u1f48"-"\u1f4d", "\u1f50"-"\u1f57", "\u1f59", "\u1f5b", "\u1f5d", 
         "\u1f5f"-"\u1f7d", "\u1f80"-"\u1fb4", "\u1fb6"-"\u1fbc", "\u1fbe", "\u1fc2"-"\u1fc4", 
         "\u1fc6"-"\u1fcc", "\u1fd0"-"\u1fd3", "\u1fd6"-"\u1fdb", "\u1fe0"-"\u1fec", 
         "\u1ff2"-"\u1ff4", "\u1ff6"-"\u1ffc", "\u200c"-"\u200f", "\u202a"-"\u202e", 
         "\u203f"-"\u2040", "\u2054", "\u2060"-"\u2063", "\u206a"-"\u206f", "\u2071", "\u207f", 
         "\u20a0"-"\u20b1", "\u20d0"-"\u20dc", "\u20e1", "\u20e5"-"\u20ea", "\u2102", "\u2107", 
         "\u210a"-"\u2113", "\u2115", "\u2119"-"\u211d", "\u2124", "\u2126", "\u2128", 
         "\u212a"-"\u212d", "\u212f"-"\u2131", "\u2133"-"\u2139", "\u213d"-"\u213f", 
         "\u2145"-"\u2149", "\u2160"-"\u2183", "\u3005"-"\u3007", "\u3021"-"\u302f", 
         "\u3031"-"\u3035", "\u3038"-"\u303c", "\u3041"-"\u3096", "\u3099"-"\u309a", 
         "\u309d"-"\u309f", "\u30a1"-"\u30ff", "\u3105"-"\u312c", "\u3131"-"\u318e", 
         "\u31a0"-"\u31b7", "\u31f0"-"\u31ff", "\u3400"-"\u4db5", "\u4e00"-"\u9fa5", 
         "\ua000"-"\ua48c", "\uac00"-"\ud7a3", "\ud801", "\ud802", "\ud834", "\udc00", "\udc01", 
         "\udd7b", "\uf900"-"\ufa2d", "\ufa30"-"\ufa6a", "\ufb00"-"\ufb06", "\ufb13"-"\ufb17", 
         "\ufb1d"-"\ufb28", "\ufb2a"-"\ufb36", "\ufb38"-"\ufb3c", "\ufb3e", "\ufb40"-"\ufb41", 
         "\ufb43"-"\ufb44", "\ufb46"-"\ufbb1", "\ufbd3"-"\ufd3d", "\ufd50"-"\ufd8f", 
         "\ufd92"-"\ufdc7", "\ufdf0"-"\ufdfc", "\ufe00"-"\ufe0f", "\ufe20"-"\ufe23", 
         "\ufe33"-"\ufe34", "\ufe4d"-"\ufe4f", "\ufe69", "\ufe70"-"\ufe74", "\ufe76"-"\ufefc", 
         "\ufeff", "\uff04", "\uff10"-"\uff19", "\uff21"-"\uff3a", "\uff3f", "\uff41"-"\uff5a", 
         "\uff65"-"\uffbe", "\uffc2"-"\uffc7", "\uffca"-"\uffcf", "\uffd2"-"\uffd7", 
         "\uffda"-"\uffdc", "\uffe0"-"\uffe1", "\uffe5"-"\uffe6", "\ufff9"-"\ufffb"
      ]
  >
}

/* OPERATORS */

TOKEN :
{
  < LT: "<" >
| < BANG: "!" >
| < EQ: "==" >
| < LE: "<=" >
| < GE: ">=" >
| < NE: "!=" >
}

/*******************************
 * THE OQL GRAMMAR STARTS HERE *
 *******************************/
 
/***************************************************************
                   GRAMMAR START
***************************************************************/

AstStart Start()        : {/*@bgen(jjtree) Start */
  AstStart jjtn000 = new AstStart(JJTSTART);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) Start */
    try {
/*@egen*/
    SelectStatement()

    <EOF>/*@bgen(jjtree)*/
    {
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
    }
/*@egen*/
    { return jjtn000; }/*@bgen(jjtree)*/
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        throw (RuntimeException)jjte000;
      }
      if (jjte000 instanceof ParseException) {
        throw (ParseException)jjte000;
      }
      throw (Error)jjte000;
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
      }
    }
/*@egen*/
}

void SelectStatement()                 :{/*@bgen(jjtree) SelectStatement */
  AstSelectStatement jjtn000 = new AstSelectStatement(JJTSELECTSTATEMENT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) SelectStatement */
        try {
/*@egen*/
	try { LOOKAHEAD({seeUnreservedKeyword("SELECT")}) <IDENTIFIER> }
	catch (ParseException e) { throw generateCustomParseException("SELECT"); }
    SelectList()
    FromClause()
    [ WhereClause() ]/*@bgen(jjtree)*/
        } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            throw (RuntimeException)jjte000;
          }
          if (jjte000 instanceof ParseException) {
            throw (ParseException)jjte000;
          }
          throw (Error)jjte000;
        } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
        }
/*@egen*/       
}

/* ---------------- select --------------------- */

void SelectList():
{
}
{
	(
	    [
	    	LOOKAHEAD({seeUnreservedKeyword("DISTINCT")})
	    		<IDENTIFIER>
		]
	    (
	    	"*"	    	
		    |
		    SelectItem()
			(
				"," SelectItem()
			)*
		)
	)
}

void SelectItem()            :
{/*@bgen(jjtree) SelectItem */
  AstSelectItem jjtn000 = new AstSelectItem(JJTSELECTITEM);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
/*@egen*/
}
{/*@bgen(jjtree) SelectItem */
        try {
/*@egen*/
	( PathExpression() )
	[
    	LOOKAHEAD({seeUnreservedKeyword("AS")}) <IDENTIFIER>
		( <STRING_LITERAL> | <IDENTIFIER> )
	]/*@bgen(jjtree)*/
        } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            throw (RuntimeException)jjte000;
          }
          if (jjte000 instanceof ParseException) {
            throw (ParseException)jjte000;
          }
          throw (Error)jjte000;
        } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
        }
/*@egen*/
}

void PathExpression()                :
{/*@bgen(jjtree) PathExpression */
        AstPathExpression jjtn000 = new AstPathExpression(JJTPATHEXPRESSION);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
/*@egen*/
	StringBuffer sb = new StringBuffer();
	String element;
}
{/*@bgen(jjtree) PathExpression */
        try {
/*@egen*/
	(
		element = ObjectFacet(true) { sb.append(element); }
	)
	(
		"." element = ObjectFacet(false) { sb.append(element); }
	)*/*@bgen(jjtree)*/
        {
          jjtree.closeNodeScope(jjtn000, true);
          jjtc000 = false;
        }
/*@egen*/
	{
		jjtn000.setPath(sb.toString());
	}/*@bgen(jjtree)*/
        } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            throw (RuntimeException)jjte000;
          }
          if (jjte000 instanceof ParseException) {
            throw (ParseException)jjte000;
          }
          throw (Error)jjte000;
        } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
        }
/*@egen*/
}

String ObjectFacet(boolean isFirstInPath):
{
	Token t = null;
}
{
	(
		t = <IDENTIFIER>
		[ LOOKAHEAD("(") ParameterList() ]
	)
	{
		return isFirstInPath ? t.image : "."+t.image;
	}
}

void ParameterList()               :
{/*@bgen(jjtree) ParameterList */
  AstParameterList jjtn000 = new AstParameterList(JJTPARAMETERLIST);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
/*@egen*/
}
{/*@bgen(jjtree) ParameterList */
        try {
/*@egen*/
	"("
	[
	(
		SimpleExpression()
		(
			"," SimpleExpression()
		)*
	)
	]
	")"/*@bgen(jjtree)*/
        } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            throw (RuntimeException)jjte000;
          }
          if (jjte000 instanceof ParseException) {
            throw (ParseException)jjte000;
          }
          throw (Error)jjte000;
        } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
        }
/*@egen*/
}

/* ---------------- from --------------------- */

void FromClause()            :
{/*@bgen(jjtree) FromClause */
  AstFromClause jjtn000 = new AstFromClause(JJTFROMCLAUSE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
/*@egen*/
}
{/*@bgen(jjtree) FromClause */
        try {
/*@egen*/
	try { LOOKAHEAD({seeUnreservedKeyword("FROM")}) <IDENTIFIER> }
	catch (ParseException e) { throw generateCustomParseException("FROM"); }
	[ LOOKAHEAD( <INSTANCEOF> ) <INSTANCEOF> ]
    ( FromItem() | "(" SelectStatement() ")" )/*@bgen(jjtree)*/
    {
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
    }
/*@egen*/
    {
    }/*@bgen(jjtree)*/
        } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            throw (RuntimeException)jjte000;
          }
          if (jjte000 instanceof ParseException) {
            throw (ParseException)jjte000;
          }
          throw (Error)jjte000;
        } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
        }
/*@egen*/
}

void FromItem()          :
{/*@bgen(jjtree) FromItem */
  AstFromItem jjtn000 = new AstFromItem(JJTFROMITEM);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
/*@egen*/
}
{/*@bgen(jjtree) FromItem */
        try {
/*@egen*/
	(
	ClassName()		
	)
	[ LOOKAHEAD({seeExclude("WHERE", "UNION", "JOIN")}) <IDENTIFIER> ]
	{
		//if (t2 != null) fromClause.setAlias(t2.image);
	}
	( JoinerExpression() )*/*@bgen(jjtree)*/
        } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            throw (RuntimeException)jjte000;
          }
          if (jjte000 instanceof ParseException) {
            throw (ParseException)jjte000;
          }
          throw (Error)jjte000;
        } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
        }
/*@egen*/
}

void JoinerExpression()                    :
{/*@bgen(jjtree) JoinPartExpression */
  AstJoinPartExpression jjtn000 = new AstJoinPartExpression(JJTJOINPARTEXPRESSION);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
/*@egen*/
/*String className = null;
Token t2 = null;
Object expr = null;*/
}
{/*@bgen(jjtree) JoinPartExpression */
        try {
/*@egen*/
	LOOKAHEAD({seeUnreservedKeyword("JOIN")}) <IDENTIFIER>
    ( ClassName())
    {
    	//fromClause.addJoinClassName(className);
    }
    [ LOOKAHEAD({seeExclude("ON")}) <IDENTIFIER> ]
    {
    	//if (t2 != null) fromClause.setJoinAlias(className, t2.image);
    }
    (JoinWhereClause())/*@bgen(jjtree)*/
    {
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
    }
/*@egen*/
    {
    	//fromClause.setJoinExpression(className, (Expression)expr);
    }/*@bgen(jjtree)*/
        } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            throw (RuntimeException)jjte000;
          }
          if (jjte000 instanceof ParseException) {
            throw (ParseException)jjte000;
          }
          throw (Error)jjte000;
        } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
        }
/*@egen*/
}

void JoinWhereClause()              :
{/*@bgen(jjtree) JoinOnClause */
  AstJoinOnClause jjtn000 = new AstJoinOnClause(JJTJOINONCLAUSE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
/*@egen*/
	//Object expr = null;	
}
{/*@bgen(jjtree) JoinOnClause */
        try {
/*@egen*/
	LOOKAHEAD({seeUnreservedKeyword("ON")}) <IDENTIFIER>
	(ConditionalOrExpression())/*@bgen(jjtree)*/
        {
          jjtree.closeNodeScope(jjtn000, true);
          jjtc000 = false;
        }
/*@egen*/
	{
		//return expr;
	}/*@bgen(jjtree)*/
        } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            throw (RuntimeException)jjte000;
          }
          if (jjte000 instanceof ParseException) {
            throw (ParseException)jjte000;
          }
          throw (Error)jjte000;
        } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
        }
/*@egen*/
}

void ClassName()           :
{/*@bgen(jjtree) ClassName */
  AstClassName jjtn000 = new AstClassName(JJTCLASSNAME);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
/*@egen*/ StringBuilder b = new StringBuilder(); Token t; }
{/*@bgen(jjtree) ClassName */
        try {
/*@egen*/
	(
	    t = <IDENTIFIER> { b.append(t.image); }
	    ( "." t = <IDENTIFIER> { b.append(".").append(t.image); } )*
	  	( "[]" { b.append("[]"); } )*
	)/*@bgen(jjtree)*/
        {
          jjtree.closeNodeScope(jjtn000, true);
          jjtc000 = false;
        }
/*@egen*/
	{
		jjtn000.setName(b.toString());
	}/*@bgen(jjtree)*/
        } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
        }
/*@egen*/
}

/* ---------------- where --------------------- */

void WhereClause()             :
{/*@bgen(jjtree) WhereClause */
  AstWhereClause jjtn000 = new AstWhereClause(JJTWHERECLAUSE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
/*@egen*/ /*Object ex;*/ }
{/*@bgen(jjtree) WhereClause */
        try {
/*@egen*/
	LOOKAHEAD({seeUnreservedKeyword("WHERE")}) <IDENTIFIER>
    ConditionalOrExpression()/*@bgen(jjtree)*/
    {
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
    }
/*@egen*/
    {
    	//q.setWhereClause((Expression)ex);
  	}/*@bgen(jjtree)*/
        } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            throw (RuntimeException)jjte000;
          }
          if (jjte000 instanceof ParseException) {
            throw (ParseException)jjte000;
          }
          throw (Error)jjte000;
        } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
        }
/*@egen*/
}

void ConditionalOrExpression()                         :
{/*@bgen(jjtree) ConditionalOrExpression */
  AstConditionalOrExpression jjtn000 = new AstConditionalOrExpression(JJTCONDITIONALOREXPRESSION);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
/*@egen*//* Object ex, r; ArrayList<Object> list = null;*/ }
{/*@bgen(jjtree) ConditionalOrExpression */
         try {
/*@egen*/
	 ConditionalAndExpression() (
  			"or" ConditionalAndExpression()
			{
				/*if (list == null)
				{
					list = new ArrayList<Object>();
					list.add(ex);
                }
				list.add(r);*/
            }
	)*/*@bgen(jjtree)*/
        {
          jjtree.closeNodeScope(jjtn000, true);
          jjtc000 = false;
        }
/*@egen*/
	{
        /*if (list != null)
        {
            ex = compiler.or(list.toArray());
        }
        return ex;*/
    }/*@bgen(jjtree)*/
         } catch (Throwable jjte000) {
           if (jjtc000) {
             jjtree.clearNodeScope(jjtn000);
             jjtc000 = false;
           } else {
             jjtree.popNode();
           }
           if (jjte000 instanceof RuntimeException) {
             throw (RuntimeException)jjte000;
           }
           if (jjte000 instanceof ParseException) {
             throw (ParseException)jjte000;
           }
           throw (Error)jjte000;
         } finally {
           if (jjtc000) {
             jjtree.closeNodeScope(jjtn000, true);
           }
         }
/*@egen*/
}

void ConditionalAndExpression()                          :
{/*@bgen(jjtree) ConditionalAndExpression */
  AstConditionalAndExpression jjtn000 = new AstConditionalAndExpression(JJTCONDITIONALANDEXPRESSION);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
/*@egen*/ /*Object ex, r; ArrayList<Object> list = null;*/ }
{/*@bgen(jjtree) ConditionalAndExpression */
        try {
/*@egen*/
	EqualityExpression() (
  			"and" EqualityExpression()
			{
				/*if (list == null)
				{
					list = new ArrayList<Object>();
					list.add(ex);
                }
				list.add(r);*/
            }
	)*/*@bgen(jjtree)*/
        {
          jjtree.closeNodeScope(jjtn000, true);
          jjtc000 = false;
        }
/*@egen*/
	{
        /*if (list != null)
        {
            ex = compiler.and(list.toArray());
        }
        return ex;*/
    }/*@bgen(jjtree)*/
        } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            throw (RuntimeException)jjte000;
          }
          if (jjte000 instanceof ParseException) {
            throw (ParseException)jjte000;
          }
          throw (Error)jjte000;
        } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
        }
/*@egen*/
}

void EqualityExpression()                    :
{/*@bgen(jjtree) EqualityExpression */
  AstEqualityExpression jjtn000 = new AstEqualityExpression(JJTEQUALITYEXPRESSION);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
/*@egen*/ /*Object ex, r;*/ }
{/*@bgen(jjtree) EqualityExpression */
        try {
/*@egen*/
	RelationalExpression() ((
  		  "=" RelationalExpression() { /*ex = compiler.equal(ex, r);*/ }
  		| "!=" RelationalExpression() { /*ex = compiler.notEqual(ex, r);*/ }
	))*/*@bgen(jjtree)*/
        {
          jjtree.closeNodeScope(jjtn000, true);
          jjtc000 = false;
        }
/*@egen*/
	{
		//return ex;
	}/*@bgen(jjtree)*/
        } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            throw (RuntimeException)jjte000;
          }
          if (jjte000 instanceof ParseException) {
            throw (ParseException)jjte000;
          }
          throw (Error)jjte000;
        } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
        }
/*@egen*/
}

void RelationalExpression()                      :
{/*@bgen(jjtree) RelationalExpression */
  AstRelationalExpression jjtn000 = new AstRelationalExpression(JJTRELATIONALEXPRESSION);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
/*@egen*//*Object ex, r;*/} 
{/*@bgen(jjtree) RelationalExpression */
        try {
/*@egen*/
	(
		SimpleExpression() ((
			  "<"  SimpleExpression() { /*ex = compiler.lessThan(ex, r);*/ }
			| ">"  SimpleExpression() { /*ex = compiler.greaterThan(ex, r);*/ }
			| "<=" SimpleExpression() { /*ex = compiler.lessThanOrEqual(ex, r);*/ }
			| ">=" SimpleExpression() { /*ex = compiler.greaterThanOrEqual(ex, r);*/ }
			| LOOKAHEAD({seeUnreservedKeyword("LIKE")}) LikeClause(true)
			| LOOKAHEAD({seeUnreservedKeyword("IN")}) InClause(true)
			| LOOKAHEAD({seeUnreservedKeyword("NOT")}) NotLikeInClause()
			| "implements" ClassName() {/*compiler.instanceOf(ex, (String)r);*/ }
	  	))?
	)/*@bgen(jjtree)*/
        {
          jjtree.closeNodeScope(jjtn000, true);
          jjtc000 = false;
        }
/*@egen*/
	{
		//return ex;
	}/*@bgen(jjtree)*/
        } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            throw (RuntimeException)jjte000;
          }
          if (jjte000 instanceof ParseException) {
            throw (ParseException)jjte000;
          }
          throw (Error)jjte000;
        } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
        }
/*@egen*/
}

// only identifer (see [2] http://www.engr.mun.ca/~theo/JavaCC-FAQ/javacc-faq-moz.htm#keywords)
void NotLikeInClause():
{
	//Object ex;
}
{
	(
		<IDENTIFIER>
		(
			LOOKAHEAD({seeUnreservedKeyword("LIKE")}) LikeClause(false)
			| LOOKAHEAD({seeUnreservedKeyword("IN")}) InClause(false)
		)
	)
	{
		//return ex;
	}
}

void LikeClause(boolean isLike)            :
{/*@bgen(jjtree) LikeClause */
        AstLikeClause jjtn000 = new AstLikeClause(JJTLIKECLAUSE);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
/*@egen*/
	//Token t1 = null;
	Token t;
}
{/*@bgen(jjtree) LikeClause */
        try {
/*@egen*/
  	(<IDENTIFIER> t = <STRING_LITERAL>)/*@bgen(jjtree)*/
        {
          jjtree.closeNodeScope(jjtn000, true);
          jjtc000 = false;
        }
/*@egen*/
	{
		/*String pattern = t1.image.substring(1, t1.image.length() - 1);
		return isLike ? compiler.like(left, pattern) : compiler.notLike(left, pattern);*/
		jjtn000.setLike(isLike);
		jjtn000.setPattern(getStringValueFromImage(t.image));
	}/*@bgen(jjtree)*/
        } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
        }
/*@egen*/
}

void InClause(/*Object left, */boolean isIn)          :
{/*@bgen(jjtree) InClause */
  AstInClause jjtn000 = new AstInClause(JJTINCLAUSE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
/*@egen*/
	//Object r;
}
{/*@bgen(jjtree) InClause */
        try {
/*@egen*/
  	<IDENTIFIER> SimpleExpression()/*@bgen(jjtree)*/
        {
          jjtree.closeNodeScope(jjtn000, true);
          jjtc000 = false;
        }
/*@egen*/
	{
		//return isIn ? compiler.in(left, r) : compiler.notIn(left, r);
	}/*@bgen(jjtree)*/
        } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            throw (RuntimeException)jjte000;
          }
          if (jjte000 instanceof ParseException) {
            throw (ParseException)jjte000;
          }
          throw (Error)jjte000;
        } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
        }
/*@egen*/
}

void SimpleExpression()                  :
{/*@bgen(jjtree) SimpleExpression */
  AstSimpleExpression jjtn000 = new AstSimpleExpression(JJTSIMPLEEXPRESSION);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
/*@egen*/ /*Object ex, r;*/ }
{/*@bgen(jjtree) SimpleExpression */
        try {
/*@egen*/
	MultiplicativeExpression()
	(
  		"+" MultiplicativeExpression() { /*ex = compiler.plus(ex, r);*/ }
  		| "-" MultiplicativeExpression() { /*ex = compiler.minus(ex, r);*/ }
	)*/*@bgen(jjtree)*/
        {
          jjtree.closeNodeScope(jjtn000, true);
          jjtc000 = false;
        }
/*@egen*/
	{
		//return ex;
	}/*@bgen(jjtree)*/
        } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            throw (RuntimeException)jjte000;
          }
          if (jjte000 instanceof ParseException) {
            throw (ParseException)jjte000;
          }
          throw (Error)jjte000;
        } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
        }
/*@egen*/
}

void MultiplicativeExpression()                          :
{/*@bgen(jjtree) MultiplicativeExpression */
  AstMultiplicativeExpression jjtn000 = new AstMultiplicativeExpression(JJTMULTIPLICATIVEEXPRESSION);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
/*@egen*/ /*Object ex, r;*/ }
{/*@bgen(jjtree) MultiplicativeExpression */
        try {
/*@egen*/
	PrimaryExpression()
	(
  		  "*" PrimaryExpression() { /*ex = compiler.multiply(ex, r);*/ }
  		| "/" PrimaryExpression() { /*ex = compiler.divide(ex, r);*/ }
	)*/*@bgen(jjtree)*/
        {
          jjtree.closeNodeScope(jjtn000, true);
          jjtc000 = false;
        }
/*@egen*/
	{
		//return ex;
	}/*@bgen(jjtree)*/
        } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            throw (RuntimeException)jjte000;
          }
          if (jjte000 instanceof ParseException) {
            throw (ParseException)jjte000;
          }
          throw (Error)jjte000;
        } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
        }
/*@egen*/
}

void PrimaryExpression()                   :
{/*@bgen(jjtree) PrimaryExpression */
  AstPrimaryExpression jjtn000 = new AstPrimaryExpression(JJTPRIMARYEXPRESSION);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
/*@egen*/ /*Object ex;*/ }
{/*@bgen(jjtree) PrimaryExpression */
        try {
/*@egen*/
	Literal()/*@bgen(jjtree)*/
        {
          jjtree.closeNodeScope(jjtn000, true);
          jjtc000 = false;
        }
/*@egen*/
	{
		//return ex;
	}
	|
	"("
	(
		LOOKAHEAD({seeUnreservedKeyword("SELECT")}) SubQuery()
		| ConditionalOrExpression()
	)
	")"/*@bgen(jjtree)*/
        {
          jjtree.closeNodeScope(jjtn000, true);
          jjtc000 = false;
        }
/*@egen*/
	{
		//return ex;
	}
	|
	PathExpression()/*@bgen(jjtree)*/
        {
          jjtree.closeNodeScope(jjtn000, true);
          jjtc000 = false;
        }
/*@egen*/
	{
		//return ex;
	}/*@bgen(jjtree)*/
        } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            throw (RuntimeException)jjte000;
          }
          if (jjte000 instanceof ParseException) {
            throw (ParseException)jjte000;
          }
          throw (Error)jjte000;
        } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
        }
/*@egen*/
}

void SubQuery()          :
{/*@bgen(jjtree) SubQuery */
  AstSubQuery jjtn000 = new AstSubQuery(JJTSUBQUERY);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
/*@egen*/ /*Query q;*/ }
{/*@bgen(jjtree) SubQuery */
        try {
/*@egen*/
	SelectStatement()/*@bgen(jjtree)*/
        {
          jjtree.closeNodeScope(jjtn000, true);
          jjtc000 = false;
        }
/*@egen*/
	{
		//return compiler.subQuery(q);	
	}/*@bgen(jjtree)*/
        } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            throw (RuntimeException)jjte000;
          }
          if (jjte000 instanceof ParseException) {
            throw (ParseException)jjte000;
          }
          throw (Error)jjte000;
        } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
        }
/*@egen*/
}

void Literal():
{ /*Object ex; Token t;*/ }
{
	(
		 NumberLiteral()
	|
		<CHARACTER_LITERAL>
		{
			//compiler.literal(Character.valueOf(t.image.charAt(1)));
		}
	|
		<STRING_LITERAL>
		{
			//ex = compiler.literal(t.image.substring(1, t.image.length() - 1));
		}
	|
		BooleanLiteral()
	|
		NullLiteral()
	)
	{
		//return ex;
	}
}

void NumberLiteral()               :
{/*@bgen(jjtree) NumberLiteral */
        AstNumberLiteral jjtn000 = new AstNumberLiteral(JJTNUMBERLITERAL);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
/*@egen*//* Object ex; Token t, unary = null;*/
	Token t; 
}
{/*@bgen(jjtree) NumberLiteral */
        try {
/*@egen*/
	( "+" | "-" )?
	(
		t=<INTEGER_LITERAL>
		{
			/*int anInt = Integer.parseInt(t.image);
			if (unary != null && "-".equals(unary.image))
				anInt *= -1;
				
			ex = compiler.literal(anInt);*/
			jjtn000.setNumber( Integer.valueOf(t.image));
		}
	|
		t=<LONG_LITERAL>
		{
			/*long aLong = Long.parseLong(t.image.substring(0, t.image.length()-1));
			if (unary != null && "-".equals(unary.image))
				aLong *= -1;
			
			ex = compiler.literal(aLong);*/
			jjtn000.setNumber( Long.valueOf(t.image));
		}
	|
		t=<FLOATING_POINT_LITERAL>
		{
			/*float aFloat = Float.parseFloat(t.image);
			if (unary != null && "-".equals(unary.image))
				aFloat *= -1;
			
			ex = compiler.literal(aFloat);*/
			jjtn000.setNumber( Float.valueOf(t.image));
		}
	)/*@bgen(jjtree)*/
        {
          jjtree.closeNodeScope(jjtn000, true);
          jjtc000 = false;
        }
/*@egen*/
	{
		//return ex;
	}/*@bgen(jjtree)*/
        } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
        }
/*@egen*/
}

void BooleanLiteral()                :
{/*@bgen(jjtree) BooleanLiteral */
  AstBooleanLiteral jjtn000 = new AstBooleanLiteral(JJTBOOLEANLITERAL);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) BooleanLiteral */
        try {
/*@egen*/
	"true"/*@bgen(jjtree)*/
        {
          jjtree.closeNodeScope(jjtn000, true);
          jjtc000 = false;
        }
/*@egen*/
	{
		jjtn000.setValue(Boolean.TRUE); 
	}
	|
	"false"/*@bgen(jjtree)*/
        {
          jjtree.closeNodeScope(jjtn000, true);
          jjtc000 = false;
        }
/*@egen*/
	{
		jjtn000.setValue(Boolean.FALSE);
	}/*@bgen(jjtree)*/
        } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
        }
/*@egen*/
}

void NullLiteral()             :
{/*@bgen(jjtree) NullLiteral */
  AstNullLiteral jjtn000 = new AstNullLiteral(JJTNULLLITERAL);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) NullLiteral */
        try {
/*@egen*/
	<NULL>/*@bgen(jjtree)*/
        {
          jjtree.closeNodeScope(jjtn000, true);
          jjtc000 = false;
        }
/*@egen*/
	{
		//return compiler.nullLiteral();
	}/*@bgen(jjtree)*/
        } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
        }
/*@egen*/
}

/* ---------------- union --------------------- */

void UnionClause():
{
	//Query unionQuery = null;
}
{
    (
    	LOOKAHEAD({seeUnreservedKeyword("UNION")}) <IDENTIFIER>
    	"(" SelectStatement() ")" { /*q.addUnionQuery(unionQuery); */} )+
}