private static Map<String, Long> getMessageSVUID(Type messageType)
throws SJIOException,
ClassNotFoundException // SJCompilerUtils has a simpler version of this routine.
{
HashMap<String, Long> ours = new HashMap<String, Long>();
if (messageType
instanceof
SJSessionType) // Should come before ordinary class cases? (But SJSessionType shouldn't be a
// class type).
{
ours.putAll(getClassSVUIDs((SJSessionType) messageType));
} else if (messageType.isPrimitive()) {
// No SVUID needed for primitive types.
} else if (messageType.isClass()) // Duplicated from above.
{
String className = messageType.toClass().fullName();
Class<?> c = Class.forName(className);
if (c.isInterface()) {
// Interfaces don't have SVUIDs (so what should we do here?). // This encourages use of
// abstract classes rather than interfaces for message types?
} else {
ObjectStreamClass osc = ObjectStreamClass.lookup(c);
if (osc == null) {
throw new SJIOException("Class not serializable: " + c);
}
ours.put(
className,
osc
.getSerialVersionUID()); // Not possible to find a different SVUID for the same
// (name) class here? // SVUIDs could be recorded in the
// session type objects. // Put currently problems working
// with these values at compilation time if the class
// binary is not available a priori (SVUID value not built
// yet?).
}
} else if (messageType.isArray()) {
throw new SJIOException("Array types not done yet: " + messageType);
}
return ours;
}
public boolean callValid(Type thisType, List<Type> argTypes, Context context) {
JL5TypeSystem ts = (JL5TypeSystem) typeSystem();
List<Type> l1 = this.formalTypes();
List<Type> l2 = argTypes;
if ((l1.size() == 0) && (l2.size() != 0)) return false;
Iterator<Type> itCallee = l1.iterator();
Iterator<Type> itCaller = l2.iterator();
// caller can either:
// - have one argument less than callee (last argument of
// callee is a varargs and caller do not provide a value)
// - have same number of args. The last arg being either
// - same type as the last arg of callee
// - or same type as the last arg of callee which is a varargs array
// - or an array of same type as the last arg of callee (which could be a varargs array)
// - have more args, then:
// - last args of callee must be a varargs array
// - all extra args provided by the caller must match
// the varargs array type of the callee.
while (itCallee.hasNext() && itCaller.hasNext()) {
Type t1 = itCallee.next();
Type t2 = itCaller.next();
// Varargs can be used only in the final argument position
// When we reach the final argument, we check if it is varargs array.
if (!itCallee.hasNext() && t1.isArray() && ((JL5ArrayType) t1).isVarargs()) {
JL5ArrayType vartype = (JL5ArrayType) t1;
// Every arguments remaining in the second iterator must match the type
// of the varargs array
if (!itCaller.hasNext()) {
// if we also reached the last element of the caller,
// check if the type matches or if it is an array
return ts.isImplicitCastValid(t2, vartype, context)
|| ts.isImplicitCastValid(t2, vartype.base(), context);
} else {
// There are several arguments left, they should all match the callee's varargs array
// type.
while (itCaller.hasNext()) { // eat up actual args
if (!ts.isImplicitCastValid(t2, vartype.base(), context)) {
return false;
}
t2 = itCaller.next();
}
}
} else {
if (!ts.isImplicitCastValid(t2, t1, context)) {
return false;
}
}
}
// Caller provided less args than the callee has, which is legal
// if callee is a variable arity method
if (itCallee.hasNext() && isVariableArrity()) {
itCallee.next();
}
// and we've reached callee's last arg.
return !(itCallee.hasNext() || itCaller.hasNext());
}
