//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
// PLEASE DO NOT EDIT WITHOUT THE EXPLICIT CONSENT OF THE AUTHOR! \\
//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
package ilog.language.design.kernel;
/**
* @version Last modified on Fri Oct 18 19:00:53 2002 by hak
* @version modified on Wed Jul 24 12:18:40 2002 by pviry
* @author Hassan Aït-Kaci
* @copyright © 2000-2002 ILOG, S.A.
*/
import ilog.language.design.types.*;
import ilog.language.design.base.*;
import ilog.language.util.Locatable;
import ilog.language.util.Location;
import ilog.language.util.Span;
import ilog.language.tools.Misc;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
/**
* This class is the mother of all expressions in the kernel language.
* It specifies the prototypes of the methods that must be implemented
* by all expression subclasses. The subclasses of Expression
* are:
*
*
*
*
* - Constant:
* constant (void, boolean, integer,
* real number,
* object);
*
*
- Abstraction:
* functional abstraction (à la lambda-calculus);
*
*
- Application:
* functional application;
*
*
- Local:
* local name;
*
*
- Global:
* global name;
*
*
- IfThenElse:
* conditional;
*
*
- AndOr:
* non-strict boolean conjunction and disjunction;
*
*
- Sequence:
* sequence of expressions (presumably with side-effects);
*
*
- Let:
* lexical scoping construct;
*
*
- Loop:
* conditional iteration construct;
*
*
- Definition:
* definition of a global name with an expression defining it
* in a global store;
*
*
- Parameter:
* a function's formal parameter (really a pseudo-expression
* as it is not fully processed as a real expression and is used
* as a shared type information repository for all occurrences
* in a function's body of the variable it stands for);
*
*
- Assignment:
* construct to set the value of a local
* or a global variable;
*
*
- NewObject:
* construct to create a new object;
*
*
- FieldUpdate:
* construct to update the value of an object's field;
*
*
- NewArray:
* construct to create a new (multidimensional) array;
*
*
- ArraySlot:
* construct to access the element of an array;
*
*
- ArraySlotUpdate:
* construct to update the element of an array;
*
*
- Tuple:
* construct to create a new position-indexed tuple;
*
*
- NamedTuple:
* construct to create a new name-indexed tuple;
*
*
- TupleProjection:
* construct to access the component of a tuple;
*
*
- TupleUpdate:
* construct to update the component of a tuple;
*
*
- DottedNotation:
* a generic "dotted notation" to be interpreted, according to the
* type of its let expression, as an object member dereference
* a tuple projection, or any other expression that this may denote.
*
*
- Dummy:
* temporary place holder in lieu of a name prior to being discriminated
* into a local or global one.
*
*
- CompiledExpression:
* pre-compiled code encapsulated as an expression;
*
*
* Typically, upon being read, an Expression will be:
*
*
*
*
*
*
- "name-sanitized" - in the context of a Sanitizer to discriminate
* between local names and global names, and establish pointers from the
* local variable occurrences to the abstraction that introduces them,
* and from global names to entries in the global symbol table;
*
*
*
- type-checked - in the context of a TypeChecker to discover
* whether it has a type at all, or several possible ones (only
* expressions that have a unique unambiguous type are further
* processed);
*
*
*
- "sort-sanitized" - in the context of a Sanitizer to discriminate
* between those local variables that are of primitive Java types
* (int or double) or of Object type (this is
* necessary because the set-up means to use unboxed values of primitive
* types for efficiency reasons); this second "sanitization" phase is
* also used to compute offsets for local names (i.e., so-called
* de Bruijn indices) for each type sort;
*
*
*
- compiled - in the context of a Compiler to generate the sequence
* of instructions whose execution in an appropriate runtime environment
* will evaluate the expression;
*
*
*
- executed - in the context of a Runtime to execute its sequence of
* instructions.
*
*
* */
public abstract class Expression implements Locatable
{
protected boolean _typeCheckLocked = false;
public final boolean typeCheckLocked ()
{
if (!_typeCheckLocked)
{
_typeCheckLocked = true;
return false;
}
//System.out.println("This "+Misc.simpleClassName(this)+" has already been type-checked!");
return true;
}
protected boolean _isSetCheckedType = false;
public final boolean isSetCheckedType ()
{
if (!_isSetCheckedType)
{
_isSetCheckedType = true;
return false;
}
//System.out.println("This "+Misc.simpleClassName(this)+" has already been set checked-type!");
return true;
}
/**
* This contains any other types that may be redudantly be prescribed to this
* expression prior to being type-checked. For example, a grammar constructing
* an expression from a concrete syntax may allow several types to be attached
* a single expression. The type-checker will then ensure that all these types
* are compatible, and can be reduced to a single consistent one.
*/
protected HashSet _otherTypes;
/**
* Returns true iff this expression is a
* Constant.
*/
public final boolean isConstant ()
{
return this instanceof Constant;
}
/**
* Returns true iff this expression denotes the constant void.
*/
public boolean isVoid ()
{
return isConstant() && ((Constant)this).isVoid();
}
/**
* Returns true iff this expression denotes the constant true.
*/
public boolean isTrue ()
{
return isConstant() && ((Constant)this).isTrue();
}
/**
* Returns true iff this expression denotes the constant false.
*/
public boolean isFalse ()
{
return isConstant() && ((Constant)this).isFalse();
}
/**
* Returns true iff this expression denotes the constant null.
*/
public boolean isNull ()
{
return isConstant() && ((Constant)this).isNull();
}
/**
* This method returns the current type of this expression. It will
* typically, but not necessarily, be the dereferenced value of a
* TypeParameter field.
* A notable exception is a Local
* since its type method will always return the type of the
* Parameter it stands for.
*/
public abstract Type type ();
/**
* This method forcibly sets this expression's type field, if it has one,
* to the specified type. It will be an empty method otherwise.
*/
public abstract void setType (Type type);
/**
* This method returns this expression's undereferenced type field if
* it has one. It will return null otherwise.
*/
public abstract Type typeRef ();
/**
* This method returns the final unambiguously checked type of this
* expression.
*/
public abstract Type checkedType ();
/**
* This method sets the final unambiguously checked type of this
* expression, possibly along with other final information that may
* be needed by the compiler for generating code.
*/
public abstract void setCheckedType ();
/**
* This method sets the final unambiguously checked type of this
* expression to the specified type. This is used when expression
* are synthesized on the fly after the type-checking phase and
* prior to the compiling phase.
*/
public abstract void setCheckedType (Type type);
/**
* This method returns the actual expression corresponding to this one
* after eliminating all the Dummy
* expressions that occur in it where names where read. It takes as an
* argument the stack of parameters it encounters along the way
* of visiting all its components. A
* ParameterStack is simply a Stack of
* Parameter objects
* along with a method to retrieve the latest one with a given
* name.
*/
public abstract Expression sanitizeNames (ParameterStack parameters,
ClassTypeHandle handle);
/**
* This method walks down the expression gathering information relating
* each Local object to the
* Abstraction containing
* the corresponding Parameter
* in its array of formal parameters. It takes as an argument an
* Enclosure, which is a Stack
* containing all Abstractions
* encountered along the way, equipped with a method to compute all
* the information necessary in computing the local's offset.
*/
public abstract void sanitizeSorts (Enclosure enclosure);
/**
* This methods visits this expression shifting the offset of all the
* Locals it encounters by the
* specified amount (per sort) as long as the offset it sees is
* referencing a parameter within the specified abstraction depth (per
* sort); This method is used when the compiler needs to synthesize an
* abstraction from an already typechecked expression (i.e.,
* for currying or un/boxing -- e.g., see the pad
* method below).
*/
public abstract Expression shiftOffsets (int intShift, int realShift, int objectShift,
int intDepth, int realDepth, int objectDepth);
public final Expression shiftOffsets (int intShift, int realShift, int objectShift)
{
return shiftOffsets(intShift,realShift,objectShift,0,0,0);
}
/**
* This method type-checks this expression in the context of the specified
* TypeChecker.
*/
public abstract void typeCheck (TypeChecker typeChecker) throws TypingErrorException;
/**
* This method ascertains that this expression has the specified type in
* the context of the specified
* TypeChecker. It amounts to first type-checking this
* expression in the type-checker, then making sure the type found for it
* by the type-checker agrees (i.e.unifies) with the specified type.
*/
public void typeCheck (Type type, TypeChecker typeChecker) throws TypingErrorException
{
typeCheck(typeChecker);
typeChecker.unify(typeRef(),type,this);
}
/**
* This method type-checks this expression in the context of the specified typechecker,
* using the type of the specified Global as a filter.
*/
public final void typeCheck (Global filter, TypeChecker typeChecker) throws TypingErrorException
{
typeCheck(typeChecker);
typeChecker.prune(filter,typeRef(),this);
filter.typeCheck(typeRef(),typeChecker);
}
/**
* This method compiles this expression in the context of the specified
* Compiler.
*/
public abstract void compile (Compiler compiler);
public final Instruction[] compile ()
{
Compiler compiler = new Compiler();
compiler.compile(this);
return(compiler.code());
}
/**
* Returns the number of subexpressions
*/
public int numberOfSubexpressions ()
{
return 0;
}
/**
* Returns the n-th subexpression of this expression; if there is no subexpression
* at the given position, this throws a NoSuchSubexpressionException
*/
public Expression subexpression (int n) throws NoSuchSubexpressionException
{
throw new NoSuchSubexpressionException(this,n);
}
/**
* This is only to enable uniform visitors on expressions. It will return non-null
* only for abstractions.
*/
public Parameter[] parameters ()
{
return null;
}
/**
* Returns the sort of this expression's type after it has been
* checked. Sorts are of three kinds and defined as global constants
* in Type: Type.INT_SORT,
* Type.REAL_SORT, and Type.OBJECT_SORT.
*/
public final byte sort ()
{
return checkedType().sort();
}
/**
* This returns the runtime sort for this expression unless its type
* has been marked as boxed - in which case it returns OBJECT_SORT.
*/
public /* final */ byte boxSort ()
{
return checkedType().boxSort();
}
/**
* This adds the specified type as another type for this expression. NB:
* This method must never be used on an expression or with a type that
* has been (even partially) type-checked. This is because, rather than making
* different type parameters separate types for this expression, it hard-binds
* together, or to the original type if there is one. It is meant to be used
* exclusively at syntax-building time prior to type-checking anything.
*/
public final Expression addType (Type newType)
{
Type oldType = type();
if (newType == null)
return this;
if (oldType == null)
setType(newType);
else
{
oldType = oldType.value();
newType = newType.value();
if (oldType == newType)
return this;
if (oldType.kind() == Type.PARAMETER)
((TypeParameter)oldType).bind(newType);
else
if (newType.kind() == Type.PARAMETER)
((TypeParameter)newType).bind(oldType);
else
{
if (_otherTypes == null)
_otherTypes = new HashSet();
_otherTypes.add(newType);
}
}
return this;
}
public final HashSet otherTypes ()
{
return _otherTypes;
}
public final Expression setOtherTypes (HashSet otherTypes)
{
_otherTypes = otherTypes;
return this;
}
/**
* Adds all the types prescribed for the specified expression to this one.
*/
public final Expression addTypes (Expression expression)
{
addType(expression.typeRef());
HashSet types = expression.otherTypes();
if (types != null)
for (Iterator i=types.iterator();i.hasNext();)
addType((Type)i.next());
return this;
}
/**
* This field may be used to contain this expression's concrete syntax origin.
*/
private Locatable _extent;
public final Locatable extent ()
{
return _extent;
}
public final Expression setExtent (Locatable extent)
{
_extent = extent;
return this;
}
/**
* Returns the start of this expressions's extent as a
* Location.
*/
public final Location getStart ()
{
return _extent == null ? null : _extent.getStart();
}
/**
* Returns the end of this expressions's extent as a
* Location.
*/
public final Location getEnd ()
{
return _extent == null ? null : _extent.getEnd();
}
/**
* Sets the start of this expressions's extent to the specified
* Location and returns this.
*/
public final Locatable setStart (Location location)
{
if (_extent == null) _extent = new Span();
_extent.setStart(location);
return this;
}
/**
* Sets the end of this expressions's extent to the specified
* Location and returns this.
*/
public final Locatable setEnd (Location location)
{
if (_extent == null) _extent = new Span();
_extent.setEnd(location);
return this;
}
/**
* Sets the extent of the specified
* StaticSemanticsErrorException to this expression.
*/
protected final StaticSemanticsErrorException locate (StaticSemanticsErrorException e)
{
return e.setExtent(this);
}
/**
* Returns an explicit string for this expression's extent's location.
*/
public final String locationString ()
{
return Misc.locationString(_extent);
}
/**
* This method analyzes the type boxing information for this expression when it
* occurs as a functional argument of an application. This returns an
* expression equivalent to this one "padded" with un/wrappers as needed to
* reconcile its type boxing information with that of the formal type expected by the
* argument of the function of which it is ac actual argument, and return the
* possibly so-modified expression. It is used by the compile method of an
* application that takes this expression as
* an argument with a functional type. Then, its type information and the type of the
* function's argument position where it appears (passed as argument to this method)
* must be used to determine whether to box or unbox its arguments and result. It is
* defined here as opposed to a concrete subclass of Expression because
* instances of several such classes may have a function type (namely, Abstractions,
* Locals, and Globals).
*/
final Expression pad (FunctionType formalType)
{
// This expression has necessarily a function type
FunctionType actualType = (FunctionType)checkedType();
int arity = actualType.arity();
boolean argumentSortsAgree = true;
for (int i=0; i 1 ? "(" : "";
// for (int i=0; i 1 ? ")" : "") + " -> " + outerPadding.checkedType();
// ilog.language.tools.Debug.step(this+" has been padded into: "+abstraction + " : "+s);
// /* end of code for debugging only */
return abstraction;
}
// HAK 2 HAK -> this below was added by PV - look into this later.
public void sanitizeTypeReferences ()
{
setType(type().sanitizeTypeReferences());
for (int i=0; i PV : what the hell is this???
protected String typed (String s)
{
if(checkedType() == null) {
return s;
} else {
return "(" + s + ") : " + checkedType();
}
}
}