Package jminusminus

package jminusminus

This package contains the scanner, parser, AST/context/type representations, JVM and MIPS code emitter, JavaCC description file, and driver classes for the j-- compiler.

Class	Description
AmbiguousName	This class is used to encapsulate ambiguous names that the parser can't distinguish and disambiguate them during the analysis phase.
ArrayTypeName	A representation of an array type.
Boxing	A boxing converter.
ByteClassLoader	A class loader to be able to load a class from a byte stream.
CharReader	A buffered character reader, which abstracts out differences between platforms, mapping all new lines to '\n', and also keeps track of line numbers.
CLAnnotation	Representation of annotation structure.
CLAnnotationDefaultAttribute	Representation of AnnotationDefault_attribute structure.
CLArithmeticInstruction	Representation for ARITHMETIC1 and ARITHMETIC2 instructions.
CLArrayInstruction	Representation for ARRAY1, ARRAY2 and ARRAY3 instructions.
ClassContext	Represents the context (scope, environment, symbol table) for a type, for example a class, in j--.
CLAttributeInfo	The abstract base class for the representation of attribute_info} structure.
CLBitInstruction	Representation for BIT instructions.
CLBranchStack	This class is used for control flow analysis to compute maximum depth of operand stack for a method.
CLBranchTarget	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.
CLCodeAttribute	Representation of Code_attribute structure.
CLComparisonInstruction	Representation for COMPARISON instructions.
CLConstantClassInfo	Representation of CONSTANT_Class_info structure.
CLConstantDoubleInfo	Representation of CONSTANT_Double_info structure.
CLConstantFieldRefInfo	Representation of CONSTANT_Fieldref_info structure.
CLConstantFloatInfo	Representation of CONSTANT_Float_info structure.
CLConstantIntegerInfo	Representation of CONSTANT_Integer_info structure.
CLConstantInterfaceMethodRefInfo	Representation of CONSTANT_InterfaceMethodref_info structure.
CLConstantLongInfo	Representation of CONSTANT_Long_info structure.
CLConstantMemberRefInfo	Abstract super class of CONSTANT_Fieldref_info, CONSTANT_Methodref_info, CONSTANT_InterfaceMethodref_info structures.
CLConstantMethodRefInfo	Representation of CONSTANT_Methodref_info structure.
CLConstantNameAndTypeInfo	Representation of CONSTANT_NameAndType_info structure.
CLConstantPool	Representation of a class' constant pool.
CLConstants	This class defines constants related to the JVM bytecode.
CLConstants.Category	We classify the JVM instructions into the following categories.
CLConstantStringInfo	Representation of CONSTANT_String_info structure.
CLConstantUtf8Info	Representation of CONSTANT_Utf8_info structure.
CLConstantValueAttribute	Representation of ConstantValue_attribute structure.
CLConversionInstruction	Representation for CONVERSION instructions.
CLCPInfo	Representation of cp_info structure.
CLDeprecatedAttribute	Representation of Deprecated_attribute structure.
CLElementValue	Representation of element_value union.
CLElementValuePair	Representation of the element_value_pairs table entry.
CLEmitter	This class provides a high level interface for creating (in-memory and file based) representation of Java classes.
CLEnclosingMethodAttribute	Representation of EnclosingMethod_attribute structure.
CLException	Representation of an exception handler.
CLExceptionInfo	Representation of exception_table entry structure.
CLExceptionsAttribute	Representation of Exceptions_attribute structure.
CLFieldInfo	This class represents the field_info structure.
CLFieldInstruction	Representation for FIELD instructions.
CLFile	This class provides a representation of the ClassFile structure.
CLFlowControlInstruction	Representation for FLOW_CONTROL1, FLOW_CONTROL2, FLOW_CONTROL3 and FLOW_CONTROL4 instructions.
CLInnerClassesAttribute	Representation of InnerClasses_attribute structure.
CLInnerClassInfo	Representation of classes table entry structure.
CLInputStream	This class inherits from java.io.DataInputStream and provides an extra function for reading unsigned int from the input stream, which is required for reading Java class files.
CLInsInfo	This class stores static information about a JVM instruction.
CLInstruction	Representation of a JVM instruction.
CLLineNumberInfo	Representation of line_number_table entry structure.
CLLineNumberTableAttribute	Representation of LineNumberTable_attribute structure.
CLLoadStoreInstruction	Representation for LOAD_STORE1, LOAD_STORE2, LOAD_STORE3 and LOAD_STORE4 instructions.
CLLocalVariableInfo	Representation of local_variable_table entry structure.
CLLocalVariableTableAttribute	Representation of LocalVariableTable_attribute structure.
CLLocalVariableTypeInfo	Representation of local_variable_type_table entry structure.
CLLocalVariableTypeTableAttribute	Representation of LocalVariableTypeTable_attribute structure.
CLMemberInfo	This abstract base class represents the member_info structure.
CLMethodInfo	This class represents the method_info structure.
CLMethodInstruction	Representation for METHOD1 and METHOD2 instructions.
CLMiscInstruction	Representation for MISC instructions.
CLObjectInstruction	Representation for OBJECT instructions.
CLOutputStream	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.
CLParameterAnnotationInfo	Representation of parameter_annotations_table entry structure.
CLPath	This class can be used to locate and load system, extension, and user-defined class files from directories and zip (jar) files.
CLRuntimeInvisibleAnnotationsAttribute	Representation of RuntimeInvisibleAnnotations_attribute structure.
CLRuntimeInvisibleParameterAnnotationsAttribute	Representation of RuntimeInvisibleParameterAnnotations_attribute structure.
CLRuntimeVisibleAnnotationsAttribute	Representation of RuntimeVisibleAnnotations_attribute structure.
CLRuntimeVisibleParameterAnnotationsAttribute	Representation of RuntimeVisibleParameterAnnotations_attribute structure.
CLSignatureAttribute	Representation of Signature_attribute structure.
CLSourceDebugExtensionAttribute	Representation of SourceDebugExtension_attribute structure.
CLSourceFileAttribute	Representation of SourceFile_attribute structure.
CLStackInstruction	Representation for STACK instructions.
CLSyntheticAttribute	Representation of Synthetic_attribute structure.
CompilationUnitContext	The compilation unit context is always the outermost context and is where imported types and locally defined types (classes) are declared.
Constructor	This class provides a wrapper for constructors.
Context	A Context encapsulates the environment in which an AST is analyzed.
Conversions	A 2D table of conversions, from one type to another.
Converter	A Converter encapsulates any (possibly none) code necessary to perform a cast operation.
Field	This class provides a wrapper for fields.
I2C	An int to char converter.
IDefn	The IDefn type is used to implement definitions of things (local variables, formal arguments, types) that are named in some context (aka scope).
Identity	An identity converter.
InstructionType	The types of possible uses.
JALeftShiftAssignOp	The AST node for an arithmetic-left-shift-assign (<<=) operation.
JALeftShiftOp	The AST node for an arithmetic left shift (<<) expression.
JAndAssignOp	The AST node for an and-assign (&=) operation.
JAndOp	The AST node for an and (&) expression.
JARightShiftAssignOp	The AST node for an arithmetic-right-shift-assign (>>=) operation.
JARightShiftOp	The AST node for an arithmetic right shift (&rt;&rt;) expression.
JArrayExpression	The AST for an array indexing operation.
JArrayInitializer	The AST node for an array initializer.
JAssignment	This abstract base class is the AST node for an assignment operation.
JAssignOp	The AST node for an assignment (=) operation.
JAST	JAST is the abstract superclass of all nodes in the abstract syntax tree (AST).
JavaCCMain	Driver class for j-- compiler using JavaCC front-end.
JavaCCParser	Parser generated by JavaCC.
JavaCCParser.JJCalls
JavaCCParserConstants	Token literal values and constants.
JavaCCParserTokenManager	Token Manager.
JBinaryExpression	This abstract base class is the AST node for a binary expression --- an expression with a binary operator and two operands: lhs and rhs.
JBlock	The AST node for a block, which delimits a nested level of scope.
JBooleanBinaryExpression	This abstract base class is the AST node for binary expressions that return booleans.
JBreakStatement	An AST node for a break-statement.
JCastOp	The AST for an cast expression, which has both a cast (a type) and the expression to be cast.
JClassDeclaration	A representation of a class declaration.
JComparisonExpression	This abstract base class is the AST node for a comparison expression.
JCompilationUnit	The abstract syntax tree (AST) node representing a compilation unit, and so the root of the AST.
JComplementOp	The AST node for a unary complement (~) expression.
JConditionalExpression	The AST node for a conditional expression.
JConstructorDeclaration	The AST node for a constructor declaration.
JContinueStatement	An AST node for a continue-statement.
JDivAssignOp	The AST node for a div-assign (/=) operation.
JDivideOp	The AST node for a division (/) expression.
JDoStatement	The AST node for a do-statement.
JEmptyStatement	The AST node for representing the empty statement.
JEqualOp	The AST node for an equality (==) expression.
JExpression	The AST node for an expression.
JFieldDeclaration	The AST node for a field declaration.
JFieldSelection	The AST node for a field selection operation.
JFormalParameter	The AST node for a formal parameter declaration.
JForStatement	The AST node for a for-statement.
JGreaterEqualOp	The AST node for a greater-than-or-equal-to (>=) expression.
JGreaterThanOp	The AST node for a greater-than (>) expression.
JIfStatement	The AST node for an if-statement.
JInstanceOfOp	The AST node for an instanceof expression, having two arguments: an expression and a reference type.
JInterfaceDeclaration	A representation of an interface declaration.
JLessEqualOp	The AST node for a less-than-or-equal-to (<=) expression.
JLessThanOp	The AST node for a less-than (<) expression.
JLhs	The type of any expression that can appear on the lhs of an assignment statement: JVariable, JFieldSelection, and JArrayExpression.
JLiteralBoolean	The AST node for a boolean literal.
JLiteralChar	The AST node for a char literal.
JLiteralDouble	The AST node for a double literal.
JLiteralInt	The AST node for an int literal.
JLiteralLong	The AST node for a long literal.
JLiteralNull	The AST node for the null literal.
JLiteralString	The AST node for a string literal.
JLogicalAndOp	The AST node for a logical-and (&&) expression.
JLogicalNotOp	The AST node for a logical NOT (!) expression.
JLogicalOrOp	The AST node for a logical-or (||) expression.
JLRightShiftAssignOp	The AST node for an logical-right-shift-assign (>>>=) operation.
JLRightShiftOp	The AST node for a logical right shift (&rt;&rt;&rt;) expression.
JMember	An interface supported by all class (or later, interface) members.
JMessageExpression	The AST node for a message expression that has a target, optionally an ambiguous part, a message name, and zero or more actual arguments.
JMethodDeclaration	The AST node for a method declaration.
JMinusAssignOp	The AST node for a minus-assign (-=) operation.
JMultiplyOp	The AST node for a multiplication (*) expression.
JNegateOp	The AST node for a unary negation (-) expression.
JNewArrayOp	The AST node for a "new" array operation.
JNewOp	The AST node for a new expression.
JNotEqualOp	The AST node for a not-equal-to (!=) expression.
JOrAssignOp	The AST node for an or-assign (|=) operation.
JOrOp	The AST node for an inclusive or (|) expression.
JPlusAssignOp	The AST node for a plus-assign (+=) operation.
JPlusOp	The AST node for a plus (+) expression.
JPostDecrementOp	The AST node for a post-decrement (--) expression.
JPostIncrementOp	The AST node for post-increment (++) expression.
JPreDecrementOp	The AST node for a pre-decrement (--) expression.
JPreIncrementOp	The AST node for pre-increment (++) expression.
JRemainderOp	The AST node for a remainder (%) expression.
JRemAssignOp	The AST node for a rem-assign (%=) operation.
JReturnStatement	The AST node for a return-statement.
JSONElement	Representation of an element with a JSON document.
JStarAssignOp	The AST node for a star-assign (*=) operation.
JStatement	This abstract base class is the AST node for a statement (includes expressions).
JStatementExpression	The AST node for an expression that appears as a statement.
JStringConcatenationOp	The AST node for a string concatenation operation.
JSubtractOp	The AST node for a subtraction (-) expression.
JSuper	The AST node for a "super" expression.
JSuperConstruction	The AST node for a super(...) constructor.
JSwitchStatement	The AST node for a switch-statement.
JThis	The AST for a "this" expression.
JThisConstruction	The AST node for a this(...) constructor.
JThrowStatement	An AST node for a throw-statement.
JTryStatement	The AST node for a try-catch-finally statement.
JTypeDecl	An interface supported by class (or later, interface) declarations.
JUnaryExpression	This abstract base class is the AST node for an unary expression --- an expression with a single operand.
JUnaryPlusOp	The AST node for a unary plus (+) expression.
JVariable	The AST node for an identifier used as a primary expression.
JVariableDeclaration	The AST node for a local variable declaration.
JVariableDeclarator	The AST node for a variable declarator, which declares a name, its type and (possibly) provides an initialization.
JWhileStatement	The AST node for a while-statement.
JWildExpression	The AST node for a "wild" expression.
JXorAssignOp	The AST node for an xor-assign (^=) operation.
JXorOp	The AST node for an exclusive or (^) expression.
LocalContext	A local context is a context (scope) in which local variables (including formal parameters) can be declared.
LocalVariableDefn	The definition for a local variable (including formal parameters).
LookaheadScanner	A lexical analyzer for j-- that interfaces with the hand-written parser (Parser).
Main	Driver class for j-- compiler using hand-written front-end.
Member	This abstract base class provides a wrapper for class members (ie, fields, methods, and constructors).
Method	This class provides a wrapper for methods.
MethodContext	A method context is where formal parameters are declared.
NarrowReference	A narrowing reference converter.
NBasicBlock	Representation of a block within a control flow graph.
NControlFlowGraph	Representation of a control flow graph (cfg) for a method.
NEmitter	A class for generating native SPIM code.
NGraphRegisterAllocator	Implements register allocation using graph coloring algorithm.
NHIRALoad	HIR instruction representing JVM array load instructions.
NHIRArithmetic	HIR instruction corresponding to the JVM arithmetic instructions.
NHIRAStore	HIR instruction representing JVM array store instructions.
NHIRConditionalJump	HIR instruction representing an conditional jump instructions in JVM.
NHIRGetField	HIR instruction representing JVM (get) field instructions.
NHIRGoto	HIR instruction representing an unconditional jump instruction in JVM.
NHIRInstruction	This abstract base class provides a high-level intermediate representation (HIR) of a JVM instruction.
NHIRIntConstant	HIR instruction corresponding to the JVM instructions representing integer constants.
NHIRInvoke	HIR instruction representing method invocation instructions in JVM.
NHIRLoadLocal	HIR instruction representing a formal parameter.
NHIRLocal	HIR instruction representing a local (not formal) variable.
NHIRNewArray	HIR instruction representing JVM array creation instructions.
NHIRPhiFunction	HIR instruction representing phi functions.
NHIRPutField	HIR instruction representing JVM (put) field instructions.
NHIRReturn	HIR instruction representing a JVM return instruction.
NHIRStringConstant	HIR instruction corresponding to the JVM instructions representing string constants.
NInterval	Represents a lifetime interval, recording the interval of LIR code for which the corresponding virtual register contains a useful value.
NLinearRegisterAllocator	Implements register allocation using linear scan algorithm.
NLIRALoad	LIR instruction representing JVM array load instructions.
NLIRArithmetic	LIR instruction corresponding to the JVM arithmetic instructions.
NLIRAStore	LIR instruction representing JVM array store instructions.
NLIRConditionalJump	LIR instruction representing an conditional jump instructions in JVM.
NLIRGetField	LIR instruction representing JVM (get) field instructions.
NLIRGoto	LIR instruction representing an unconditional jump instruction in JVM.
NLIRInstruction	This abstract base class provides a low-level intermediate representation (LIR) of a JVM instruction.
NLIRIntConstant	LIR instruction corresponding to the JVM instructions representing integer constants.
NLIRInvoke	LIR instruction representing method invocation instructions in JVM.
NLIRLoad	LIR instruction representing a load from memory to register.
NLIRLoadLocal	LIR instruction representing a formal parameter.
NLIRMove	LIR move instruction.
NLIRNewArray	LIR instruction representing JVM array creation instructions.
NLIRPhiFunction	LIR instruction representing phi functions.
NLIRPutField	LIR instruction representing JVM (put) field instructions.
NLIRReturn	HIR instruction representing a JVM return instruction.
NLIRStore	LIR instruction representing a store from a register to memory.
NLIRStringConstant	LIR instruction corresponding to the JVM instructions representing string constants.
NNaiveRegisterAllocator	Implements a naive register allocation method.
NPhysicalRegister	Representation for a physical register.
NRange	Representation of a liveness range for an interval.
NRegister	An abstract representation for a (physical and virtual) register.
NRegisterAllocator	The abstract base class for a register allocator that maps virtual registers (from LIR code) to physical registers on the target (MIPS) machine.
NTuple	A tuple representation of a JVM instruction.
NVirtualRegister	Representation for a virtual register.
OffsetFrom	The types of stack pointers.
ParseException	This exception is thrown when parse errors are encountered.
Parser	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.
PrettyPrinter	A utility class that allows pretty (indented) printing to standard output.
Scanner	A lexical analyzer for j--, that has no backtracking mechanism.
SimpleCharStream	An implementation of interface CharStream, where the stream is assumed to contain only ASCII characters (without unicode processing).
SPIM	This is a Java wrapper class for the SPIM runtime file SPIM.s.
SwitchStatementGroup	A switch statement group consists of case labels and a block of statements.
Token	Describes the input token stream.
TokenInfo	A representation of tokens returned by the Scanner method getNextToken().
TokenKind	An enum of token kinds.
TokenMgrError	Token Manager Error.
Type	A class for representing j-- types.
TypeName	A representation of any reference type that can be denoted as a (possibly qualified) identifier.
TypeNameDefn	A definition of a type name.
UnBoxing	An un-boxing converter.