All Classes and Interfaces
Class
Description
This class is used to encapsulate ambiguous names that the parser can't distinguish and disambiguate them during
the analysis phase.
A representation of an array type.
A boxing converter.
A class loader to be able to load a class from a byte stream.
A buffered character reader, which abstracts out differences between platforms, mapping all new lines to '\n', and
also keeps track of line numbers.
Representation of annotation structure.
Representation of AnnotationDefault_attribute structure.
Representation for ARITHMETIC1 and ARITHMETIC2 instructions.
Representation for ARRAY1, ARRAY2 and ARRAY3 instructions.
Represents the context (scope, environment, symbol table) for a type, for example a class, in j--.
The abstract base class for the representation of attribute_info structure.
Representation for BIT instructions.
This class is used for control flow analysis to compute maximum depth of operand stack for a
method.
Instances of this class form the elements of the CLBranchStack which is used for control flow analysis to compute
maximum depth of operand stack for a method.
Representation of Code_attribute structure.
Representation for COMPARISON instructions.
Representation of CONSTANT_Class_info structure.
Representation of CONSTANT_Double_info structure.
Representation of CONSTANT_Fieldref_info structure.
Representation of CONSTANT_Float_info structure.
Representation of CONSTANT_Integer_info structure.
Representation of CONSTANT_InterfaceMethodref_info structure.
Representation of CONSTANT_Long_info structure.
Abstract super class of CONSTANT_Fieldref_info, CONSTANT_Methodref_info, CONSTANT_InterfaceMethodref_info structures.
Representation of CONSTANT_Methodref_info structure.
Representation of CONSTANT_NameAndType_info structure.
Representation of a class' constant pool.
This class defines constants related to the JVM bytecode.
We classify the JVM instructions into the following categories.
Representation of CONSTANT_String_info structure.
Representation of CONSTANT_Utf8_info structure.
Representation of ConstantValue_attribute structure.
Representation for CONVERSION instructions.
Representation of cp_info structure.
Representation of Deprecated_attribute structure.
Representation of element_value union.
Representation of the element_value_pairs table entry.
This class provides a high level interface for creating (in-memory and file based) representation of Java classes.
Representation of EnclosingMethod_attribute structure.
Representation of an exception handler.
Representation of exception_table entry structure.
Representation of Exceptions_attribute structure.
This class represents the field_info structure.
Representation for FIELD instructions.
This class provides a representation of the ClassFile structure.
Representation for FLOW_CONTROL1, FLOW_CONTROL2, FLOW_CONTROL3 and FLOW_CONTROL4 instructions.
Representation of InnerClasses_attribute structure.
Representation of classes table entry structure.
This class stores static information about a JVM instruction.
Representation of a JVM instruction.
Representation of line_number_table entry structure.
Representation of LineNumberTable_attribute structure.
Representation for LOAD_STORE1, LOAD_STORE2, LOAD_STORE3 and LOAD_STORE4 instructions.
Representation of local_variable_table entry structure.
Representation of LocalVariableTable_attribute structure.
Representation of local_variable_type_table entry structure.
Representation of LocalVariableTypeTable_attribute structure.
This abstract base class represents the member_info structure.
This class represents the method_info structure.
Representation for METHOD1 and METHOD2 instructions.
Representation for MISC instructions.
Representation for OBJECT instructions.
Inherits from java.out.DataOutputStream and provides an extra function for writing unsigned int to the output
stream, which is required for writing Java class files.
Representation of parameter_annotations_table entry structure.
Representation of RuntimeInvisibleAnnotations_attribute structure.
Representation of RuntimeInvisibleParameterAnnotations_attribute structure.
Representation of RuntimeVisibleAnnotations_attribute structure.
Representation of RuntimeVisibleParameterAnnotations_attribute structure.
Representation of Signature_attribute structure.
Representation of SourceDebugExtension_attribute structure.
Representation of SourceFile_attribute structure.
Representation for STACK instructions.
Representation of Synthetic_attribute structure.
The compilation unit context is always the outermost context and is where imported types and locally defined types
(classes) are declared.
This class provides a wrapper for constructors.
A Context encapsulates the environment in which an AST is analyzed.
A 2D table of conversions, from one type to another.
A Converter encapsulates any (possibly none) code necessary to perform a cast operation.
A double to int converter.
A double to long converter.
The Defn type is used to implement definitions of things (local variables, formal arguments, types) that are
named in some context (aka scope).
This class provides a wrapper for fields.
An int to char converter.
An int to double converter.
An int to long converter.
An identity converter.
The AST for an array indexing operation.
The AST node for an array initializer.
This abstract base class is the AST node for an assignment operation.
The AST node for an assignment (=) operation.
JAST is the abstract superclass of all nodes in the abstract syntax tree (AST).
Driver class for j-- compiler using JavaCC front-end.
Parser generated by JavaCC.
Token literal values and constants.
Token Manager.
This abstract base class is the AST node for a binary expression --- an expression with a binary operator and two
operands: lhs and rhs.
The AST node for a block, which delimits a nested level of scope.
This abstract base class is the AST node for binary expressions that return booleans.
An AST node for a break-statement.
The AST for a cast expression, which has both a cast (a type) and the expression to be cast.
A representation of a class declaration.
This abstract base class is the AST node for a comparison expression.
The abstract syntax tree (AST) node representing a compilation unit, and so the root of the AST.
The AST node for a conditional expression.
The AST node for a constructor declaration.
An AST node for a continue-statement.
The AST node for a div-assign (/=) operation.
The AST node for a division (/) expression.
The AST node for a do-statement.
The AST node for representing the empty statement.
The AST node for an equality (==) expression.
The AST node for an expression.
The AST node for a field declaration.
The AST node for a field selection operation.
The AST node for a formal parameter declaration.
The AST node for a for-statement.
The AST node for a greater-than-or-equal-to (>=) expression.
The AST node for a greater-than (>) expression.
The AST node for an if-statement.
The AST node for an instanceof expression, having two arguments: an expression and a reference type.
The AST node for a less-than-or-equal-to (<=) expression.
The AST node for a less-than (<) expression.
The type of any expression that can appear on the lhs of an assignment statement: JVariable, JFieldSelection, and
JArrayExpression.
The AST node for a boolean literal.
The AST node for a char literal.
The AST node for a double literal.
The AST node for an int literal.
The AST node for a long literal.
The AST node for the null literal.
The AST node for a string literal.
The AST node for a logical-and (&&) expression.
The AST node for a logical NOT (!) expression.
The AST node for a logical-or (||) expression.
An interface supported by all class (or later, interface) members.
The AST node for a message expression that has a target, optionally an ambiguous part, a message name, and zero or
more actual arguments.
The AST node for a method declaration.
The AST node for a minus-assign (-=) operation.
The AST node for a multiplication (*) expression.
The AST node for a unary negation (-) expression.
The AST node for a "new" array operation.
The AST node for a new expression.
The AST node for a not-equal-to (!=) expression.
The AST node for a plus-assign (+=) operation.
The AST node for a plus (+) expression.
The AST node for a post-decrement (--) expression.
The AST node for post-increment (++) expression.
The AST node for a pre-decrement (--) expression.
The AST node for pre-increment (++) expression.
The AST node for a remainder (%) expression.
The AST node for a rem-assign (%=) operation.
The AST node for a return-statement.
Representation of an element with a JSON document.
The AST node for a star-assign (*=) operation.
This abstract base class is the AST node for a statement (includes expressions).
The AST node for an expression that appears as a statement.
The AST node for a string concatenation operation.
The AST node for a subtraction (-) expression.
The AST node for a "super" expression.
The AST node for a super(...) constructor.
The AST node for a switch-statement.
The AST for a "this" expression.
The AST node for a this(...) constructor.
An interface supported by class (or later, interface) declarations.
This abstract base class is the AST node for a unary expression --- an expression with a single operand.
The AST node for a unary plus (+) expression.
The AST node for an identifier used as a primary expression.
The AST node for a local variable declaration.
The AST node for a variable declarator, which declares a name, its type and (possibly) provides an initialization.
The AST node for a while-statement.
The AST node for a "wild" expression.
A long to double converter.
A long to int converter.
A local context is a context (scope) in which local variables (including formal parameters) can be declared.
The definition for a local variable (including formal parameters).
A lexical analyzer for j-- that interfaces with the hand-written parser (Parser).
Driver class for j-- compiler using hand-written front-end.
This abstract base class provides a wrapper for class members (ie, fields, methods, and constructors).
This class provides a wrapper for methods.
A method context is where formal parameters are declared.
A narrowing reference converter.
This exception is thrown when parse errors are encountered.
A recursive descent parser that, given a lexical analyzer (a LookaheadScanner), parses a j-- compilation unit
(program file), taking tokens from the LookaheadScanner, and produces an abstract syntax tree (AST) for it.
A lexical analyzer for j--, that has no backtracking mechanism.
An implementation of interface CharStream, where the stream is assumed to
contain only ASCII characters (without unicode processing).
A switch-statement group consists of a list of switch labels and a block of statements.
Describes the input token stream.
A representation of tokens returned by the Scanner method getNextToken().
An enum of token kinds.
Token Manager Error.
A class for representing j-- types.
A representation of any reference type that can be denoted as a (possibly qualified) identifier.
A definition of a type name.
An un-boxing converter.