* * A Runtime object consists of attributes and structures that * together define a state of computation, and methods that are used by * instructions to effect this state as they are executed. Thus, each * instruction class defines an execute(Runtime) method that * specifies its operational semantics as a state transformation of its * given runtime context. * *
* * Initiating execution of a Runtime object consists of setting * its code array to a given instruction sequence, setting its * instruction pointer _ip to its code's first instruction and * repeatedly calling execute(this) on whatever instruction is * currently at address _ip in the current code array. The * final state is reached when a flag indicating that it is so is set to * true. Each instruction is responsible for appropriately * setting the next state according to its semantics, including saving * and restoring states, and (re)setting the code array and the various * runtime registers pointing into the state's structures. * *
* * Runtime states encapsulated by objects in this class are essentially * those of a stack automaton, specifically conceived to support the * computations of a higher-order functional language with lexical * closures - i.e., a λ-calculus machine. As * such it may viewed as an optimized variant of Peter Landin's SECD * machine - in the same spirit as Luca Cardelli's Functional Abstract * Machine (FAM), although our design is quite different from * Cardelli's in its structure and operations. It supports many * features beyond basic λ-calculus - e.g., * in-place assignments (both stack-based and heap-based), automatic * boxing/unboxing for polymorphic functions, objects, automatic * currying, to name a few... * *
*
* Because this is a Java implementation, in order to avoid the space
* and performance overhead of being confined to boxed values for
* primitive type computations, three concurrent sets of structures are
* maintained: in addition to those needed for boxed (Java object)
* values, two extra ones are used to support unboxed integer and
* floating-point values, respectively. The runtime operations performed
* by instructions on a Runtime object are guaranteed to be
* type-safe in that each state is always such as it must be expected for
* the correct accessing and setting of values. Such a guarantee must be
* (and is!) provided by the TypeChecker
* and the Sanitizer, which
* ascertain all the conditions that must be met prior to having a Compiler proceed to generating
* instructions which will safely act on the appropriate stacks and
* environments of the correct sort (integer, floating-point, or object).
*/
public class Runtime
{
/**
* A constant that denotes the unboxed boolean false at runtime.
*/
public static final int FALSE = 0;
/**
* A constant that denotes the unboxed boolean true at runtime.
*/
public static final int TRUE = 1;
/**
* A constant that denotes the unboxed void value at runtime.
*/
public static final int VOID = -1;
/**
* A constant that denotes the boxed boolean false at runtime.
*/
public static final RuntimeInt BOXED_FALSE = newInt(FALSE);
/**
* A constant that denotes the boxed boolean true at runtime.
*/
public static final RuntimeInt BOXED_TRUE = newInt(TRUE);
/**
* A constant that denotes the boxed void value at runtime.
*/
public static final RuntimeInt BOXED_VOID = newInt(VOID);
//////////////////////////////////////////////////////////////////////////
/**
* This is the code array containing the instruction sequence being currently
* executed.
*/
protected Instruction[] _code;
/**
* This is the instruction pointer - an index into the code array
* indicating the instruction to execute next.
*/
protected int _ip;
/**
* This is the stack recording saved states of computation to allow safe
* excursions on closure applications. This is affected by the
* saveState() and restoreState() methods.
*/
protected Stack _saveStack = new Stack();
/**
* This is the stack recording saved states of computation to allow safe
* excursions on definition calls. This is affected by the pushCall()
* and popCall() methods.
*/
protected Stack _callStack = new Stack();
/**
* The three following stacks record intermediate results of computations (i.e.,
* the values returned by expressions that are arguments of another expression).
*/
/**
* This stack records intermediate integer results.
*/
protected IntStack _intStack = new IntStack();
/**
* This stack records intermediate floating-point number results.
*/
protected DoubleStack _realStack = new DoubleStack();
/**
* This stack records intermediate object results.
*/
protected Stack _objectStack = new Stack();
/**
* The three following stacks record closure environments (i.e., encapsulated
* values of local variables that belong to enclosing lexical scopes).
*/
/**
* This stack records integer environments.
*/
protected IntStack _intEnv = new IntStack();
/**
* This stack records floating-point number environments.
*/
protected DoubleStack _realEnv = new DoubleStack();
/**
* This stack records object environments.
*/
protected Stack _objectEnv = new Stack();
/**
* When non null, this is the state saved when the current
* enclosing exitable closure is applied.
*/
protected State _currentExitableState = null;
/**
* This value records the runtime sort of the latest value that was pushed
* on one of the three result stacks.
*/
protected byte _resultSort;
/**
* This flag indicates that execution has completed.
*/
private boolean _terminated = false;
/**
* This flag indicates that tracing in on (for debugging purposes).
*/
private static boolean _tracing = false;
////////////////////////////////////////////////////////////////////
/**
* This is the default display manager associated to this runtime.
*/
private DisplayManager _displayManager = new DefaultDisplayManager();
/**
* Returns this runtime's display manager.
*/
public final DisplayManager displayManager ()
{
return _displayManager;
}
/**
* Returns this runtime's display manager.
*/
public final DisplayManager getDisplayManager ()
{
return _displayManager;
}
/**
* Sets this runtime's display manager to the specified one, and returns
* this runtime.
*/
public final Runtime setDisplayManager (DisplayManager displayManager)
{
_displayManager = displayManager;
return this;
}
/**
* Returns this runtime's display device manager.
*/
public final DisplayDeviceManager displayDeviceManager ()
{
return _displayManager.displayDeviceManager();
}
/**
* Returns this runtime's display device manager.
*/
public final DisplayDeviceManager getDisplayDeviceManager ()
{
return _displayManager.displayDeviceManager();
}
/**
* Sets this runtime's display Device manager to the specified one, and returns
* this runtime.
*/
public final Runtime setDisplayDeviceManager (DisplayDeviceManager displayDeviceManager)
{
_displayManager.setDisplayDeviceManager(displayDeviceManager);
return this;
}
/**
* Returns this runtime's display form manager.
*/
public final DisplayFormManager displayFormManager ()
{
return _displayManager.displayFormManager();
}
/**
* Returns this runtime's display form manager.
*/
public final DisplayFormManager getDisplayFormManager ()
{
return _displayManager.displayFormManager();
}
/**
* Sets this runtime's display Form manager to the specified one, and returns
* this runtime.
*/
public final Runtime setDisplayFormManager (DisplayFormManager displayFormManager)
{
_displayManager.setDisplayFormManager(displayFormManager);
return this;
}
////////////////////////////////////////////////////////////////////
/**
* Sets the code array to the specified one.
*/
public final void setCode (Instruction[] code)
{
_code = code;
}
/**
* Returns the value of the current instruction pointer.
*/
public final int ip ()
{
return _ip;
}
/**
* Sets the value of the current instruction pointer to the specified one.
*/
public final void setIP (int ip)
{
_ip = ip;
}
/**
* Resets the value of the current instruction pointer to 0, and unsets
* the termination flag.
*/
public final void resetIP ()
{
_ip = 0;
_terminated = false;
}
/**
* Increments the instruction pointer (i.e., sets it to point to the
* next instruction in the code array).
*/
public final void incIP ()
{
_ip++;
}
////////////////////////////////////////////////////////////////////
/**
* Pushes the specified integer on the result stack.
*/
public final void pushInt (int x)
{
_intStack.push(x);
_resultSort = Type.INT_SORT;
}
/**
* Pushes the specified double on the result stack.
*/
public final void pushReal (double x)
{
_realStack.push(x);
_resultSort = Type.REAL_SORT;
}
/**
* Pushes the specified object on the result stack.
*/
public final void pushObject (Object x)
{
_objectStack.push(x);
_resultSort = Type.OBJECT_SORT;
}
/**
* Pushes the specified boolean on the result stack.
*/
public final void pushBoolean (boolean x)
{
_intStack.push(x ? TRUE : FALSE);
_resultSort = Type.INT_SORT;
}
/**
* Returns the char corresponding to the Unicode numeric value popped from
* the result stack. This assumes that the integer value is non-negative.
*/
public final char popChar ()
{
return (char)popInt();
}
/**
* Pushes the Unicode numeric value of the character as a nonnegative integer
* on the result stack.
*/
public final void pushChar (char c)
{
pushInt(c);
}
////////////////////////////////////////////////////////////////////
/**
* Returns the runtime sort of the latest value pushed on the result stack.
*/
public final byte resultSort ()
{
return _resultSort;
}
/**
* Set the runtime sort of the latest value pushed on the result stack to
* be that of an int. This is useful for maintaining consistency when an
* instruction acts on the top of the result stack without popping it.
*/
public final void setIntSort ()
{
_resultSort = Type.INT_SORT;
}
/**
* Set the runtime sort of the latest value pushed on the result stack to
* be that of a real. This is useful for maintaining consistency when an
* instruction acts on the top of the result stack without popping it.
*/
public final void setRealSort ()
{
_resultSort = Type.REAL_SORT;
}
/**
* Set the runtime sort of the latest value pushed on the result stack to
* be that of an object. This is useful for maintaining consistency when
* an instruction acts on the top of the result stack without popping it.
*/
public final void setObjectSort ()
{
_resultSort = Type.OBJECT_SORT;
}
////////////////////////////////////////////////////////////////////
/**
* Returns the value of the latest integer pushed on the result stack.
*/
public final int intResult ()
{
return _intStack.peek();
}
/**
* Returns the value of the latest floating-point number pushed on the
* result stack.
*/
public final double realResult ()
{
return _realStack.peek();
}
/**
* Returns the value of the latest object pushed on the result stack.
*/
public final Object objectResult ()
{
return _objectStack.peek();
}
/**
* Returns the value of the latest boolean pushed on the result stack.
*/
public final boolean booleanResult ()
{
return _intStack.peek() == TRUE;
}
////////////////////////////////////////////////////////////////////
/**
* Removes and returns the value of the latest integer pushed on the result
* stack.
*/
public final int popInt ()
{
return _intStack.pop();
}
/**
* Removes and returns the value of the latest floating-point number pushed
* on the result stack.
*/
public final double popReal ()
{
return _realStack.pop();
}
/**
* Removes and returns the value of the latest object pushed on the result
* stack.
*/
public final Object popObject ()
{
return _objectStack.pop();
}
/**
* Removes and returns the value of the latest object pushed on the
* result stack if this object is not null. Otherwise, throws
* a NullValueException with the specified object as
* argument. */
public final Object popObject (Object infoIfNull) throws NullValueException
{
Object object = _objectStack.pop();
if (object == null)
throw new NullValueException(infoIfNull);
return object;
}
/**
* Removes and returns the value of the latest boolean pushed on the result
* stack.
*/
public final boolean popBoolean ()
{
return _intStack.pop() == TRUE;
}
/**
* Removes the latest object pushed on the result stack, which must be an
* array or an IntMap, and returns
* the array (i.e., if it's a map, extracts its array).
*/
public int[] popIntArray ()
{
Object a = _objectStack.pop();
if (a instanceof IntMap)
return ((IntMap)a).array();
return (int[])a;
}
/**
* If the latest object pushed on the result stack is null, this
* throws a NullValueException with the specified object as argument;
* otherwise, this works as popIntArray().
*/
public int[] popIntArray (Object infoIfNull) throws NullValueException
{
Object a = popObject(infoIfNull);
if (a instanceof IntMap)
return ((IntMap)a).array();
return (int[])a;
}
/**
* Removes the latest object pushed on the result stack, which must be an
* array or a RealMap, and returns
* the array (i.e., if it's a map, extracts its array).
*/
public double[] popRealArray ()
{
Object a = _objectStack.pop();
if (a instanceof RealMap)
return ((RealMap)a).array();
return (double[])a;
}
/**
* If the latest object pushed on the result stack is null, this
* throws a NullValueException with the specified object as argument;
* otherwise, this works as popRealArray().
*/
public double[] popRealArray (Object infoIfNull) throws NullValueException
{
Object a = popObject(infoIfNull);
if (a instanceof RealMap)
return ((RealMap)a).array();
return (double[])a;
}
/**
* Removes the latest object pushed on the result stack, which must be an
* array or an ObjectMap, and returns
* the array (i.e., if it's a map, extracts its array).
*/
public Object[] popObjectArray ()
{
Object a = _objectStack.pop();
if (a instanceof ObjectMap)
return ((ObjectMap)a).array();
return (Object[])a;
}
/**
* If the latest object pushed on the result stack is null, this
* throws a NullValueException with the specified object as argument;
* otherwise, this works as popObjectArray().
*/
public Object[] popObjectArray (Object infoIfNull) throws NullValueException
{
Object a = popObject(infoIfNull);
if (a instanceof ObjectMap)
return ((ObjectMap)a).array();
return (Object[])a;
}
////////////////////////////////////////////////////////////////////
// /**
// * Returns true iff the latest object pushed on the result stack
// * is null.
// */
// public final boolean objectIsNull ()
// {
// return _objectStack.peek() == null;
// }
// /**
// * Returns true iff the object preceding the latest object pushed on the
// * result stack is null. This is used by
// * FieldInstructions when updating a field, in which case the object is the
// * penultimate object on the object stack.
// */
// public final boolean fieldObjectIsNull ()
// {
// if (_objectStack.size() < 2) return false;
// return _objectStack.peek(1) == null;
// }
////////////////////////////////////////////////////////////////////
/**
* This returns a boxed integer with the specified int value; values 0
* and 1 are boxed into unique canonical objects since they are frequently
* used.
*/
public static final RuntimeInt newInt (int value)
{
switch (value)
{
case 0: return RuntimeInt.ZERO;
case 1: return RuntimeInt.ONE;
}
return new RuntimeInt(value);
}
/**
* This returns a boxed real number with the specified double value; the value
* 0.0 is boxed into a unique canonical object it is frequently used.
*/
public static final RuntimeReal newReal (double value)
{
if (value == 0.0) return RuntimeReal.ZERO;
return new RuntimeReal(value);
}
////////////////////////////////////////////////////////////////////
/**
* Pushes the specified int value on the environment stack.
*/
public final void pushIntEnv (int x)
{
_intEnv.push(x);
}
/**
* Pushes the specified double value on the environment stack.
*/
public final void pushRealEnv (double x)
{
_realEnv.push(x);
}
/**
* Pushes the specified object on the environment stack.
*/
public final void pushObjectEnv (Object x)
{
_objectEnv.push(x);
}
////////////////////////////////////////////////////////////////////
/**
* Pushes all the elements of the specified int array on the environment stack.
*/
public final void pushIntEnvArray (int[] frame)
{
for (int i=0; i