javacc-7.0.1.test.lineNumbers.out-dir.JJTree.jj Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of javacc Show documentation
Show all versions of javacc Show documentation
JavaCC is a parser/scanner generator for Java.
/*@bgen(jjtree) Generated By:JJTree: Do not edit this line. JJTree.jj */
/*@egen*//* Copyright (c) 2006, Sun Microsystems, Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the Sun Microsystems, Inc. nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
* THE POSSIBILITY OF SUCH DAMAGE.
*/
options {
JAVA_UNICODE_ESCAPE = true;
STATIC = false;
OUTPUT_DIRECTORY = "out-dir";
}
PARSER_BEGIN(JJTreeParser)
package org.javacc.jjtree;
public class JJTreeParser/*@bgen(jjtree)*/implements JJTreeParserTreeConstants/*@egen*/ {/*@bgen(jjtree)*/
protected JJTJJTreeParserState jjtree = new JJTJJTreeParserState();
/*@egen*/
void jjtreeOpenNodeScope(Node n)
{
((JJTreeNode)n).setFirstToken(getToken(1));
}
void jjtreeCloseNodeScope(Node n)
{
((JJTreeNode)n).setLastToken(getToken(0));
}
/**
* Returns true if the next token is not in the FOLLOW list of "expansion".
* It is used to decide when the end of an "expansion" has been reached.
*/
private boolean notTailOfExpansionUnit() {
Token t;
t = getToken(1);
if (t.kind == BIT_OR || t.kind == COMMA || t.kind == RPAREN || t.kind == RBRACE || t.kind == RBRACKET) return false;
return true;
}
}
PARSER_END(JJTreeParser)
/**********************************************
* THE JAVACC TOKEN SPECIFICATION STARTS HERE *
**********************************************/
/* JAVACC RESERVED WORDS: These are the only tokens in JavaCC but not in Java */
TOKEN :
{
// Options is no longer a reserved word (Issue 126)
// < _OPTIONS: "options" >
< _LOOKAHEAD: "LOOKAHEAD" >
| < _IGNORE_CASE: "IGNORE_CASE" >
| < _PARSER_BEGIN: "PARSER_BEGIN" >
| < _PARSER_END: "PARSER_END" >
| < _JAVACODE: "JAVACODE" >
| < _TOKEN: "TOKEN" >
| < _SPECIAL_TOKEN: "SPECIAL_TOKEN" >
| < _MORE: "MORE" >
| < _SKIP: "SKIP" >
| < _TOKEN_MGR_DECLS: "TOKEN_MGR_DECLS" >
| < _EOF: "EOF" >
}
/*
* The remainder of the tokens are exactly (except for the removal of tokens
* containing ">>" and "<<") as in the Java grammar and must be diff equivalent
* (again with the exceptions above) to it.
*/
/* WHITE SPACE */
SPECIAL_TOKEN :
{
" "
| "\t"
| "\n"
| "\r"
| "\f"
}
/* COMMENTS */
MORE :
{
"//" : IN_SINGLE_LINE_COMMENT
|
<"/**" ~["/"]> { input_stream.backup(1); } : IN_FORMAL_COMMENT
|
"/*" : IN_MULTI_LINE_COMMENT
}
SPECIAL_TOKEN :
{
: DEFAULT
}
SPECIAL_TOKEN :
{
: DEFAULT
}
SPECIAL_TOKEN :
{
: DEFAULT
}
MORE :
{
< ~[] >
}
/* JAVA RESERVED WORDS AND LITERALS */
TOKEN :
{
< ABSTRACT: "abstract" >
| < BOOLEAN: "boolean" >
| < BREAK: "break" >
| < BYTE: "byte" >
| < CASE: "case" >
| < CATCH: "catch" >
| < CHAR: "char" >
| < CLASS: "class" >
| < CONST: "const" >
| < CONTINUE: "continue" >
| < _DEFAULT: "default" >
| < DO: "do" >
| < DOUBLE: "double" >
| < ELSE: "else" >
| < EXTENDS: "extends" >
| < FALSE: "false" >
| < FINAL: "final" >
| < FINALLY: "finally" >
| < FLOAT: "float" >
| < FOR: "for" >
| < GOTO: "goto" >
| < IF: "if" >
| < IMPLEMENTS: "implements" >
| < IMPORT: "import" >
| < INSTANCEOF: "instanceof" >
| < INT: "int" >
| < INTERFACE: "interface" >
| < LONG: "long" >
| < NATIVE: "native" >
| < NEW: "new" >
| < NULL: "null" >
| < PACKAGE: "package">
| < PRIVATE: "private" >
| < PROTECTED: "protected" >
| < PUBLIC: "public" >
| < RETURN: "return" >
| < SHORT: "short" >
| < STATIC: "static" >
| < SUPER: "super" >
| < SWITCH: "switch" >
| < SYNCHRONIZED: "synchronized" >
| < THIS: "this" >
| < THROW: "throw" >
| < THROWS: "throws" >
| < TRANSIENT: "transient" >
| < TRUE: "true" >
| < TRY: "try" >
| < VOID: "void" >
| < VOLATILE: "volatile" >
| < WHILE: "while" >
}
/* JAVA LITERALS */
TOKEN :
{
< INTEGER_LITERAL:
(["l","L"])?
| (["l","L"])?
| (["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:
|
>
|
< #DECIMAL_FLOATING_POINT_LITERAL:
(["0"-"9"])+ "." (["0"-"9"])* ()? (["f","F","d","D"])?
| "." (["0"-"9"])+ ()? (["f","F","d","D"])?
| (["0"-"9"])+ (["f","F","d","D"])?
| (["0"-"9"])+ ()? ["f","F","d","D"]
>
|
< #DECIMAL_EXPONENT: ["e","E"] (["+","-"])? (["0"-"9"])+ >
|
< #HEXADECIMAL_FLOATING_POINT_LITERAL:
"0" ["x", "X"] (["0"-"9","a"-"f","A"-"F"])+ (".")? (["f","F","d","D"])?
| "0" ["x", "X"] (["0"-"9","a"-"f","A"-"F"])* "." (["0"-"9","a"-"f","A"-"F"])+ (["f","F","d","D"])?
>
|
< #HEXADECIMAL_EXPONENT: ["p","P"] (["+","-"])? (["0"-"9"])+ >
|
< CHARACTER_LITERAL:
"'"
( (~["'","\\","\n","\r"])
| ("\\"
( ["n","t","b","r","f","\\","'","\""]
| ["0"-"7"] ( ["0"-"7"] )?
| ["0"-"3"] ["0"-"7"] ["0"-"7"]
)
)
)
"'"
>
|
< STRING_LITERAL:
"\""
( (~["\"","\\","\n","\r"])
| ("\\"
( ["n","t","b","r","f","\\","'","\""]
| ["0"-"7"] ( ["0"-"7"] )?
| ["0"-"3"] ["0"-"7"] ["0"-"7"]
)
)
)*
"\""
>
}
/* SEPARATORS */
TOKEN :
{
< LPAREN: "(" >
| < RPAREN: ")" >
| < LBRACE: "{" >
| < RBRACE: "}" >
| < LBRACKET: "[" >
| < RBRACKET: "]" >
| < SEMICOLON: ";" >
| < COMMA: "," >
| < DOT: "." >
}
/* OPERATORS */
TOKEN :
{
< ASSIGN: "=" >
//| < GT: ">" >
| < LT: "<" >
| < BANG: "!" >
| < TILDE: "~" >
| < HOOK: "?" >
| < COLON: ":" >
| < EQ: "==" >
| < LE: "<=" >
| < GE: ">=" >
| < NE: "!=" >
| < SC_OR: "||" >
| < SC_AND: "&&" >
| < INCR: "++" >
| < DECR: "--" >
| < PLUS: "+" >
| < MINUS: "-" >
| < STAR: "*" >
| < SLASH: "/" >
| < BIT_AND: "&" >
| < BIT_OR: "|" >
| < XOR: "^" >
| < REM: "%" >
// | < LSHIFT: "<<" >
// | < RSIGNEDSHIFT: ">>" >
// | < RUNSIGNEDSHIFT: ">>>" >
| < PLUSASSIGN: "+=" >
| < MINUSASSIGN: "-=" >
| < STARASSIGN: "*=" >
| < SLASHASSIGN: "/=" >
| < ANDASSIGN: "&=" >
| < ORASSIGN: "|=" >
| < XORASSIGN: "^=" >
| < REMASSIGN: "%=" >
// | < LSHIFTASSIGN: "<<=" >
// | < RSIGNEDSHIFTASSIGN: ">>=" >
// | < RUNSIGNEDSHIFTASSIGN: ">>>=" >
}
/* >'s need special attention due to generics syntax. */
TOKEN :
{
< RUNSIGNEDSHIFT: ">>>" >
{
matchedToken.kind = GT;
((Token.GTToken)matchedToken).realKind = RUNSIGNEDSHIFT;
input_stream.backup(2);
matchedToken.image = ">";
}
| < RSIGNEDSHIFT: ">>" >
{
matchedToken.kind = GT;
((Token.GTToken)matchedToken).realKind = RSIGNEDSHIFT;
input_stream.backup(1);
matchedToken.image = ">";
}
| < GT: ">" >
}
/************************************************
* THE JAVACC GRAMMAR SPECIFICATION STARTS HERE *
************************************************/
void javacc_input() :
{/*@bgen(jjtree) Grammar */
ASTGrammar jjtn000 = new ASTGrammar(JJTGRAMMAR);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
jjtreeOpenNodeScope(jjtn000);
/*@egen*/
Token t;
}
{/*@bgen(jjtree) Grammar */
try {
/*@egen*/
javacc_options()/*@bgen(jjtree) #CompilationUnit( true) */
{
ASTCompilationUnit jjtn001 = new ASTCompilationUnit(JJTCOMPILATIONUNIT);
boolean jjtc001 = true;
jjtree.openNodeScope(jjtn001);
jjtreeOpenNodeScope(jjtn001);
}
try {
/*@egen*/
(
"PARSER_BEGIN" "(" t=identifier() ")"
{
JJTreeGlobals.parserName = t.image;
}
CompilationUnit()
"PARSER_END" LOOKAHEAD(1) "(" identifier() ")"/*@bgen(jjtree)*/
{
jjtree.closeNodeScope(jjtn001, true);
jjtc001 = false;
if (jjtree.nodeCreated()) {
jjtreeCloseNodeScope(jjtn001);
}
}
/*@egen*/
{
if (JJTreeOptions.getNodePackage().equals("")) {
JJTreeGlobals.nodePackageName = JJTreeGlobals.packageName;
} else {
JJTreeGlobals.nodePackageName = JJTreeOptions.getNodePackage();
}
}
)/*@bgen(jjtree)*/
} catch (Throwable jjte001) {
if (jjtc001) {
jjtree.clearNodeScope(jjtn001);
jjtc001 = false;
} else {
jjtree.popNode();
}
if (jjte001 instanceof RuntimeException) {
throw (RuntimeException)jjte001;
}
if (jjte001 instanceof ParseException) {
throw (ParseException)jjte001;
}
throw (Error)jjte001;
} finally {
if (jjtc001) {
jjtree.closeNodeScope(jjtn001, true);
if (jjtree.nodeCreated()) {
jjtreeCloseNodeScope(jjtn001);
}
}
}
/*@egen*/ /*@bgen(jjtree) Productions */
{
ASTProductions jjtn002 = new ASTProductions(JJTPRODUCTIONS);
boolean jjtc002 = true;
jjtree.openNodeScope(jjtn002);
jjtreeOpenNodeScope(jjtn002);
}
try {
/*@egen*/
(
( production() )+
)/*@bgen(jjtree)*/
} catch (Throwable jjte002) {
if (jjtc002) {
jjtree.clearNodeScope(jjtn002);
jjtc002 = false;
} else {
jjtree.popNode();
}
if (jjte002 instanceof RuntimeException) {
throw (RuntimeException)jjte002;
}
if (jjte002 instanceof ParseException) {
throw (ParseException)jjte002;
}
throw (Error)jjte002;
} finally {
if (jjtc002) {
jjtree.closeNodeScope(jjtn002, true);
if (jjtree.nodeCreated()) {
jjtreeCloseNodeScope(jjtn002);
}
}
}
/*@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);
if (jjtree.nodeCreated()) {
jjtreeCloseNodeScope(jjtn000);
}
}
}
/*@egen*/
}
void javacc_options() :
{
}
{
[ LOOKAHEAD( { getToken(1).image.equals("options") })/*@bgen(jjtree) Options */
{
ASTOptions jjtn001 = new ASTOptions(JJTOPTIONS);
boolean jjtc001 = true;
jjtree.openNodeScope(jjtn001);
jjtreeOpenNodeScope(jjtn001);
}
try {
/*@egen*/ ( "{" ( option_binding() )* "}" )/*@bgen(jjtree)*/
} catch (Throwable jjte001) {
if (jjtc001) {
jjtree.clearNodeScope(jjtn001);
jjtc001 = false;
} else {
jjtree.popNode();
}
if (jjte001 instanceof RuntimeException) {
throw (RuntimeException)jjte001;
}
if (jjte001 instanceof ParseException) {
throw (ParseException)jjte001;
}
throw (Error)jjte001;
} finally {
if (jjtc001) {
jjtree.closeNodeScope(jjtn001, true);
if (jjtree.nodeCreated()) {
jjtreeCloseNodeScope(jjtn001);
}
}
}
/*@egen*/ ]
}
void option_binding() :
{/*@bgen(jjtree) OptionBinding */
ASTOptionBinding jjtn000 = new ASTOptionBinding(JJTOPTIONBINDING);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
jjtreeOpenNodeScope(jjtn000);
/*@egen*/
Token o, v;
}
{/*@bgen(jjtree) OptionBinding */
try {
/*@egen*/
( o= | o="LOOKAHEAD" | o="IGNORE_CASE" | o="static" )
"="
(
v=IntegerLiteral()
{
JJTreeOptions.setInputFileOption(o, v, o.image, new Integer(v.image));
jjtn000.initialize(o.image, v.image);
}
| v=BooleanLiteral()
{
JJTreeOptions.setInputFileOption(o, v, o.image,
Boolean.valueOf(v.image));
jjtn000.initialize(o.image, v.image);
}
| v=StringLiteral()
{
String vs = TokenUtils.remove_escapes_and_quotes(v, v.image);
JJTreeOptions.setInputFileOption(o, v, o.image, (Object)vs);
jjtn000.initialize(o.image, vs);
}
) ";"/*@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);
if (jjtree.nodeCreated()) {
jjtreeCloseNodeScope(jjtn000);
}
}
}
/*@egen*/
}
void production() :
{
}
{
LOOKAHEAD(1)
/*
* Since JAVACODE is both a JavaCC reserved word and a Java identifier,
* we need to give preference to "javacode_production" over
* "bnf_production".
*/
javacode_production()
|
LOOKAHEAD(1)
/*
* Since SKIP, TOKEN, etc. are both JavaCC reserved words and Java
* identifiers, we need to give preference to "regular_expression_production"
* over "bnf_production".
*/
regular_expr_production()
|
LOOKAHEAD(1)
/*
* Since TOKEN_MGR_DECLS is both a JavaCC reserved word and a Java identifier,
* we need to give preference to "token_manager_decls" over
* "bnf_production".
*/
token_manager_decls()
|
bnf_production()
}
void javacode_production() :
{/*@bgen(jjtree) Javacode */
ASTJavacode jjtn000 = new ASTJavacode(JJTJAVACODE);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
jjtreeOpenNodeScope(jjtn000);
/*@egen*/
Token t1, t2;
ASTJavacode prod;
ASTNodeDescriptor nd = null;
String n;
}
{/*@bgen(jjtree) Javacode */
try {
/*@egen*/
{
prod = jjtn000;
}
"JAVACODE"
AccessModifier() ResultType() t1=identifier() FormalParameters()
[
"throws" n=Name()
{
prod.throws_list.addElement(n);
}
( "," n=Name()
{
prod.throws_list.addElement(n);
}
)*
]
[ nd=node_descriptor() ]
// This is really a Block()
t2="{"
{
prod.name = t1.image;
prod.stmBeginLoc = t2;
}/*@bgen(jjtree) JavacodeBody */
{
ASTJavacodeBody jjtn001 = new ASTJavacodeBody(JJTJAVACODEBODY);
boolean jjtc001 = true;
jjtree.openNodeScope(jjtn001);
jjtreeOpenNodeScope(jjtn001);
}
try {
/*@egen*/
(
( BlockStatement() )*/*@bgen(jjtree)*/
{
jjtree.closeNodeScope(jjtn001, true);
jjtc001 = false;
if (jjtree.nodeCreated()) {
jjtreeCloseNodeScope(jjtn001);
}
}
/*@egen*/
{
jjtn001.node_scope = new NodeScope(prod, nd);
}
)/*@bgen(jjtree)*/
} catch (Throwable jjte001) {
if (jjtc001) {
jjtree.clearNodeScope(jjtn001);
jjtc001 = false;
} else {
jjtree.popNode();
}
if (jjte001 instanceof RuntimeException) {
throw (RuntimeException)jjte001;
}
if (jjte001 instanceof ParseException) {
throw (ParseException)jjte001;
}
throw (Error)jjte001;
} finally {
if (jjtc001) {
jjtree.closeNodeScope(jjtn001, true);
if (jjtree.nodeCreated()) {
jjtreeCloseNodeScope(jjtn001);
}
}
}
/*@egen*/
"}"/*@bgen(jjtree)*/
{
jjtree.closeNodeScope(jjtn000, true);
jjtc000 = false;
if (jjtree.nodeCreated()) {
jjtreeCloseNodeScope(jjtn000);
}
}
/*@egen*/
{
JJTreeGlobals.productions.put(prod.name, prod);
}/*@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);
if (jjtree.nodeCreated()) {
jjtreeCloseNodeScope(jjtn000);
}
}
}
/*@egen*/
}
void bnf_production() :
{/*@bgen(jjtree) BNF */
ASTBNF jjtn000 = new ASTBNF(JJTBNF);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
jjtreeOpenNodeScope(jjtn000);
/*@egen*/
Token t1, t2;
ASTBNF prod;
ASTNodeDescriptor nd = null;
NodeScope ns;
JJTreeNode eu;
String n;
}
{/*@bgen(jjtree) BNF */
try {
/*@egen*/
{
prod = jjtn000;
}
AccessModifier() ResultType() t1=identifier() FormalParameters()
[
"throws" n=Name()
{
prod.throws_list.addElement(n);
}
( "," n=Name()
{
prod.throws_list.addElement(n);
}
)*
]
[ nd=node_descriptor() ]
":"
// This is really a Block()
t2="{"
{
prod.name = t1.image;
prod.declBeginLoc = t2;
ns = new NodeScope(prod, nd);
}/*@bgen(jjtree) BNFDeclaration */
{
ASTBNFDeclaration jjtn001 = new ASTBNFDeclaration(JJTBNFDECLARATION);
boolean jjtc001 = true;
jjtree.openNodeScope(jjtn001);
jjtreeOpenNodeScope(jjtn001);
}
try {
/*@egen*/
(
( BlockStatement() )*/*@bgen(jjtree)*/
{
jjtree.closeNodeScope(jjtn001, true);
jjtc001 = false;
if (jjtree.nodeCreated()) {
jjtreeCloseNodeScope(jjtn001);
}
}
/*@egen*/
{
jjtn001.node_scope = ns;
}
)/*@bgen(jjtree)*/
} catch (Throwable jjte001) {
if (jjtc001) {
jjtree.clearNodeScope(jjtn001);
jjtc001 = false;
} else {
jjtree.popNode();
}
if (jjte001 instanceof RuntimeException) {
throw (RuntimeException)jjte001;
}
if (jjte001 instanceof ParseException) {
throw (ParseException)jjte001;
}
throw (Error)jjte001;
} finally {
if (jjtc001) {
jjtree.closeNodeScope(jjtn001, true);
if (jjtree.nodeCreated()) {
jjtreeCloseNodeScope(jjtn001);
}
}
}
/*@egen*/
"}"
"{"/*@bgen(jjtree) BNFNodeScope */
{
ASTBNFNodeScope jjtn002 = new ASTBNFNodeScope(JJTBNFNODESCOPE);
boolean jjtc002 = true;
jjtree.openNodeScope(jjtn002);
jjtreeOpenNodeScope(jjtn002);
}
try {
/*@egen*/
(
eu=expansion_choices(prod)/*@bgen(jjtree)*/
{
jjtree.closeNodeScope(jjtn002, true);
jjtc002 = false;
if (jjtree.nodeCreated()) {
jjtreeCloseNodeScope(jjtn002);
}
}
/*@egen*/
{
jjtn002.node_scope = ns;
jjtn002.expansion_unit = eu;
}
)/*@bgen(jjtree)*/
} catch (Throwable jjte002) {
if (jjtc002) {
jjtree.clearNodeScope(jjtn002);
jjtc002 = false;
} else {
jjtree.popNode();
}
if (jjte002 instanceof RuntimeException) {
throw (RuntimeException)jjte002;
}
if (jjte002 instanceof ParseException) {
throw (ParseException)jjte002;
}
throw (Error)jjte002;
} finally {
if (jjtc002) {
jjtree.closeNodeScope(jjtn002, true);
if (jjtree.nodeCreated()) {
jjtreeCloseNodeScope(jjtn002);
}
}
}
/*@egen*/
"}"/*@bgen(jjtree)*/
{
jjtree.closeNodeScope(jjtn000, true);
jjtc000 = false;
if (jjtree.nodeCreated()) {
jjtreeCloseNodeScope(jjtn000);
}
}
/*@egen*/
{
JJTreeGlobals.productions.put(prod.name, prod);
}/*@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);
if (jjtree.nodeCreated()) {
jjtreeCloseNodeScope(jjtn000);
}
}
}
/*@egen*/
}
void AccessModifier() :
{}
{
( "public" | "protected" | "private" )?
}
void regular_expr_production() :
{/*@bgen(jjtree) RE */
ASTRE jjtn000 = new ASTRE(JJTRE);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
jjtreeOpenNodeScope(jjtn000);
/*@egen*/
}
{/*@bgen(jjtree) RE */
try {
/*@egen*/
[
LOOKAHEAD(2) "<" "*" ">"
|
"<" ( "," )* ">"
]
regexpr_kind() [ "[" "IGNORE_CASE" "]" ] ":"
"{" regexpr_spec() ( "|" regexpr_spec() )* "}"/*@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);
if (jjtree.nodeCreated()) {
jjtreeCloseNodeScope(jjtn000);
}
}
}
/*@egen*/
}
void token_manager_decls() :
{/*@bgen(jjtree) TokenDecls */
ASTTokenDecls jjtn000 = new ASTTokenDecls(JJTTOKENDECLS);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
jjtreeOpenNodeScope(jjtn000);
/*@egen*/
}
{/*@bgen(jjtree) TokenDecls */
try {
/*@egen*/
"TOKEN_MGR_DECLS" ":" ClassOrInterfaceBody()/*@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);
if (jjtree.nodeCreated()) {
jjtreeCloseNodeScope(jjtn000);
}
}
}
/*@egen*/
}
void regexpr_kind() :
{
}
{
"TOKEN"
|
"SPECIAL_TOKEN"
|
"SKIP"
|
"MORE"
}
void regexpr_spec() :
{/*@bgen(jjtree) RESpec */
ASTRESpec jjtn000 = new ASTRESpec(JJTRESPEC);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
jjtreeOpenNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) RESpec */
try {
/*@egen*/
regular_expression() [ Block() ] [ ":" ]/*@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);
if (jjtree.nodeCreated()) {
jjtreeCloseNodeScope(jjtn000);
}
}
}
/*@egen*/
}
JJTreeNode expansion_choices(ASTProduction p) :
{/*@bgen(jjtree) #BNFChoice(> 1) */
ASTBNFChoice jjtn000 = new ASTBNFChoice(JJTBNFCHOICE);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
jjtreeOpenNodeScope(jjtn000);
/*@egen*/
}
{/*@bgen(jjtree) #BNFChoice(> 1) */
try {
/*@egen*/
expansion(p) ( "|" expansion(p) )*/*@bgen(jjtree)*/
{
jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
jjtc000 = false;
if (jjtree.nodeCreated()) {
jjtreeCloseNodeScope(jjtn000);
}
}
/*@egen*/
{
return (JJTreeNode)jjtree.peekNode();
}/*@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, jjtree.nodeArity() > 1);
if (jjtree.nodeCreated()) {
jjtreeCloseNodeScope(jjtn000);
}
}
}
/*@egen*/
}
void expansion(ASTProduction p) :
{/*@bgen(jjtree) #BNFSequence(> 1) */
ASTBNFSequence jjtn000 = new ASTBNFSequence(JJTBNFSEQUENCE);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
jjtreeOpenNodeScope(jjtn000);
/*@egen*/
JJTreeNode eu;
ASTNodeDescriptor nd = null;
}
{/*@bgen(jjtree) #BNFSequence(> 1) */
try {
/*@egen*/
(
LOOKAHEAD(1)/*@bgen(jjtree) BNFLookahead */
{
ASTBNFLookahead jjtn001 = new ASTBNFLookahead(JJTBNFLOOKAHEAD);
boolean jjtc001 = true;
jjtree.openNodeScope(jjtn001);
jjtreeOpenNodeScope(jjtn001);
}
try {
/*@egen*/
( "LOOKAHEAD" "(" local_lookahead(p) ")" )/*@bgen(jjtree)*/
} catch (Throwable jjte001) {
if (jjtc001) {
jjtree.clearNodeScope(jjtn001);
jjtc001 = false;
} else {
jjtree.popNode();
}
if (jjte001 instanceof RuntimeException) {
throw (RuntimeException)jjte001;
}
if (jjte001 instanceof ParseException) {
throw (ParseException)jjte001;
}
throw (Error)jjte001;
} finally {
if (jjtc001) {
jjtree.closeNodeScope(jjtn001, true);
if (jjtree.nodeCreated()) {
jjtreeCloseNodeScope(jjtn001);
}
}
}
/*@egen*/
)?
(
LOOKAHEAD(0, { notTailOfExpansionUnit() } )/*@bgen(jjtree) #ExpansionNodeScope(> 1) */
{
ASTExpansionNodeScope jjtn002 = new ASTExpansionNodeScope(JJTEXPANSIONNODESCOPE);
boolean jjtc002 = true;
jjtree.openNodeScope(jjtn002);
jjtreeOpenNodeScope(jjtn002);
}
try {
/*@egen*/
(
eu=expansion_unit(p)
[ nd=node_descriptor() ]/*@bgen(jjtree)*/
{
jjtree.closeNodeScope(jjtn002, jjtree.nodeArity() > 1);
jjtc002 = false;
if (jjtree.nodeCreated()) {
jjtreeCloseNodeScope(jjtn002);
}
}
/*@egen*/
{
if (jjtree.nodeCreated()) {
jjtn002.node_scope = new NodeScope(p, nd);
jjtn002.expansion_unit = eu;
}
}
)/*@bgen(jjtree)*/
} catch (Throwable jjte002) {
if (jjtc002) {
jjtree.clearNodeScope(jjtn002);
jjtc002 = false;
} else {
jjtree.popNode();
}
if (jjte002 instanceof RuntimeException) {
throw (RuntimeException)jjte002;
}
if (jjte002 instanceof ParseException) {
throw (ParseException)jjte002;
}
throw (Error)jjte002;
} finally {
if (jjtc002) {
jjtree.closeNodeScope(jjtn002, jjtree.nodeArity() > 1);
if (jjtree.nodeCreated()) {
jjtreeCloseNodeScope(jjtn002);
}
}
}
/*@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, jjtree.nodeArity() > 1);
if (jjtree.nodeCreated()) {
jjtreeCloseNodeScope(jjtn000);
}
}
}
/*@egen*/
}
void local_lookahead(ASTProduction p) :
{
boolean commaAtEnd = false, emptyLA = true;
}
{
[
/*
* The lookahead of 1 is to turn off the warning message that lets
* us know that an expansion choice can also start with an integer
* literal because a primary expression can do the same. But we
* know that this is what we want.
*/
LOOKAHEAD(1)
IntegerLiteral()
{
emptyLA = false;
}
]
[ LOOKAHEAD(0, { !emptyLA && (getToken(1).kind != RPAREN) } )
","
{
commaAtEnd = true;
}
]
[ LOOKAHEAD(0, { getToken(1).kind != RPAREN && getToken(1).kind != LBRACE } )
expansion_choices(p)
{
emptyLA = false; commaAtEnd = false;
}
]
[ LOOKAHEAD(0, { !emptyLA && !commaAtEnd && (getToken(1).kind != RPAREN) } )
","
{
commaAtEnd = true;
}
]
[ LOOKAHEAD(0, { emptyLA || commaAtEnd } )
"{" Expression() "}"
]
}
JJTreeNode expansion_unit(ASTProduction p) :
{
Token t;
}
{
(
LOOKAHEAD(1)/*@bgen(jjtree) BNFLookahead */
{
ASTBNFLookahead jjtn001 = new ASTBNFLookahead(JJTBNFLOOKAHEAD);
boolean jjtc001 = true;
jjtree.openNodeScope(jjtn001);
jjtreeOpenNodeScope(jjtn001);
}
try {
/*@egen*/
/*
* We give this priority over primary expressions which use LOOKAHEAD as the
* name of its identifier.
*/
(
"LOOKAHEAD" "(" local_lookahead(p) ")"
)/*@bgen(jjtree)*/
} catch (Throwable jjte001) {
if (jjtc001) {
jjtree.clearNodeScope(jjtn001);
jjtc001 = false;
} else {
jjtree.popNode();
}
if (jjte001 instanceof RuntimeException) {
throw (RuntimeException)jjte001;
}
if (jjte001 instanceof ParseException) {
throw (ParseException)jjte001;
}
throw (Error)jjte001;
} finally {
if (jjtc001) {
jjtree.closeNodeScope(jjtn001, true);
if (jjtree.nodeCreated()) {
jjtreeCloseNodeScope(jjtn001);
}
}
}
/*@egen*/
|/*@bgen(jjtree) BNFAction */
{
ASTBNFAction jjtn002 = new ASTBNFAction(JJTBNFACTION);
boolean jjtc002 = true;
jjtree.openNodeScope(jjtn002);
jjtreeOpenNodeScope(jjtn002);
}
try {
/*@egen*/
Block()/*@bgen(jjtree)*/
} catch (Throwable jjte002) {
if (jjtc002) {
jjtree.clearNodeScope(jjtn002);
jjtc002 = false;
} else {
jjtree.popNode();
}
if (jjte002 instanceof RuntimeException) {
throw (RuntimeException)jjte002;
}
if (jjte002 instanceof ParseException) {
throw (ParseException)jjte002;
}
throw (Error)jjte002;
} finally {
if (jjtc002) {
jjtree.closeNodeScope(jjtn002, true);
if (jjtree.nodeCreated()) {
jjtreeCloseNodeScope(jjtn002);
}
}
}
/*@egen*/
|/*@bgen(jjtree) BNFZeroOrOne */
{
ASTBNFZeroOrOne jjtn003 = new ASTBNFZeroOrOne(JJTBNFZEROORONE);
boolean jjtc003 = true;
jjtree.openNodeScope(jjtn003);
jjtreeOpenNodeScope(jjtn003);
}
try {
/*@egen*/
(
"[" expansion_choices(p) "]"
)/*@bgen(jjtree)*/
} catch (Throwable jjte003) {
if (jjtc003) {
jjtree.clearNodeScope(jjtn003);
jjtc003 = false;
} else {
jjtree.popNode();
}
if (jjte003 instanceof RuntimeException) {
throw (RuntimeException)jjte003;
}
if (jjte003 instanceof ParseException) {
throw (ParseException)jjte003;
}
throw (Error)jjte003;
} finally {
if (jjtc003) {
jjtree.closeNodeScope(jjtn003, true);
if (jjtree.nodeCreated()) {
jjtreeCloseNodeScope(jjtn003);
}
}
}
/*@egen*/
|/*@bgen(jjtree) BNFTryBlock */
{
ASTBNFTryBlock jjtn004 = new ASTBNFTryBlock(JJTBNFTRYBLOCK);
boolean jjtc004 = true;
jjtree.openNodeScope(jjtn004);
jjtreeOpenNodeScope(jjtn004);
}
try {
/*@egen*/
(
"try" "{" expansion_choices(p) "}"
( "catch" "(" Name() ")" Block() )*
[ "finally" Block() ]
)/*@bgen(jjtree)*/
} catch (Throwable jjte004) {
if (jjtc004) {
jjtree.clearNodeScope(jjtn004);
jjtc004 = false;
} else {
jjtree.popNode();
}
if (jjte004 instanceof RuntimeException) {
throw (RuntimeException)jjte004;
}
if (jjte004 instanceof ParseException) {
throw (ParseException)jjte004;
}
throw (Error)jjte004;
} finally {
if (jjtc004) {
jjtree.closeNodeScope(jjtn004, true);
if (jjtree.nodeCreated()) {
jjtreeCloseNodeScope(jjtn004);
}
}
}
/*@egen*/
|
LOOKAHEAD( identifier() | StringLiteral() | "<" | PrimaryExpression() "=" )/*@bgen(jjtree) #BNFAssignment(> 1) */
{
ASTBNFAssignment jjtn006 = new ASTBNFAssignment(JJTBNFASSIGNMENT);
boolean jjtc006 = true;
jjtree.openNodeScope(jjtn006);
jjtreeOpenNodeScope(jjtn006);
}
try {
/*@egen*/
(
[
LOOKAHEAD(PrimaryExpression() "=")
PrimaryExpression() "="
]
(
regular_expression() [ "." t= ]
|/*@bgen(jjtree) BNFNonTerminal */
{
ASTBNFNonTerminal jjtn005 = new ASTBNFNonTerminal(JJTBNFNONTERMINAL);
boolean jjtc005 = true;
jjtree.openNodeScope(jjtn005);
jjtreeOpenNodeScope(jjtn005);
}
try {
/*@egen*/ ( identifier() Arguments() )/*@bgen(jjtree)*/
} catch (Throwable jjte005) {
if (jjtc005) {
jjtree.clearNodeScope(jjtn005);
jjtc005 = false;
} else {
jjtree.popNode();
}
if (jjte005 instanceof RuntimeException) {
throw (RuntimeException)jjte005;
}
if (jjte005 instanceof ParseException) {
throw (ParseException)jjte005;
}
throw (Error)jjte005;
} finally {
if (jjtc005) {
jjtree.closeNodeScope(jjtn005, true);
if (jjtree.nodeCreated()) {
jjtreeCloseNodeScope(jjtn005);
}
}
}
/*@egen*/
)
)/*@bgen(jjtree)*/
} catch (Throwable jjte006) {
if (jjtc006) {
jjtree.clearNodeScope(jjtn006);
jjtc006 = false;
} else {
jjtree.popNode();
}
if (jjte006 instanceof RuntimeException) {
throw (RuntimeException)jjte006;
}
if (jjte006 instanceof ParseException) {
throw (ParseException)jjte006;
}
throw (Error)jjte006;
} finally {
if (jjtc006) {
jjtree.closeNodeScope(jjtn006, jjtree.nodeArity() > 1);
if (jjtree.nodeCreated()) {
jjtreeCloseNodeScope(jjtn006);
}
}
}
/*@egen*/
|
t="(" expansion_choices(p) ")"
(/*@bgen(jjtree) #BNFOneOrMore( 1) */
{
ASTBNFOneOrMore jjtn007 = new ASTBNFOneOrMore(JJTBNFONEORMORE);
boolean jjtc007 = true;
jjtree.openNodeScope(jjtn007);
jjtreeOpenNodeScope(jjtn007);
}
try {
/*@egen*/
"+"/*@bgen(jjtree)*/
} finally {
if (jjtc007) {
jjtree.closeNodeScope(jjtn007, 1);
if (jjtree.nodeCreated()) {
jjtreeCloseNodeScope(jjtn007);
}
}
}
/*@egen*/
|/*@bgen(jjtree) #BNFZeroOrMore( 1) */
{
ASTBNFZeroOrMore jjtn008 = new ASTBNFZeroOrMore(JJTBNFZEROORMORE);
boolean jjtc008 = true;
jjtree.openNodeScope(jjtn008);
jjtreeOpenNodeScope(jjtn008);
}
try {
/*@egen*/
"*"/*@bgen(jjtree)*/
} finally {
if (jjtc008) {
jjtree.closeNodeScope(jjtn008, 1);
if (jjtree.nodeCreated()) {
jjtreeCloseNodeScope(jjtn008);
}
}
}
/*@egen*/
|/*@bgen(jjtree) #BNFZeroOrOne( 1) */
{
ASTBNFZeroOrOne jjtn009 = new ASTBNFZeroOrOne(JJTBNFZEROORONE);
boolean jjtc009 = true;
jjtree.openNodeScope(jjtn009);
jjtreeOpenNodeScope(jjtn009);
}
try {
/*@egen*/
"?"/*@bgen(jjtree)*/
} finally {
if (jjtc009) {
jjtree.closeNodeScope(jjtn009, 1);
if (jjtree.nodeCreated()) {
jjtreeCloseNodeScope(jjtn009);
}
}
}
/*@egen*/
|/*@bgen(jjtree) #BNFParenthesized( 1) */
{
ASTBNFParenthesized jjtn010 = new ASTBNFParenthesized(JJTBNFPARENTHESIZED);
boolean jjtc010 = true;
jjtree.openNodeScope(jjtn010);
jjtreeOpenNodeScope(jjtn010);
}
try {
/*@egen*//*@bgen(jjtree)*/
{
jjtree.closeNodeScope(jjtn010, 1);
jjtc010 = false;
if (jjtree.nodeCreated()) {
jjtreeCloseNodeScope(jjtn010);
}
}
/*@egen*/
{}/*@bgen(jjtree)*/
} finally {
if (jjtc010) {
jjtree.closeNodeScope(jjtn010, 1);
if (jjtree.nodeCreated()) {
jjtreeCloseNodeScope(jjtn010);
}
}
}
/*@egen*/
)
{
((JJTreeNode)jjtree.peekNode()).setFirstToken(t);
}
)
{
return (JJTreeNode)jjtree.peekNode();
}
}
void regular_expression() :
{
}
{/*@bgen(jjtree) REStringLiteral */
{
ASTREStringLiteral jjtn001 = new ASTREStringLiteral(JJTRESTRINGLITERAL);
boolean jjtc001 = true;
jjtree.openNodeScope(jjtn001);
jjtreeOpenNodeScope(jjtn001);
}
try {
/*@egen*/
StringLiteral()/*@bgen(jjtree)*/
} catch (Throwable jjte001) {
if (jjtc001) {
jjtree.clearNodeScope(jjtn001);
jjtc001 = false;
} else {
jjtree.popNode();
}
if (jjte001 instanceof RuntimeException) {
throw (RuntimeException)jjte001;
}
if (jjte001 instanceof ParseException) {
throw (ParseException)jjte001;
}
throw (Error)jjte001;
} finally {
if (jjtc001) {
jjtree.closeNodeScope(jjtn001, true);
if (jjtree.nodeCreated()) {
jjtreeCloseNodeScope(jjtn001);
}
}
}
/*@egen*/
|
LOOKAHEAD(3)/*@bgen(jjtree) RENamed */
{
ASTRENamed jjtn002 = new ASTRENamed(JJTRENAMED);
boolean jjtc002 = true;
jjtree.openNodeScope(jjtn002);
jjtreeOpenNodeScope(jjtn002);
}
try {
/*@egen*/
(
"<" [ [ "#" ] identifier() ":" ] complex_regular_expression_choices() ">"
)/*@bgen(jjtree)*/
} catch (Throwable jjte002) {
if (jjtc002) {
jjtree.clearNodeScope(jjtn002);
jjtc002 = false;
} else {
jjtree.popNode();
}
if (jjte002 instanceof RuntimeException) {
throw (RuntimeException)jjte002;
}
if (jjte002 instanceof ParseException) {
throw (ParseException)jjte002;
}
throw (Error)jjte002;
} finally {
if (jjtc002) {
jjtree.closeNodeScope(jjtn002, true);
if (jjtree.nodeCreated()) {
jjtreeCloseNodeScope(jjtn002);
}
}
}
/*@egen*/
|
LOOKAHEAD(2)/*@bgen(jjtree) REReference */
{
ASTREReference jjtn003 = new ASTREReference(JJTREREFERENCE);
boolean jjtc003 = true;
jjtree.openNodeScope(jjtn003);
jjtreeOpenNodeScope(jjtn003);
}
try {
/*@egen*/
(
"<" identifier() ">"
)/*@bgen(jjtree)*/
} catch (Throwable jjte003) {
if (jjtc003) {
jjtree.clearNodeScope(jjtn003);
jjtc003 = false;
} else {
jjtree.popNode();
}
if (jjte003 instanceof RuntimeException) {
throw (RuntimeException)jjte003;
}
if (jjte003 instanceof ParseException) {
throw (ParseException)jjte003;
}
throw (Error)jjte003;
} finally {
if (jjtc003) {
jjtree.closeNodeScope(jjtn003, true);
if (jjtree.nodeCreated()) {
jjtreeCloseNodeScope(jjtn003);
}
}
}
/*@egen*/
|/*@bgen(jjtree) REEOF */
{
ASTREEOF jjtn004 = new ASTREEOF(JJTREEOF);
boolean jjtc004 = true;
jjtree.openNodeScope(jjtn004);
jjtreeOpenNodeScope(jjtn004);
}
try {
/*@egen*/
(
"<" "EOF" ">"
)/*@bgen(jjtree)*/
} finally {
if (jjtc004) {
jjtree.closeNodeScope(jjtn004, true);
if (jjtree.nodeCreated()) {
jjtreeCloseNodeScope(jjtn004);
}
}
}
/*@egen*/
}
void complex_regular_expression_choices() :
{/*@bgen(jjtree) #REChoice(> 1) */
ASTREChoice jjtn000 = new ASTREChoice(JJTRECHOICE);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
jjtreeOpenNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) #REChoice(> 1) */
try {
/*@egen*/
complex_regular_expression() ( "|" complex_regular_expression() )*/*@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, jjtree.nodeArity() > 1);
if (jjtree.nodeCreated()) {
jjtreeCloseNodeScope(jjtn000);
}
}
}
/*@egen*/
}
void complex_regular_expression() :
{/*@bgen(jjtree) #RESequence(> 1) */
ASTRESequence jjtn000 = new ASTRESequence(JJTRESEQUENCE);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
jjtreeOpenNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) #RESequence(> 1) */
try {
/*@egen*/
( complex_regular_expression_unit() )+/*@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, jjtree.nodeArity() > 1);
if (jjtree.nodeCreated()) {
jjtreeCloseNodeScope(jjtn000);
}
}
}
/*@egen*/
}
void complex_regular_expression_unit() :
{
Token t;
}
{/*@bgen(jjtree) REStringLiteral */
{
ASTREStringLiteral jjtn001 = new ASTREStringLiteral(JJTRESTRINGLITERAL);
boolean jjtc001 = true;
jjtree.openNodeScope(jjtn001);
jjtreeOpenNodeScope(jjtn001);
}
try {
/*@egen*/
StringLiteral()/*@bgen(jjtree)*/
} catch (Throwable jjte001) {
if (jjtc001) {
jjtree.clearNodeScope(jjtn001);
jjtc001 = false;
} else {
jjtree.popNode();
}
if (jjte001 instanceof RuntimeException) {
throw (RuntimeException)jjte001;
}
if (jjte001 instanceof ParseException) {
throw (ParseException)jjte001;
}
throw (Error)jjte001;
} finally {
if (jjtc001) {
jjtree.closeNodeScope(jjtn001, true);
if (jjtree.nodeCreated()) {
jjtreeCloseNodeScope(jjtn001);
}
}
}
/*@egen*/
|/*@bgen(jjtree) REReference */
{
ASTREReference jjtn002 = new ASTREReference(JJTREREFERENCE);
boolean jjtc002 = true;
jjtree.openNodeScope(jjtn002);
jjtreeOpenNodeScope(jjtn002);
}
try {
/*@egen*/
( "<" identifier() ">" )/*@bgen(jjtree)*/
} catch (Throwable jjte002) {
if (jjtc002) {
jjtree.clearNodeScope(jjtn002);
jjtc002 = false;
} else {
jjtree.popNode();
}
if (jjte002 instanceof RuntimeException) {
throw (RuntimeException)jjte002;
}
if (jjte002 instanceof ParseException) {
throw (ParseException)jjte002;
}
throw (Error)jjte002;
} finally {
if (jjtc002) {
jjtree.closeNodeScope(jjtn002, true);
if (jjtree.nodeCreated()) {
jjtreeCloseNodeScope(jjtn002);
}
}
}
/*@egen*/
|
character_list()
|
t="(" complex_regular_expression_choices() ")"
(/*@bgen(jjtree) #REOneOrMore( 1) */
{
ASTREOneOrMore jjtn003 = new ASTREOneOrMore(JJTREONEORMORE);
boolean jjtc003 = true;
jjtree.openNodeScope(jjtn003);
jjtreeOpenNodeScope(jjtn003);
}
try {
/*@egen*/
"+"/*@bgen(jjtree)*/
} finally {
if (jjtc003) {
jjtree.closeNodeScope(jjtn003, 1);
if (jjtree.nodeCreated()) {
jjtreeCloseNodeScope(jjtn003);
}
}
}
/*@egen*/
|/*@bgen(jjtree) #REZeroOrMore( 1) */
{
ASTREZeroOrMore jjtn004 = new ASTREZeroOrMore(JJTREZEROORMORE);
boolean jjtc004 = true;
jjtree.openNodeScope(jjtn004);
jjtreeOpenNodeScope(jjtn004);
}
try {
/*@egen*/
"*"/*@bgen(jjtree)*/
} finally {
if (jjtc004) {
jjtree.closeNodeScope(jjtn004, 1);
if (jjtree.nodeCreated()) {
jjtreeCloseNodeScope(jjtn004);
}
}
}
/*@egen*/
|/*@bgen(jjtree) #REZeroOrOne( 1) */
{
ASTREZeroOrOne jjtn005 = new ASTREZeroOrOne(JJTREZEROORONE);
boolean jjtc005 = true;
jjtree.openNodeScope(jjtn005);
jjtreeOpenNodeScope(jjtn005);
}
try {
/*@egen*/
"?"/*@bgen(jjtree)*/
} finally {
if (jjtc005) {
jjtree.closeNodeScope(jjtn005, 1);
if (jjtree.nodeCreated()) {
jjtreeCloseNodeScope(jjtn005);
}
}
}
/*@egen*/
| "{" IntegerLiteral() [ "," [ IntegerLiteral() ] ]/*@bgen(jjtree) #RRepetitionRange( 1) */
{
ASTRRepetitionRange jjtn006 = new ASTRRepetitionRange(JJTRREPETITIONRANGE);
boolean jjtc006 = true;
jjtree.openNodeScope(jjtn006);
jjtreeOpenNodeScope(jjtn006);
}
try {
/*@egen*/ "}"/*@bgen(jjtree)*/
} finally {
if (jjtc006) {
jjtree.closeNodeScope(jjtn006, 1);
if (jjtree.nodeCreated()) {
jjtreeCloseNodeScope(jjtn006);
}
}
}
/*@egen*/
|/*@bgen(jjtree) #REParenthesized( 1) */
{
ASTREParenthesized jjtn007 = new ASTREParenthesized(JJTREPARENTHESIZED);
boolean jjtc007 = true;
jjtree.openNodeScope(jjtn007);
jjtreeOpenNodeScope(jjtn007);
}
try {
/*@egen*//*@bgen(jjtree)*/
{
jjtree.closeNodeScope(jjtn007, 1);
jjtc007 = false;
if (jjtree.nodeCreated()) {
jjtreeCloseNodeScope(jjtn007);
}
}
/*@egen*/
{}/*@bgen(jjtree)*/
} finally {
if (jjtc007) {
jjtree.closeNodeScope(jjtn007, 1);
if (jjtree.nodeCreated()) {
jjtreeCloseNodeScope(jjtn007);
}
}
}
/*@egen*/
)
{
((JJTreeNode)jjtree.peekNode()).setFirstToken(t);
}
}
void character_list() :
{/*@bgen(jjtree) RECharList */
ASTRECharList jjtn000 = new ASTRECharList(JJTRECHARLIST);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
jjtreeOpenNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) RECharList */
try {
/*@egen*/
[ "~" ] "[" [ character_descriptor() ( "," character_descriptor() )* ] "]"/*@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);
if (jjtree.nodeCreated()) {
jjtreeCloseNodeScope(jjtn000);
}
}
}
/*@egen*/
}
void character_descriptor() :
{/*@bgen(jjtree) CharDescriptor */
ASTCharDescriptor jjtn000 = new ASTCharDescriptor(JJTCHARDESCRIPTOR);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
jjtreeOpenNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) CharDescriptor */
try {
/*@egen*/
StringLiteral() [ "-" StringLiteral() ]/*@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);
if (jjtree.nodeCreated()) {
jjtreeCloseNodeScope(jjtn000);
}
}
}
/*@egen*/
}
Token identifier() :
{
Token t;
}
{
t=
{
return t;
}
}
/**********************************************
* THE JJTREE PRODUCTIONS START HERE *
**********************************************/
ASTNodeDescriptor node_descriptor() :
{/*@bgen(jjtree) NodeDescriptor */
ASTNodeDescriptor jjtn000 = new ASTNodeDescriptor(JJTNODEDESCRIPTOR);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
jjtreeOpenNodeScope(jjtn000);
/*@egen*/
Token t = null;
String s = null;
}
{/*@bgen(jjtree) NodeDescriptor */
try {
/*@egen*/
"#"
(
s=Name()
{
jjtn000.name = s;
}
| t=
{
jjtn000.name = t.image;
}
)
[
LOOKAHEAD(1)
"("
[ ">"
{
jjtn000.isGT = true;
}
]
node_descriptor_expression()
{
jjtn000.expression =
(ASTNodeDescriptorExpression)jjtree.peekNode();
}
")"
]/*@bgen(jjtree)*/
{
jjtree.closeNodeScope(jjtn000, true);
jjtc000 = false;
if (jjtree.nodeCreated()) {
jjtreeCloseNodeScope(jjtn000);
}
}
/*@egen*/
{
jjtn000.setNodeIdValue();
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);
if (jjtree.nodeCreated()) {
jjtreeCloseNodeScope(jjtn000);
}
}
}
/*@egen*/
}
JAVACODE
void node_descriptor_expression()
{/*@bgen(jjtree) NodeDescriptorExpression */
ASTNodeDescriptorExpression jjtn000 = new ASTNodeDescriptorExpression(JJTNODEDESCRIPTOREXPRESSION);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
jjtreeOpenNodeScope(jjtn000);
try {
/*@egen*/
Token tok;
int nesting = 1;
while (true) {
tok = getToken(1);
if (tok.kind == 0) {
throw new ParseException();
}
if (tok.kind == LPAREN) nesting++;
if (tok.kind == RPAREN) {
nesting--;
if (nesting == 0) break;
}
tok = getNextToken();
}/*@bgen(jjtree)*/
} finally {
if (jjtc000) {
jjtree.closeNodeScope(jjtn000, true);
if (jjtree.nodeCreated()) {
jjtreeCloseNodeScope(jjtn000);
}
}
}
/*@egen*/
}
/**********************************************
* THE JAVA GRAMMAR SPECIFICATION STARTS HERE *
**********************************************/
/*
* The Java grammar is modified to use sequences of tokens
* for the missing tokens - those that include "<<" and ">>".
*/
/*
* The following production defines Java identifiers - it
* includes the reserved words of JavaCC also.
*/
String JavaIdentifier() :
{}
{
(
| "LOOKAHEAD"
| "IGNORE_CASE"
| "PARSER_BEGIN"
| "PARSER_END"
| "JAVACODE"
| "TOKEN"
| "SPECIAL_TOKEN"
| "MORE"
| "SKIP"
| "TOKEN_MGR_DECLS"
| "EOF"
)
{
return token.image;
}
}
/*
* Program structuring syntax follows.
*/
void CompilationUnit() :
{}
{
[ LOOKAHEAD( ( Annotation() )* "package" ) PackageDeclaration() ]
{ JJTreeGlobals.parserImports = getToken(1); }
( ImportDeclaration() )*
( TypeDeclaration() )*
}
void PackageDeclaration() :
{
String s;
}
{
Modifiers() "package" s=Name() ";"
{
JJTreeGlobals.packageName = s;
}
}
void ImportDeclaration() :
{}
{
"import" [ "static" ] Name() [ "." "*" ] ";"
}
/*
* Modifiers. We match all modifiers in a single rule to reduce the chances of
* syntax errors for simple modifier mistakes. It will also enable us to give
* better error messages.
*/
void Modifiers():
{}
{
(
LOOKAHEAD(2)
(
"public"
|
"static"
|
"protected"
|
"private"
|
"final"
|
"abstract"
|
"synchronized"
|
"native"
|
"transient"
|
"volatile"
|
"strictfp"
|
Annotation()
)
)*
}
/*
* Declaration syntax follows.
*/
void TypeDeclaration():
{
;
}
{
";"
|
Modifiers()
(
ClassOrInterfaceDeclaration()
|
EnumDeclaration()
|
AnnotationTypeDeclaration()
)
}
void ClassOrInterfaceDeclaration():
{
Token t = null;
String s;
}
{
( "class" | "interface" )
s=JavaIdentifier()
[ TypeParameters() ]
[ ExtendsList() ]
[ { t = getToken(1); } ImplementsList() ]
{
if (s.equals(JJTreeGlobals.parserName)) {
if (t != null) {
JJTreeGlobals.parserImplements = t;
} else {
JJTreeGlobals.parserImplements = getToken(1);
}
JJTreeGlobals.parserClassBodyStart = getToken(1);
}
}
ClassOrInterfaceBody()
}
void ExtendsList():
{}
{
"extends" ClassOrInterfaceType()
( "," ClassOrInterfaceType() )*
}
void ImplementsList():
{}
{
"implements" ClassOrInterfaceType()
( "," ClassOrInterfaceType() )*
}
void EnumDeclaration():
{}
{
"enum" JavaIdentifier()
[ ImplementsList() ]
EnumBody()
}
void EnumBody():
{}
{
"{"
[ EnumConstant() ( LOOKAHEAD(2) "," EnumConstant() )* ]
[ "," ]
[ ";" ( ClassOrInterfaceBodyDeclaration() )* ]
"}"
}
void EnumConstant():
{}
{
Modifiers() JavaIdentifier() [ Arguments() ] [ ClassOrInterfaceBody() ]
}
void TypeParameters():
{}
{
"<" TypeParameter() ( "," TypeParameter() )* ">"
}
void TypeParameter():
{}
{
JavaIdentifier() [ TypeBound() ]
}
void TypeBound():
{}
{
"extends" ClassOrInterfaceType() ( "&" ClassOrInterfaceType() )*
}
void ClassOrInterfaceBody():
/*
* Parsing this fills "tokens" with all tokens of the block
* excluding the braces at each end.
*/
{}
{
"{"
( ClassOrInterfaceBodyDeclaration() )*
"}"
}
void ClassOrInterfaceBodyDeclaration():
{}
{
LOOKAHEAD(2)
Initializer()
|
Modifiers() // Just get all the modifiers out of the way. If you want to do
// more checks, pass the modifiers down to the member
(
ClassOrInterfaceDeclaration()
|
EnumDeclaration()
|
LOOKAHEAD( [ TypeParameters() ] JavaIdentifier() "(" )
ConstructorDeclaration()
|
LOOKAHEAD( Type() JavaIdentifier() ( "[" "]" )* ( "," | "=" | ";" ) )
FieldDeclaration()
|
MethodDeclaration()
)
|
";"
}
void FieldDeclaration():
{}
{
// Modifiers are already matched in the caller
Type() VariableDeclarator() ( "," VariableDeclarator() )* ";"
}
void VariableDeclarator():
{}
{
VariableDeclaratorId() [ "=" VariableInitializer() ]
}
void VariableDeclaratorId():
{}
{
JavaIdentifier() ( "[" "]" )*
}
void VariableInitializer():
{}
{
ArrayInitializer()
|
Expression()
}
void ArrayInitializer():
{}
{
"{" [ VariableInitializer() ( LOOKAHEAD(2) "," VariableInitializer() )* ] [ "," ] "}"
}
void MethodDeclaration():
{}
{
// Modifiers already matched in the caller!
[ TypeParameters() ]
ResultType()
MethodDeclarator() [ "throws" NameList() ]
( Block() | ";" )
}
void MethodDeclarator():
{}
{
JavaIdentifier() FormalParameters() ( "[" "]" )*
}
void FormalParameters() :
/*
* Parsing this fills "tokens" with all tokens of the formal
* parameters excluding the parentheses at each end.
*/
{}
{
"("
[ FormalParameter() ( "," FormalParameter() )* ]
")"
}
void FormalParameter():
{}
{
Modifiers() Type() [ "..." ] VariableDeclaratorId()
}
void ConstructorDeclaration():
{}
{
[ TypeParameters() ]
// Modifiers matched in the caller
JavaIdentifier() LOOKAHEAD(1) FormalParameters() [ "throws" NameList() ]
"{"
[ LOOKAHEAD(ExplicitConstructorInvocation()) ExplicitConstructorInvocation() ]
( BlockStatement() )*
"}"
}
void ExplicitConstructorInvocation():
{}
{
LOOKAHEAD("this" Arguments() ";")
"this" Arguments() ";"
|
[ LOOKAHEAD(2) PrimaryExpression() "." ] "super" Arguments() ";"
}
void Initializer():
{}
{
[ "static" ] Block()
}
/*
* Type, name and expression syntax follows.
*/
void Type():
{}
{
LOOKAHEAD(2) ReferenceType()
|
PrimitiveType()
}
void ReferenceType():
{}
{
PrimitiveType() ( LOOKAHEAD(2) "[" "]" )+
|
( ClassOrInterfaceType() ) ( LOOKAHEAD(2) "[" "]" )*
}
void ClassOrInterfaceType():
{}
{
JavaIdentifier() [ LOOKAHEAD(2) TypeArguments() ]
( LOOKAHEAD(2) "." JavaIdentifier() [ LOOKAHEAD(2) TypeArguments() ] )*
}
void TypeArguments():
{}
{
"<" TypeArgument() ( "," TypeArgument() )* ">"
}
void TypeArgument():
{}
{
ReferenceType()
|
"?" [ WildcardBounds() ]
}
void WildcardBounds():
{}
{
"extends" ReferenceType()
|
"super" ReferenceType()
}
void PrimitiveType():
{}
{
"boolean"
|
"char"
|
"byte"
|
"short"
|
"int"
|
"long"
|
"float"
|
"double"
}
void ResultType() :
{}
{
(
"void"
|
Type()
)
}
String Name() :
/*
* A lookahead of 2 is required below since "Name" can be followed
* by a ".*" when used in the context of an "ImportDeclaration".
*/
{
String s, ss;
}
{
s=JavaIdentifier()
( LOOKAHEAD(2) "." ss=JavaIdentifier() { s += "." + ss; } )*
{
return s;
}
}
void NameList():
{}
{
Name() ( "," Name() )*
}
/*
* Expression syntax follows.
*/
void Expression() :
/*
* This expansion has been written this way instead of:
* Assignment() | ConditionalExpression()
* for performance reasons.
* However, it is a weakening of the grammar for it allows the LHS of
* assignments to be any conditional expression whereas it can only be
* a primary expression. Consider adding a semantic predicate to work
* around this.
*/
{}
{
ConditionalExpression()
[
LOOKAHEAD(2)
AssignmentOperator() Expression()
]
}
void AssignmentOperator():
{}
{
"=" | "*=" | "/=" | "%=" | "+=" | "-=" | "<<=" | ">>=" | ">>>=" | "&=" | "^=" | "|="
}
void ConditionalExpression():
{}
{
ConditionalOrExpression() [ "?" Expression() ":" Expression() ]
}
void ConditionalOrExpression():
{}
{
ConditionalAndExpression() ( "||" ConditionalAndExpression() )*
}
void ConditionalAndExpression():
{}
{
InclusiveOrExpression() ( "&&" InclusiveOrExpression() )*
}
void InclusiveOrExpression():
{}
{
ExclusiveOrExpression() ( "|" ExclusiveOrExpression() )*
}
void ExclusiveOrExpression():
{}
{
AndExpression() ( "^" AndExpression() )*
}
void AndExpression():
{}
{
EqualityExpression() ( "&" EqualityExpression() )*
}
void EqualityExpression():
{}
{
InstanceOfExpression() ( ( "==" | "!=" ) InstanceOfExpression() )*
}
void InstanceOfExpression():
{}
{
RelationalExpression() [ "instanceof" Type() ]
}
void RelationalExpression():
{}
{
ShiftExpression() ( ( "<" | ">" | "<=" | ">=" ) ShiftExpression() )*
}
void ShiftExpression():
{}
{
AdditiveExpression() ( ( "<<" | RSIGNEDSHIFT() | RUNSIGNEDSHIFT() ) AdditiveExpression() )*
}
void AdditiveExpression():
{}
{
MultiplicativeExpression() ( ( "+" | "-" ) MultiplicativeExpression() )*
}
void MultiplicativeExpression():
{}
{
UnaryExpression() ( ( "*" | "/" | "%" ) UnaryExpression() )*
}
void UnaryExpression():
{}
{
( "+" | "-" ) UnaryExpression()
|
PreIncrementExpression()
|
PreDecrementExpression()
|
UnaryExpressionNotPlusMinus()
}
void PreIncrementExpression():
{}
{
"++" PrimaryExpression()
}
void PreDecrementExpression():
{}
{
"--" PrimaryExpression()
}
void UnaryExpressionNotPlusMinus():
{}
{
( "~" | "!" ) UnaryExpression()
|
LOOKAHEAD( CastLookahead() )
CastExpression()
|
PostfixExpression()
}
// This production is to determine lookahead only. The LOOKAHEAD specifications
// below are not used, but they are there just to indicate that we know about
// this.
void CastLookahead():
{}
{
LOOKAHEAD(2)
"(" PrimitiveType()
|
LOOKAHEAD("(" Type() "[")
"(" Type() "[" "]"
|
"(" Type() ")" ( "~" | "!" | "(" | JavaIdentifier() | "this" | "super" | "new" | Literal() )
}
void PostfixExpression():
{}
{
PrimaryExpression() [ "++" | "--" ]
}
void CastExpression():
{}
{
LOOKAHEAD("(" PrimitiveType())
"(" Type() ")" UnaryExpression()
|
"(" Type() ")" UnaryExpressionNotPlusMinus()
}
void PrimaryExpression() :
{/*@bgen(jjtree) PrimaryExpression */
ASTPrimaryExpression jjtn000 = new ASTPrimaryExpression(JJTPRIMARYEXPRESSION);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
jjtreeOpenNodeScope(jjtn000);
/*@egen*/}
{/*@bgen(jjtree) PrimaryExpression */
try {
/*@egen*/
PrimaryPrefix() ( LOOKAHEAD(2) PrimarySuffix() )*/*@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);
if (jjtree.nodeCreated()) {
jjtreeCloseNodeScope(jjtn000);
}
}
}
/*@egen*/
}
void MemberSelector():
{}
{
"." TypeArguments() JavaIdentifier()
}
void PrimaryPrefix():
{}
{
Literal()
|
"this"
|
"super" "." JavaIdentifier()
|
"(" Expression() ")"
|
AllocationExpression()
|
LOOKAHEAD( ResultType() "." "class" )
ResultType() "." "class"
|
Name()
}
void PrimarySuffix():
{}
{
LOOKAHEAD(2)
"." "this"
|
LOOKAHEAD(2)
"." AllocationExpression()
|
LOOKAHEAD(3)
MemberSelector()
|
"[" Expression() "]"
|
"." JavaIdentifier()
|
Arguments()
}
void Literal():
{}
{
|
|
|
|
BooleanLiteral()
|
NullLiteral()
}
Token IntegerLiteral() :
{
Token t;
}
{
t=
{
return t;
}
}
Token BooleanLiteral() :
{
Token t;
}
{
t="true"
{
return t;
}
|
t="false"
{
return t;
}
}
Token StringLiteral() :
{
Token t;
}
{
t=
{
return t;
}
}
void NullLiteral() :
{}
{
"null"
}
void Arguments() :
/*
* Parsing this fills "tokens" with all tokens of the arguments
* excluding the parentheses at each end.
*/
{}
{
"("
[ ArgumentList() ]
")"
}
void ArgumentList():
{}
{
Expression() ( "," Expression() )*
}
void AllocationExpression():
{}
{
LOOKAHEAD(2)
"new" PrimitiveType() ArrayDimsAndInits()
|
"new" ClassOrInterfaceType() [ TypeArguments() ]
(
ArrayDimsAndInits()
|
Arguments() [ ClassOrInterfaceBody() ]
)
}
/*
* The third LOOKAHEAD specification below is to parse to PrimarySuffix
* if there is an expression between the "[...]".
*/
void ArrayDimsAndInits():
{}
{
LOOKAHEAD(2)
( LOOKAHEAD(2) "[" Expression() "]" )+ ( LOOKAHEAD(2) "[" "]" )*
|
( "[" "]" )+ ArrayInitializer()
}
/*
* Statement syntax follows.
*/
void Statement():
{}
{
LOOKAHEAD(2)
LabeledStatement()
|
AssertStatement()
|
Block()
|
EmptyStatement()
|
StatementExpression() ";"
|
SwitchStatement()
|
IfStatement()
|
WhileStatement()
|
DoStatement()
|
ForStatement()
|
BreakStatement()
|
ContinueStatement()
|
ReturnStatement()
|
ThrowStatement()
|
SynchronizedStatement()
|
TryStatement()
}
void AssertStatement():
{}
{
"assert" Expression() [ ":" Expression() ] ";"
}
void LabeledStatement():
{}
{
JavaIdentifier() ":" Statement()
}
void Block() :
/*
* Parsing this fills "tokens" with all tokens of the block
* excluding the braces at each end.
*/
{}
{
"{"
( BlockStatement() )*
"}"
}
void BlockStatement():
{}
{
LOOKAHEAD( Modifiers() Type() JavaIdentifier() )
LocalVariableDeclaration() ";"
|
Statement()
|
ClassOrInterfaceDeclaration( )
}
void LocalVariableDeclaration():
{}
{
Modifiers() Type() VariableDeclarator() ( "," VariableDeclarator() )*
}
void EmptyStatement():
{}
{
";"
}
void StatementExpression():
/*
* The last expansion of this production accepts more than the legal
* Java expansions for StatementExpression. This expansion does not
* use PostfixExpression for performance reasons.
*/
{}
{
PreIncrementExpression()
|
PreDecrementExpression()
|
PrimaryExpression()
[
"++"
|
"--"
|
AssignmentOperator() Expression()
]
}
void SwitchStatement():
{}
{
"switch" "(" Expression() ")" "{"
( SwitchLabel() ( BlockStatement() )* )*
"}"
}
void SwitchLabel():
{}
{
"case" Expression() ":"
|
"default" ":"
}
void IfStatement():
/*
* The disambiguating algorithm of JavaCC automatically binds dangling
* else's to the innermost if statement. The LOOKAHEAD specification
* is to tell JavaCC that we know what we are doing.
*/
{}
{
"if" "(" Expression() ")" Statement() [ LOOKAHEAD(1) "else" Statement() ]
}
void WhileStatement():
{}
{
"while" "(" Expression() ")" Statement()
}
void DoStatement():
{}
{
"do" Statement() "while" "(" Expression() ")" ";"
}
void ForStatement():
{}
{
"for" "("
(
LOOKAHEAD(Modifiers() Type() JavaIdentifier() ":")
Modifiers() Type() JavaIdentifier() ":" Expression()
|
[ ForInit() ] ";" [ Expression() ] ";" [ ForUpdate() ]
)
")" Statement()
}
void ForInit():
{}
{
LOOKAHEAD( Modifiers() Type() JavaIdentifier() )
LocalVariableDeclaration()
|
StatementExpressionList()
}
void StatementExpressionList():
{}
{
StatementExpression() ( "," StatementExpression() )*
}
void ForUpdate():
{}
{
StatementExpressionList()
}
void BreakStatement():
{}
{
"break" [ JavaIdentifier() ] ";"
}
void ContinueStatement():
{}
{
"continue" [ JavaIdentifier() ] ";"
}
void ReturnStatement() :
{}
{
"return" [ Expression() ] ";"
}
void ThrowStatement() :
{}
{
"throw" Expression() ";"
}
void SynchronizedStatement():
{}
{
"synchronized" "(" Expression() ")" Block()
}
void TryStatement():
/*
* Semantic check required here to make sure that at least one
* finally/catch is present.
*/
{}
{
"try" Block()
( "catch" "(" FormalParameter() ")" Block() )*
[ "finally" Block() ]
}
/* We use productions to match >>>, >> and > so that we can keep the
* type declaration syntax with generics clean
*/
void RUNSIGNEDSHIFT():
{}
{
( LOOKAHEAD({ getToken(1).kind == GT &&
((Token.GTToken)getToken(1)).realKind == RUNSIGNEDSHIFT} )
">" ">" ">"
)
}
void RSIGNEDSHIFT():
{}
{
( LOOKAHEAD({ getToken(1).kind == GT &&
((Token.GTToken)getToken(1)).realKind == RSIGNEDSHIFT} )
">" ">"
)
}
/* Annotation syntax follows. */
void Annotation():
{}
{
LOOKAHEAD( "@" Name() "(" ( JavaIdentifier() "=" | ")" ))
NormalAnnotation()
|
LOOKAHEAD( "@" Name() "(" )
SingleMemberAnnotation()
|
MarkerAnnotation()
}
void NormalAnnotation():
{}
{
"@" Name() "(" [ MemberValuePairs() ] ")"
}
void MarkerAnnotation():
{}
{
"@" Name()
}
void SingleMemberAnnotation():
{}
{
"@" Name() "(" MemberValue() ")"
}
void MemberValuePairs():
{}
{
MemberValuePair() ( "," MemberValuePair() )*
}
void MemberValuePair():
{}
{
JavaIdentifier() "=" MemberValue()
}
void MemberValue():
{}
{
Annotation()
|
MemberValueArrayInitializer()
|
ConditionalExpression()
}
void MemberValueArrayInitializer():
{}
{
"{" MemberValue() ( LOOKAHEAD(2) "," MemberValue() )* [ "," ] "}"
}
/* Annotation Types. */
void AnnotationTypeDeclaration():
{}
{
"@" "interface" LOOKAHEAD(1) JavaIdentifier() AnnotationTypeBody()
}
void AnnotationTypeBody():
{}
{
"{" ( AnnotationTypeMemberDeclaration() )* "}"
}
void AnnotationTypeMemberDeclaration():
{}
{
Modifiers()
(
LOOKAHEAD(Type() JavaIdentifier() "(")
Type() JavaIdentifier() "(" ")" [ DefaultValue() ] ";"
|
ClassOrInterfaceDeclaration()
|
EnumDeclaration()
|
AnnotationTypeDeclaration()
|
FieldDeclaration()
)
|
( ";" )
}
void DefaultValue():
{}
{
"default" MemberValue()
}
/* IDENTIFIERS */
TOKEN :
{
< IDENTIFIER: ()* >
|
< #LETTER:
[ // all chars for which Character.isIdentifierStart is true
"$",
"A"-"Z",
"_",
"a"-"z",
"\u00a2"-"\u00a5",
"\u00aa",
"\u00b5",
"\u00ba",
"\u00c0"-"\u00d6",
"\u00d8"-"\u00f6",
"\u00f8"-"\u021f",
"\u0222"-"\u0233",
"\u0250"-"\u02ad",
"\u02b0"-"\u02b8",
"\u02bb"-"\u02c1",
"\u02d0"-"\u02d1",
"\u02e0"-"\u02e4",
"\u02ee",
"\u037a",
"\u0386",
"\u0388"-"\u038a",
"\u038c",
"\u038e"-"\u03a1",
"\u03a3"-"\u03ce",
"\u03d0"-"\u03d7",
"\u03da"-"\u03f3",
"\u0400"-"\u0481",
"\u048c"-"\u04c4",
"\u04c7"-"\u04c8",
"\u04cb"-"\u04cc",
"\u04d0"-"\u04f5",
"\u04f8"-"\u04f9",
"\u0531"-"\u0556",
"\u0559",
"\u0561"-"\u0587",
"\u05d0"-"\u05ea",
"\u05f0"-"\u05f2",
"\u0621"-"\u063a",
"\u0640"-"\u064a",
"\u0671"-"\u06d3",
"\u06d5",
"\u06e5"-"\u06e6",
"\u06fa"-"\u06fc",
"\u0710",
"\u0712"-"\u072c",
"\u0780"-"\u07a5",
"\u0905"-"\u0939",
"\u093d",
"\u0950",
"\u0958"-"\u0961",
"\u0985"-"\u098c",
"\u098f"-"\u0990",
"\u0993"-"\u09a8",
"\u09aa"-"\u09b0",
"\u09b2",
"\u09b6"-"\u09b9",
"\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"-"\u0a8b",
"\u0a8d",
"\u0a8f"-"\u0a91",
"\u0a93"-"\u0aa8",
"\u0aaa"-"\u0ab0",
"\u0ab2"-"\u0ab3",
"\u0ab5"-"\u0ab9",
"\u0abd",
"\u0ad0",
"\u0ae0",
"\u0b05"-"\u0b0c",
"\u0b0f"-"\u0b10",
"\u0b13"-"\u0b28",
"\u0b2a"-"\u0b30",
"\u0b32"-"\u0b33",
"\u0b36"-"\u0b39",
"\u0b3d",
"\u0b5c"-"\u0b5d",
"\u0b5f"-"\u0b61",
"\u0b85"-"\u0b8a",
"\u0b8e"-"\u0b90",
"\u0b92"-"\u0b95",
"\u0b99"-"\u0b9a",
"\u0b9c",
"\u0b9e"-"\u0b9f",
"\u0ba3"-"\u0ba4",
"\u0ba8"-"\u0baa",
"\u0bae"-"\u0bb5",
"\u0bb7"-"\u0bb9",
"\u0c05"-"\u0c0c",
"\u0c0e"-"\u0c10",
"\u0c12"-"\u0c28",
"\u0c2a"-"\u0c33",
"\u0c35"-"\u0c39",
"\u0c60"-"\u0c61",
"\u0c85"-"\u0c8c",
"\u0c8e"-"\u0c90",
"\u0c92"-"\u0ca8",
"\u0caa"-"\u0cb3",
"\u0cb5"-"\u0cb9",
"\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"-"\u10f6",
"\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",
"\u1780"-"\u17b3",
"\u17db",
"\u1820"-"\u1877",
"\u1880"-"\u18a8",
"\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",
"\u207f",
"\u20a0"-"\u20af",
"\u2102",
"\u2107",
"\u210a"-"\u2113",
"\u2115",
"\u2119"-"\u211d",
"\u2124",
"\u2126",
"\u2128",
"\u212a"-"\u212d",
"\u212f"-"\u2131",
"\u2133"-"\u2139",
"\u2160"-"\u2183",
"\u3005"-"\u3007",
"\u3021"-"\u3029",
"\u3031"-"\u3035",
"\u3038"-"\u303a",
"\u3041"-"\u3094",
"\u309d"-"\u309e",
"\u30a1"-"\u30fe",
"\u3105"-"\u312c",
"\u3131"-"\u318e",
"\u31a0"-"\u31b7",
"\u3400"-"\u4db5",
"\u4e00"-"\u9fa5",
"\ua000"-"\ua48c",
"\uac00"-"\ud7a3",
"\uf900"-"\ufa2d",
"\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"-"\ufdfb",
"\ufe33"-"\ufe34",
"\ufe4d"-"\ufe4f",
"\ufe69",
"\ufe70"-"\ufe72",
"\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",
"A"-"Z",
"_",
"a"-"z",
"\u007f"-"\u009f",
"\u00a2"-"\u00a5",
"\u00aa",
"\u00b5",
"\u00ba",
"\u00c0"-"\u00d6",
"\u00d8"-"\u00f6",
"\u00f8"-"\u021f",
"\u0222"-"\u0233",
"\u0250"-"\u02ad",
"\u02b0"-"\u02b8",
"\u02bb"-"\u02c1",
"\u02d0"-"\u02d1",
"\u02e0"-"\u02e4",
"\u02ee",
"\u0300"-"\u034e",
"\u0360"-"\u0362",
"\u037a",
"\u0386",
"\u0388"-"\u038a",
"\u038c",
"\u038e"-"\u03a1",
"\u03a3"-"\u03ce",
"\u03d0"-"\u03d7",
"\u03da"-"\u03f3",
"\u0400"-"\u0481",
"\u0483"-"\u0486",
"\u048c"-"\u04c4",
"\u04c7"-"\u04c8",
"\u04cb"-"\u04cc",
"\u04d0"-"\u04f5",
"\u04f8"-"\u04f9",
"\u0531"-"\u0556",
"\u0559",
"\u0561"-"\u0587",
"\u0591"-"\u05a1",
"\u05a3"-"\u05b9",
"\u05bb"-"\u05bd",
"\u05bf",
"\u05c1"-"\u05c2",
"\u05c4",
"\u05d0"-"\u05ea",
"\u05f0"-"\u05f2",
"\u0621"-"\u063a",
"\u0640"-"\u0655",
"\u0660"-"\u0669",
"\u0670"-"\u06d3",
"\u06d5"-"\u06dc",
"\u06df"-"\u06e8",
"\u06ea"-"\u06ed",
"\u06f0"-"\u06fc",
"\u070f"-"\u072c",
"\u0730"-"\u074a",
"\u0780"-"\u07b0",
"\u0901"-"\u0903",
"\u0905"-"\u0939",
"\u093c"-"\u094d",
"\u0950"-"\u0954",
"\u0958"-"\u0963",
"\u0966"-"\u096f",
"\u0981"-"\u0983",
"\u0985"-"\u098c",
"\u098f"-"\u0990",
"\u0993"-"\u09a8",
"\u09aa"-"\u09b0",
"\u09b2",
"\u09b6"-"\u09b9",
"\u09bc",
"\u09be"-"\u09c4",
"\u09c7"-"\u09c8",
"\u09cb"-"\u09cd",
"\u09d7",
"\u09dc"-"\u09dd",
"\u09df"-"\u09e3",
"\u09e6"-"\u09f3",
"\u0a02",
"\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"-"\u0a8b",
"\u0a8d",
"\u0a8f"-"\u0a91",
"\u0a93"-"\u0aa8",
"\u0aaa"-"\u0ab0",
"\u0ab2"-"\u0ab3",
"\u0ab5"-"\u0ab9",
"\u0abc"-"\u0ac5",
"\u0ac7"-"\u0ac9",
"\u0acb"-"\u0acd",
"\u0ad0",
"\u0ae0",
"\u0ae6"-"\u0aef",
"\u0b01"-"\u0b03",
"\u0b05"-"\u0b0c",
"\u0b0f"-"\u0b10",
"\u0b13"-"\u0b28",
"\u0b2a"-"\u0b30",
"\u0b32"-"\u0b33",
"\u0b36"-"\u0b39",
"\u0b3c"-"\u0b43",
"\u0b47"-"\u0b48",
"\u0b4b"-"\u0b4d",
"\u0b56"-"\u0b57",
"\u0b5c"-"\u0b5d",
"\u0b5f"-"\u0b61",
"\u0b66"-"\u0b6f",
"\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",
"\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",
"\u0cbe"-"\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"-"\u10f6",
"\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",
"\u1780"-"\u17d3",
"\u17db",
"\u17e0"-"\u17e9",
"\u180b"-"\u180e",
"\u1810"-"\u1819",
"\u1820"-"\u1877",
"\u1880"-"\u18a9",
"\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",
"\u206a"-"\u206f",
"\u207f",
"\u20a0"-"\u20af",
"\u20d0"-"\u20dc",
"\u20e1",
"\u2102",
"\u2107",
"\u210a"-"\u2113",
"\u2115",
"\u2119"-"\u211d",
"\u2124",
"\u2126",
"\u2128",
"\u212a"-"\u212d",
"\u212f"-"\u2131",
"\u2133"-"\u2139",
"\u2160"-"\u2183",
"\u3005"-"\u3007",
"\u3021"-"\u302f",
"\u3031"-"\u3035",
"\u3038"-"\u303a",
"\u3041"-"\u3094",
"\u3099"-"\u309a",
"\u309d"-"\u309e",
"\u30a1"-"\u30fe",
"\u3105"-"\u312c",
"\u3131"-"\u318e",
"\u31a0"-"\u31b7",
"\u3400"-"\u4db5",
"\u4e00"-"\u9fa5",
"\ua000"-"\ua48c",
"\uac00"-"\ud7a3",
"\uf900"-"\ufa2d",
"\ufb00"-"\ufb06",
"\ufb13"-"\ufb17",
"\ufb1d"-"\ufb28",
"\ufb2a"-"\ufb36",
"\ufb38"-"\ufb3c",
"\ufb3e",
"\ufb40"-"\ufb41",
"\ufb43"-"\ufb44",
"\ufb46"-"\ufbb1",
"\ufbd3"-"\ufd3d",
"\ufd50"-"\ufd8f",
"\ufd92"-"\ufdc7",
"\ufdf0"-"\ufdfb",
"\ufe20"-"\ufe23",
"\ufe33"-"\ufe34",
"\ufe4d"-"\ufe4f",
"\ufe69",
"\ufe70"-"\ufe72",
"\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"
]
>
}