comment on

I started writing one once but stopped for lack of interest. Here's where I left off. (which is actually very, very early in the process). Sun publishes the Java Language Specification which is the source for this snippet of code.

package Regex::JavaLanguage;
use utf8;

$UnicodeInputCharacter =
    qr/ $UnicodeEscape
       | $RawInputCharacter /x;

$UnicodeEscape =
    qr/ \\ $UnicodeMarker $HexDigit $HexDigit $HexDigit $HexDigit /x;

$UnicodeMarker =
    qr/ u
     | $UnicodeMarker u /x;

$RawInputCharacter = qr/\X/;

__DATA__
Identifier:
    IDENTIFIER

QualifiedIdentifier:
    Identifier { . Identifier }

Literal:
    IntegerLiteral     
    FloatingPointLiteral     
    CharacterLiteral     
    StringLiteral     
    BooleanLiteral
    NullLiteral

Expression: 
    Expression1 [AssignmentOperator Expression1]]

AssignmentOperator: 
    = 
    += 
    -= 
    *= 
    /= 
    &= 
    |= 
    ^= 
    %= 
    <<= 
    >>= 
    >>>= 

Type: 
    Identifier {   .   Identifier } BracketsOpt
    BasicType

StatementExpression: 
    Expression

ConstantExpression: 
    Expression

Expression1: 
    Expression2 [Expression1Rest]

Expression1Rest: 
    [  ?   Expression   :   Expression1]

Expression2 : 
    Expression3 [Expression2Rest]

Expression2Rest: 
    {Infixop Expression3}
    Expression3 instanceof Type

Infixop:
    || 
    && 
    | 
    ^ 
    & 
    == 
    != 
    < 
    > 
    <= 
    >= 
    << 
    >> 
    >>> 
    + 
    - 
    * 
    / 
    % 

Expression3: 
    PrefixOp Expression3
    (   Expr | Type   )   Expression3
    Primary {Selector} {PostfixOp}

Primary: 
    ( Expression )
    this [Arguments]
    super SuperSuffix
    Literal
    new Creator
    Identifier { . Identifier }[ IdentifierSuffix]
    BasicType BracketsOpt .class
    void.class

IdentifierSuffix:
    [ ( ] BracketsOpt   .   class | Expression ])
    Arguments
    .   ( class | this | super Arguments | new InnerCreator )

PrefixOp:
    ++ 
    -- 
    ! 
    ~ 
    + 
    - 

PostfixOp: 
    ++ 
    -- 

Selector: 
    . Identifier [Arguments]
    . this
    . super SuperSuffix
    . new InnerCreator
    [ Expression ]

SuperSuffix: 
    Arguments 
    . Identifier [Arguments]

BasicType: 
    byte 
    short 
    char 
    int 
    long 
    float 
    double 
    boolean

ArgumentsOpt: 
    [ Arguments ]

Arguments: 
    ( [Expression { , Expression }] )

BracketsOpt: 
    {[]}

Creator: 
    QualifiedIdentifier ( ArrayCreatorRest  | ClassCreatorRest )

InnerCreator: 
    Identifier ClassCreatorRest

ArrayCreatorRest: 
    [ ( ] BracketsOpt ArrayInitializer | Expression ] {[ Expression ]}
+ 
BracketsOpt )

ClassCreatorRest: 
    Arguments [ClassBody]

ArrayInitializer: 
    { [VariableInitializer {, VariableInitializer} [,]] }

VariableInitializer: 
    ArrayInitializer
    Expression

ParExpression: 
    ( Expression )

Block: 
    { BlockStatements }

BlockStatements: 
    { BlockStatement }

BlockStatement : 
    LocalVariableDeclarationStatement
    ClassOrInterfaceDeclaration
    [Identifier :] Statement

LocalVariableDeclarationStatement:
    [final] Type VariableDeclarators   ;  

Statement:
    Block
    if ParExpression Statement [else Statement]
    for ( ForInitOpt   ;   [Expression]   ;   ForUpdateOpt ) Statement
    while ParExpression Statement
    do Statement while ParExpression   ; 
    try Block ( Catches | [Catches] finally Block )
    switch ParExpression { SwitchBlockStatementGroups }
    synchronized ParExpression Block
    return [Expression] ; 
    throw Expression   ; 
    break [Identifier]
    continue [Identifier]
    ; 
    ExpressionStatement
    Identifier   :   Statement

Catches:
    CatchClause {CatchClause}

CatchClause: 
    catch ( FormalParameter ) Block

SwitchBlockStatementGroups: 
    { SwitchBlockStatementGroup }

SwitchBlockStatementGroup: 
    SwitchLabel BlockStatements

SwitchLabel: 
    case ConstantExpression   :
    default:  

MoreStatementExpressions: 
    { , StatementExpression }

ForInit: 
    StatementExpression MoreStatementExpressions
    [final] Type VariableDeclarators

ForUpdate: 
    StatementExpression MoreStatementExpressions

ModifiersOpt: 
    { Modifier }

Modifier: 
    public 
    protected 
    private 
    static 
    abstract 
    final 
    native 
    synchronized 
    transient 
    volatile
    strictfp

VariableDeclarators: 
    VariableDeclarator { ,   VariableDeclarator }

VariableDeclaratorsRest: 
    VariableDeclaratorRest { ,   VariableDeclarator }

ConstantDeclaratorsRest: 
    ConstantDeclaratorRest { ,   ConstantDeclarator }

VariableDeclarator: 
    Identifier VariableDeclaratorRest

ConstantDeclarator: 
    Identifier ConstantDeclaratorRest

VariableDeclaratorRest: 
    BracketsOpt [  =   VariableInitializer]

ConstantDeclaratorRest: 
    BracketsOpt   =   VariableInitializer

VariableDeclaratorId: 
    Identifier BracketsOpt

CompilationUnit: 
    [package QualifiedIdentifier   ;  ] {ImportDeclaration} 
{TypeDeclaration}

ImportDeclaration: 
    import Identifier {   .   Identifier } [   .     *   ] ;  

TypeDeclaration: 
    ClassOrInterfaceDeclaration
    ;

ClassOrInterfaceDeclaration: 
    ModifiersOpt (ClassDeclaration | InterfaceDeclaration)

ClassDeclaration: 
    class Identifier [extends Type] [implements TypeList] ClassBody

InterfaceDeclaration: 
    interface Identifier [extends TypeList] InterfaceBody

TypeList: 
    Type {  ,   Type}

ClassBody: 
    { {ClassBodyDeclaration} }

InterfaceBody: 
    { {InterfaceBodyDeclaration} }

ClassBodyDeclaration:
    ; 
    [static] Block
    ModifiersOpt MemberDecl

MemberDecl:
    MethodOrFieldDecl
    void Identifier MethodDeclaratorRest
    Identifier ConstructorDeclaratorRest
    ClassOrInterfaceDeclaration

MethodOrFieldDecl:
    Type Identifier MethodOrFieldRest

MethodOrFieldRest:
    VariableDeclaratorRest
    MethodDeclaratorRest

InterfaceBodyDeclaration:
    ; 
    ModifiersOpt InterfaceMemberDecl

InterfaceMemberDecl:
    InterfaceMethodOrFieldDecl
    void Identifier VoidInterfaceMethodDeclaratorRest
    ClassOrInterfaceDeclaration

InterfaceMethodOrFieldDecl:
    Type Identifier InterfaceMethodOrFieldRest

InterfaceMethodOrFieldRest:
    ConstantDeclaratorsRest ;
    InterfaceMethodDeclaratorRest

MethodDeclaratorRest:
        FormalParameters BracketsOpt [throws QualifiedIdentifierList] 
+( 
MethodBody |   ;  )

VoidMethodDeclaratorRest:
        FormalParameters [throws QualifiedIdentifierList] ( MethodBody
+ |   ;  )

InterfaceMethodDeclaratorRest:
    FormalParameters BracketsOpt [throws QualifiedIdentifierList]   ; 
+ 

VoidInterfaceMethodDeclaratorRest:
    FormalParameters [throws QualifiedIdentifierList]   ;  

ConstructorDeclaratorRest:
    FormalParameters [throws QualifiedIdentifierList] MethodBody

QualifiedIdentifierList: 
    QualifiedIdentifier {  ,   QualifiedIdentifier}

FormalParameters: 
    ( [FormalParameter { , FormalParameter}] )

FormalParameter: 
    [final] Type VariableDeclaratorId

MethodBody:
    Block
[download]

In reply to Re: Java Language Parser by diotalevi
in thread Java Language Parser by enoch

Are you posting in the right place? Check out Where do I post X? to know for sure.
Posts may use any of the Perl Monks Approved HTML tags. Currently these include the following:
<code> <a> <b> <big> <blockquote> <br /> <dd> <dl> <dt> <em> <font> <h1> <h2> <h3> <h4> <h5> <h6> <hr /> <i> <li> <nbsp> <ol> <p> <small> <strike> <strong> <sub> <sup> <table> <td> <th> <tr> <tt> <u> <ul>
Snippets of code should be wrapped in <code> tags not <pre> tags. In fact, <pre> tags should generally be avoided. If they must be used, extreme care should be taken to ensure that their contents do not have long lines (<70 chars), in order to prevent horizontal scrolling (and possible janitor intervention).
Want more info? How to link or How to display code and escape characters are good places to start.


Keep It Simple, Stupid
	PerlMonks