public Expression gen(Context ctx) throws SemanticException { Expression res = null; Expression srcExpr = null; String opname = fOp.getText(); if (fSrcExpr != null) { srcExpr = fSrcExpr.gen(ctx); res = gen1(ctx, srcExpr); } else { // if no source expression is given, it is either a // variable or a reference to expression determined by // context. In the latter case we use the context as // source expression and proceed as if it has been given // explicitly. if (!fHasParentheses) { // variable? // (7) check for variable Type type = ctx.varTable().lookup(opname); if (type != null) res = new ExpVariable(opname, type); } // do we have a context expression that is implicitly // assumed to be the source expression? if (res == null) { ExprContext ec = ctx.exprContext(); if (!ec.isEmpty()) { // construct source expression ExprContext.Entry e = ec.peek(); srcExpr = new ExpVariable(e.fName, e.fType); if (e.fType.isCollection()) fFollowsArrow = true; res = gen1(ctx, srcExpr); } else throw new SemanticException( fOp, "Undefined " + (fHasParentheses ? "operation" : "variable") + " `" + opname + "'."); } } if (fIsPre) { if (!ctx.insidePostCondition()) throw new SemanticException(fOp, "Modifier @pre is only allowed in postconditions."); res.setIsPre(); } if (opname.equals("oclIsNew")) { if (!ctx.insidePostCondition()) throw new SemanticException(fOp, "Operation oclIsNew is only allowed in postconditions."); } return res; }
/** Handles shorthand notation for collect and expands to an explicit collect expression. */ private Expression collectShorthandWithArgs(String opname, Expression srcExpr) throws SemanticException { Expression res = null; // c.op() 201 (5) with implicit (3,1) CollectionType cType = (CollectionType) srcExpr.type(); Type elemType = cType.elemType(); if (elemType.isObjectType()) { MClass srcClass = ((ObjectType) elemType).cls(); MOperation op = srcClass.operation(opname, true); if (op != null) { // check for isQuery operation with OCL body if (!op.hasExpression()) throw new SemanticException( fOp, "Operation `" + srcClass.name() + "::" + op.signature() + "' cannot be used in OCL expression " + "(only side effect-free operations with a return type and an OCL expression as body may be used)."); // transform c.op(...) into c->collect($e | $e.op(...)) ExpVariable eVar = new ExpVariable("$e", elemType); fArgExprs[0] = eVar; try { // constructor performs additional checks res = new ExpObjOp(op, fArgExprs); } catch (ExpInvalidException ex) { throw new SemanticException( fOp, "In operation call `" + srcClass.name() + "::" + opname + "': " + ex.getMessage()); } res = genImplicitCollect(srcExpr, res, elemType); } } if (res == null) { // try (1) predefined OCL operation res = collectShorthandStdOp(opname, srcExpr, cType, elemType); } return res; }
/** Handles shorthand notation for collect and expands to an explicit collect expression. */ private Expression collectShorthandWithOutArgs(String opname, Expression srcExpr) throws SemanticException { Expression res = null; // c.op 200 (5) with implicit (2,4,1) CollectionType cType = (CollectionType) srcExpr.type(); Type elemType = cType.elemType(); if (elemType.isObjectType()) { MClass srcClass = ((ObjectType) elemType).cls(); MAttribute attr = srcClass.attribute(opname, true); if (attr != null) { // (2) attribute operation on object type (no arguments) // transform c.a into c->collect($e | $e.a) ExpVariable eVar = new ExpVariable("$e", elemType); ExpAttrOp eAttr = new ExpAttrOp(attr, eVar); res = genImplicitCollect(srcExpr, eAttr, elemType); } else { MAssociationEnd dstEnd = srcClass.navigableEnd(opname); if (dstEnd != null) { // (4) navigation operation on object type must be // a role name // transform c.r into c->collect($e | $e.r) ExpVariable eVar = new ExpVariable("$e", elemType); Expression eNav = genNavigation(fOp, srcClass, eVar, dstEnd); res = genImplicitCollect(srcExpr, eNav, elemType); } } } if (res == null) { // ! objectType || ! (attr || navigation) // try (1) predefined OCL operation res = collectShorthandStdOp(opname, srcExpr, cType, elemType); } return res; }
public Expression gen(Context ctx) throws SemanticException { String opname = fOp.getText(); Expression res = null; Expression range, expr; // check for empty range: do we have a context expression that // is implicitly assumed to be the source expression? if (fRange != null) range = fRange.gen(ctx); else { ExprContext ec = ctx.exprContext(); if (!ec.isEmpty()) { // construct source expression ExprContext.Entry e = ec.peek(); range = new ExpVariable(e.fName, e.fType); } else throw new SemanticException(fOp, "Need a collection to apply `" + opname + "'."); } if (!range.type().isCollection()) throw new SemanticException( fOp, "Source of `" + opname + "' expression must be a collection, " + "found source expression of type `" + range.type() + "'."); VarDeclList declList = new VarDeclList(true); if (fDeclList.isEmpty()) { // when there are no explicit var decls, we declare an // internal variable with the element type ExprContext ec = ctx.exprContext(); CollectionType ct = (CollectionType) range.type(); String var = ec.push(ct.elemType()); expr = fExpr.gen(ctx); ec.pop(); // use the generated element variable VarDecl decl = new VarDecl(var, ct.elemType()); declList.add(decl); } else { declList = fDeclList.gen(ctx, range); // enter declared variable into scope before evaluating // the argument expression Symtable vars = ctx.varTable(); vars.enterScope(); fDeclList.addVariablesToSymtable(vars, declList.varDecl(0).type()); expr = fExpr.gen(ctx); vars.exitScope(); } try { Integer id = (Integer) GParser.queryIdentMap.get(opname); if (id == null) throw new SemanticException( fOp, "Internal error: unknown query operation `" + opname + "'."); int idval = id.intValue(); switch (idval) { case GParser.Q_SELECT_ID: case GParser.Q_COLLECT_ID: case GParser.Q_REJECT_ID: case GParser.Q_ISUNIQUE_ID: case GParser.Q_SORTEDBY_ID: case GParser.Q_ANY_ID: case GParser.Q_ONE_ID: VarDecl decl; if (declList.isEmpty()) decl = null; else if (declList.size() == 1) decl = declList.varDecl(0); else throw new SemanticException( fOp, "Only one element variable in " + opname + " expression allowed."); switch (idval) { case GParser.Q_SELECT_ID: res = new ExpSelect(decl, range, expr); break; case GParser.Q_COLLECT_ID: res = new ExpCollect(decl, range, expr); break; case GParser.Q_REJECT_ID: res = new ExpReject(decl, range, expr); break; case GParser.Q_ISUNIQUE_ID: res = new ExpIsUnique(decl, range, expr); break; case GParser.Q_SORTEDBY_ID: res = new ExpSortedBy(decl, range, expr); break; case GParser.Q_ANY_ID: res = new ExpAny(decl, range, expr); break; case GParser.Q_ONE_ID: res = new ExpOne(decl, range, expr); break; } break; case GParser.Q_EXISTS_ID: res = new ExpExists(declList, range, expr); break; case GParser.Q_FORALL_ID: res = new ExpForAll(declList, range, expr); break; default: // internal error throw new SemanticException( fOp, "Internal error: unknown query operation `" + opname + "'."); } } catch (ExpInvalidException ex) { throw new SemanticException(fOp, ex); } 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; }