/*

* Janino - An embedded Java[TM] compiler

*

* Copyright (c) 2001-2010, Arno Unkrig

* All rights reserved.

*

* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the

* following conditions are met:

*

* 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the

* following disclaimer.

* 2. 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.

* 3. The name of the author may not be used to endorse or promote products derived from this software without

* specific prior written permission.

*

* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.

*/

package org.codehaus.janino;

import java.io.IOException;

import java.util.ArrayList;

import java.util.List;

import org.codehaus.commons.compiler.CompileException;

import org.codehaus.commons.compiler.Location;

import org.codehaus.commons.compiler.WarningHandler;

import org.codehaus.janino.Java.AlternateConstructorInvocation;

import org.codehaus.janino.Java.AmbiguousName;

import org.codehaus.janino.Java.Annotation;

import org.codehaus.janino.Java.AnonymousClassDeclaration;

import org.codehaus.janino.Java.ArrayAccessExpression;

import org.codehaus.janino.Java.ArrayInitializer;

import org.codehaus.janino.Java.ArrayInitializerOrRvalue;

import org.codehaus.janino.Java.ArrayType;

import org.codehaus.janino.Java.AssertStatement;

import org.codehaus.janino.Java.Assignment;

import org.codehaus.janino.Java.Atom;

import org.codehaus.janino.Java.BasicType;

import org.codehaus.janino.Java.BinaryOperation;

import org.codehaus.janino.Java.Block;

import org.codehaus.janino.Java.BlockStatement;

import org.codehaus.janino.Java.BooleanLiteral;

import org.codehaus.janino.Java.BreakStatement;

import org.codehaus.janino.Java.Cast;

import org.codehaus.janino.Java.CatchClause;

import org.codehaus.janino.Java.CharacterLiteral;

import org.codehaus.janino.Java.ClassDeclaration;

import org.codehaus.janino.Java.ClassLiteral;

import org.codehaus.janino.Java.CompilationUnit;

import org.codehaus.janino.Java.CompilationUnit.ImportDeclaration;

import org.codehaus.janino.Java.ConditionalExpression;

import org.codehaus.janino.Java.ConstructorDeclarator;

import org.codehaus.janino.Java.ConstructorInvocation;

import org.codehaus.janino.Java.ContinueStatement;

import org.codehaus.janino.Java.Crement;

import org.codehaus.janino.Java.DoStatement;

import org.codehaus.janino.Java.ElementValue;

import org.codehaus.janino.Java.ElementValuePair;

import org.codehaus.janino.Java.EmptyStatement;

import org.codehaus.janino.Java.ExpressionStatement;

import org.codehaus.janino.Java.FieldAccessExpression;

import org.codehaus.janino.Java.FieldDeclaration;

import org.codehaus.janino.Java.FloatingPointLiteral;

import org.codehaus.janino.Java.ForEachStatement;

import org.codehaus.janino.Java.ForStatement;

import org.codehaus.janino.Java.FunctionDeclarator.FormalParameter;

import org.codehaus.janino.Java.FunctionDeclarator.FormalParameters;

import org.codehaus.janino.Java.IfStatement;

import org.codehaus.janino.Java.Initializer;

import org.codehaus.janino.Java.Instanceof;

import org.codehaus.janino.Java.IntegerLiteral;

import org.codehaus.janino.Java.InterfaceDeclaration;

import org.codehaus.janino.Java.LabeledStatement;

import org.codehaus.janino.Java.LocalClassDeclaration;

import org.codehaus.janino.Java.LocalClassDeclarationStatement;

import org.codehaus.janino.Java.LocalVariableDeclarationStatement;

import org.codehaus.janino.Java.Lvalue;

import org.codehaus.janino.Java.MemberClassDeclaration;

import org.codehaus.janino.Java.MemberInterfaceDeclaration;

import org.codehaus.janino.Java.MemberTypeDeclaration;

import org.codehaus.janino.Java.MethodDeclarator;

import org.codehaus.janino.Java.MethodInvocation;

import org.codehaus.janino.Java.Modifiers;

import org.codehaus.janino.Java.NamedClassDeclaration;

import org.codehaus.janino.Java.NewAnonymousClassInstance;

import org.codehaus.janino.Java.NewArray;

import org.codehaus.janino.Java.NewClassInstance;

import org.codehaus.janino.Java.NewInitializedArray;

import org.codehaus.janino.Java.NullLiteral;

import org.codehaus.janino.Java.PackageDeclaration;

import org.codehaus.janino.Java.PackageMemberClassDeclaration;

import org.codehaus.janino.Java.PackageMemberInterfaceDeclaration;

import org.codehaus.janino.Java.PackageMemberTypeDeclaration;

import org.codehaus.janino.Java.ParenthesizedExpression;

import org.codehaus.janino.Java.QualifiedThisReference;

import org.codehaus.janino.Java.ReferenceType;

import org.codehaus.janino.Java.ReturnStatement;

import org.codehaus.janino.Java.Rvalue;

import org.codehaus.janino.Java.RvalueMemberType;

import org.codehaus.janino.Java.Statement;

import org.codehaus.janino.Java.StringLiteral;

import org.codehaus.janino.Java.SuperConstructorInvocation;

import org.codehaus.janino.Java.SuperclassFieldAccessExpression;

import org.codehaus.janino.Java.SuperclassMethodInvocation;

import org.codehaus.janino.Java.SwitchStatement;

import org.codehaus.janino.Java.SynchronizedStatement;

import org.codehaus.janino.Java.ThisReference;

import org.codehaus.janino.Java.ThrowStatement;

import org.codehaus.janino.Java.TryStatement;

import org.codehaus.janino.Java.Type;

import org.codehaus.janino.Java.TypeArgument;

import org.codehaus.janino.Java.TypeParameter;

import org.codehaus.janino.Java.UnaryOperation;

import org.codehaus.janino.Java.VariableDeclarator;

import org.codehaus.janino.Java.WhileStatement;

import org.codehaus.janino.Java.Wildcard;

import org.codehaus.janino.Scanner.Token;

import org.codehaus.janino.util.enumerator.Enumerator;

/**

* A parser for the Java™ programming language.

* <p>

* 'JLS7' refers to the <a href="http://docs.oracle.com/javase/specs/">Java Language Specification, Java SE 7

* Edition</a>.

*/

@SuppressWarnings({ "rawtypes", "unchecked" }) public

class Parser {

private final Scanner scanner;

public

Parser(Scanner scanner) { this.scanner = scanner; }

/** @return The scanner that produces the tokens for this parser. */

public Scanner

getScanner() { return this.scanner; }

/**

* <pre>

* CompilationUnit := [ PackageDeclaration ]

* { ImportDeclaration }

* { TypeDeclaration }

* </pre>

*/

public CompilationUnit

parseCompilationUnit() throws CompileException, IOException {

CompilationUnit compilationUnit = new CompilationUnit(this.location().getFileName());

if (this.peek("package")) {

compilationUnit.setPackageDeclaration(this.parsePackageDeclaration());

}

while (this.peek("import")) {

compilationUnit.addImportDeclaration(this.parseImportDeclaration());

}

while (!this.peekEof()) {

if (this.peekRead(";")) continue;

compilationUnit.addPackageMemberTypeDeclaration(this.parsePackageMemberTypeDeclaration());

}

return compilationUnit;

}

/**

* <pre>

* PackageDeclaration := 'package' QualifiedIdentifier ';'

* </pre>

*/

public PackageDeclaration

parsePackageDeclaration() throws CompileException, IOException {

this.read("package");

Location loc = this.location();

String packageName = Parser.join(this.parseQualifiedIdentifier(), ".");

this.read(";");

this.verifyStringIsConventionalPackageName(packageName, loc);

return new PackageDeclaration(loc, packageName);

}

/**

* <pre>

* ImportDeclaration := 'import' ImportDeclarationBody ';'

* </pre>

*/

public CompilationUnit.ImportDeclaration

parseImportDeclaration() throws CompileException, IOException {

this.read("import");

CompilationUnit.ImportDeclaration importDeclaration = this.parseImportDeclarationBody();

this.read(";");

return importDeclaration;

}

/**

* <pre>

* ImportDeclarationBody := [ 'static' ] Identifier { '.' Identifier } [ '.' '*' ]

* </pre>

*/

public CompilationUnit.ImportDeclaration

parseImportDeclarationBody() throws CompileException, IOException {

final Location loc = this.location();

boolean isStatic = this.peekRead("static");

List<String> l = new ArrayList();

l.add(this.readIdentifier());

for (;;) {

if (!this.peek(".")) {

String[] identifiers = (String[]) l.toArray(new String[l.size()]);

return (

isStatic

? (ImportDeclaration) new CompilationUnit.SingleStaticImportDeclaration(loc, identifiers)

: (ImportDeclaration) new CompilationUnit.SingleTypeImportDeclaration(loc, identifiers)

);

}

this.read(".");

if (this.peekRead("*")) {

String[] identifiers = (String[]) l.toArray(new String[l.size()]);

return (

isStatic

? (ImportDeclaration) new CompilationUnit.StaticImportOnDemandDeclaration(loc, identifiers)

: (ImportDeclaration) new CompilationUnit.TypeImportOnDemandDeclaration(loc, identifiers)

);

}

l.add(this.readIdentifier());

}

}

/**

* <pre>

* QualifiedIdentifier := Identifier { '.' Identifier }

* </pre>

*/

public String[]

parseQualifiedIdentifier() throws CompileException, IOException {

List<String> l = new ArrayList();

l.add(this.readIdentifier());

while (this.peek(".") && this.peekNextButOne().type == Token.IDENTIFIER) {

this.read();

l.add(this.readIdentifier());

}

return (String[]) l.toArray(new String[l.size()]);

}

/**

* <pre>

* PackageMemberTypeDeclaration :=

* ModifiersOpt 'class' ClassDeclarationRest |

* ModifiersOpt 'interface' InterfaceDeclarationRest

* </pre>

*/

public PackageMemberTypeDeclaration

parsePackageMemberTypeDeclaration() throws CompileException, IOException {

String optionalDocComment = this.scanner.doc();

Modifiers modifiers = this.parseModifiers();

switch (this.read(new String[] { "class", "interface" })) {

case 0:

if (optionalDocComment == null) this.warning("CDCM", "Class doc comment missing", this.location());

return (PackageMemberClassDeclaration) this.parseClassDeclarationRest(

optionalDocComment, // optionalDocComment

modifiers, // modifiers

ClassDeclarationContext.COMPILATION_UNIT // context

);

case 1:

if (optionalDocComment == null) this.warning("IDCM", "Interface doc comment missing", this.location());

return (PackageMemberInterfaceDeclaration) this.parseInterfaceDeclarationRest(

optionalDocComment, // optionalDocComment

modifiers, // modifiers

InterfaceDeclarationContext.COMPILATION_UNIT // context

);

default:

throw new IllegalStateException();

}

}

/**

* <pre>

* ModifiersAndAnnotations := { 'public' | 'protected' | 'private' | 'static' | 'abstract' | 'final' | 'native'

* | 'synchronized' | 'transient' | 'volatile' | 'strictfp' | Annotation }

* </pre>

*/

public Java.Modifiers

parseModifiers() throws CompileException, IOException {

short mod = 0;

List<Java.Annotation> as = new ArrayList();

for (;;) {

if (this.peek("@")) {

as.add(this.parseAnnotation());

continue;

}

int idx = this.peekRead(Parser.MODIFIER_NAMES);

if (idx == -1) break;

String kw = Parser.MODIFIER_NAMES[idx];

short x = Parser.MODIFIER_CODES[idx];

if ((mod & x) != 0) throw this.compileException("Duplicate modifier \"" + kw + "\"");

for (short m : Parser.MUTUALLY_EXCLUSIVE_MODIFIER_CODES) {

if ((x & m) != 0 && (mod & m) != 0) {

throw this.compileException("Only one of '" + Mod.shortToString(m) + "' allowed");

}

}

mod |= x;

}

return new Modifiers(mod, (Annotation[]) as.toArray(new Java.Annotation[as.size()]));

}

private static final String[] MODIFIER_NAMES = {

"public", "protected", "private", "static", "abstract", "final", "native", "synchronized",

"transient", "volatile", "strictfp"

};

private static final short[] MODIFIER_CODES = {

Mod.PUBLIC, Mod.PROTECTED, Mod.PRIVATE, Mod.STATIC, Mod.ABSTRACT, Mod.FINAL, Mod.NATIVE, Mod.SYNCHRONIZED,

Mod.TRANSIENT, Mod.VOLATILE, Mod.STRICTFP

};

private static final short[] MUTUALLY_EXCLUSIVE_MODIFIER_CODES = {

Mod.PUBLIC | Mod.PROTECTED | Mod.PRIVATE,

Mod.ABSTRACT | Mod.FINAL,

};

/**

* <pre>

* Annotation :=

* MarkerAnnotation // JLS7 9.7.2

* | SingleElementAnnotation // JLS7 9.7.3

* | NormalAnnotation // JLS7 9.7.1

*

* MarkerAnnotation := '@' Identifier

*

* SingleElementAnnotation := '@' Identifier '(' ElementValue ')'

*

* NormalAnnotation := '@' TypeName '(' ElementValuePairsOpt ')'

*

* ElementValuePairsOpt := [ ElementValuePair { ',' ElementValuePair } ]

* </pre>

*/

private Java.Annotation

parseAnnotation() throws CompileException, IOException {

this.read("@");

ReferenceType type = this.parseReferenceType();

if (!this.peekRead("(")) return new Java.MarkerAnnotation(type);

if (this.peekIdentifier() == null || !this.peekNextButOne("=")) {

Java.ElementValue elementValue = this.parseElementValue();

this.read(")");

return new Java.SingleElementAnnotation(type, elementValue);

}

List<Java.ElementValuePair> evps = new ArrayList();

while (!this.peekRead(")")) evps.add(this.parseElementValuePair());

return new Java.NormalAnnotation(

type,

(ElementValuePair[]) evps.toArray(new Java.ElementValuePair[evps.size()])

);

}

/**

* <pre>

* ElementValuePair := Identifier '=' ElementValue

* </pre>

*/

private Java.ElementValuePair

parseElementValuePair() throws CompileException, IOException {

String identifier = this.readIdentifier();

this.read("=");

return new Java.ElementValuePair(identifier, this.parseElementValue());

}

/**

* <pre>

* ElementValue :=

* ConditionalExpression

* | Annotation

* | ElementValueArrayInitializer

* </pre>

*/

private Java.ElementValue

parseElementValue() throws CompileException, IOException {

if (this.peek("@")) return this.parseAnnotation();

if (this.peek("{")) return this.parseElementValueArrayInitializer();

return this.parseConditionalAndExpression().toRvalueOrCompileException();

}

/**

* <pre>

* ElementValueArrayInitializer := '{' { ElementValue | ',' } '}'

* </pre>

*/

private ElementValue

parseElementValueArrayInitializer() throws CompileException, IOException {

this.read("{");

List<Java.ElementValue> evs = new ArrayList();

while (!this.peekRead("}")) {

if (this.peekRead(",")) continue;

evs.add(this.parseElementValue());

}

return new Java.ElementValueArrayInitializer((ElementValue[]) evs.toArray(new Java.ElementValue[evs.size()]));

}

/**

* <pre>

* ClassDeclarationRest :=

* Identifier [ typeParameters ]

* [ 'extends' ReferenceType ]

* [ 'implements' ReferenceTypeList ]

* ClassBody

* </pre>

*/

public NamedClassDeclaration

parseClassDeclarationRest(

String optionalDocComment,

Modifiers modifiers,

ClassDeclarationContext context

) throws CompileException, IOException {

Location location = this.location();

String className = this.readIdentifier();

this.verifyIdentifierIsConventionalClassOrInterfaceName(className, location);

TypeParameter[] optionalTypeParameters = this.parseTypeParametersOpt();

ReferenceType optionalExtendedType = null;

if (this.peekRead("extends")) {

optionalExtendedType = this.parseReferenceType();

}

ReferenceType[] implementedTypes = new ReferenceType[0];

if (this.peekRead("implements")) {

implementedTypes = this.parseReferenceTypeList();

}

NamedClassDeclaration namedClassDeclaration;

if (context == ClassDeclarationContext.COMPILATION_UNIT) {

namedClassDeclaration = new PackageMemberClassDeclaration(

location, // location

optionalDocComment, // optionalDocComment

modifiers, // modifiers

className, // name

optionalTypeParameters, // optionalTypeParameters

optionalExtendedType, // optinalExtendedType

implementedTypes // implementedTypes

);

} else

if (context == ClassDeclarationContext.TYPE_DECLARATION) {

namedClassDeclaration = new MemberClassDeclaration(

location, // location

optionalDocComment, // optionalDocComment

modifiers, // modifiers

className, // name

optionalTypeParameters, // optionalTypeParameters

optionalExtendedType, // optionalExtendedType

implementedTypes // implementedTypes

);

} else

if (context == ClassDeclarationContext.BLOCK) {

namedClassDeclaration = new LocalClassDeclaration(

location, // location

optionalDocComment, // optionalDocComment

modifiers, // modifiers

className, // name

optionalTypeParameters, // optionalTypeParameters

optionalExtendedType, // optionalExtendedType

implementedTypes // implementedTypes

);

} else

{

throw new JaninoRuntimeException("SNO: Class declaration in unexpected context " + context);

}

this.parseClassBody(namedClassDeclaration);

return namedClassDeclaration;

}

/** Enumerator for the kinds of context where a class declaration can occur. */

public static final

class ClassDeclarationContext extends Enumerator {

/** Enumerator for the kinds of context where a class declaration can occur. */

/** The class declaration appears inside a 'block'. */

/** The class declaration appears inside a 'block'. */

public static final ClassDeclarationContext BLOCK = new ClassDeclarationContext("block");

/** The class declaration appears (directly) inside a type declaration. */

public static final ClassDeclarationContext TYPE_DECLARATION = new ClassDeclarationContext("type_declaration");

/** The class declaration appears on the top level. */

public static final ClassDeclarationContext COMPILATION_UNIT = new ClassDeclarationContext("compilation_unit");

private ClassDeclarationContext(String name) { super(name); }

}

/**

* <pre>

* ClassBody := '{' { ClassBodyDeclaration } '}'

* </pre>

*/

public void

parseClassBody(ClassDeclaration classDeclaration) throws CompileException, IOException {

this.read("{");

for (;;) {

if (this.peekRead("}")) return;

this.parseClassBodyDeclaration(classDeclaration);

}

}

/**

* <pre>

* ClassBodyDeclaration :=

* ';' |

* ModifiersOpt (

* Block | // Instance (JLS7 8.6) or static initializer (JLS7 8.7)

* 'void' Identifier MethodDeclarationRest |

* 'class' ClassDeclarationRest |

* 'interface' InterfaceDeclarationRest |

* ConstructorDeclarator |

* Type Identifier (

* MethodDeclarationRest |

* FieldDeclarationRest ';'

* )

* )

*

* </pre>

*/

public void

parseClassBodyDeclaration(ClassDeclaration classDeclaration) throws CompileException, IOException {

if (this.peekRead(";")) return;

String optionalDocComment = this.scanner.doc();

Modifiers modifiers = this.parseModifiers();

// Initializer?

if (this.peek("{")) {

if ((modifiers.flags & ~Mod.STATIC) != 0) {

throw this.compileException("Only modifier \"static\" allowed on initializer");

}

Initializer initializer = new Initializer(

this.location(), // location

Mod.isStatic(modifiers.flags), // statiC

this.parseBlock() // block

);

classDeclaration.addInitializer(initializer);

return;

}

// "void" method declaration.

if (this.peekRead("void")) {

Location location = this.location();

if (optionalDocComment == null) this.warning("MDCM", "Method doc comment missing", location);

String name = this.readIdentifier();

classDeclaration.addDeclaredMethod(this.parseMethodDeclarationRest(

optionalDocComment, // optionalDocComment

modifiers, // modifiers

new BasicType(location, BasicType.VOID), // type

name // name

));

return;

}

// Member class.

if (this.peekRead("class")) {

if (optionalDocComment == null) this.warning("MCDCM", "Member class doc comment missing", this.location());

classDeclaration.addMemberTypeDeclaration((MemberTypeDeclaration) this.parseClassDeclarationRest(

optionalDocComment, // optionalDocComment

modifiers, // modifiers

ClassDeclarationContext.TYPE_DECLARATION // context

));

return;

}

// Member interface.

if (this.peekRead("interface")) {

if (optionalDocComment == null) {

this.warning("MIDCM", "Member interface doc comment missing", this.location());

}

classDeclaration.addMemberTypeDeclaration((MemberTypeDeclaration) this.parseInterfaceDeclarationRest(

optionalDocComment, // optionalDocComment

modifiers.add(Mod.STATIC), // modifiers

InterfaceDeclarationContext.NAMED_TYPE_DECLARATION // context

));

return;

}

// Constructor.

if (

classDeclaration instanceof NamedClassDeclaration

&& this.peek().value.equals(((NamedClassDeclaration) classDeclaration).getName())

&& this.peekNextButOne("(")

) {

if (optionalDocComment == null) this.warning("CDCM", "Constructor doc comment missing", this.location());

classDeclaration.addConstructor(this.parseConstructorDeclarator(

optionalDocComment, // declaringClass

modifiers // modifiers

));

return;

}

// Member method or field.

Type memberType = this.parseType();

Location location = this.location();

String memberName = this.readIdentifier();

// Method declarator.

if (this.peek("(")) {

if (optionalDocComment == null) this.warning("MDCM", "Method doc comment missing", this.location());

classDeclaration.addDeclaredMethod(this.parseMethodDeclarationRest(

optionalDocComment, // optionalDocComment

modifiers, // modifiers

memberType, // type

memberName // name

));

return;

}

// Field declarator.

if (optionalDocComment == null) this.warning("FDCM", "Field doc comment missing", this.location());

FieldDeclaration fd = new FieldDeclaration(

location, // location

optionalDocComment, // optionalDocComment

modifiers, // modifiers

memberType, // type

this.parseFieldDeclarationRest(memberName) // variableDeclarators

);

this.read(";");

classDeclaration.addFieldDeclaration(fd);

}

/**

* <pre>

* InterfaceDeclarationRest :=

* Identifier [ typeParameters ]

* [ 'extends' ReferenceTypeList ]

* InterfaceBody

* </pre>

*/

public InterfaceDeclaration

parseInterfaceDeclarationRest(

String optionalDocComment,

Modifiers modifiers,

InterfaceDeclarationContext context

) throws CompileException, IOException {

Location location = this.location();

String interfaceName = this.readIdentifier();

this.verifyIdentifierIsConventionalClassOrInterfaceName(interfaceName, location);

TypeParameter[] optionalTypeParameters = this.parseTypeParametersOpt();

ReferenceType[] extendedTypes = new ReferenceType[0];

if (this.peekRead("extends")) {

extendedTypes = this.parseReferenceTypeList();

}

InterfaceDeclaration interfaceDeclaration;

if (context == InterfaceDeclarationContext.COMPILATION_UNIT) {

interfaceDeclaration = new PackageMemberInterfaceDeclaration(

location, // location

optionalDocComment, // optionalDocComment

modifiers, // modifiers

interfaceName, // name

optionalTypeParameters, // optionalTypeParameters

extendedTypes // extendedTypes

);

} else

if (context == InterfaceDeclarationContext.NAMED_TYPE_DECLARATION) {

interfaceDeclaration = new MemberInterfaceDeclaration(

location, // location

optionalDocComment, // optionalDocComment

modifiers, // modifiers

interfaceName, // name

optionalTypeParameters, // optionalTypeParameters

extendedTypes // extendedTypes

);

} else

{

throw new JaninoRuntimeException("SNO: Interface declaration in unexpected context " + context);

}

this.parseInterfaceBody(interfaceDeclaration);

return interfaceDeclaration;

}

/** Enumerator for the kinds of context where an interface declaration can occur. */

public static final

class InterfaceDeclarationContext extends Enumerator {

/** The interface declaration appears (directly) inside a 'named type declaration'. */

public static final InterfaceDeclarationContext

NAMED_TYPE_DECLARATION = new InterfaceDeclarationContext("named_type_declaration");

/** The interface declaration appears at the top level. */

public static final InterfaceDeclarationContext

COMPILATION_UNIT = new InterfaceDeclarationContext("compilation_unit");

private InterfaceDeclarationContext(String name) { super(name); }

}

/**

* <pre>

* InterfaceBody := '{' {

* ';' |

* ModifiersOpt (

* 'void' Identifier MethodDeclarationRest |

* 'class' ClassDeclarationRest |

* 'interface' InterfaceDeclarationRest |

* Type Identifier (

* MethodDeclarationRest |

* FieldDeclarationRest

* )

* )

* } '}'

* </pre>

*/

public void

parseInterfaceBody(InterfaceDeclaration interfaceDeclaration) throws CompileException, IOException {

this.read("{");

while (!this.peekRead("}")) {

if (this.peekRead(";")) continue;

String optionalDocComment = this.scanner.doc();

Modifiers modifiers = this.parseModifiers();

// "void" method declaration.

if (this.peekRead("void")) {

if (optionalDocComment == null) this.warning("MDCM", "Method doc comment missing", this.location());

Location location = this.location();

String name = this.readIdentifier();

interfaceDeclaration.addDeclaredMethod(this.parseMethodDeclarationRest(

optionalDocComment, // optionalDocComment

modifiers.add(Mod.ABSTRACT | Mod.PUBLIC), // modifiers

new BasicType(location, BasicType.VOID), // type

name // name

));

} else

// Member class.

if (this.peekRead("class")) {

if (optionalDocComment == null) {

this.warning("MCDCM", "Member class doc comment missing", this.location());

}

interfaceDeclaration.addMemberTypeDeclaration(

(MemberTypeDeclaration) this.parseClassDeclarationRest(

optionalDocComment, // optionalDocComment

modifiers.add(Mod.STATIC | Mod.PUBLIC), // ModifiersAndAnnotations

ClassDeclarationContext.TYPE_DECLARATION // context

)

);

} else

// Member interface.

if (this.peekRead("interface")) {

if (optionalDocComment == null) {

this.warning("MIDCM", "Member interface doc comment missing", this.location());

}

interfaceDeclaration.addMemberTypeDeclaration(

(MemberTypeDeclaration) this.parseInterfaceDeclarationRest(

optionalDocComment, // optionalDocComment

modifiers.add(Mod.STATIC | Mod.PUBLIC), // ModifiersAndAnnotations

InterfaceDeclarationContext.NAMED_TYPE_DECLARATION // context

)

);

} else

// Member method or field.

{

this.parseTypeArgumentsOpt();

Type memberType = this.parseType();

String memberName = this.readIdentifier();

Location location = this.location();

// Method declarator.

if (this.peek("(")) {

if (optionalDocComment == null) this.warning("MDCM", "Method doc comment missing", this.location());

interfaceDeclaration.addDeclaredMethod(this.parseMethodDeclarationRest(

optionalDocComment, // optionalDocComment

modifiers.add(Mod.ABSTRACT | Mod.PUBLIC), // modifiers

memberType, // type

memberName // name

));

} else

// Field declarator.

{

if (optionalDocComment == null) this.warning("FDCM", "Field doc comment missing", this.location());

FieldDeclaration fd = new FieldDeclaration(

location, // location

optionalDocComment, // optionalDocComment

modifiers.add(Mod.PUBLIC | Mod.STATIC | Mod.FINAL), // modifiers

memberType, // type

this.parseFieldDeclarationRest(memberName) // variableDeclarators

);

interfaceDeclaration.addConstantDeclaration(fd);

}

}

}

}

/**

* <pre>

* ConstructorDeclarator :=

* Identifier

* FormalParameters

* [ 'throws' ReferenceTypeList ]

* '{'

* [ 'this' Arguments ';' | 'super' Arguments ';' | Primary '.' 'super' Arguments ';' ]

* BlockStatements

* '}'

* </pre>

*/

public ConstructorDeclarator

parseConstructorDeclarator(String optionalDocComment, Modifiers modifiers)

throws CompileException, IOException {

this.readIdentifier(); // Class name

// Parse formal parameters.

final FormalParameters formalParameters = this.parseFormalParameters();

// Parse "throws" clause.

ReferenceType[] thrownExceptions;

if (this.peekRead("throws")) {

thrownExceptions = this.parseReferenceTypeList();

} else {

thrownExceptions = new ReferenceType[0];

}

// Parse constructor body.

final Location location = this.location();

this.read("{");

// Special treatment for the first statement of the constructor body: If this is surely an

// expression statement, and if it could be a "ConstructorInvocation", then parse the

// expression and check if it IS a ConstructorInvocation.

ConstructorInvocation optionalConstructorInvocation = null;

List<BlockStatement> statements = new ArrayList();

if (

this.peek(new String[] {

"this", "super", "new", "void",

"byte", "char", "short", "int", "long", "float", "double", "boolean",

}) != -1

|| this.peekLiteral()

|| this.peekIdentifier() != null

) {

Atom a = this.parseExpression();

if (a instanceof ConstructorInvocation) {

this.read(";");

optionalConstructorInvocation = (ConstructorInvocation) a;

} else {

Statement s;

if (this.peekIdentifier() != null) {

Type variableType = a.toTypeOrCompileException();

s = new LocalVariableDeclarationStatement(

a.getLocation(), // location

new Java.Modifiers(Mod.NONE), // modifiers

variableType, // type

this.parseVariableDeclarators() // variableDeclarators

);

this.read(";");

} else {

s = new ExpressionStatement(a.toRvalueOrCompileException());

this.read(";");

}

statements.add(s);

}

}

statements.addAll(this.parseBlockStatements());

this.read("}");

return new ConstructorDeclarator(

location, // location

optionalDocComment, // optionalDocComment

modifiers, // modifiers

formalParameters, // formalParameters

thrownExceptions, // thrownExceptions

optionalConstructorInvocation, // optionalConstructorInvocationStatement

statements // statements

);

}

/**

* <pre>

* MethodDeclarationRest :=

* FormalParameters

* { '[' ']' }

* [ 'throws' ReferenceTypeList ]

* ( ';' | MethodBody )

* </pre>

*/

public MethodDeclarator

parseMethodDeclarationRest(

String optionalDocComment,

Modifiers modifiers,

Type type,

String name

) throws CompileException, IOException {

Location location = this.location();

this.verifyIdentifierIsConventionalMethodName(name, location);

final FormalParameters formalParameters = this.parseFormalParameters();

for (int i = this.parseBracketsOpt(); i > 0; --i) type = new ArrayType(type);

ReferenceType[] thrownExceptions;

if (this.peekRead("throws")) {

thrownExceptions = this.parseReferenceTypeList();

} else {

thrownExceptions = new ReferenceType[0];

}

List<BlockStatement> optionalStatements;

if (this.peekRead(";")) {

if (!Mod.isAbstract(modifiers.flags) && !Mod.isNative(modifiers.flags)) {

throw this.compileException("Non-abstract, non-native method must have a body");

}

optionalStatements = null;

} else {

if (Mod.isAbstract(modifiers.flags) || Mod.isNative(modifiers.flags)) {

throw this.compileException("Abstract or native method must not have a body");

}

this.read("{");

optionalStatements = this.parseBlockStatements();

this.read("}");

}

return new MethodDeclarator(

location, // location

optionalDocComment, // optionalDocComment

modifiers, // modifiers

type, // type

name, // name

formalParameters, // formalParameters

thrownExceptions, // thrownExceptions

optionalStatements // optionalStatements

);

}

/**

* <pre>

* VariableInitializer :=

* ArrayInitializer |

* Expression

* </pre>

*/

public ArrayInitializerOrRvalue

parseVariableInitializer() throws CompileException, IOException {

if (this.peek("{")) {

return this.parseArrayInitializer();

} else

{

return this.parseExpression().toRvalueOrCompileException();

}

}

/**

* <pre>

* ArrayInitializer :=

* '{' [ VariableInitializer { ',' VariableInitializer } [ ',' ] '}'

* </pre>

*/

public ArrayInitializer

parseArrayInitializer() throws CompileException, IOException {

final Location location = this.location();

this.read("{");

List<ArrayInitializerOrRvalue> l = new ArrayList();

while (!this.peekRead("}")) {

l.add(this.parseVariableInitializer());

if (this.peekRead("}")) break;

this.read(",");

}

return new ArrayInitializer(

location,

(ArrayInitializerOrRvalue[]) l.toArray(new ArrayInitializerOrRvalue[l.size()])

);

}

/**

* <pre>

* FormalParameters := '(' [ FormalParameter { ',' FormalParameter } ] ')'

* </pre>

*/

public FormalParameters

parseFormalParameters() throws CompileException, IOException {

this.read("(");

if (this.peekRead(")")) return new FormalParameters();