java.mouse

//===========================================================================
//
//  Parsing Expression Grammar for Java 1.5 in Mouse 1.1 format.
//  Based on Chapters 3 and 18 of Java Language Specification, Third Edition (JLS)
//  at http://java.sun.com/docs/books/jls/third_edition/html/j3TOC.html.
//
//---------------------------------------------------------------------------
//
//  Copyright (C) 2006,2009 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.
//
//---------------------------------------------------------------------------
//
//  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.
// 
//===========================================================================


//-------------------------------------------------------------------------
//  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                         // 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* TypeArguments? Identifier Arguments? ClassBody?
    ;

EnumBodyDeclarations
    = SEMI ClassBodyDeclaration*
    ;

//-------------------------------------------------------------------------
//  Variable Declarations
//-------------------------------------------------------------------------

LocalVariableDeclarationStatement
    = FINAL? Type VariableDeclarators SEMI
    ;

VariableDeclarators
    = VariableDeclarator (COMMA VariableDeclarator)*
    ;

VariableDeclarator
    = Identifier Dim* (EQU VariableInitializer)?
    ;

//-------------------------------------------------------------------------
//  Formal Parameters
//-------------------------------------------------------------------------

FormalParameters
    = LPAR FormalParameterDecls? RPAR
    ;

FormalParameter
    = (FINAL / Annotation)* Type VariableDeclaratorId
    ;
 
FormalParameterDecls
    = FINAL? Annotation* Type FormalParameterDeclsRest
    ;

FormalParameterDeclsRest
    = VariableDeclaratorId (COMMA FormalParameterDecls)?
    / ELLIPSIS VariableDeclaratorId
    ;

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 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
    ;

AnnotationTypeElementRest
    = Type Identifier AnnotationMethodOrConstantRest SEMI
    / ClassDeclaration
    / EnumDeclaration
    / InterfaceDeclaration
    / AnnotationTypeDeclaration
    ;

AnnotationMethodOrConstantRest
    = AnnotationMethodRest
    / AnnotationConstantRest
    ;

AnnotationMethodRest
    = LPAR RPAR DefaultValue?
    ;

AnnotationConstantRest
    = VariableDeclarators
    ;

DefaultValue
    = DEFAULT ElementValue
    ;

Annotation
    = AT QualifiedIdentifier (LPAR (Identifier EQU)? ElementValue RPAR)?
    ;

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
//-------------------------------------------------------------------------

Keyword

    = ( "abstract" 
      / "assert"   
      / "boolean"  
      / "break"    
      / "byte"     
      / "case"     
      / "catch"    
      / "char"     
      / "class"    
      / "continue" 
      / "default"  
      / "double"   
      / "do"       
      / "else"     
      / "enum"     
      / "extends"  
      / "false"    
      / "finally"  
      / "final"    
      / "float"    
      / "for"      
      / "if"       
      / "implements"
      / "import"   
      / "interface"
      / "int"      
      / "instanceof"
      / "long"     
      / "native"   
      / "new"      
      / "null"     
      / "package"  
      / "private"  
      / "protected"
      / "public"   
      / "return"   
      / "short"    
      / "static"   
      / "strictfp" 
      / "super"    
      / "switch"   
      / "synchronized"
      / "this"     
      / "threadsafe"
      / "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]Digit*         
    ;
      
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
    = HexNumeral "."?
    / ("0x" / "0X") HexDigit* "." HexDigit+
    ;
    
BinaryExponent
    = [pP] [+\-]? Digit+
    ;

CharLiteral 
    = "'" (Escape / !['\\] _) "'"
    ;

StringLiteral 
    = "\"" (Escape / !["\\] _)* "\""
    ;

Escape 
    = "\\" ([btnfr"'\\] / OctalEscape / UnicodeEscape) 
    ;

OctalEscape 
    = [0-3][0-7][0-7]
    / [0-7][0-7]
    / [0-7]
    ;
    
UnicodeEscape
    = "u" HexDigit HexDigit HexDigit HexDigit
    ;
    
    // Unicode escape is not defined in JLS syntax because unicode
    // characters are processed very early (see 3.10.4).

//-------------------------------------------------------------------------
//  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 = !_ ;