Created
August 8, 2014 20:04
-
-
Save tolmasky/98dc8f57385304626c12 to your computer and use it in GitHub Desktop.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
//=========================================================================== | |
// | |
// Parsing Expression Grammar for Java 1.6 for Mouse 1.1 - 1.6. | |
// Based on Chapters 3 and 18 of Java Language Specification, Third Edition, | |
// at http://java.sun.com/docs/books/jls/third_edition/html/j3TOC.html. | |
// | |
//--------------------------------------------------------------------------- | |
// | |
// Copyright (C) 2006, 2009, 2010, 2011, 2013 | |
// by Roman R Redziejowski (www.romanredz.se). | |
// | |
// The author gives unlimited permission to copy and distribute | |
// this file, with or without modifications, as long as this notice | |
// is preserved, and any changes are properly documented. | |
// | |
// This file is distributed in the hope that it will be useful, | |
// but WITHOUT ANY WARRANTY; without even the implied warranty of | |
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. | |
// | |
//--------------------------------------------------------------------------- | |
// | |
// Latest update 2013-04-23 | |
// | |
//--------------------------------------------------------------------------- | |
// | |
// Change log | |
// 2006-12-06 Posted on Internet. | |
// 2009-04-04 Modified to conform to Mouse syntax: | |
// Underscore removed from names | |
// \f in Space replaced by Unicode for FormFeed. | |
// 2009-07-10 Unused rule THREADSAFE removed. | |
// 2009-07-10 Copying and distribution conditions relaxed by the author. | |
// 2010-07-01 Updated Mouse version in the comment. | |
// 2010-09-15 Updated comment on Java release. | |
// 2010-09-18 Updated list of reserved words ("keywords") according to | |
// JLS 3.9: added "const" and "goto", removed "threadsafe". | |
// 2010-09-18 Removed superfluous "?" everywhere after "Spacing". | |
// 2010-10-05 Removed erroneous "TypeArguments?" from "EnumConstant". | |
// See JLS 8.9, JLS 18.1. | |
// NB. "Annotations" are optional, but not shown as such in JLS. | |
// 2010-10-20 Corrected "FormalParameterList" according to JLS 8.4.1. | |
// NB. "VariableModifiers" in "FormalParameter" and "LastFormalParameter" | |
// are optional, but not shown as such in JLS. | |
// 2010-10-20 Corrected "Annotation" according to JLS 9.7. | |
// Is incorrect in JLS 18.1 (does not allow list of value pairs). | |
// 2010-10-20 Corrected "LocalVariableDeclarationStatement". | |
// Is incorrect in JLS 18.1: only FINAL allowed as "VariableModifier". | |
// Is incorrect in JLS 14.4: "VariableModifiers" not shown as optional. | |
// 2010-10-20 Corrected "AnnotationTypeElementRest": added SEMI as last alternative. | |
// See JLS 9.6. NB. Missing in JLS 18.1. | |
// 2010-10-20 Moved "Identifier" from "AnnotationTypeElementRest" to | |
// "AnnotationMethodRest". Was incorrect in JLS 18.1. | |
// 2010-10-21 Inverted order of alternatives in "HexSignificand". | |
// 2010-10-24 Corrected previous correction: moved SEMI from | |
// "AnnotationTypeElementRest" to "AnnotationTypeElementDeclaration". | |
// 2010-10-25 Repeated "u" allowed in UnicodeEscape (JLS 3.3). | |
// Line terminators not allowed in StringLiteral (JLS 3.10.5). | |
// (Found thanks to Java PEG for Parboiled, which in turn credits | |
// Reinier Zwitserloot for finding it.) | |
// 2011-07-19 Added SEMI after "VariableDeclarators" in "MemberDecl" (JLS 8.3). | |
// 2011-07-21 Corrected "ArrayInitializer" to allow for "{,}" (JLS 10.6). | |
// 2011-10-15 Updated Mouse version in the comment. | |
// 2011-11-05 Updated Mouse version in the comment. | |
// 2013-02-18 Line terminators not allowed in CharLiteral (JLS 3.10.4). | |
// 2013-02-19 Added "NonWildcardTypeArguments?" in the second alternative | |
// of "SuperSuffix". Version in Chapter 18 is incorrect. | |
// See JLS 15.10. | |
// 2013-04-23 Updated Mouse version in the comment. | |
// | |
//=========================================================================== | |
//------------------------------------------------------------------------- | |
// Compilation Unit | |
//------------------------------------------------------------------------- | |
CompilationUnit | |
= Spacing PackageDeclaration? ImportDeclaration* TypeDeclaration* EOT | |
PackageDeclaration | |
= Annotation* PACKAGE QualifiedIdentifier SEMI | |
ImportDeclaration | |
= IMPORT STATIC? QualifiedIdentifier (DOT STAR)? SEMI | |
TypeDeclaration | |
= Modifier* | |
( ClassDeclaration | |
/ EnumDeclaration | |
/ InterfaceDeclaration | |
/ AnnotationTypeDeclaration | |
) | |
/ SEMI | |
//------------------------------------------------------------------------- | |
// Class Declaration | |
//------------------------------------------------------------------------- | |
ClassDeclaration | |
= CLASS Identifier TypeParameters? (EXTENDS ClassType)? (IMPLEMENTS ClassTypeList)? ClassBody | |
ClassBody | |
= LWING ClassBodyDeclaration* RWING | |
ClassBodyDeclaration | |
= SEMI | |
/ STATIC? Block // Static or Instance Initializer | |
/ Modifier* MemberDecl // ClassMemberDeclaration | |
MemberDecl | |
= TypeParameters GenericMethodOrConstructorRest // Generic Method or Constructor | |
/ Type Identifier MethodDeclaratorRest // Method | |
/ Type VariableDeclarators SEMI // Field | |
/ VOID Identifier VoidMethodDeclaratorRest // Void method | |
/ Identifier ConstructorDeclaratorRest // Constructor | |
/ InterfaceDeclaration // Interface | |
/ ClassDeclaration // Class | |
/ EnumDeclaration // Enum | |
/ AnnotationTypeDeclaration // Annotation | |
GenericMethodOrConstructorRest | |
= (Type / VOID) Identifier MethodDeclaratorRest | |
/ Identifier ConstructorDeclaratorRest | |
MethodDeclaratorRest | |
= FormalParameters Dim* (THROWS ClassTypeList)? (MethodBody / SEMI) | |
VoidMethodDeclaratorRest | |
= FormalParameters (THROWS ClassTypeList)? (MethodBody / SEMI) | |
ConstructorDeclaratorRest | |
= FormalParameters (THROWS ClassTypeList)? MethodBody | |
MethodBody | |
= Block | |
//------------------------------------------------------------------------- | |
// Interface Declaration | |
//------------------------------------------------------------------------- | |
InterfaceDeclaration | |
= INTERFACE Identifier TypeParameters? (EXTENDS ClassTypeList)? InterfaceBody | |
InterfaceBody | |
= LWING InterfaceBodyDeclaration* RWING | |
InterfaceBodyDeclaration | |
= Modifier* InterfaceMemberDecl | |
/ SEMI | |
InterfaceMemberDecl | |
= InterfaceMethodOrFieldDecl | |
/ InterfaceGenericMethodDecl | |
/ VOID Identifier VoidInterfaceMethodDeclaratorRest | |
/ InterfaceDeclaration | |
/ AnnotationTypeDeclaration | |
/ ClassDeclaration | |
/ EnumDeclaration | |
InterfaceMethodOrFieldDecl | |
= Type Identifier InterfaceMethodOrFieldRest | |
InterfaceMethodOrFieldRest | |
= ConstantDeclaratorsRest SEMI | |
/ InterfaceMethodDeclaratorRest | |
InterfaceMethodDeclaratorRest | |
= FormalParameters Dim* (THROWS ClassTypeList)? SEMI | |
InterfaceGenericMethodDecl | |
= TypeParameters (Type / VOID) Identifier InterfaceMethodDeclaratorRest | |
VoidInterfaceMethodDeclaratorRest | |
= FormalParameters (THROWS ClassTypeList)? SEMI | |
ConstantDeclaratorsRest | |
= ConstantDeclaratorRest (COMMA ConstantDeclarator)* | |
ConstantDeclarator | |
= Identifier ConstantDeclaratorRest | |
ConstantDeclaratorRest | |
= Dim* EQU VariableInitializer | |
//------------------------------------------------------------------------- | |
// Enum Declaration | |
//------------------------------------------------------------------------- | |
EnumDeclaration | |
= ENUM Identifier (IMPLEMENTS ClassTypeList)? EnumBody | |
EnumBody | |
= LWING EnumConstants? COMMA? EnumBodyDeclarations? RWING | |
EnumConstants | |
= EnumConstant (COMMA EnumConstant)* | |
EnumConstant | |
= Annotation* Identifier Arguments? ClassBody? | |
EnumBodyDeclarations | |
= SEMI ClassBodyDeclaration* | |
//------------------------------------------------------------------------- | |
// Variable Declarations | |
//------------------------------------------------------------------------- | |
LocalVariableDeclarationStatement | |
= (FINAL / Annotation)* Type VariableDeclarators SEMI | |
VariableDeclarators | |
= VariableDeclarator (COMMA VariableDeclarator)* | |
VariableDeclarator | |
= Identifier Dim* (EQU VariableInitializer)? | |
//------------------------------------------------------------------------- | |
// Formal Parameters | |
//------------------------------------------------------------------------- | |
FormalParameters | |
= LPAR FormalParameterList? RPAR | |
FormalParameter | |
= (FINAL / Annotation)* Type VariableDeclaratorId | |
LastFormalParameter | |
= (FINAL / Annotation)* Type ELLIPSIS VariableDeclaratorId | |
FormalParameterList | |
= FormalParameter (COMMA FormalParameter)* (COMMA LastFormalParameter)? | |
/ LastFormalParameter | |
VariableDeclaratorId | |
= Identifier Dim* | |
//------------------------------------------------------------------------- | |
// Statements | |
//------------------------------------------------------------------------- | |
Block | |
= LWING BlockStatements RWING | |
BlockStatements | |
= BlockStatement* | |
BlockStatement | |
= LocalVariableDeclarationStatement | |
/ Modifier* | |
( ClassDeclaration | |
/ EnumDeclaration | |
) | |
/ Statement | |
Statement | |
= Block | |
/ ASSERT Expression (COLON Expression)? SEMI | |
/ IF ParExpression Statement (ELSE Statement)? | |
/ FOR LPAR ForInit? SEMI Expression? SEMI ForUpdate? RPAR Statement | |
/ FOR LPAR FormalParameter COLON Expression RPAR Statement | |
/ WHILE ParExpression Statement | |
/ DO Statement WHILE ParExpression SEMI | |
/ TRY Block (Catch+ Finally? / Finally) | |
/ SWITCH ParExpression LWING SwitchBlockStatementGroups RWING | |
/ SYNCHRONIZED ParExpression Block | |
/ RETURN Expression? SEMI | |
/ THROW Expression SEMI | |
/ BREAK Identifier? SEMI | |
/ CONTINUE Identifier? SEMI | |
/ SEMI | |
/ StatementExpression SEMI | |
/ Identifier COLON Statement | |
Catch | |
= CATCH LPAR FormalParameter RPAR Block | |
Finally | |
= FINALLY Block | |
SwitchBlockStatementGroups | |
= SwitchBlockStatementGroup* | |
SwitchBlockStatementGroup | |
= SwitchLabel BlockStatements | |
SwitchLabel | |
= CASE ConstantExpression COLON | |
/ CASE EnumConstantName COLON | |
/ DEFAULT COLON | |
ForInit | |
= (FINAL / Annotation)* Type VariableDeclarators | |
/ StatementExpression (COMMA StatementExpression)* | |
ForUpdate | |
= StatementExpression (COMMA StatementExpression)* | |
EnumConstantName | |
= Identifier | |
//------------------------------------------------------------------------- | |
// Expressions | |
//------------------------------------------------------------------------- | |
StatementExpression | |
= Expression | |
// This is more generous than definition in section 14.8, which allows only | |
// specific forms of Expression. | |
ConstantExpression | |
= Expression | |
Expression | |
= ConditionalExpression (AssignmentOperator ConditionalExpression)* | |
// This definition is part of the modification in JLS Chapter 18 | |
// to minimize look ahead. In JLS Chapter 15.27, Expression is defined | |
// as AssignmentExpression, which is effectively defined as | |
// (LeftHandSide AssignmentOperator)* ConditionalExpression. | |
// The above is obtained by allowing ANY ConditionalExpression | |
// as LeftHandSide, which results in accepting statements like 5 = a. | |
AssignmentOperator | |
= EQU | |
/ PLUSEQU | |
/ MINUSEQU | |
/ STAREQU | |
/ DIVEQU | |
/ ANDEQU | |
/ OREQU | |
/ HATEQU | |
/ MODEQU | |
/ SLEQU | |
/ SREQU | |
/ BSREQU | |
ConditionalExpression | |
= ConditionalOrExpression (QUERY Expression COLON ConditionalOrExpression)* | |
ConditionalOrExpression | |
= ConditionalAndExpression (OROR ConditionalAndExpression)* | |
ConditionalAndExpression | |
= InclusiveOrExpression (ANDAND InclusiveOrExpression)* | |
InclusiveOrExpression | |
= ExclusiveOrExpression (OR ExclusiveOrExpression)* | |
ExclusiveOrExpression | |
= AndExpression (HAT AndExpression)* | |
AndExpression | |
= EqualityExpression (AND EqualityExpression)* | |
EqualityExpression | |
= RelationalExpression ((EQUAL / NOTEQUAL) RelationalExpression)* | |
RelationalExpression | |
= ShiftExpression ((LE / GE / LT / GT) ShiftExpression / INSTANCEOF ReferenceType)* | |
ShiftExpression | |
= AdditiveExpression ((SL / SR / BSR) AdditiveExpression)* | |
AdditiveExpression | |
= MultiplicativeExpression ((PLUS / MINUS) MultiplicativeExpression)* | |
MultiplicativeExpression | |
= UnaryExpression ((STAR / DIV / MOD) UnaryExpression)* | |
UnaryExpression | |
= PrefixOp UnaryExpression | |
/ LPAR Type RPAR UnaryExpression | |
/ Primary (Selector)* (PostfixOp)* | |
Primary | |
= ParExpression | |
/ NonWildcardTypeArguments (ExplicitGenericInvocationSuffix / THIS Arguments) | |
/ THIS Arguments? | |
/ SUPER SuperSuffix | |
/ Literal | |
/ NEW Creator | |
/ QualifiedIdentifier IdentifierSuffix? | |
/ BasicType Dim* DOT CLASS | |
/ VOID DOT CLASS | |
IdentifierSuffix | |
= LBRK ( RBRK Dim* DOT CLASS / Expression RBRK) | |
/ Arguments | |
/ DOT | |
( CLASS | |
/ ExplicitGenericInvocation | |
/ THIS | |
/ SUPER Arguments | |
/ NEW NonWildcardTypeArguments? InnerCreator | |
) | |
ExplicitGenericInvocation | |
= NonWildcardTypeArguments ExplicitGenericInvocationSuffix | |
NonWildcardTypeArguments | |
= LPOINT ReferenceType (COMMA ReferenceType)* RPOINT | |
ExplicitGenericInvocationSuffix | |
= SUPER SuperSuffix | |
/ Identifier Arguments | |
PrefixOp | |
= INC | |
/ DEC | |
/ BANG | |
/ TILDA | |
/ PLUS | |
/ MINUS | |
PostfixOp | |
= INC | |
/ DEC | |
Selector | |
= DOT Identifier Arguments? | |
/ DOT ExplicitGenericInvocation | |
/ DOT THIS | |
/ DOT SUPER SuperSuffix | |
/ DOT NEW NonWildcardTypeArguments? InnerCreator | |
/ DimExpr | |
SuperSuffix | |
= Arguments | |
/ DOT NonWildcardTypeArguments? Identifier Arguments? | |
BasicType | |
= ( "byte" | |
/ "short" | |
/ "char" | |
/ "int" | |
/ "long" | |
/ "float" | |
/ "double" | |
/ "boolean" | |
) !LetterOrDigit Spacing | |
Arguments | |
= LPAR (Expression (COMMA Expression)*)? RPAR | |
Creator | |
= NonWildcardTypeArguments? CreatedName ClassCreatorRest | |
/ NonWildcardTypeArguments? (ClassType / BasicType) ArrayCreatorRest | |
CreatedName | |
= Identifier NonWildcardTypeArguments? (DOT Identifier NonWildcardTypeArguments?)* | |
InnerCreator | |
= Identifier ClassCreatorRest | |
ArrayCreatorRest | |
= LBRK ( RBRK Dim* ArrayInitializer / Expression RBRK DimExpr* Dim* ) | |
// This is more generous than JLS 15.10. According to that definition, | |
// BasicType must be followed by at least one DimExpr or by ArrayInitializer. | |
ClassCreatorRest | |
= Arguments ClassBody? | |
ArrayInitializer | |
= LWING (VariableInitializer (COMMA VariableInitializer)*)? COMMA? RWING | |
VariableInitializer | |
= ArrayInitializer | |
/ Expression | |
ParExpression | |
= LPAR Expression RPAR | |
QualifiedIdentifier | |
= Identifier (DOT Identifier)* | |
Dim | |
= LBRK RBRK | |
DimExpr | |
= LBRK Expression RBRK | |
//------------------------------------------------------------------------- | |
// Types and Modifiers | |
//------------------------------------------------------------------------- | |
Type | |
= (BasicType / ClassType) Dim* | |
ReferenceType | |
= BasicType Dim+ | |
/ ClassType Dim* | |
ClassType | |
= Identifier TypeArguments? (DOT Identifier TypeArguments?)* | |
ClassTypeList | |
= ClassType (COMMA ClassType)* | |
TypeArguments | |
= LPOINT TypeArgument (COMMA TypeArgument)* RPOINT | |
TypeArgument | |
= ReferenceType | |
/ QUERY ((EXTENDS / SUPER) ReferenceType)? | |
TypeParameters | |
= LPOINT TypeParameter (COMMA TypeParameter)* RPOINT | |
TypeParameter | |
= Identifier (EXTENDS Bound)? | |
Bound | |
= ClassType (AND ClassType)* | |
Modifier | |
= Annotation | |
/ ( "public" | |
/ "protected" | |
/ "private" | |
/ "static" | |
/ "abstract" | |
/ "final" | |
/ "native" | |
/ "synchronized" | |
/ "transient" | |
/ "volatile" | |
/ "strictfp" | |
) !LetterOrDigit Spacing | |
// This common definition of Modifier is part of the modification | |
// in JLS Chapter 18 to minimize look ahead. The main body of JLS has | |
// different lists of modifiers for different language elements. | |
//------------------------------------------------------------------------- | |
// Annotations | |
//------------------------------------------------------------------------- | |
AnnotationTypeDeclaration | |
= AT INTERFACE Identifier AnnotationTypeBody | |
AnnotationTypeBody | |
= LWING AnnotationTypeElementDeclaration* RWING | |
AnnotationTypeElementDeclaration | |
= Modifier* AnnotationTypeElementRest | |
/ SEMI | |
AnnotationTypeElementRest | |
= Type AnnotationMethodOrConstantRest SEMI | |
/ ClassDeclaration | |
/ EnumDeclaration | |
/ InterfaceDeclaration | |
/ AnnotationTypeDeclaration | |
AnnotationMethodOrConstantRest | |
= AnnotationMethodRest | |
/ AnnotationConstantRest | |
AnnotationMethodRest | |
= Identifier LPAR RPAR DefaultValue? | |
AnnotationConstantRest | |
= VariableDeclarators | |
DefaultValue | |
= DEFAULT ElementValue | |
Annotation | |
= NormalAnnotation | |
/ SingleElementAnnotation | |
/ MarkerAnnotation | |
NormalAnnotation | |
= AT QualifiedIdentifier LPAR ElementValuePairs? RPAR | |
SingleElementAnnotation | |
= AT QualifiedIdentifier LPAR ElementValue RPAR | |
MarkerAnnotation | |
= AT QualifiedIdentifier | |
ElementValuePairs | |
= ElementValuePair (COMMA ElementValuePair)* | |
ElementValuePair | |
= Identifier EQU ElementValue | |
ElementValue | |
= ConditionalExpression | |
/ Annotation | |
/ ElementValueArrayInitializer | |
ElementValueArrayInitializer | |
= LWING ElementValues? COMMA? RWING | |
ElementValues | |
= ElementValue (COMMA ElementValue)* | |
//========================================================================= | |
// Lexical Structure | |
//========================================================================= | |
//------------------------------------------------------------------------- | |
// JLS 3.6-7 Spacing | |
//------------------------------------------------------------------------- | |
_ = . | |
Spacing | |
= ( [ \t\r\n\u000C]+ // WhiteSpace | |
/ "/*" (!"*/" _)* "*/" // TraditionalComment | |
/ "//" (![\r\n] _)* [\r\n] // EndOfLineComment | |
)* | |
//------------------------------------------------------------------------- | |
// JLS 3.8 Identifiers | |
//------------------------------------------------------------------------- | |
Identifier = !Keyword Letter LetterOrDigit* Spacing | |
Letter = [a-z] / [A-Z] / [_$] | |
LetterOrDigit = [a-z] / [A-Z] / [0-9] / [_$] | |
// These are traditional definitions of letters and digits. | |
// JLS defines letters and digits as Unicode characters recognized | |
// as such by special Java procedures, which is difficult | |
// to express in terms of Parsing Expressions. | |
//------------------------------------------------------------------------- | |
// JLS 3.9 Keywords | |
// More precisely: reserved words. According to JLS, "true", "false", | |
// and "null" are technically not keywords - but still must not appear | |
// as identifiers. Keywords "const" and "goto" are not used; JLS explains | |
// the reason. | |
//------------------------------------------------------------------------- | |
Keyword | |
= ( "abstract" | |
/ "assert" | |
/ "boolean" | |
/ "break" | |
/ "byte" | |
/ "case" | |
/ "catch" | |
/ "char" | |
/ "class" | |
/ "const" | |
/ "continue" | |
/ "default" | |
/ "double" | |
/ "do" | |
/ "else" | |
/ "enum" | |
/ "extends" | |
/ "false" | |
/ "finally" | |
/ "final" | |
/ "float" | |
/ "for" | |
/ "goto" | |
/ "if" | |
/ "implements" | |
/ "import" | |
/ "interface" | |
/ "int" | |
/ "instanceof" | |
/ "long" | |
/ "native" | |
/ "new" | |
/ "null" | |
/ "package" | |
/ "private" | |
/ "protected" | |
/ "public" | |
/ "return" | |
/ "short" | |
/ "static" | |
/ "strictfp" | |
/ "super" | |
/ "switch" | |
/ "synchronized" | |
/ "this" | |
/ "throws" | |
/ "throw" | |
/ "transient" | |
/ "true" | |
/ "try" | |
/ "void" | |
/ "volatile" | |
/ "while" | |
) !LetterOrDigit | |
ASSERT = "assert" !LetterOrDigit Spacing | |
BREAK = "break" !LetterOrDigit Spacing | |
CASE = "case" !LetterOrDigit Spacing | |
CATCH = "catch" !LetterOrDigit Spacing | |
CLASS = "class" !LetterOrDigit Spacing | |
CONTINUE = "continue" !LetterOrDigit Spacing | |
DEFAULT = "default" !LetterOrDigit Spacing | |
DO = "do" !LetterOrDigit Spacing | |
ELSE = "else" !LetterOrDigit Spacing | |
ENUM = "enum" !LetterOrDigit Spacing | |
EXTENDS = "extends" !LetterOrDigit Spacing | |
FINALLY = "finally" !LetterOrDigit Spacing | |
FINAL = "final" !LetterOrDigit Spacing | |
FOR = "for" !LetterOrDigit Spacing | |
IF = "if" !LetterOrDigit Spacing | |
IMPLEMENTS = "implements" !LetterOrDigit Spacing | |
IMPORT = "import" !LetterOrDigit Spacing | |
INTERFACE = "interface" !LetterOrDigit Spacing | |
INSTANCEOF = "instanceof" !LetterOrDigit Spacing | |
NEW = "new" !LetterOrDigit Spacing | |
PACKAGE = "package" !LetterOrDigit Spacing | |
RETURN = "return" !LetterOrDigit Spacing | |
STATIC = "static" !LetterOrDigit Spacing | |
SUPER = "super" !LetterOrDigit Spacing | |
SWITCH = "switch" !LetterOrDigit Spacing | |
SYNCHRONIZED = "synchronized" !LetterOrDigit Spacing | |
THIS = "this" !LetterOrDigit Spacing | |
THROWS = "throws" !LetterOrDigit Spacing | |
THROW = "throw" !LetterOrDigit Spacing | |
TRY = "try" !LetterOrDigit Spacing | |
VOID = "void" !LetterOrDigit Spacing | |
WHILE = "while" !LetterOrDigit Spacing | |
//------------------------------------------------------------------------- | |
// JLS 3.10 Literals | |
//------------------------------------------------------------------------- | |
Literal | |
= ( FloatLiteral | |
/ IntegerLiteral // May be a prefix of FloatLiteral | |
/ CharLiteral | |
/ StringLiteral | |
/ "true" !LetterOrDigit | |
/ "false" !LetterOrDigit | |
/ "null" !LetterOrDigit | |
) Spacing | |
IntegerLiteral | |
= ( HexNumeral | |
/ OctalNumeral // May be a prefix of HexNumeral | |
/ DecimalNumeral // May be a prefix of OctalNumeral | |
) [lL]? | |
DecimalNumeral | |
= "0" | |
/ [1-9][0-9]* | |
HexNumeral | |
= ("0x" / "0X") HexDigit+ | |
HexDigit | |
= [a-f] / [A-F] / [0-9] | |
OctalNumeral | |
= "0" [0-7]+ | |
FloatLiteral | |
= HexFloat | |
/ DecimalFloat | |
DecimalFloat | |
= Digit+ "." Digit* Exponent? [fFdD]? | |
/ "." Digit+ Exponent? [fFdD]? | |
/ Digit+ Exponent [fFdD]? | |
/ Digit+ Exponent? [fFdD] | |
Exponent | |
= [eE] [+\-]? Digit+ | |
Digit = [0-9] | |
HexFloat | |
= HexSignificand BinaryExponent [fFdD]? | |
HexSignificand | |
= ("0x" / "0X") HexDigit* "." HexDigit+ | |
/ HexNumeral "."? // May be a prefix of above | |
BinaryExponent | |
= [pP] [+\-]? Digit+ | |
CharLiteral | |
= "'" (Escape / !['\\\n\r] _) "'" | |
StringLiteral | |
= "\"" (Escape / !["\\\n\r] _)* "\"" | |
Escape | |
= "\\" ([btnfr"'\\] / OctalEscape / UnicodeEscape) | |
OctalEscape | |
= [0-3][0-7][0-7] | |
/ [0-7][0-7] | |
/ [0-7] | |
UnicodeEscape | |
= "u"+ HexDigit HexDigit HexDigit HexDigit | |
//------------------------------------------------------------------------- | |
// JLS 3.11-12 Separators, Operators | |
//------------------------------------------------------------------------- | |
AT = "@" Spacing | |
AND = "&"![=&] Spacing | |
ANDAND = "&&" Spacing | |
ANDEQU = "&=" Spacing | |
BANG = "!" !"=" Spacing | |
BSR = ">>>"!"=" Spacing | |
BSREQU = ">>>=" Spacing | |
COLON = ":" Spacing | |
COMMA = "," Spacing | |
DEC = "--" Spacing | |
DIV = "/" !"=" Spacing | |
DIVEQU = "/=" Spacing | |
DOT = "." Spacing | |
ELLIPSIS = "..." Spacing | |
EQU = "=" !"=" Spacing | |
EQUAL = "==" Spacing | |
GE = ">=" Spacing | |
GT = ">"![=>] Spacing | |
HAT = "^"!"=" Spacing | |
HATEQU = "^=" Spacing | |
INC = "++" Spacing | |
LBRK = "[" Spacing | |
LE = "<=" Spacing | |
LPAR = "(" Spacing | |
LPOINT = "<" Spacing | |
LT = "<"![=<] Spacing | |
LWING = "{" Spacing | |
MINUS = "-"![=\-] Spacing | |
MINUSEQU = "-=" Spacing | |
MOD = "%"!"=" Spacing | |
MODEQU = "%=" Spacing | |
NOTEQUAL = "!=" Spacing | |
OR = "|"![=|] Spacing | |
OREQU = "|=" Spacing | |
OROR = "||" Spacing | |
PLUS = "+"![=+] Spacing | |
PLUSEQU = "+=" Spacing | |
QUERY = "?" Spacing | |
RBRK = "]" Spacing | |
RPAR = ")" Spacing | |
RPOINT = ">" Spacing | |
RWING = "}" Spacing | |
SEMI = ";" Spacing | |
SL = "<<"!"=" Spacing | |
SLEQU = "<<=" Spacing | |
SR = ">>"![=>] Spacing | |
SREQU = ">>=" Spacing | |
STAR = "*"!"=" Spacing | |
STAREQU = "*=" Spacing | |
TILDA = "~" Spacing | |
EOT = !_ |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
var candidates = ["CompilationUnit", | |
"PackageDeclaration", | |
"ImportDeclaration", | |
"TypeDeclaration", | |
"ClassDeclaration", | |
"ClassBody", | |
"ClassBodyDeclaration", | |
"MemberDecl", | |
"GenericMethodOrConstructorRest", | |
"MethodDeclaratorRest", | |
"VoidMethodDeclaratorRest", | |
"ConstructorDeclaratorRest", | |
"MethodBody", | |
"InterfaceDeclaration", | |
"InterfaceBody", | |
"InterfaceBodyDeclaration", | |
"InterfaceMemberDecl", | |
"InterfaceMethodOrFieldDecl", | |
"InterfaceMethodOrFieldRest", | |
"InterfaceMethodDeclaratorRest", | |
"InterfaceGenericMethodDecl", | |
"VoidInterfaceMethodDeclaratorRest", | |
"ConstantDeclaratorsRest", | |
"ConstantDeclarator", | |
"ConstantDeclaratorRest", | |
"EnumDeclaration", | |
"EnumBody", | |
"EnumConstants", | |
"EnumConstant", | |
"EnumBodyDeclarations", | |
"LocalVariableDeclarationStatement", | |
"VariableDeclarators", | |
"VariableDeclarator", | |
"FormalParameters", | |
"FormalParameter", | |
"LastFormalParameter", | |
"FormalParameterList", | |
"VariableDeclaratorId", | |
"Block", | |
"BlockStatements", | |
"BlockStatement", | |
"Statement", | |
"Catch", | |
"Finally", | |
"SwitchBlockStatementGroups", | |
"SwitchBlockStatementGroup", | |
"SwitchLabel", | |
"ForInit", | |
"ForUpdate", | |
"EnumConstantName", | |
"StatementExpression", | |
"ConstantExpression", | |
"Expression", | |
"AssignmentOperator", | |
"ConditionalExpression", | |
"ConditionalOrExpression", | |
"ConditionalAndExpression", | |
"InclusiveOrExpression", | |
"ExclusiveOrExpression", | |
"AndExpression", | |
"EqualityExpression", | |
"RelationalExpression", | |
"ShiftExpression", | |
"AdditiveExpression", | |
"MultiplicativeExpression", | |
"UnaryExpression", | |
"Primary", | |
"IdentifierSuffix", | |
"ExplicitGenericInvocation", | |
"NonWildcardTypeArguments", | |
"ExplicitGenericInvocationSuffix", | |
"PrefixOp", | |
"PostfixOp", | |
"Selector", | |
"SuperSuffix", | |
"BasicType", | |
"Arguments", | |
"Creator", | |
"CreatedName", | |
"InnerCreator", | |
"ArrayCreatorRest", | |
"ClassCreatorRest", | |
"ArrayInitializer", | |
"VariableInitializer", | |
"ParExpression", | |
"QualifiedIdentifier", | |
"Dim", | |
"DimExpr", | |
"Type", | |
"ReferenceType", | |
"ClassType", | |
"ClassTypeList", | |
"TypeArguments", | |
"TypeArgument", | |
"TypeParameters", | |
"TypeParameter", | |
"Bound", | |
"Modifier", | |
"AnnotationTypeDeclaration", | |
"AnnotationTypeBody", | |
"AnnotationTypeElementDeclaration", | |
"AnnotationTypeElementRest", | |
"AnnotationMethodOrConstantRest", | |
"AnnotationMethodRest", | |
"AnnotationConstantRest", | |
"DefaultValue", | |
"Annotation", | |
"NormalAnnotation", | |
"SingleElementAnnotation", | |
"MarkerAnnotation", | |
"ElementValuePairs", | |
"ElementValuePair", | |
"ElementValue", | |
"ElementValueArrayInitializer", | |
"ElementValues", | |
"_", | |
"Spacing", | |
"Identifier", | |
"Letter", | |
"LetterOrDigit", | |
"Keyword", | |
"ASSERT", | |
"BREAK", | |
"CASE", | |
"CATCH", | |
"CLASS", | |
"CONTINUE", | |
"DEFAULT", | |
"DO", | |
"ELSE", | |
"ENUM", | |
"EXTENDS", | |
"FINALLY", | |
"FINAL", | |
"FOR", | |
"IF", | |
"IMPLEMENTS", | |
"IMPORT", | |
"INTERFACE", | |
"INSTANCEOF", | |
"NEW", | |
"PACKAGE", | |
"RETURN", | |
"STATIC", | |
"SUPER", | |
"SWITCH", | |
"SYNCHRONIZED", | |
"THIS", | |
"THROWS", | |
"THROW", | |
"TRY", | |
"VOID", | |
"WHILE", | |
"Literal", | |
"IntegerLiteral", | |
"DecimalNumeral", | |
"HexNumeral", | |
"HexDigit", | |
"OctalNumeral", | |
"FloatLiteral", | |
"DecimalFloat", | |
"Exponent", | |
"Digit", | |
"HexFloat", | |
"HexSignificand", | |
"BinaryExponent", | |
"CharLiteral", | |
"StringLiteral", | |
"Escape", | |
"OctalEscape", | |
"UnicodeEscape", | |
"AT", | |
"AND", | |
"ANDAND", | |
"ANDEQU", | |
"BANG", | |
"BSR", | |
"BSREQU", | |
"COLON", | |
"COMMA", | |
"DEC", | |
"DIV", | |
"DIVEQU", | |
"DOT", | |
"ELLIPSIS", | |
"EQU", | |
"EQUAL", | |
"GE", | |
"GT", | |
"HAT", | |
"HATEQU", | |
"INC", | |
"LBRK", | |
"LE", | |
"LPAR", | |
"LPOINT", | |
"LT", | |
"LWING", | |
"MINUS", | |
"MINUSEQU", | |
"MOD", | |
"MODEQU", | |
"NOTEQUAL", | |
"OR", | |
"OREQU", | |
"OROR", | |
"PLUS", | |
"PLUSEQU", | |
"QUERY", | |
"RBRK", | |
"RPAR", | |
"RPOINT", | |
"RWING", | |
"SEMI", | |
"SL", | |
"SLEQU", | |
"SR", | |
"SREQU", | |
"STAR", | |
"STAREQU", | |
"TILDA", | |
"EOT"]; | |
var parser = require("pegjs").buildParser(require("fs").readFileSync("Java.1.6.peg", "utf8"), { allowedStartRules:candidates }); | |
console.log("CHECKING " + process.argv[2]) | |
for (i =0; i < candidates.length; ++i) | |
{ | |
try | |
{ | |
parser.parse(process.argv[2], { startRule: candidates[i] }); | |
console.log(candidates[i]); | |
} | |
catch (e) | |
{ | |
// console.log(e); | |
} | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment