/** 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; }