package ilog.language.design.kernel;
/**
* @version Last modified on Wed Jul 24 12:18:21 2002 by pviry
* @version modified on Mon Jul 08 17:20:39 2002 by hak
* @author Hassan Aït-Kaci
* @copyright © 2001 ILOG, S.A.
*/
import ilog.language.design.types.*;
import ilog.language.design.base.*;
import java.util.ArrayList;
/**
* This class represents a syntactic construct that is often used,
* albeit with different, though related, interpretations. A dotted
* notation is an expression (most often an application, but it could be
* any composition - of what to/with what to be determined
* according to partial type analysis).
* Thus, this class can be used to represent a particular kind of
* functional applications à la object-oriented
* programming; or (equivalently), arrow composition in Category
* Theory. More precisely, it represents the application (resp.,
* composition) of an Expression to (resp., with) another
* Expression, those Expressions being determined
* according to the type of the expression on the left of the
* "dot".
* Thus, a dotted notation is interpreted as follows.
* A DottedNotation object is a wrapper of an expression - most
* often, of an application, but more generally, of any composition. It
* is a binary expression of the form
* e1.e2, where the
* ei's,
* i=1,2, are expressions. This is
* interpreted depending on the type of
* e1 as follows:
*
* - if e1's type is a class C,
* then this is interpreted as:
*
* mangle(e1:C,e2)args(e2)
*
* where mangle(o:C,e) is some "mangling"
* of the name of the member of the object expression o of class type
* C being so-referred, and args(e) is either
* the empty string or the args of the member expression e.
*
*
* For example, consider:
*
* counter.set(1);
*
* when counter : Counter is an object of class Counter,
* with method (say) Counter_set : (Counter, int) -> int. Then,
* for example, a default "mangling"
* mangle(C,member)
* may simply concatenate the names of the class and the member separated with an underscore
* character ('_'), followed by '(', the object, and ')'; in other words:
* mangle(counter:Counter,set(1)) = "Counter_set(counter)" and
* args(set(1)) = "(1)". Therefore,
*
* counter.set(1) ====> Counter_set(counter)(1);
*
* that is:
*
* counter.set(1) ====> Counter_set(counter,1);
*
* - if e1's type is a tuple type
* <T1,...Tn> or
* <l1:T1,...ln:Tn>,
* then this is interpreted as:
*
* projecte2(e1)
*
* where projecte is a tuple
* projection of type <T1,...Tn>
* -> Tk and e=k,
* k=1,...,n, or of type
* <l1:T1,...ln:Tn>
* -> Tk and e=lk,
* k=1,...,n.
* This is interpreted as:
*
* TupleProjection(e1,e2) : Tk.
*
* For example:
*
* <name:="a",number:=1>.name ====> TupleProjection(<name:="a",number:=1>,name)
*
* In other words,
*
* projectname : <name:string,number:int> -> string (<name:="a",number:=1>) : string
*
* - Otherwise, the default is simply to interpret this as the application:
*
* member_name(e2)(e1)(args(e2)).
*
* This default behavior can be overridden and customized through the methods:
* setNoDefault() and
* setDefault(Expression).
*
*/
public class DottedNotation extends ProtoExpression
{
/**
* This is the symbol tables.
*/
private Tables _tables;
/**
* This is the "left" expression of this dotted notation.
*/
private Expression _left;
/**
* This is the "rite" expression of this dotted notation.
*/
private Expression _rite;
private boolean _default = true;
public final DottedNotation setNoDefault ()
{
_default = false;
return this;
}
public final DottedNotation setDefault (Expression expression)
{
_actualExpression = expression;
return this;
}
/**
* This is the "actual" expression this dotted notation is eventually
* translated into.
*/
private Expression _actualExpression;
// /**
// * Constructs a dotted notation with the specified tables, object expression, and
// * member/args.
// */
// public DottedNotation (Tables tables, Expression object, String member, ArrayList args)
// {
// _tables = tables;
// _left = left;
// _rite = rite;
// }
/**
* Constructs a dotted notation with the specified tables, and left and rite expressions.
*/
public DottedNotation (Tables tables, Expression left, Expression rite)
{
_tables = tables;
_left = left;
_rite = rite;
}
public final int numberOfSubexpressions ()
{
return 2;
}
public final Expression subexpression (int n) throws NoSuchSubexpressionException
{
if (n == 0)
return _left;
if (n == 1)
return _rite;
throw new NoSuchSubexpressionException(this,n);
}
public final Expression left ()
{
return _left;
}
public final Expression rite ()
{
return _rite;
}
public final DottedNotation setTables (Tables tables)
{
_tables = tables;
return this;
}
public final DottedNotation setLeft (Expression left)
{
_left = left;
return this;
}
public final DottedNotation setRite (Expression rite)
{
_rite = rite;
return this;
}
public final Expression actualExpression ()
{
return _actualExpression;
}
public final void setCheckedType ()
{
setCheckedType(type().copy());
_actualExpression.setCheckedType();
}
public final Expression sanitizeNames (ParameterStack parameters, ClassTypeHandle handle)
{
_left = _left.sanitizeNames(parameters,handle);
_rite = _rite.sanitizeNames(parameters,handle);
return this;
}
public final void sanitizeSorts (Enclosure enclosure)
{
_left.sanitizeSorts(enclosure);
_rite.sanitizeSorts(enclosure);
}
public final Expression shiftOffsets (int intShift, int realShift, int objectShift,
int intDepth, int realDepth, int objectDepth)
{
_left = _left.shiftOffsets(intShift,realShift,objectShift,
intDepth,realDepth,objectDepth);
_rite = _rite.shiftOffsets(intShift,realShift,objectShift,
intDepth,realDepth,objectDepth);
return this;
}
/**
* This is a "fragile" typing rule in the sense that it relies
* on partial type-checking of one (the left) of its
* subexpressions. This means that ambiguous types for the left
* expression are not allowed! When a single typing has been
* obtained, however, type-checking a dotted notation simply delegates
* the "real" type-checking to the underlying actual expression.
*/
public void typeCheck (TypeChecker typeChecker) throws TypingErrorException
{
TypeChecker tmp = new TypeChecker();
ArrayList possibleLeftTypes = tmp.allTypes(_left);
if (possibleLeftTypes.isEmpty())
typeChecker.error
(new TypingErrorException
("this dotted notation's left expression has no type!"),
_left);
if (possibleLeftTypes.size() > 1)
typeChecker.error
(new TypingErrorException
("this dotted notation's left expression has ambiguous types: "
+possibleLeftTypes),
_left);
Type leftType = ((Type)possibleLeftTypes.get(0)).value();
switch (leftType.kind())
{
case Type.CLASS:
_actualExpression
= new Application(new Application(new Global(_tables,
mangledMemberName((ClassType)leftType)),
_left),
_rite.args());
break;
case Type.TUPLE: case Type.NAMED_TUPLE:
_actualExpression
= new TupleProjection(_left,(Constant)_rite);
break;
default:
if (!_default)
typeChecker.error
(new TypingErrorException
("dotted notation has bad left type (must be Class or Tuple; found: "
+leftType+")"),
this);
_actualExpression
= new Application(new Application(new Global(_tables,
_rite.memberName()),
_left),
_rite.args());
break;
}
_actualExpression.typeCheck(typeRef(),typeChecker);
}
public final String mangledMemberName (ClassType classType)
{
return classType.mangledMemberName(this);
}
public final String mangle (ClassType classType)
{
return classType.mangle(this);
}
/**
* Compiling a dotted notation simply delegates the "real" compiling
* to the underlying actual expression.
*/
public final void compile (Compiler compiler)
{
_actualExpression.compile(compiler);
}
public String toString ()
{
return _left + " . " + _rite;
}
// Added by PV
public String toTypedString ()
{
return typed(_left.toTypedString() + " . " + _rite.toTypedString());
}
}