javacc-7.0.3.test.lineNumbers.JJTree.jjt 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.
/* 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 {
MULTI = true;
NODE_DEFAULT_VOID = true;
NODE_SCOPE_HOOK=true;
JAVA_UNICODE_ESCAPE = true;
STATIC = false;
NODE_CLASS = "JJTreeNode";
OUTPUT_DIRECTORY = "out-dir";
}
PARSER_BEGIN(JJTreeParser)
package org.javacc.jjtree;
public class JJTreeParser {
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() #Grammar :
{
Token t;
}
{
javacc_options()
(
"PARSER_BEGIN" "(" t=identifier() ")"
{
JJTreeGlobals.parserName = t.image;
}
CompilationUnit()
"PARSER_END" LOOKAHEAD(1) "(" identifier() ")"
{
if (JJTreeOptions.getNodePackage().equals("")) {
JJTreeGlobals.nodePackageName = JJTreeGlobals.packageName;
} else {
JJTreeGlobals.nodePackageName = JJTreeOptions.getNodePackage();
}
}
) #CompilationUnit(true)
(
( production() )+
) #Productions
}
void javacc_options() :
{
}
{
[ LOOKAHEAD( { getToken(1).image.equals("options") }) ( "{" ( option_binding() )* "}" ) #Options ]
}
void option_binding() #OptionBinding :
{
Token o, v;
}
{
( o= | o="LOOKAHEAD" | o="IGNORE_CASE" | o="static" )
"="
(
v=IntegerLiteral()
{
JJTreeOptions.setInputFileOption(o, v, o.image, new Integer(v.image));
jjtThis.initialize(o.image, v.image);
}
| v=BooleanLiteral()
{
JJTreeOptions.setInputFileOption(o, v, o.image,
Boolean.valueOf(v.image));
jjtThis.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);
jjtThis.initialize(o.image, vs);
}
) ";"
}
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() #Javacode :
{
Token t1, t2;
ASTJavacode prod;
ASTNodeDescriptor nd = null;
String n;
}
{
{
prod = jjtThis;
}
"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;
}
(
( BlockStatement() )*
{
jjtThis.node_scope = new NodeScope(prod, nd);
}
) #JavacodeBody
"}"
{
JJTreeGlobals.productions.put(prod.name, prod);
}
}
void bnf_production() #BNF :
{
Token t1, t2;
ASTBNF prod;
ASTNodeDescriptor nd = null;
NodeScope ns;
JJTreeNode eu;
String n;
}
{
{
prod = jjtThis;
}
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);
}
(
( BlockStatement() )*
{
jjtThis.node_scope = ns;
}
) #BNFDeclaration
"}"
"{"
(
eu=expansion_choices(prod)
{
jjtThis.node_scope = ns;
jjtThis.expansion_unit = eu;
}
) #BNFNodeScope
"}"
{
JJTreeGlobals.productions.put(prod.name, prod);
}
}
void AccessModifier() :
{}
{
( "public" | "protected" | "private" )?
}
void regular_expr_production() #RE :
{
}
{
[
LOOKAHEAD(2) "<" "*" ">"
|
"<" ( "," )* ">"
]
regexpr_kind() [ "[" "IGNORE_CASE" "]" ] ":"
"{" regexpr_spec() ( "|" regexpr_spec() )* "}"
}
void token_manager_decls() #TokenDecls :
{
}
{
"TOKEN_MGR_DECLS" ":" ClassOrInterfaceBody()
}
void regexpr_kind() :
{
}
{
"TOKEN"
|
"SPECIAL_TOKEN"
|
"SKIP"
|
"MORE"
}
void regexpr_spec() #RESpec :
{}
{
regular_expression() [ Block() ] [ ":" ]
}
JJTreeNode expansion_choices(ASTProduction p) #BNFChoice(>1) :
{
}
{
expansion(p) ( "|" expansion(p) )*
{
return (JJTreeNode)jjtree.peekNode();
}
}
void expansion(ASTProduction p) #BNFSequence(>1) :
{
JJTreeNode eu;
ASTNodeDescriptor nd = null;
}
{
(
LOOKAHEAD(1)
( "LOOKAHEAD" "(" local_lookahead(p) ")" ) #BNFLookahead
)?
(
LOOKAHEAD(0, { notTailOfExpansionUnit() } )
(
eu=expansion_unit(p)
[ nd=node_descriptor() ]
{
if (jjtree.nodeCreated()) {
jjtThis.node_scope = new NodeScope(p, nd);
jjtThis.expansion_unit = eu;
}
}
) #ExpansionNodeScope(>1)
)+
}
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)
/*
* We give this priority over primary expressions which use LOOKAHEAD as the
* name of its identifier.
*/
(
"LOOKAHEAD" "(" local_lookahead(p) ")"
) #BNFLookahead
|
Block() #BNFAction
|
(
"[" expansion_choices(p) "]"
) #BNFZeroOrOne
|
(
"try" "{" expansion_choices(p) "}"
( "catch" "(" Name() ")" Block() )*
[ "finally" Block() ]
) #BNFTryBlock
|
LOOKAHEAD( identifier() | StringLiteral() | "<" | PrimaryExpression() "=" )
(
[
LOOKAHEAD(PrimaryExpression() "=")
PrimaryExpression() "="
]
(
regular_expression() [ "." t= ]
| ( identifier() Arguments() ) #BNFNonTerminal
)
) #BNFAssignment(>1)
|
t="(" expansion_choices(p) ")"
(
"+"
#BNFOneOrMore(1)
|
"*"
#BNFZeroOrMore(1)
|
"?"
#BNFZeroOrOne(1)
|
{}
#BNFParenthesized(1)
)
{
((JJTreeNode)jjtree.peekNode()).setFirstToken(t);
}
)
{
return (JJTreeNode)jjtree.peekNode();
}
}
void regular_expression() :
{
}
{
StringLiteral() #REStringLiteral
|
LOOKAHEAD(3)
(
"<" [ [ "#" ] identifier() ":" ] complex_regular_expression_choices() ">"
) #RENamed
|
LOOKAHEAD(2)
(
"<" identifier() ">"
) #REReference
|
(
"<" "EOF" ">"
) #REEOF
}
void complex_regular_expression_choices() #REChoice(>1) :
{}
{
complex_regular_expression() ( "|" complex_regular_expression() )*
}
void complex_regular_expression() #RESequence(>1) :
{}
{
( complex_regular_expression_unit() )+
}
void complex_regular_expression_unit() :
{
Token t;
}
{
StringLiteral() #REStringLiteral
|
( "<" identifier() ">" ) #REReference
|
character_list()
|
t="(" complex_regular_expression_choices() ")"
(
"+"
#REOneOrMore(1)
|
"*"
#REZeroOrMore(1)
|
"?"
#REZeroOrOne(1)
| "{" IntegerLiteral() [ "," [ IntegerLiteral() ] ] "}"
#RRepetitionRange(1)
|
{}
#REParenthesized(1)
)
{
((JJTreeNode)jjtree.peekNode()).setFirstToken(t);
}
}
void character_list() #RECharList :
{}
{
[ "~" ] "[" [ character_descriptor() ( "," character_descriptor() )* ] "]"
}
void character_descriptor() #CharDescriptor :
{}
{
StringLiteral() [ "-" StringLiteral() ]
}
Token identifier() :
{
Token t;
}
{
t=
{
return t;
}
}
/**********************************************
* THE JJTREE PRODUCTIONS START HERE *
**********************************************/
ASTNodeDescriptor node_descriptor() #NodeDescriptor :
{
Token t = null;
String s = null;
}
{
"#"
(
s=Name()
{
jjtThis.name = s;
}
| t=
{
jjtThis.name = t.image;
}
)
[
LOOKAHEAD(1)
"("
[ ">"
{
jjtThis.isGT = true;
}
]
node_descriptor_expression()
{
jjtThis.expression =
(ASTNodeDescriptorExpression)jjtree.peekNode();
}
")"
]
{
jjtThis.setNodeIdValue();
return jjtThis;
}
}
JAVACODE
void node_descriptor_expression() #NodeDescriptorExpression
{
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();
}
}
/**********************************************
* 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() #PrimaryExpression:
{}
{
PrimaryPrefix() ( LOOKAHEAD(2) PrimarySuffix() )*
}
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"
]
>
}