/** * @brief Run tests on BinaryOperation::partialTypeSignatureIsPlausible() * with a known result type and unknown (NULL) argument types. * * @param op An implementation of BinaryOperation to test. * @param plausible_result_type_ids A list of TypeIDs indicating which Types * are considered plausible for op to return. **/ static void CheckPlausibilityWithKnownResultAndUnknownArguments( const BinaryOperation &op, const std::initializer_list<TypeID> &plausible_result_type_ids) { for (const TypeID result_type_id : {kInt, kLong, kFloat, kDouble, kChar, kVarChar, kDatetime, kDatetimeInterval, kYearMonthInterval}) { const Type *result_type = TypeFactory::TypeRequiresLengthParameter(result_type_id) ? &TypeFactory::GetType(result_type_id, 10, false) : &TypeFactory::GetType(result_type_id, false); const Type *result_type_nullable = &result_type->getNullableVersion(); if (std::find(plausible_result_type_ids.begin(), plausible_result_type_ids.end(), result_type_id) == plausible_result_type_ids.end()) { EXPECT_FALSE(op.partialTypeSignatureIsPlausible(result_type_nullable, nullptr, nullptr)); } else { EXPECT_TRUE(op.partialTypeSignatureIsPlausible(result_type_nullable, nullptr, nullptr)); } // The non-nullable version of the result type is never considered // plausible, because the unknown argument types represent unresolved // NULL values. EXPECT_FALSE(op.partialTypeSignatureIsPlausible(result_type, nullptr, nullptr)); } }
bool Why3Translator::visit(BinaryOperation const& _binaryOperation) { Expression const& leftExpression = _binaryOperation.leftExpression(); Expression const& rightExpression = _binaryOperation.rightExpression(); solAssert(!!_binaryOperation.annotation().commonType, ""); Type const& commonType = *_binaryOperation.annotation().commonType; Token::Value const c_op = _binaryOperation.getOperator(); if (commonType.category() == Type::Category::RationalNumber) { auto const& constantNumber = dynamic_cast<RationalNumberType const&>(commonType); if (constantNumber.isFractional()) error(_binaryOperation, "Fractional numbers not supported."); else add("(of_int " + toString(commonType.literalValue(nullptr)) + ")"); return false; } static const map<Token::Value, char const*> optrans({ {Token::And, " && "}, {Token::Or, " || "}, {Token::BitOr, " lor "}, {Token::BitXor, " lxor "}, {Token::BitAnd, " land "}, {Token::Add, " + "}, {Token::Sub, " - "}, {Token::Mul, " * "}, {Token::Div, " / "}, {Token::Mod, " mod "}, {Token::Equal, " = "}, {Token::NotEqual, " <> "}, {Token::LessThan, " < "}, {Token::GreaterThan, " > "}, {Token::LessThanOrEqual, " <= "}, {Token::GreaterThanOrEqual, " >= "} }); if (!optrans.count(c_op)) { error(_binaryOperation, "Operator not supported."); return true; } add("("); leftExpression.accept(*this); add(optrans.at(c_op)); rightExpression.accept(*this); add(")"); return false; }
bool ASTPrinter::visit(BinaryOperation const& _node) { writeLine(string("BinaryOperation using operator ") + Token::toString(_node.getOperator())); printType(_node); printSourcePart(_node); return goDeeper(); }
/** * @brief Run tests on BinaryOperation::partialTypeSignatureIsPlausible() * with an unknown result type and a single known argument type. * * @param op An implementation of BinaryOperation to test. * @param plausible_argument_type_ids A list of TypeIDs indicating which * Types are considered plausible arguments (left or right) to op. * @param check_left_argument If true, check the plausibility of Types in the * left argument position. * @param check_right_argument If true, check the plausibility of Types in * the right argument position. **/ static void CheckPlausibilityWithUnknownResultAndSingleKnownArgument( const BinaryOperation &op, const std::initializer_list<TypeID> &plausible_argument_type_ids, const bool check_left_argument, const bool check_right_argument) { for (const TypeID argument_type_id : {kInt, kLong, kFloat, kDouble, kChar, kVarChar, kDate, kDatetime, kDatetimeInterval, kYearMonthInterval}) { const Type *argument_type = TypeFactory::TypeRequiresLengthParameter(argument_type_id) ? &TypeFactory::GetType(argument_type_id, 10, false) : &TypeFactory::GetType(argument_type_id, false); const Type *argument_type_nullable = &argument_type->getNullableVersion(); if (std::find(plausible_argument_type_ids.begin(), plausible_argument_type_ids.end(), argument_type_id) == plausible_argument_type_ids.end()) { if (check_left_argument) { EXPECT_FALSE(op.partialTypeSignatureIsPlausible( nullptr, argument_type, nullptr)); EXPECT_FALSE(op.partialTypeSignatureIsPlausible( nullptr, argument_type_nullable, nullptr)); } if (check_right_argument) { EXPECT_FALSE(op.partialTypeSignatureIsPlausible( nullptr, nullptr, argument_type)); EXPECT_FALSE(op.partialTypeSignatureIsPlausible( nullptr, nullptr, argument_type_nullable)); } } else { if (check_left_argument) { EXPECT_TRUE(op.partialTypeSignatureIsPlausible( nullptr, argument_type, nullptr)); EXPECT_TRUE(op.partialTypeSignatureIsPlausible( nullptr, argument_type_nullable, nullptr)); } if (check_right_argument) { EXPECT_TRUE(op.partialTypeSignatureIsPlausible( nullptr, nullptr, argument_type)); EXPECT_TRUE(op.partialTypeSignatureIsPlausible( nullptr, nullptr, argument_type_nullable)); } } } }
T pow(const T& arg, int n,const BinaryOperation<T>& binaryOperation){ T for_return; if (n>0){ std::vector<T> mass; mass.push_back(arg); int max_binary_pow=1; int max_pow=1; while(n>=2*max_pow){ mass.push_back(binaryOperation(mass[max_binary_pow-1],mass[max_binary_pow-1])); max_binary_pow++; max_pow=max_pow*2; } while (n>0){ if (max_pow<=n){ for_return=binaryOperation(for_return,mass[max_binary_pow-1]); n=n-max_pow; } max_pow=max_pow/2; max_binary_pow--; } } else for_return=binaryOperation.normEl(); return for_return; };
Method* addComplicated(Model::Model* model, Class* parent) { Method* met = nullptr; if (!parent) met = dynamic_cast<Method*> (model->createRoot("Method")); model->beginModification(parent? static_cast<Model::Node*> (parent) : met, "Adding a Complicated method."); if (!met) { met = new Method(); parent->methods()->append(met); } met->setName("complicated"); VariableDeclarationExpression* a = new VariableDeclarationExpression("a"); met->items()->append(new ExpressionStatement(a)); a->decl()->setTypeExpression(new PrimitiveTypeExpression(PrimitiveTypeExpression::PrimitiveTypes::INT)); VariableDeclarationExpression* b = new VariableDeclarationExpression("b"); met->items()->append(new ExpressionStatement(b)); b->decl()->setTypeExpression(new PrimitiveTypeExpression(PrimitiveTypeExpression::PrimitiveTypes::UNSIGNED_INT)); b->decl()->setInitialValue(new IntegerLiteral(1000)); LoopStatement* loop = new LoopStatement(); met->items()->append(loop); VariableDeclarationExpression* initStep = new VariableDeclarationExpression("i"); loop->setInitStep(initStep); initStep->decl()->setTypeExpression(new PrimitiveTypeExpression(PrimitiveTypeExpression::PrimitiveTypes::INT)); initStep->decl()->setInitialValue(new IntegerLiteral(0)); BinaryOperation* loopCondition = new BinaryOperation(); loop->setCondition(loopCondition); loopCondition->setLeft(new ReferenceExpression("i")); loopCondition->setOp(BinaryOperation::LESS); loopCondition->setRight(new ReferenceExpression("a")); AssignmentExpression* updateStep = new AssignmentExpression(); loop->setUpdateStep(updateStep); updateStep->setLeft(new ReferenceExpression("i")); updateStep->setOp(AssignmentExpression::PLUS_ASSIGN); updateStep->setRight(new IntegerLiteral(1)); AssignmentExpression* loopBodyAssignment = new AssignmentExpression(); loop->body()->append(loopBodyAssignment); loopBodyAssignment->setLeft(new ReferenceExpression("b")); loopBodyAssignment->setOp(AssignmentExpression::TIMES_ASSIGN); loopBodyAssignment->setRight(new IntegerLiteral(2)); IfStatement* loopIf = new IfStatement(); loop->body()->append(loopIf); BinaryOperation* ifCond = new BinaryOperation(); loopIf->setCondition(ifCond); ifCond->setLeft(new ReferenceExpression("i")); ifCond->setOp(BinaryOperation::NOT_EQUALS); ifCond->setRight(new IntegerLiteral(10)); IfStatement* loopIfLeft = new IfStatement(); loopIf->thenBranch()->append(loopIfLeft); IfStatement* loopIfRight = new IfStatement(); loopIf->elseBranch()->append(loopIfRight); BinaryOperation* ifLeftCondition = new BinaryOperation(); loopIfLeft->setCondition(ifLeftCondition); ifLeftCondition->setLeft(new ReferenceExpression("a")); ifLeftCondition->setOp(BinaryOperation::GREATER_EQUALS); ifLeftCondition->setRight(new IntegerLiteral(3)); loopIfLeft->thenBranch()->append(new ContinueStatement()); loopIfLeft->thenBranch()->append(new BreakStatement()); loopIfLeft->thenBranch()->append(new ContinueStatement()); loopIfLeft->thenBranch()->append(new BreakStatement()); BinaryOperation* ifRightCondition = new BinaryOperation(); loopIfRight->setCondition(ifRightCondition); ifRightCondition->setLeft(new ReferenceExpression("b")); ifRightCondition->setOp(BinaryOperation::EQUALS); ifRightCondition->setRight(new IntegerLiteral(-20)); loopIfRight->thenBranch()->append(new ContinueStatement()); loopIfRight->thenBranch()->append(new BreakStatement()); loopIfRight->thenBranch()->append(new ContinueStatement()); loopIfRight->thenBranch()->append(new BreakStatement()); loopIfRight->elseBranch()->append(new ContinueStatement()); loopIfRight->elseBranch()->append(new BreakStatement()); loopIfRight->elseBranch()->append(new ContinueStatement()); loopIfRight->elseBranch()->append(new BreakStatement()); loop->body()->append(new ContinueStatement()); loop->body()->append(new BreakStatement()); ForEachStatement* forEach = new ForEachStatement(); met->items()->append(forEach); forEach->setVarName("elem"); forEach->setVarType( new PrimitiveTypeExpression(PrimitiveTypeExpression::PrimitiveTypes::UNSIGNED_INT) ); forEach->setCollection(new ReferenceExpression("SomeCollection")); AssignmentExpression* assignEach = new AssignmentExpression(); forEach->body()->append(assignEach); assignEach->setLeft(new ReferenceExpression("a")); assignEach->setOp(AssignmentExpression::DIVIDE_ASSIGN); assignEach->setRight(new ReferenceExpression("elem")); ReturnStatement* metReturn = new ReturnStatement(); metReturn->values()->append(new IntegerLiteral(42)); met->items()->append(metReturn); met->extension<Position>()->setX(500); model->endModification(); return met; }
Method* addDivBySix(Model::Model* model, Class* parent) { Method* divbysix = nullptr; if (!parent) divbysix = dynamic_cast<Method*> (model->createRoot("Method")); model->beginModification(parent? static_cast<Model::Node*> (parent) : divbysix, "Adding a divBySix method."); if (!divbysix) { divbysix = new Method(); parent->methods()->append(divbysix); } divbysix->setName("findDivBySix"); FormalResult* divbysixResult = new FormalResult(); divbysixResult->setTypeExpression(new PrimitiveTypeExpression(PrimitiveTypeExpression::PrimitiveTypes::INT)); divbysix->results()->append(divbysixResult); FormalArgument* arg = new FormalArgument(); divbysix->arguments()->append(arg); arg->setName("numbers"); ArrayTypeExpression* argType = new ArrayTypeExpression(); argType->setTypeExpression(new PrimitiveTypeExpression(PrimitiveTypeExpression::PrimitiveTypes::INT)); arg->setTypeExpression(argType); VariableDeclarationExpression* result = new VariableDeclarationExpression("result"); divbysix->items()->append(new ExpressionStatement(result)); result->decl()->setTypeExpression(new PrimitiveTypeExpression(PrimitiveTypeExpression::PrimitiveTypes::INT)); result->decl()->setInitialValue(new IntegerLiteral(-1)); LoopStatement* sixloop = new LoopStatement(); divbysix->items()->append(sixloop); VariableDeclarationExpression* sixLoopInit = new VariableDeclarationExpression("i"); sixloop->setInitStep(sixLoopInit); sixLoopInit->decl()->setTypeExpression(new PrimitiveTypeExpression(PrimitiveTypeExpression::PrimitiveTypes::INT)); sixLoopInit->decl()->setInitialValue(new IntegerLiteral(0)); BinaryOperation* sixLoopCond = new BinaryOperation(); sixloop->setCondition(sixLoopCond); sixLoopCond->setLeft(new ReferenceExpression("i")); sixLoopCond->setOp(BinaryOperation::LESS); MethodCallExpression* sizeCall = new MethodCallExpression("size", new ReferenceExpression("numbers")); sixLoopCond->setRight(sizeCall); //TODO test the visualization without the remaining parts of this method AssignmentExpression* sixLoopUpdate = new AssignmentExpression(); sixloop->setUpdateStep(sixLoopUpdate); sixLoopUpdate->setLeft(new ReferenceExpression("i")); sixLoopUpdate->setOp(AssignmentExpression::PLUS_ASSIGN); sixLoopUpdate->setRight(new IntegerLiteral(1)); VariableDeclarationExpression* n = new VariableDeclarationExpression("n"); sixloop->body()->append(new ExpressionStatement(n)); n->decl()->setTypeExpression(new PrimitiveTypeExpression(PrimitiveTypeExpression::PrimitiveTypes::INT)); BinaryOperation* item = new BinaryOperation(); n->decl()->setInitialValue(item); item->setLeft(new ReferenceExpression("numbers")); item->setOp(BinaryOperation::ARRAY_INDEX); item->setRight(new ReferenceExpression("i")); IfStatement* ifdiv2 = new IfStatement(); sixloop->body()->append(ifdiv2); BinaryOperation* eq0 = new BinaryOperation(); ifdiv2->setCondition(eq0); eq0->setOp(BinaryOperation::EQUALS); eq0->setRight(new IntegerLiteral(0)); BinaryOperation* div2 = new BinaryOperation(); eq0->setLeft(div2); div2->setLeft(new ReferenceExpression("n")); div2->setOp(BinaryOperation::REMAINDER); div2->setRight(new IntegerLiteral(2)); ifdiv2->elseBranch()->append(new ContinueStatement()); IfStatement* ifdiv3 = new IfStatement(); ifdiv2->thenBranch()->append(ifdiv3); eq0 = new BinaryOperation(); ifdiv3->setCondition(eq0); eq0->setOp(BinaryOperation::EQUALS); eq0->setRight(new IntegerLiteral(0)); BinaryOperation* div3 = new BinaryOperation(); eq0->setLeft(div3); div3->setLeft(new ReferenceExpression("n")); div3->setOp(BinaryOperation::REMAINDER); div3->setRight(new IntegerLiteral(3)); AssignmentExpression* resultFound = new AssignmentExpression(); ifdiv3->thenBranch()->append(resultFound); resultFound->setLeft(new ReferenceExpression("result")); resultFound->setOp(AssignmentExpression::ASSIGN); resultFound->setRight(new ReferenceExpression("i")); ifdiv3->thenBranch()->append( new BreakStatement()); ReturnStatement* divbysixFinalReturn = new ReturnStatement(); divbysixFinalReturn->values()->append(new ReferenceExpression("result")); divbysix->items()->append(divbysixFinalReturn); model->endModification(); return divbysix; }
Method* addDivBySix(Model::Model* model, Class* parent) { Method* divbysix = nullptr; if (!parent) divbysix = dynamic_cast<Method*> (model->createRoot("Method")); model->beginModification(parent? static_cast<Model::Node*> (parent) : divbysix, "Adding a divBySix method."); if (!divbysix) { divbysix = new Method(); parent->methods()->append(divbysix); } divbysix->setName("findDivBySix"); FormalResult* divbysixResult = new FormalResult(); divbysixResult->setType(new PrimitiveType(PrimitiveType::INT)); divbysix->results()->append(divbysixResult); FormalArgument* arg = new FormalArgument(); divbysix->arguments()->append(arg); arg->setName("numbers"); ArrayType* argType = new ArrayType(); argType->setType(new PrimitiveType(PrimitiveType::INT)); arg->setType(argType); ExpressionStatement* es = new ExpressionStatement(); es->setExpression( new EmptyExpression()); divbysix->items()->append(es); VariableDeclaration* exprtest = new VariableDeclaration(); divbysix->items()->append(new ExpressionStatement(exprtest)); exprtest->setName("exprtest"); exprtest->setType(new PrimitiveType(PrimitiveType::INT)); exprtest->setInitialValue( OOExpressionBuilder::getOOExpression("+aa++&b,*e/d-#") ); VariableDeclaration* exprtest2 = new VariableDeclaration(); divbysix->items()->append(new ExpressionStatement(exprtest2)); exprtest2->setName("exprtest2"); exprtest2->setType(new PrimitiveType(PrimitiveType::VOID)); exprtest2->setInitialValue( OOExpressionBuilder::getOOExpression("a*b+c/e-d++%--e*-f==g") ); VariableDeclaration* exprtest3 = new VariableDeclaration(); divbysix->items()->append(new ExpressionStatement(exprtest3)); exprtest3->setName("exprtest3"); exprtest3->setType(new PrimitiveType(PrimitiveType::VOID)); exprtest3->setInitialValue( OOExpressionBuilder::getOOExpression("a<b||c>d&&e<=f|g&h^~i") ); VariableDeclaration* exprtest4 = new VariableDeclaration(); divbysix->items()->append(new ExpressionStatement(exprtest4)); exprtest4->setName("exprtest4"); exprtest4->setType(new PrimitiveType(PrimitiveType::VOID)); exprtest4->setInitialValue( OOExpressionBuilder::getOOExpression("new value[5]") ); VariableDeclaration* exprtest5 = new VariableDeclaration(); divbysix->items()->append(new ExpressionStatement(exprtest5)); exprtest5->setName("exprtest5"); exprtest5->setType(new PrimitiveType(PrimitiveType::VOID)); exprtest5->setInitialValue( OOExpressionBuilder::getOOExpression("(castto)object") ); VariableDeclaration* exprtest6 = new VariableDeclaration(); divbysix->items()->append(new ExpressionStatement(exprtest6)); exprtest6->setName("exprtest6"); exprtest6->setType(new PrimitiveType(PrimitiveType::VOID)); exprtest6->setInitialValue( OOExpressionBuilder::getOOExpression("{a,bb,ccc}") ); VariableDeclaration* exprtest7 = new VariableDeclaration(); divbysix->items()->append(new ExpressionStatement(exprtest7)); exprtest7->setName("exprtest7"); exprtest7->setType(new PrimitiveType(PrimitiveType::VOID)); exprtest7->setInitialValue( OOExpressionBuilder::getOOExpression("{{123,hello},{2,b}}") ); VariableDeclaration* exprtest8 = new VariableDeclaration(); divbysix->items()->append(new ExpressionStatement(exprtest8)); exprtest8->setName("exprtest8"); exprtest8->setType(new PrimitiveType(PrimitiveType::VOID)); exprtest8->setInitialValue( OOExpressionBuilder::getOOExpression("a.b+c.d[i].f") ); VariableDeclaration* exprtest9 = new VariableDeclaration(); divbysix->items()->append(new ExpressionStatement(exprtest9)); exprtest9->setName("exprtest9"); exprtest9->setType(new PrimitiveType(PrimitiveType::VOID)); exprtest9->setInitialValue( OOExpressionBuilder::getOOExpression("a()+a.b()+a.b[i].f().g()") ); VariableDeclaration* exprtest10 = new VariableDeclaration(); divbysix->items()->append(new ExpressionStatement(exprtest10)); exprtest10->setName("exprtest10"); exprtest10->setType(new PrimitiveType(PrimitiveType::VOID)); exprtest10->setInitialValue( OOExpressionBuilder::getOOExpression("this.b(a,b,c,123,false)") ); VariableDeclaration* exprtest11 = new VariableDeclaration(); divbysix->items()->append(new ExpressionStatement(exprtest11)); exprtest11->setName("exprtest11"); exprtest11->setType(new PrimitiveType(PrimitiveType::VOID)); exprtest11->setInitialValue( OOExpressionBuilder::getOOExpression("a+\"hello world\"") ); VariableDeclaration* exprtest12 = new VariableDeclaration(); divbysix->items()->append(new ExpressionStatement(exprtest12)); exprtest12->setName("exprtest12"); exprtest12->setType(new PrimitiveType(PrimitiveType::VOID)); exprtest12->setInitialValue( OOExpressionBuilder::getOOExpression("int[]") ); auto exprtest13 = dynamic_cast<AssignmentExpression*>( OOExpressionBuilder::getOOExpression("a=b%=c>>>=d+C")); divbysix->items()->append(new ExpressionStatement(exprtest13)); divbysix->items()->append(new ExpressionStatement( OOExpressionBuilder::getOOExpression("int abc"))); divbysix->items()->append(new ExpressionStatement( OOExpressionBuilder::getOOExpression("int abc=5+3"))); divbysix->items()->append(new ExpressionStatement( OOExpressionBuilder::getOOExpression("int cond=abc<50?42:b+c"))); VariableDeclaration* result = new VariableDeclaration(); divbysix->items()->append( new ExpressionStatement(result) ); result->setName("result"); result->setType(new PrimitiveType(PrimitiveType::INT)); result->setInitialValue(new IntegerLiteral(-1)); LoopStatement* sixloop = new LoopStatement(); divbysix->items()->append(sixloop); VariableDeclaration* sixLoopInit = new VariableDeclaration(); sixloop->setInitStep(sixLoopInit); sixLoopInit->setName("i"); sixLoopInit->setType(new PrimitiveType(PrimitiveType::INT)); sixLoopInit->setInitialValue(new IntegerLiteral(0)); BinaryOperation* sixLoopCond = new BinaryOperation(); sixloop->setCondition(sixLoopCond); sixLoopCond->setLeft(new VariableAccess("local:i")); sixLoopCond->setOp(BinaryOperation::LESS); MethodCallExpression* sizeCall = new MethodCallExpression(); sixLoopCond->setRight(sizeCall); sizeCall->ref()->set("size"); sizeCall->setPrefix(new VariableAccess("local:numbers")); //TODO test the visualization without the remaining parts of this method AssignmentExpression* sixLoopUpdate = new AssignmentExpression(); sixloop->setUpdateStep(sixLoopUpdate); sixLoopUpdate->setLeft(new VariableAccess("local:i")); sixLoopUpdate->setOp(AssignmentExpression::PLUS_ASSIGN); sixLoopUpdate->setRight(new IntegerLiteral(1)); VariableDeclaration* n = new VariableDeclaration(); sixloop->body()->append(new ExpressionStatement(n)); n->setName("n"); n->setType(new PrimitiveType(PrimitiveType::INT)); BinaryOperation* item = new BinaryOperation(); n->setInitialValue(item); item->setLeft(new VariableAccess("local:numbers")); item->setOp(BinaryOperation::ARRAY_INDEX); item->setRight(new VariableAccess("local:i")); IfStatement* ifdiv2 = new IfStatement(); sixloop->body()->append(ifdiv2); BinaryOperation* eq0 = new BinaryOperation(); ifdiv2->setCondition(eq0); eq0->setOp(BinaryOperation::EQUALS); eq0->setRight(new IntegerLiteral(0)); BinaryOperation* div2 = new BinaryOperation(); eq0->setLeft(div2); div2->setLeft(new VariableAccess("local:n")); div2->setOp(BinaryOperation::REMAINDER); div2->setRight(new IntegerLiteral(2)); ifdiv2->elseBranch()->append(new ContinueStatement()); IfStatement* ifdiv3 = new IfStatement(); ifdiv2->thenBranch()->append(ifdiv3); eq0 = new BinaryOperation(); ifdiv3->setCondition(eq0); eq0->setOp(BinaryOperation::EQUALS); eq0->setRight(new IntegerLiteral(0)); BinaryOperation* div3 = new BinaryOperation(); eq0->setLeft(div3); div3->setLeft(new VariableAccess("local:n")); div3->setOp(BinaryOperation::REMAINDER); div3->setRight(new IntegerLiteral(3)); AssignmentExpression* resultFound = new AssignmentExpression(); ifdiv3->thenBranch()->append(resultFound); resultFound->setLeft(new VariableAccess("local:result")); resultFound->setOp(AssignmentExpression::ASSIGN); resultFound->setRight(new VariableAccess("local:i")); ifdiv3->thenBranch()->append(new BreakStatement()); ReturnStatement* divbysixReturn = new ReturnStatement(); divbysixReturn->values()->append(new VariableAccess("local:result")); divbysix->items()->append(divbysixReturn); model->endModification(); return divbysix; }