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).
A wrapper object that turns a ClassFile object into a IClass.
An IClassLoader that loads IClasses through a reflection ClassLoader.
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 Iterator that retrieves its elements from a delegate Iterator.
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.
"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).
 
 
Abstract base class for Java.Type, Java.Rvalue and Java.Lvalue.
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.
 
 
 
 
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.
An Exception that is associated with an optional Location in a source file.
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.
An Iterator that traverses a Collection of 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.
An Iterator that iterates over all the objects produced by a delegate Producer.
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.
This IClassLoader loads IClasses through a a ResourceFinder that designates ClassFiles.
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.
 
A ResourceFinder that finds resources in a ZIP file.