All Classes and Interfaces
Class
Description
Base class for a simple
ICompilerFactory
.A
ClassLoader
that, unlike usual ClassLoader
s, does not load byte code, but reads Java™ source
code and then scans, parses, compiles and loads it into the virtual machine.Return value for
IClass.IMember.getAccess()
.A simple
for the "ant" tool
that silently ignores most of the configuration parameters and attempts to compile all given
source files into class files.
invalid reference
org.apache.tools.ant.taskdefs.compilers.CompilerAdapter
A
FilterWriter
that automatically indents lines by looking at
trailing opening braces ('{') and leading closing braces ('}').Implements a scheme for benchmarking, i.e.
Interface used to report messages.
This
ClassLoader
allows for the loading of a set of Java™ classes
provided in class file format.A
ForwardingJavaFileManager
that stores JavaFileObject
s in byte arrays, i.e.Byte array-based implementation of
JavaFileObject
.A
JavaSourceClassLoader
that uses a resource storage provided by the application to cache
compiled classes and thus saving unnecessary recompilations.To set up a
ClassBodyEvaluator
object, proceed as described for IClassBodyEvaluator
.The
optionalClassLoader
serves two purposes:
It is used to look for classes referenced by the class body.An object that represents the Java™ "class file" format.
Representation of a class file attribute (see JVMS 4.7).
Representation of a "ConstantValue" attribute (see JVMS 4.7.2).
Representation of a "Deprecated" attribute (see JVMS 4.7.10).
Representation of an "Exceptions" attribute (see JVMS 4.7.4).
Representation of an "InnerClasses" attribute (see JVMS 4.7.5).
Representation of a "LineNumberTable" attribute (see JVMS 4.7.8).
Representation of a "LocalVariableTable" attribute (see JVMS 4.7.9).
Representation of a "SourceFile" attribute (see JVMS 4.7.7).
Representation of a "Synthetic" attribute (see JVMS 4.7.6).
The context of the compilation of a function (constructor or method).
A throw-in interface that marks
CodeContext.Offset
s
as "fix-ups": During the execution of
CodeContext.fixUp()
, all "fix-ups" are invoked and
can do last touches to the code attribute.An exception that reflects an error during compilation.
A simplified substitute for the javac tool.
The JANINO implementation of
ICompilerFactory
.Utility class that finds implementations of
ICompilerFactory
s.Base class for a simple
ICookable
.An example application for the
Traverser
:
Reads, scans and parses the files named on the command line and counts
several kinds of declarations.Helper class that defines useful methods for handling "field descriptors"
(JVMS 4.3.2) and "method descriptors" (JVMS 4.3.3).
An
Iterator
that finds the normal File
s who's names are
accepted
by the
fileNameFilter
and
that exist in the given rootDirectory
,
and those that exist in all subdirectories of the
rootDirectory
who's names are
FilenameFilter.accept(java.io.File, java.lang.String)
ed by the
directoryNameFilter
Creates a resource in a given directory:
A
FileResourceFinder
that finds file resources in
a directory.An
Iterator
that iterates over the elements of an
Enumeration
.A class that represents an enumerated value.
Represents a problem related to parsing
Enumerator
s.This
IExpressionEvaluator
is implemented by creating and compiling a temporary compilation unit defining one
class with one static method with one RETURN statement.This
IExpressionEvaluator
is implemented by creating and compiling a temporary
compilation unit defining one class with one static method with one RETURN statement.Representation of a resource that is a
File
.Stores a stream of bytes in a named resource.
This class specializes the
ResourceFinder
for finding resources in File
s.An
ListIterator
that retrieves its elements from a delegate
ListIterator
.Invokes a delegate iff the handle of the warning matches one or more of a set of
StringPattern
s.Example for object allocation statistics:
java -Xrunhprof:heap=sites,monitor=n,cutoff=0,depth=4 MyClass
A simplified equivalent to "java.lang.reflect".
Parses a class body and returns it as a
Class
object ready for use with
java.lang.reflect.Loads an
IClass
by type name.An entity that produces implementations of
IExpressionEvaluator
, IScriptEvaluator
, IClassBodyEvaluator
, ISimpleCompiler
or AbstractJavaSourceClassLoader
."Cooking" means scanning a sequence of characters and turning them into some
JVM-executable artifact.
An engine that evaluates expressions in Java™ bytecode.
An engine that executes a script in Java™ bytecode.
A simplified Java™ compiler that can compile only a single compilation unit.
A
Collection
that lazily reads its elements from an
Iterator
.All Janino components that throw
RuntimeException
throw this subclass
to allow for client libraries to intercept them more easily.Finds resources in any of the "*.jar" files that exist in a given set of directories.
This wrapper class defines classes that represent the elements of the
Java™ programming language.
This class is special: It does not extend/implement the Atom subclasses,
but overrides Atom's "to...()" methods.
This class implements an array access.
Represents a Java™ array initializer (JLS 10.6).
Representation of a Java™ array type (JLS 10.1).
Representation of a Java™ "basic type" (obviously
equaivalent to a "primitive type") (JLS 4.2).
Representation of all non-operand-modifying Java™ binary
operations.
Representation of a Java™ "block" (JLS 14.2).
Everything that can be compiled to code, e.g.
Base class for
Java.Rvalue
s that compile better as conditional
branches.Base class for statements that can be terminated abnormally with a
"break" statement.
Representation of the Java™ "break" statement (JLS 14.14).
Holds the result of
Parser.parseCompilationUnit()
.Represents a single static import declaration like
Represents a single type import declaration like
Represents a static-import-on-demand declaration like
Represents a type-import-on-demand declaration like
Representation of the Java™ "continue" statement (JLS
14.15).
Objects of this class represent represent one pre- or post-increment
or decrement.
Represents the "empty statement", i.e.
Lazily determines and returns the enclosing
Java.Scope
of the given
Java.TypeDeclaration
.Representation of an access to a field of a class or an interface.
This class implements class or interface field access, and also the "array length"
expression "xy.length".
This class is derived from "Statement", because it provides for the
initialization of the field.
Abstract base class for
Java.ConstructorDeclarator
and
Java.MethodDeclarator
.Representation of an instance (JLS2 8.6) or static initializer (JLS2 8.7).
Used during resolution.
Representation of a local variable access -- used during compilation.
All local variables have a slot number, local variables that get written into the localvariabletable
also have a start and end offset that defines the variable's extent in the bytecode.
This interface is implemented by objects which are associated with a
location in the source code.
Representation of an "lvalue", i.e.
Represents a class or interface declaration where the immediately enclosing scope is
another class or interface declaration.
Represents the declaration of a class or an interface that has a name.
Represents a package declaration like
Represents a class or interface declaration on compilation unit level.
Representation of an access to the current object or an enclosing instance.
Representation of an "rvalue", i.e.
Everything that can occur in the body of a method or in a block.
Representation of "super.fld" and "Type.super.fld".
14.10 The "switch" Statement
Representation of an access to the innermost enclosing instance.
Representation of a Java™ type.
Representation of a "ClassBodyDeclaration" or an "InterfaceMemberDeclaration".
This class implements the unary operators "+", "-", "~" and "!".
Used by FieldDeclaration and LocalVariableDeclarationStatement.
A
ClassLoader
that, unlike usual ClassLoader
s,
does not load byte code, but reads Java™ source code and then scans, parses,
compiles and loads it into the virtual machine.This
IClassLoader
finds, scans and parses compilation units.Reads a set of compilation units from the file system and searches it for specific
Java™ constructs, e.g.
A
ResourceFinder
that examines a set
of ResourceFinder
s lazily as it
searches for resources.Represents the location of a character in a document, as defined by an optional file name, a
line number and a column number.
Creates resources as byte arrays in a delegate
Map
.A
ResourceFinder
that provides access
to resource stored as byte arrays in a Map
.Representation of a "method descriptor" (JVMS 4.3.3).
This class defines constants and convenience methods for the handling of modifiers as defined by the JVM.
An
Iterator
that iterates over a delegate, which produces
arrays, Collection
s, Enumeration
s or
Iterator
s.Similar to
FilterReader
, but when the first delegate is at end-of-input, it continues
with reading from the next delegate.A
ResourceFinder
that finds its resources through a collection of
other ResourceFinder
s.A parser for the Java™ programming language.
A
ResourceFinder
that finds its resources along a "path"
consisting of JAR file names, ZIP file names, and directory names.A helper class that wraps primitive values in their wrapper classes.
An object that produces some
Object
each time the
Producer.produce()
method is invoked.A
Resource
is "something" that is typically found by a
ResourceFinder
, can be Resource.open()
ed for
reading, and optionally has a Resource.lastModified()
property.Opens a resource, characterized by a name, for writing.
Finds a resource by name.
A
ClassLoader
that uses a ResourceFinder
to find ".class" files.A
ListIterator
that reverses the direction of all operations
of a delegate ListIterator
.Splits up a character stream into tokens and returns them as
String
objects.To set up a
ScriptEvaluator
object, proceed as described for IScriptEvaluator
.A number of "convenience constructors" exist that execute the setup steps instantly.
To set up a
SimpleCompiler
object, proceed as described for ISimpleCompiler
.Implementation of a UNIX shell-like string pattern algorithm.
A
FilterReader
that copies the bytes being passed through
to a given Writer
.An
Iterator
that transforms its elements on-the-fly.This class traverses the subnodes of an AST.
An
Iterator
that iterates over a delegate, and while
it encounters an array, a Collection
, an
Enumeration
or a Iterator
element, it iterates
into it recursively.Represents a problem that occurred while unescaping a unicode escape
sequence through a
UnicodeUnescapeReader
.A
FilterReader
that unescapes the "Unicode Escapes"
as described in
the
Java Language Specification, 2nd edition.This class actually implements the Java™ compiler.
Short-hand implementation of
IClass.IField
that implements a non-constant, non-static,
package-accessible field.Thrown by
MultiDimensionalIterator
to
indicate that it has encountered an element that cannot be iterated.A visitor that unparses (un-compiles) an AST to a
Writer
.Basis for the "visitor" pattern as described in "Gamma, Helm, Johnson,
Vlissides: Design Patterns".
The visitor for all kinds of block statements (statements that may appear with a block).
The visitor for all kinds of IMPORT declarations.
The visitor for all kinds of type body declarations (declarations that may appear in the body of a type
declaration).
The visitor for all kinds of type declarations.
Interface type for
UnitCompiler.setWarningHandler(WarningHandler)
.A
ResourceFinder
that finds resources in a ZIP file.