Uses of Class
org.codehaus.commons.compiler.CompileException

Reads a set of Java compilation units (a.k.a.

Reads, scans, parses and compiles Java tokens from the given InputStream, encoded in the "platform default encoding".

Reads, scans, parses and compiles Java tokens from the given Reader.

Reads, scans, parses and compiles Java tokens from the given InputStream, encoded in the "platform default encoding".

Reads, scans, parses and compiles Java tokens from the given Reader.

Same as Cookable.cook(InputStream), but cooks a set of documents into one class.

Same as Cookable.cook(Reader), but cooks a set of documents into one class.

Same as Cookable.cook(String, InputStream), but cooks a set of documents into one class.

Same as Cookable.cook(String, Reader), but cooks a set of documents into one class.

Same as ICookable.cook(Reader), but for multiple scripts.

Same as ICookable.cook(String, Reader), but cooks a set of scripts into one class.

Reads, scans, parses and compiles Java tokens from the given File, encoded in the "platform default encoding".

Reads, scans, parses and compiles Java tokens from the named file, encoded in the "platform default encoding".

Same as Cookable.cookFile(File), but cooks a set of documents into one class.

Same as Cookable.cookFile(String), but cooks a set of documents into one class.

If the parameter and return types of the expression are known at compile time, then a "fast" script evaluator can be instantiated through this method.

Scans, parses and compiles a class body from the tokens delivered by the the given Reader, then creates and returns an instance of that class.

May or may not choose to throw a CompileException.

Equivalent to

Equivalent to

Equivalent to

Equivalent to

Convenience method for throwing a CompileException.

Generates a set of ClassFile objects which represent the classes and interfaces declared in the compilation unit.

Like ExpressionEvaluator.cook(Scanner), but cooks a set of scripts into one class.

Cooks a set of scripts into one class.

Cooks this compilation unit directly.

Deprecated.

Notice: This method is not declared in IScriptEvaluator, and is hence only available in this implementation of org.codehaus.commons.compiler.

Deprecated.

Deprecated.

Deprecated.

Deprecated.

Finds methods of the mi.target named mi.methodName, examines the argument types and chooses the most specific method.

Determines the applicable invocables and choose the most specific invocable.

Attempts to evaluate as a constant expression.

Returns the classes and interfaces declared as members of the class (but not inherited classes and interfaces).

Adds all methods with the given methodName that are declared by the type, its superclasses and all their superinterfaces to the result list v.

The uncached version of IClass.getDeclaredIConstructors() which must be implemented by derived classes.

Returns the types of the parameters of this constructor or method.

Returns the superclass of the class.

Guess the names of the parameters used in the given expression.

If this represents a class: Return true if this class directly or indirectly implements that interface.

Determines if this is assignable from that.

Parses statements from the parser until end-of-input.

AdditiveExpression := MultiplicativeExpression { ( '+' | '-' ) MultiplicativeExpression }

AnnotationTypeDeclarationRest := Identifier AnnotationTypeBody

Arguments := '(' [ ArgumentList ] ')'

AssertStatement := 'assert' Expression [ ':' Expression ] ';'

Block := '{' BlockStatements '}'

BlockStatements := { BlockStatement }

CatchFormalParameter := { VariableModifier } CatchType VariableDeclaratorId CatchType := UnannClassType { '|' ClassType } VariableModifier := Annotation | 'final' VariableDeclaratorId := Identifier [ Dims ] Dims := { Annotation } '[' ']' { { Annotation } '[' ']' } UnannClassType := Identifier [ TypeArguments ] | UnannClassOrInterfaceType '.' { Annotation } Identifier [ TypeArguments ] UnannInterfaceType := UnannClassType UnannClassOrInterfaceType := UnannClassType | UnannInterfaceType ClassType := { Annotation } Identifier [ TypeArguments ] | ClassOrInterfaceType '.' { Annotation } Identifier [ TypeArguments ]

ClassBodyDeclaration := ';' | ModifiersOpt ( Block | // Instance (JLS7 8.6) or static initializer (JLS7 8.7) 'void' Identifier MethodDeclarationRest | 'class' ClassDeclarationRest | 'interface' InterfaceDeclarationRest | ConstructorDeclarator | [ TypeArguments ] Type Identifier MethodDeclarationRest | Type Identifier FieldDeclarationRest ';' )

ConditionalAndExpression := InclusiveOrExpression { '&&' InclusiveOrExpression }

ConditionalOrExpression := ConditionalAndExpression { '||' ConditionalAndExpression ]

ContinueStatement := 'continue' [ Identifier ] ';'

DimExprs := DimExpr { DimExpr }

EmptyStatement := ';'

EnumConstant := [ Annotations ] Identifier [ Arguments ] [ ClassBody ]

EqualityExpression := RelationalExpression { ( '==' | '!=' ) RelationalExpression }

Expression := AssignmentExpression | LambdaExpression

Same as Parser.parseExpression(), but types like int or Map<String, Object> are also parsed.

FieldDeclarationRest := VariableDeclaratorRest { ',' VariableDeclarator }

FormalParameterList := FormalParameter { ',' FormalParameter }

FormalParameterRest := [ '.' '.' '.' ] Identifier BracketsOpt

ForStatement := 'for' '(' [ ForInit ] ';' [ Expression ] ';' [ ExpressionList ] ')' Statement | 'for' '(' FormalParameter ':' Expression ')' Statement ForInit := Modifiers Type VariableDeclarators | ModifiersOpt PrimitiveType VariableDeclarators | Expression VariableDeclarators (1) | Expression { ',' Expression }

ImportDeclaration := 'import' ImportDeclarationBody ';'

InclusiveOrExpression := ExclusiveOrExpression { '|' ExclusiveOrExpression }

InterfaceDeclarationRest := Identifier [ typeParameters ] [ 'extends' ReferenceTypeList ] InterfaceBody

Literal := IntegerLiteral | FloatingPointLiteral | BooleanLiteral | CharacterLiteral | StringLiteral | NullLiteral

Equivalent with parseMethodDeclaration(false, MethodDeclarationContext.CLASS_DECLARATION).

MethodDeclarationRest := FormalParameters { '[' ']' } [ 'throws' ReferenceTypeList ] [ 'default' expression ] ( ';' | MethodBody )

ModuleDeclarationRest := [ 'open' ] 'module' identifier { '.' identifier} '{' { ModuleDirective } '}'

Modifier := Annotation | 'public' | 'protected' | 'private' | 'static' | 'abstract' | 'final' | 'native' | 'synchronized' | 'transient' | 'volatile' | 'strictfp' | 'default'

PackageDeclaration := { PackageModifier } 'package' identifier { '.' identifier} ';'

Primary := CastExpression | // CastExpression 15.16 '(' Expression ')' | // ParenthesizedExpression 15.8.5 Literal | // Literal 15.8.1 Name | // AmbiguousName Name Arguments | // MethodInvocation Name '[]' { '[]' } | // ArrayType 10.1 Name '[]' { '[]' } '.' 'class' | // ClassLiteral 15.8.2 'this' | // This 15.8.3 'this' Arguments | // Alternate constructor invocation 8.8.5.1 'super' Arguments | // Unqualified superclass constructor invocation 8.8.5.1 'super' '.' Identifier | // SuperclassFieldAccess 15.11.2 'super' '.' Identifier Arguments | // SuperclassMethodInvocation 15.12.4.9 NewClassInstance | NewAnonymousClassInstance | // ClassInstanceCreationExpression 15.9 NewArray | // ArrayCreationExpression 15.10 NewInitializedArray | // ArrayInitializer 10.6 PrimitiveType { '[]' } | // Type PrimitiveType { '[]' } '.' 'class' | // ClassLiteral 15.8.2 'void' '.' 'class' | // ClassLiteral 15.8.2 MethodReference // MethodReference JLS9 15.13 Name := Identifier { '.' Identifier } CastExpression := '(' PrimitiveType { '[]' } ')' UnaryExpression | '(' Expression ')' UnaryExpression NewClassInstance := 'new' ReferenceType Arguments NewAnonymousClassInstance := 'new' ReferenceType Arguments [ ClassBody ] NewArray := 'new' Type DimExprs { '[]' } NewInitializedArray := 'new' ArrayType ArrayInitializer

ReferenceType := { Annotation } QualifiedIdentifier [ TypeArguments ]

RelationalExpression := ShiftExpression { 'instanceof' ReferenceType | '<' ShiftExpression [ { ',' TypeArgument } '>' ] | '<' TypeArgument [ { ',' TypeArgument } '>' ] | ( '>' | '<=' | '>=' ) ShiftExpression }

Selector := '.' Identifier | // FieldAccess 15.11.1 '.' Identifier Arguments | // MethodInvocation '.' '<' TypeList '>' 'super' Arguments // Superconstructor invocation (?) '.' '<' TypeList '>' 'super' '.' .

Statement := LabeledStatement | Block | IfStatement | ForStatement | WhileStatement | DoStatement | TryStatement | 'switch' ...

SynchronizedStatement := 'synchronized' '(' expression ')' Block

TryStatement := 'try' Block Catches [ Finally ] | 'try' Block Finally Catches := CatchClause { CatchClause } CatchClause := 'catch' '(' FormalParameter ')' Block Finally := 'finally' Block

UnaryExpression := { PrefixOperator } Primary { Selector } { PostfixOperator } PrefixOperator := '++' | '--' | '+' | '-' | '~' | '!' PostfixOperator := '++' | '--'

VariableDeclaratorRest := { '[' ']' } [ '=' VariableInitializer ]

VariableInitializer := ArrayInitializer | Expression

WhileStatement := 'while' '(' Expression ')' Statement

Checks whether the value of the next token equals any of the suspected; does not consume the next token.

Checks whether the type of the next token is any of the suspected; does not consume the next token.

Checks whether the value of the next token equals the suspected; if so, consumes the token.

Checks whether the type of the next token is the suspected; if so, consumes the token.

Produces and returns the next token.

Verifies that the value of the next token equals expected, and consumes the token.

Verifies that the type of the next token is the expected, and consumes the token.

Equivalent to

Equivalent to

Equivalent to

Equivalent to

Creates an expression evaluator with the full configurability.

Equivalent to

Equivalent to

Equivalent to

Equivalent to

Equivalent to

Equivalent to

Equivalent to