/** Handles shorthand notation for collect and expands to an explicit collect expression. */
private Expression collectShorthandStdOp(
String opname, Expression srcExpr, Type cType, Type elemType) throws SemanticException {
Expression res = null;
// (1) predefined OCL operation
// find operation on element type
Type[] params = new Type[fArgExprs.length];
params[0] = elemType;
for (int i = 1; i < fArgExprs.length; i++) params[i] = fArgExprs[i].type();
if (!ExpStdOp.exists(opname, params)) {
String msg =
"Undefined operation `"
+ elemType
+ "."
+ opname
+ "' in shorthand notation for collect.";
// maybe the user just confused . with ->, check for
// operation on collection and give a hint.
params[0] = cType;
if (ExpStdOp.exists(opname, params))
msg +=
" However, there is an operation `"
+ cType
+ "->"
+ opname
+ "'. Maybe you wanted to use `->' instead of `.'?";
throw new SemanticException(fOp, msg);
}
// transform c.op(...) into c->collect($e | $e.op(...))
fArgExprs[0] = new ExpVariable("$e", elemType);
try {
Expression eOp = ExpStdOp.create(opname, fArgExprs);
res = genImplicitCollect(srcExpr, eOp, elemType);
} catch (ExpInvalidException ex) {
// shouldn't fail because we already checked the
// existence above
throw new RuntimeException("collectShorthand failed: " + ex.getMessage());
}
return res;
}
private Expression gen1(Context ctx, Expression srcExpr) throws SemanticException {
Expression res = null;
String opname = fOp.getText();
Type srcType = srcExpr.type();
// generate argument expressions
fArgExprs = new Expression[fArgs.size() + 1];
fArgExprs[0] = srcExpr;
Iterator it = fArgs.iterator();
int i = 1;
while (it.hasNext()) {
ASTExpression astExpr = (ASTExpression) it.next();
fArgExprs[i++] = astExpr.gen(ctx);
}
// flags for various cases
final int SRC_SIMPLE_TYPE = 0x100;
final int SRC_OBJECT_TYPE = 0x200;
final int SRC_COLLECTION_TYPE = 0x400;
final int DOT = 0x010;
final int ARROW = 0x020;
final int NO_PARENTHESES = 0x000;
final int PARENTHESES = 0x001;
int opcase;
if (srcType.isObjectType()) opcase = SRC_OBJECT_TYPE;
else if (srcType.isCollection()) opcase = SRC_COLLECTION_TYPE;
else opcase = SRC_SIMPLE_TYPE;
opcase += fFollowsArrow ? ARROW : DOT;
opcase += fHasParentheses ? PARENTHESES : NO_PARENTHESES;
switch (opcase) {
case SRC_SIMPLE_TYPE + DOT + NO_PARENTHESES:
case SRC_SIMPLE_TYPE + DOT + PARENTHESES:
case SRC_COLLECTION_TYPE + ARROW + PARENTHESES:
case SRC_COLLECTION_TYPE + ARROW + NO_PARENTHESES:
// (1) predefined OCL operation
res = genStdOperation(ctx, fOp, opname, fArgExprs);
break;
case SRC_SIMPLE_TYPE + ARROW + NO_PARENTHESES:
case SRC_SIMPLE_TYPE + ARROW + PARENTHESES:
ctx.reportWarning(
fOp,
"application of `"
+ opname
+ "' to a single value should be done with `.' "
+ "instead of `->'.");
// (1) predefined OCL operation
res = genStdOperation(ctx, fOp, opname, fArgExprs);
break;
case SRC_OBJECT_TYPE + DOT + NO_PARENTHESES:
MClass srcClass = ((ObjectType) srcType).cls();
MAttribute attr = srcClass.attribute(opname, true);
if (attr != null) {
// (2) attribute operation on object type (no arguments)
res = new ExpAttrOp(attr, srcExpr);
} else {
// (4) navigation operation on object type
// must be a role name
MAssociationEnd dstEnd = srcClass.navigableEnd(opname);
if (dstEnd != null) res = genNavigation(fOp, srcClass, srcExpr, dstEnd);
else {
// (1) predefined OCL operation
res = genStdOperation(ctx, fOp, opname, fArgExprs);
}
}
break;
case SRC_OBJECT_TYPE + DOT + PARENTHESES:
// (3) "isQuery" operation on object type (possibly with
// arguments) or (1)
MClass srcClass2 = ((ObjectType) srcType).cls();
res = genObjOperation(ctx, srcClass2, srcExpr);
break;
case SRC_OBJECT_TYPE + ARROW + NO_PARENTHESES:
case SRC_OBJECT_TYPE + ARROW + PARENTHESES:
// (6) set operation on single object resulting from
// navigation over associations with multiplicity zero
// or one (p. 7-13 of OMG UML 1.3)
if (srcExpr instanceof ExpNavigation) {
// first map object to set with internal operation
Expression mappedSrcExpr = new ExpObjAsSet(srcExpr);
// replace receiver in arg list
fArgExprs[0] = mappedSrcExpr;
try {
// lookup collection operation
res = ExpStdOp.create(opname, fArgExprs);
} catch (ExpInvalidException ex) {
throw new SemanticException(fOp, ex);
}
} else {
throw new SemanticException(
fOp,
"An arrow operation treating a single object as a "
+ "set may only be applied, if the object results "
+ "from a navigation to an association end with "
+ "multiplicity 0..1.");
}
break;
case SRC_COLLECTION_TYPE + DOT + NO_PARENTHESES:
// c.op 200 (5) with implicit (2,4,1)
if (Options.disableCollectShorthand)
throw new SemanticException(fOp, MSG_DISABLE_COLLECT_SHORTHAND);
res = collectShorthandWithOutArgs(opname, srcExpr);
break;
case SRC_COLLECTION_TYPE + DOT + PARENTHESES:
// c.op() 201 (5) with implicit (3,1)
if (Options.disableCollectShorthand)
throw new SemanticException(fOp, MSG_DISABLE_COLLECT_SHORTHAND);
res = collectShorthandWithArgs(opname, srcExpr);
break;
// throw new SemanticException(fOp,
// "If you want to apply an operation to a collection, please use an `->' instead of a
// `.'. If you are trying to apply the shorthand notation for `collect' - sorry, this is not
// yet supported. Please use the explicit notation.");
default:
throw new RuntimeException("case " + Integer.toHexString(opcase) + " not handled");
}
if (fIsPre) res.setIsPre();
return res;
}