Skip to content

Instantly share code, notes, and snippets.

Embed
What would you like to do?
//===========================================================================
//
// 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 = !_
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