|
Class Summary |
| ArgList |
List of arguments to a function or method call, be they constants or other expressions. |
| ArrayAccess |
Expression of the form x[[i]],
x[i], and variants
with more terms such as x[i,j,k++]
indicating a subsetting operation on a target object. |
| ArrayAccessAssignExpression |
Assignment to an index of a container of the form
x[i] = 10. |
| ArrayAccessInfix |
Infix operation expression on one or more elements of a container,
of the form x[i]++ and --x[j++] |
| ArrayConstructorExpression |
Expression for instantiating and optionally initializing an
array of the form
new int[][]{1::10, 1::5}, etc. |
| ArrayDimensionExpression |
Term in an subsetting expression of a container, such as the i in
x[i]. |
| ArrayType |
Declaration of an array of a specifiable class. |
| AssignExpression |
General assignment expression of the form x = 1. |
| BasicExpression |
Fundamental expression class which most of the language expression
classes extend. |
| BinaryExpression |
Abstract class used by many others to hold left and right hand side
org.omegahat.Models.Formulae.Expressions. |
| CastExpression |
Expression treating an object as an instance of a particular class,
such as (int) 1.0. |
| Catch |
Expression used to represent an entire catch declaration
including the exception type, variable name and body of the catch clause. |
| ClassDefinition |
Representation of the parsed input defining an interpreted class with its
field and method declarations. |
| ClassList |
Not certain this is ever used! |
| ClassName |
(Partially) qualified name of a Class, different from a regular Name used
to identify that a class is needed rather than an arbitrary object. |
| ClassReference |
Symbolic reference to the class field of a generic Java class
as in Integer.class. |
| Comment |
General abstract comment expression class which is
the foundation for the SingleLineComment
and MultiLineComment
classes. |
| ConditionalExpressionStatement |
General expression for testing conditions and returning a logical value
as the result. |
| ConstantExpression |
Expression that returns the value stored in it, effectively
working as an escape mechanism. |
| ConstantSymbol |
Expression used for representing certain constants, specifically null |
| ConstructorDefinitionExpression |
Class used to differentiate a constructor function (which has no name)
from a regular named function. |
| ConstructorExpression |
An expression for creating a instance of a class, of the form
new ClassName(arg1, arg2,..., argk) |
| DynamicFieldAccess |
Provides the regular field access for an object
and additional facilities for probing objects which
implement the DynamicFieldAccessInt
for entries that are not officially fields - e.g. |
| ElementAccess |
Abstract class from which FieldAccess
and MethodCall are derived
to describe access to a compiled element of an instance of a class or a class itself. |
| EnumeratedForLoop |
Expression for a loop of the form for(var in expr) { body; }
using the in syntax rather than triple of the regular
for loop |
| FieldAccess |
Expression of the form
x.foo
retrieving the "field" foo in the object
identified by x. |
| FlowControl |
Class for representing expressions of the form break
or continue. |
| ForLoop |
Standard Java-like for loop
of the form for(i=0; i < n ; i++) |
| FormalComment |
Javadoc-style comment introduced by |
| FunctionCall |
Unqualified method call which can be determined at parse time
of the form foo(), foo(x,y,1). |
| FunctionExpression |
Class representing a parsed function declaration which is evaluated
to create the function object. |
| FunctionParameterModifier |
Qualifier for a parameter definition of a function/method, includeing
public, protected, private,
final, lazy, eager. |
| FunctionType |
This is used as a place holder in the parse tree to transmit
information about which keyword function or
method was used to declare a function object. |
| GlobalName |
Analagous to SuperName, this identifies use of
the keyword global in the Omegahat language which is
(currently) used to indicate the element (variable, field, method or function)
to which the qualifier applies should be found outside of the local or immediate
scope. |
| IfElseExpression |
Expression representing a if(){..} else {..}
statement. |
| ImportExpression |
|
| InstanceOfExpression |
Expression of the form object instanceof Class,
more general than the Java version since the
right hand side is interpreted so can be an expression
that evaluates to a Class. |
| List |
A basic vector-like list for storing objects,
used in numerous places in the parser, such as
method call arguments, collections of statements, etc. |
| LocalVariable |
Declaration of a local variable - e.g. |
| LogicalExpression |
Simple logical expression storing the left and right hand side
and the operator defining the nature of the expression. |
| MathExpression |
Objects from this class represent and perform (binary) mathematical operations for the parser. |
| MethodCall |
Expressions representing a call to a function or a method
of an object or class, containing an expression for the qualifier in which
the method should be invoked (or null implying a function or implicit this),
a list of argument expressions and the name of the function or method. |
| MethodDefinition |
Simple holder for the elements of a method declaration. |
| MethodExpression |
Body of a function or method. |
| MethodHeader |
Header for the declaration of a method. |
| MethodLocator |
This class provides the mechanisms to determine the method in a
class of a given name "most closely" matching the signature
specified by the arguments provided. |
| MethodParameter |
This class contains information about a parameter of a method and
also of a catch clause. |
| Modifier |
Store the details of a collection of modifiers,
used for parameters, methods and variable declarations. |
| MultiLineComment |
One or more lines of comments, identified
by a * * pairing. |
| Name |
Class representing an expression of the form
a.b.c.d
consisting of multiple components separated by `.' |
| NumberExpression |
Class from which others are derived to provide
capabilities for handling objects as numbers
and converting them to appropriate types and back
for computations. |
| OperatorExpression |
General class representing numerous binary operations
that are identified by an type rather than having a class
for each one. |
| SequenceExpression |
This class is used to represent the unevaluated specification of a
sequence generated within the parser. |
| ShiftExpression |
Specializes the OperatorExpression class to
handle only the bit-shift operations. |
| SimpleParameterModifier |
Parameter modifier that only records whether the
declaration includes final or not. |
| SingleLineComment |
Simple single line comment of the form // comment text |
| StatementList |
This class is used to gather an ordered collection of expressions
into a unit such as the body of a loop, etc. |
| SuperName |
Class used to identify the keyword super
in order to simplify the evaluation and understanding of the parse tree. |
| SwitchCase |
This class represents one or more case statements within
a switch construct. |
| SwitchStatement |
This is the toplevel switch construct representation,
embodying the expression on which the switch is made and the
different stanzas that are identified by the value of the
expression. |
| SynchronizedExpression |
Class to represent evaluation of body of code as a critical section
synchronized on an object which is the result of an interpreted expression. |
| TryCatch |
This is the top-level expression class that forms the interpreted version of a
|
| Type |
Symbolic expression referring to a class or
primitive type. |
| UnaryExpression |
Expression representing a unary (in contrast to a binary)
operation, include negation, binary complement, etc. |
| UpdateUnaryExpression |
This is the class that represents
and performs the evaluation of increment and decrement operations,
be they either prefix or postfix,
such as
|
| UserClassFieldAccess |
Field accessor expression that handles
invocation in a user-level class,
extending the regular FieldAccess
to look in the additional locations for methods. |
| UserClassFunctionExpression |
Expression defining a user-level function as a method in an interpreted
class. |
| UserClassMethodCall |
Version of MethodCall that takes account of the purely
interpreted user-level classes (rather than the partially compiled versions)
and knows how to find methods within these by looking at the qualifer
to determine if it is a user-level class, or in the list of
user-level classes to see if it is a "static" interpreted method. |
| UserClassMethodExpression |
Expression defining a method or function definition
as part of an interpreted or user level class. |
| While |
This class represents a while loop (or
do-while loop), consisting
of a condition and an expression body. |