All Classes and Interfaces
Class
Description
Base class for a simple
ICompilerFactory.A
ClassLoader that, unlike usual ClassLoaders, 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
org.apache.tools.ant.taskdefs.compilers.CompilerAdapter for the "ant" tool
that silently ignores most of the configuration parameters and attempts to compile all given
source files into class files.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 JavaFileObjects 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.Offsets
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
ICompilerFactorys.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 Files 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
Enumerators.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 Files.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
StringPatterns.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.Rvalues 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 ClassLoaders,
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 ResourceFinders 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, Collections, Enumerations or
Iterators.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 ResourceFinders.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.