END_TEST START_TEST ( test_uncertml_write_normalDistribution) { const char *expected = "<UncertML xmlns=\"http://www.uncertml.org/3.0\">\n" " <NormalDistribution definition=\"http://www.uncertml.org/distributions/normal\">\n" " <mean>\n" " <var varId=\"mu\"/>\n" " </mean>\n" " <variance>\n" " <var varId=\"sigma\"/>\n" " </variance>\n" " </NormalDistribution>\n" "</UncertML>"; char *filename = safe_strcat(TestDataDirectory, "normalDistrib.xml"); SBMLDocument *document = readSBMLFromFile(filename); fail_unless ( document->getModel() != NULL ); FunctionDefinition * fd = document->getModel()->getFunctionDefinition(0); DistribFunctionDefinitionPlugin * plug = static_cast<DistribFunctionDefinitionPlugin*>(fd->getPlugin("distrib")); const DrawFromDistribution * d = plug->getDrawFromDistribution(); const UncertMLNode * uncert = d->getUncertML(); std::string xml = uncert->toXMLString(); fail_unless( equals(expected, xml.c_str()) ); }
int main(int argc, char* argv[]) { std::cout << "\n Testing ActionsAndRules class\n " << std::string(30,'=') << std::endl; try { //std::queue<std::string> resultsQ; PrintPreproc pp; PreprocStatement pps; pps.addAction(&pp); FunctionDefinition fnd; PrintFunction prt; fnd.addAction(&prt); Toker toker("../ActionsAndRules.h"); SemiExp se(&toker); Parser parser(&se); parser.addRule(&pps); parser.addRule(&fnd); while(se.get()) parser.parse(); std::cout << "\n\n"; } catch(std::exception& ex) { std::cout << "\n\n " << ex.what() << "\n\n"; } }
void CodeGenVisitor::JIT(Expression* e) { StatementList* sl = new StatementList(); sl->addStatement(new ReturnStatement(e)); FunctionDefinition* fd = new FunctionDefinition(Type::INT, "", new ParameterList(), sl); value_ = 0; fd->accept(this); if (!value_) { delete fd; throw "error evaluating expression"; } llvm::Function* f = dynamic_cast<llvm::Function*>(value_); void* fPtr = ee_->getPointerToFunction(f); // some casting ... because we like magic int (*fP)() = (int (*)())(intptr_t)fPtr; std::cout << "Evaluated to: " << fP() << std::endl; // throw it away f->eraseFromParent(); }
void AdaptSignatureAssistant::textChanged(KTextEditor::View* view, const KTextEditor::Range& invocationRange, const QString& removedText) { reset(); m_view = view; //FIXME: update signature assistant to play well with the rename assistant KTextEditor::Range sigAssistRange = invocationRange; if (!removedText.isEmpty()) { sigAssistRange.setRange(sigAssistRange.start(), sigAssistRange.start()); } m_document = view->document()->url(); DUChainReadLocker lock(DUChain::lock(), 300); if(!lock.locked()) { qCDebug(CPP) << "failed to lock duchain in time"; return; } KTextEditor::Range simpleInvocationRange = KTextEditor::Range(sigAssistRange); Declaration* funDecl = getDeclarationAtCursor(simpleInvocationRange.start(), m_document); if(!funDecl || !funDecl->type<FunctionType>()) return; if(QtFunctionDeclaration* classFun = dynamic_cast<QtFunctionDeclaration*>(funDecl)) { if (classFun->isSignal()) { // do not offer to change signature of a signal, as the implementation will be generated by moc return; } } Declaration* otherSide = 0; FunctionDefinition* definition = dynamic_cast<FunctionDefinition*>(funDecl); if (definition) { m_editingDefinition = true; otherSide = definition->declaration(); } else if ((definition = FunctionDefinition::definition(funDecl))) { m_editingDefinition = false; otherSide = definition; } if (!otherSide) return; m_otherSideContext = DUContextPointer(DUChainUtils::getFunctionContext(otherSide)); if (!m_otherSideContext) return; m_declarationName = funDecl->identifier(); m_otherSideId = otherSide->id(); m_otherSideTopContext = ReferencedTopDUContext(otherSide->topContext()); m_oldSignature = getDeclarationSignature(otherSide, m_otherSideContext.data(), true); //Schedule an update, to make sure the ranges match DUChain::self()->updateContextForUrl(m_otherSideTopContext->url(), TopDUContext::AllDeclarationsAndContexts); }
void MMOModel::add (const FunctionDefinition &f) { string fname = f.getId (); MMOFunction *func = new MMOFunction (fname); int na = f.getNumArguments (); MMOMath d = MMOMath (_replace, &_functions, _prefix); list<string> funcArgs; for (int i = 0; i < na; i++) { d.parseEquation (f.getArgument (i)); string argExp = d.getExp (); MMODecl *adec = new MMODecl (argExp, function_input); func->add (adec); funcArgs.push_back (argExp); } string var = MMOUtils::getInstance ()->getVar (); d.parseEquation (f.getBody ()); _addAlgebraicReplacement (d); MMODecl *adec = new MMODecl (var, d.getExp (), function_definition); func->add (adec); _functions[fname] = pair<list<string>, ASTNode*> ( funcArgs, new ASTNode (*f.getBody ())); _add (func, external_functions); }
void FunctionDefinitionRecursion::addDependencies(const Model& m, const FunctionDefinition& object) { unsigned int ns; std::string thisId = object.getId(); /* loop thru the list of names in the Math * if they refer to a FunctionDefinition add to the map * with the variable as key */ List* variables = object.getMath()->getListOfNodes( ASTNode_isFunction ); for (ns = 0; ns < variables->getSize(); ns++) { ASTNode* node = static_cast<ASTNode*>( variables->get(ns) ); string name = node->getName() ? node->getName() : ""; if (m.getFunctionDefinition(name)) { mIdMap.insert(pair<const std::string, std::string>(thisId, name)); } } delete variables; }
CodeGen::CodeGen(AbstractSyntaxTree *tree) { for(unsigned i = 0; i < tree->functions.size(); ++i) { FunctionDefinition *fn = tree->functions[i]; currentFn = fn; Value *f = fn->codegen(); } }
bool ASTPrinter::visit(FunctionDefinition const& _node) { writeLine("FunctionDefinition \"" + _node.getName() + "\"" + (_node.isPublic() ? " - public" : "") + (_node.isDeclaredConst() ? " - const" : "")); printSourcePart(_node); return goDeeper(); }
AbstractDeclarationNavigationContext::AbstractDeclarationNavigationContext( DeclarationPointer decl, KDevelop::TopDUContextPointer topContext, AbstractNavigationContext* previousContext) : AbstractNavigationContext((topContext ? topContext : TopDUContextPointer(decl ? decl->topContext() : 0)), previousContext), m_declaration(decl), m_fullBackwardSearch(false) { //Jump from definition to declaration if possible FunctionDefinition* definition = dynamic_cast<FunctionDefinition*>(m_declaration.data()); if(definition && definition->declaration()) m_declaration = DeclarationPointer(definition->declaration()); }
FunctionDefinition* configureRuleForFunction(Parser* pParser, Repository* pRepo) { FunctionDefinition* pFunctionDefinition = new FunctionDefinition(); PushFunction* pPushFunction = new PushFunction(pRepo); AddFunctionNode* pAddFunctionNode = new AddFunctionNode(pRepo); pFunctionDefinition->addAction(pPushFunction); pFunctionDefinition->addAction(pAddFunctionNode); pParser->addRule(pFunctionDefinition); return pFunctionDefinition; }
END_TEST START_TEST ( test_FunctionDefinition_parent_create ) { Model *m = new Model(2, 4); FunctionDefinition *fd = m->createFunctionDefinition(); ListOf *lo = m->getListOfFunctionDefinitions(); fail_unless(lo == m->getFunctionDefinition(0)->getParentSBMLObject()); fail_unless(lo == fd->getParentSBMLObject()); fail_unless(m == lo->getParentSBMLObject()); }
END_TEST START_TEST ( test_FunctionDefinition ) { FunctionDefinition* fd = new FunctionDefinition(2, 4); fail_unless (!(fd->hasRequiredAttributes())); fd->setId("fd"); fail_unless (fd->hasRequiredAttributes()); delete fd; }
END_TEST START_TEST ( test_FunctionDefinition ) { FunctionDefinition* fd = new FunctionDefinition(2, 4); fail_unless (!(fd->hasRequiredElements())); fd->setMath(SBML_parseFormula("fd")); fail_unless (fd->hasRequiredElements()); delete fd; }
int main(int argc, char* argv[]) { std::cout << "\n Testing ActionsAndRules class\n " << std::string(30,'=') << std::endl; RelationshipAnal* p = new RelationshipAnal; TypeAnal* q = new TypeAnal; try { PrintPreproc pp; PreprocStatement pps; pps.addAction(&pp); FunctionDefinition fnd; PrintFunction prt; fnd.addAction(&prt); ClassStructEnumDefinition cls1; std::vector<std::string> classResult; PrintClass cls2(&classResult); cls1.addAction(&cls2); InheritanceDetection* cls3 = new InheritanceDetection; InheritanceAction* cls4 = new InheritanceAction(q, p); cls3->addAction(cls4); Toker toker("../ActionsAndRules.h"); SemiExp se(&toker); Parser parser(&se); parser.addRule(&pps); parser.addRule(&fnd); parser.addRule(&cls1); parser.addRule(cls3); while(se.get()) parser.parse(); std::cout << "\n\n"; } catch(std::exception& ex) { std::cout << "\n\n " << ex.what() << "\n\n"; } }
END_TEST START_TEST ( test_FunctionDefinition_parent_NULL ) { SBMLDocument *d = new SBMLDocument(); Model *m = d->createModel(); FunctionDefinition *c = m->createFunctionDefinition(); FunctionDefinition *c1 = c->clone(); delete d; fail_unless(c1->getAncestorOfType(SBML_MODEL) == NULL); fail_unless(c1->getParentSBMLObject() == NULL); fail_unless (c1->getSBMLDocument() == NULL); delete c1; }
int main(int argc, char* argv[]) { std::cout << "\n Testing ActionsAndRules class\n " << std::string(30,'=') << std::endl; try { std::queue<std::string> resultsQ; PreprocToQ ppq(resultsQ); //Modified Pallavi PrintPreproc ppq; PreprocStatement pps; pps.addAction(&ppq); FunctionDefinition fnd; PrettyPrintToQ pprtQ(resultsQ); //Modified Pallavi PrettyPrintFunction pprtQ; fnd.addAction(&pprtQ); Toker toker("../ActionsAndRules.h"); SemiExp se(&toker); Parser parser(&se); parser.addRule(&pps); parser.addRule(&fnd); while(se.get()) parser.parse(); size_t len = resultsQ.size(); for(size_t i=0; i<len; ++i) { std::cout << "\n " << resultsQ.front().c_str(); resultsQ.pop(); } std::cout << "\n\n"; } catch(std::exception& ex) { std::cout << "\n\n " << ex.what() << "\n\n"; } }
END_TEST START_TEST ( test_FunctionDefinition_parent_add ) { FunctionDefinition *fd = new FunctionDefinition(2, 4); Model *m = new Model(2, 4); fd->setId("fd"); fd->setMath(SBML_parseFormula("l")); m->addFunctionDefinition(fd); delete fd; ListOf *lo = m->getListOfFunctionDefinitions(); fail_unless(lo == m->getFunctionDefinition(0)->getParentSBMLObject()); fail_unless(m == lo->getParentSBMLObject()); }
eth::AssemblyItem CompilerContext::virtualFunctionEntryLabel(FunctionDefinition const& _function) { // Libraries do not allow inheritance and their functions can be inlined, so we should not // search the inheritance hierarchy (which will be the wrong one in case the function // is inlined). if (auto scope = dynamic_cast<ContractDefinition const*>(_function.scope())) if (scope->isLibrary()) return functionEntryLabel(_function); solAssert(!m_inheritanceHierarchy.empty(), "No inheritance hierarchy set."); return virtualFunctionEntryLabel(_function, m_inheritanceHierarchy.begin()); }
void Compiler::appendConstructor(FunctionDefinition const& _constructor) { CompilerContext::LocationSetter locationSetter(m_context, _constructor); // copy constructor arguments from code to memory and then to stack, they are supplied after the actual program if (!_constructor.getParameters().empty()) { unsigned argumentSize = 0; for (ASTPointer<VariableDeclaration> const& var: _constructor.getParameters()) if (var->getType()->isDynamicallySized()) { argumentSize = 0; break; } else argumentSize += var->getType()->getCalldataEncodedSize(); CompilerUtils(m_context).fetchFreeMemoryPointer(); if (argumentSize == 0) { // argument size is dynamic, use CODESIZE to determine it m_context.appendProgramSize(); // program itself // CODESIZE is program plus manually added arguments m_context << eth::Instruction::CODESIZE << eth::Instruction::SUB; } else m_context << u256(argumentSize); // stack: <memptr> <argument size> m_context << eth::Instruction::DUP1; m_context.appendProgramSize(); m_context << eth::Instruction::DUP4 << eth::Instruction::CODECOPY; m_context << eth::Instruction::ADD; CompilerUtils(m_context).storeFreeMemoryPointer(); appendCalldataUnpacker( FunctionType(_constructor).getParameterTypes(), true, CompilerUtils::freeMemoryPointer + 0x20 ); } _constructor.accept(*this); }
void Compiler::appendBaseConstructor(FunctionDefinition const& _constructor) { CompilerContext::LocationSetter locationSetter(m_context, _constructor); FunctionType constructorType(_constructor); if (!constructorType.getParameterTypes().empty()) { solAssert(m_baseArguments.count(&_constructor), ""); std::vector<ASTPointer<Expression>> const* arguments = m_baseArguments[&_constructor]; solAssert(arguments, ""); for (unsigned i = 0; i < arguments->size(); ++i) compileExpression(*(arguments->at(i)), constructorType.getParameterTypes()[i]); } _constructor.accept(*this); }
void FunctionDefinitionRecursion::logSelfRecursion ( const FunctionDefinition& fd, const string& varname ) { char * formula = SBML_formulaToString(fd.getMath()); msg = "The functionDefinition with id '"; msg += varname; msg += "' refers to itself within the math formula "; msg += formula; msg += "'."; safe_free(formula); logFailure(fd); }
/** * Checks that all variables referenced in FunctionDefinition bodies are * bound variables (function arguments). */ void FunctionDefinitionVars::check_ (const Model& m, const FunctionDefinition& fd) { if ( fd.getLevel() == 1 ) return; if ( !fd.isSetMath() ) return; if ( fd.getBody() == NULL ) return; if ( fd.getNumArguments() == 0 ) return; List* variables = fd.getBody()->getListOfNodes( ASTNode_isName ); for (unsigned int n = 0; n < variables->getSize(); ++n) { ASTNode* node = static_cast<ASTNode*>( variables->get(n) ); string name = node->getName() ? node->getName() : ""; if ( fd.getArgument(name) == NULL ) { /* if this is the csymbol time - technically it is allowed * in L2v1 and L2v2 */ if (node->getType() == AST_NAME_TIME) { if (fd.getLevel() > 2 || (fd.getLevel() == 2 && fd.getVersion() > 2)) { logUndefined(fd, name); } } else { logUndefined(fd, name); } } } delete variables; }
eth::AssemblyItem CompilerContext::virtualFunctionEntryLabel( FunctionDefinition const& _function, vector<ContractDefinition const*>::const_iterator _searchStart ) { string name = _function.name(); FunctionType functionType(_function); auto it = _searchStart; for (; it != m_inheritanceHierarchy.end(); ++it) for (FunctionDefinition const* function: (*it)->definedFunctions()) if ( function->name() == name && !function->isConstructor() && FunctionType(*function).hasEqualArgumentTypes(functionType) ) return functionEntryLabel(*function); solAssert(false, "Super function " + name + " not found."); return m_asm.newTag(); // not reached }
/** * Logs a message about an undefined variable in the given * FunctionDefinition. */ void FunctionDefinitionVars::logUndefined ( const FunctionDefinition& fd, const string& varname ) { msg = msg = //"Inside the 'lambda' of a <functionDefinition>, if a 'ci' element is not " //"the first element within a MathML 'apply', then the 'ci''s value can " //"only be the value of a 'bvar' element declared in that 'lambda'. In " //"other words, all model entities referenced inside a function definition " //"must be passed arguments to that function. (References: L2V2 Section " //"4.3.2.)" "The variable '"; msg += varname; msg += "' is not listed as a <bvar> of FunctionDefinition '"; msg += fd.getId(); msg += "'."; logFailure(fd); }
void PlotFunctionRegister::registerDefaultFunctions() { FunctionDefinition *def = nullptr; QString category; // Core fundamentals category = "general"; add(static_cast<double (*)(double)>(&std::abs), category, "abs", "Absolute value of x."); add(new FunctionClean(category)); def = add(&clipFunc, category, "clip", "Clip x to to the range [min,max]. All values are clipped to this range.", 3); def->setDisplayName("clip(x,min,max)"); def = add(&clipmaxFunc, category, "clipmax", "Clip x to a maximum value. Any value above max is displayed as min.", 2); def->setDisplayName("clipmax(x,max)"); def = add(&clipminFunc, category, "clipmin", "Clip x to a minimum value. Any value below min is displayed as min.", 2); def->setDisplayName("clipmin(x,min)"); add(&deltaFunc, category, "delta", "Delta from the last value of x.", 1); add(static_cast<double (*)(double)>(&std::exp), category, "exp", "Calculate e (2.718...) to the power of x."); add(&isNanFunc, category, "isnan", "Test if the input value is NaN. 1 if so, zero otherwise.", 1); add(&isInfFunc, category, "isinf", "Test if the input value is +/- infinity. 1 if so, zero otherwise.", 1); add(static_cast<double(*)(double)>(&std::log), category, "log", "Natural logarithm of x."); add(static_cast<double(*)(double)>(&std::log10), category, "log10", "Base 10 logarithm of x."); add(&maxFunc, category, "max", "Most recent maximum value of x.", 1); add(&minFunc, category, "min", "Most recent minimum value of x.", 1); add(static_cast<double (*)(double)>(&std::sqrt), category, "sqrt", "Sqrt of the value of x."); add(&nowFunc, category, "now", "Returns the current sample time.", 0); add(new FunctionUnwrap(category)); category = "rounding"; add(static_cast<double(*)(double)>(&std::ceil), category, "ceil", "Nearest integer not less than x."); add(static_cast<double(*)(double)>(&std::floor), category, "floor", "Nearest integer not greater than x."); add(static_cast<double(*)(double)>(&std::trunc), category, "trunc", "Nearest integer not greater in magnitude than x."); add(static_cast<double(*)(double)>(&std::round), category, "round", "Nearest integer rounding up (in magnitude) from halfway cases."); add(&fmodFunc, category, "fmod", "Floating point remainder of the division x/y.", 2); add(&remainderFunc, category, "remainder", "Integer remainder (closest) of the division x/y. Sign may differ from fmod.", 2); add(&signFunc, category, "sign", "Return the sign of x. -1 if negative, 1 otherwise.", 1); // Statistics category = "statistics"; add(&abserrFunc, category, "abserr", "Absolute error between x and y.", 2); add(&avgFunc, category, "avg", "Running average value of x.", 1); add(new FunctionMAvg(category)); add(&maxofFunc, category, "maxof", "Maximum value of any number of graphs.", 1, true); add(&minofFunc, category, "minof", "Minimum value of any number of graphs.", 1, true); add(&relerrFunc, category, "relerr", "Relative error between x and y.", 2); add(&totalFunc, category, "total", "Running sum of x.", 1); // Trigonometry category = "trigonometry"; add(static_cast<double(*)(double)>(&std::acos), category, "acos", "Trigonometric arccos function of x"); add(static_cast<double(*)(double)>(&std::asin), category, "asin", "Trigonometric arcsin function of x"); add(static_cast<double(*)(double)>(&std::atan), category, "atan", "Trigonometric arctan function of x"); def = add(&atan2Func, category, "atan2", "Trigonometric arctan of y/x with quadrant selection.", 2); if (def) { def->setDisplayName("atan2(y,x)"); } add(static_cast<double(*)(double)>(&std::cos), category, "cos", "Trigonometric cos function of x"); add(static_cast<double(*)(double)>(&std::sin), category, "sin", "Trigonometric sin function of x"); add(static_cast<double(*)(double)>(&std::tan), category, "tan", "Trigonometric tan function of x"); add(static_cast<double(*)(double)>(&std::cosh), category, "cosh", "Hyperbolic cos function of x"); add(static_cast<double(*)(double)>(&std::sinh), category, "sinh", "Hyperbolic sin function of x"); add(static_cast<double(*)(double)>(&std::tanh), category, "tanh", "Hyperbolic tan function of x"); add(static_cast<double(*)(double)>(&std::acosh), category, "acosh", "Hyperbolic arccos function of x"); add(static_cast<double(*)(double)>(&std::asinh), category, "asinh", "Hyperbolic arcsin function of x"); add(static_cast<double(*)(double)>(&std::atanh), category, "atanh", "Hyperbolic arctan function of x"); add(&piFunc, category, "pi", "Pi constant (3.141...).", 0); }
bool Why3Translator::visit(FunctionDefinition const& _function) { if (!_function.isImplemented()) { error(_function, "Unimplemented functions not supported."); return false; } if (_function.name().empty()) { error(_function, "Fallback functions not supported."); return false; } if (!_function.modifiers().empty()) { error(_function, "Modifiers not supported."); return false; } m_localVariables.clear(); for (auto const& var: _function.parameters()) m_localVariables[var->name()] = var.get(); for (auto const& var: _function.returnParameters()) m_localVariables[var->name()] = var.get(); for (auto const& var: _function.localVariables()) m_localVariables[var->name()] = var; add("let rec _" + _function.name()); add(" (this: account)"); for (auto const& param: _function.parameters()) { string paramType; try { paramType = toFormalType(*param->annotation().type); } catch (NoFormalType &err) { string const* typeName = boost::get_error_info<errinfo_noFormalTypeFrom>(err); error(*param, "Parameter type \"" + (typeName ? *typeName : "") + "\" not supported."); } if (param->name().empty()) error(*param, "Anonymous function parameters not supported."); add(" (arg_" + param->name() + ": " + paramType + ")"); } add(":"); indent(); indent(); string retString = "("; for (auto const& retParam: _function.returnParameters()) { string paramType; try { paramType = toFormalType(*retParam->annotation().type); } catch (NoFormalType &err) { string const* typeName = boost::get_error_info<errinfo_noFormalTypeFrom>(err); error(*retParam, "Parameter type " + (typeName ? *typeName : "") + " not supported."); } if (retString.size() != 1) retString += ", "; retString += paramType; } add(retString + ")"); unindent(); addSourceFromDocStrings(_function.annotation()); if (!m_currentContract.contract) error(_function, "Only functions inside contracts allowed."); addSourceFromDocStrings(m_currentContract.contract->annotation()); if (_function.isDeclaredConst()) addLine("ensures { (old this) = this }"); else addLine("writes { this }"); addLine("="); // store the prestate in the case we need to revert addLine("let prestate = {balance = this.balance; storage = " + copyOfStorage() + "} in "); // initialise local variables for (auto const& variable: _function.parameters()) addLine("let _" + variable->name() + " = ref arg_" + variable->name() + " in"); for (auto const& variable: _function.returnParameters()) { if (variable->name().empty()) error(*variable, "Unnamed return variables not yet supported."); string varType; try { varType = toFormalType(*variable->annotation().type); } catch (NoFormalType &err) { string const* typeNamePtr = boost::get_error_info<errinfo_noFormalTypeFrom>(err); error(*variable, "Type " + (typeNamePtr ? *typeNamePtr : "") + "in return parameter not yet supported."); } addLine("let _" + variable->name() + ": ref " + varType + " = ref (of_int 0) in"); } for (VariableDeclaration const* variable: _function.localVariables()) { if (variable->name().empty()) error(*variable, "Unnamed variables not yet supported."); string varType; try { varType = toFormalType(*variable->annotation().type); } catch (NoFormalType &err) { string const* typeNamePtr = boost::get_error_info<errinfo_noFormalTypeFrom>(err); error(*variable, "Type " + (typeNamePtr ? *typeNamePtr : "") + "in variable declaration not yet supported."); } addLine("let _" + variable->name() + ": ref " + varType + " = ref (of_int 0) in"); } addLine("try"); _function.body().accept(*this); add(";"); addLine("raise Return"); string retVals; for (auto const& variable: _function.returnParameters()) { if (!retVals.empty()) retVals += ", "; retVals += "!_" + variable->name(); } addLine("with Return -> (" + retVals + ") |"); string reversion = " Revert -> this.balance <- prestate.balance; "; for (auto const* variable: m_currentContract.stateVariables) reversion += "this.storage._" + variable->name() + " <- prestate.storage._" + variable->name() + "; "; //@TODO in case of reversion the return values are wrong - we need to change the // return type to include a bool to signify if an exception was thrown. reversion += "(" + retVals + ")"; addLine(reversion); unindent(); addLine("end"); addLine(""); return false; }
bool DocStringAnalyser::visit(FunctionDefinition const& _node) { handleCallable(_node, _node, _node.annotation()); return true; }
/** * * Creates an SBML model represented in "7.8 Example involving function definitions" * in the SBML Level 2 Version 4 Specification. * */ SBMLDocument* createExampleInvolvingFunctionDefinitions() { const unsigned int level = Level; const unsigned int version = Version; //--------------------------------------------------------------------------- // // Creates an SBMLDocument object // //--------------------------------------------------------------------------- SBMLDocument* sbmlDoc = new SBMLDocument(level,version); //--------------------------------------------------------------------------- // // Creates a Model object inside the SBMLDocument object. // //--------------------------------------------------------------------------- Model* model = sbmlDoc->createModel(); model->setId("functionExample"); //--------------------------------------------------------------------------- // // Creates a FunctionDefinition object inside the Model object. // //--------------------------------------------------------------------------- FunctionDefinition* fdef = model->createFunctionDefinition(); fdef->setId("f"); // Sets a math (ASTNode object) to the FunctionDefinition object. string mathXMLString = "<math xmlns=\"http://www.w3.org/1998/Math/MathML\">" " <lambda>" " <bvar>" " <ci> x </ci>" " </bvar>" " <apply>" " <times/>" " <ci> x </ci>" " <cn> 2 </cn>" " </apply>" " </lambda>" "</math>"; ASTNode* astMath = readMathMLFromString(mathXMLString.c_str()); fdef->setMath(astMath); delete astMath; //--------------------------------------------------------------------------- // // Creates a Compartment object inside the Model object. // //--------------------------------------------------------------------------- Compartment* comp; const string compName = "compartmentOne"; // Creates a Compartment object ("compartmentOne") comp = model->createCompartment(); comp->setId(compName); // Sets the "size" attribute of the Compartment object. // // The units of this Compartment object is the default SBML // units of volume (litre), and thus we don't have to explicitly invoke // setUnits("litre") function to set the default units. // comp->setSize(1); //--------------------------------------------------------------------------- // // Creates Species objects inside the Model object. // //--------------------------------------------------------------------------- Species* sp; //--------------------------------------------------------------------------- // (Species1) Creates a Species object ("S1") //--------------------------------------------------------------------------- sp = model->createSpecies(); sp->setId("S1"); // Sets the "compartment" attribute of the Species object to identify the // compartnet in which the Species object located. sp->setCompartment(compName); // Sets the "initialConcentration" attribute of the Species object. // // The units of this Species object is determined by two attributes of this // Species object ("substanceUnits" and "hasOnlySubstanceUnits") and the // "spatialDimension" attribute of the Compartment object ("cytosol") in which // this species object located. // Since the default values are used for "substanceUnits" (substance (mole)) // and "hasOnlySubstanceUnits" (false) and the value of "spatialDimension" (3) // is greater than 0, the units of this Species object is mole/litre . // sp->setInitialConcentration(1); //--------------------------------------------------------------------------- // (Species2) Creates a Species object ("S2") //--------------------------------------------------------------------------- sp = model->createSpecies(); sp->setId("S2"); sp->setCompartment(compName); sp->setInitialConcentration(0); //--------------------------------------------------------------------------- // // Creates a global Parameter object inside the Model object. // //--------------------------------------------------------------------------- Parameter* para; // Creates a Parameter ("t") para = model->createParameter(); para->setId("t"); para->setValue(1); para->setUnits("second"); //--------------------------------------------------------------------------- // // Creates Reaction objects inside the Model object. // //--------------------------------------------------------------------------- // Temporary pointers. Reaction* reaction; SpeciesReference* spr; KineticLaw* kl; //--------------------------------------------------------------------------- // (Reaction1) Creates a Reaction object ("reaction_1"). //--------------------------------------------------------------------------- reaction = model->createReaction(); reaction->setId("reaction_1"); reaction->setReversible(false); //--------------------------------------------------------------------------- // Creates Reactant objects inside the Reaction object ("reaction_1"). //--------------------------------------------------------------------------- // (Reactant1) Creates a Reactant object that references Species "S1" // in the model. spr = reaction->createReactant(); spr->setSpecies("S1"); //--------------------------------------------------------------------------- // Creates a Product object inside the Reaction object ("reaction_1"). //--------------------------------------------------------------------------- // Creates a Product object that references Species "S2" in the model. spr = reaction->createProduct(); spr->setSpecies("S2"); //--------------------------------------------------------------------------- // Creates a KineticLaw object inside the Reaction object ("reaction_1"). //--------------------------------------------------------------------------- kl = reaction->createKineticLaw(); //--------------------------------------------------------------------------- // Sets a math (ASTNode object) to the KineticLaw object. //--------------------------------------------------------------------------- mathXMLString = "<math xmlns=\"http://www.w3.org/1998/Math/MathML\">" " <apply>" " <divide/>" " <apply>" " <times/>" " <apply>" " <ci> f </ci>" " <ci> S1 </ci>" " </apply>" " <ci> compartmentOne </ci>" " </apply>" " <ci> t </ci>" " </apply>" "</math>"; astMath = readMathMLFromString(mathXMLString.c_str()); kl->setMath(astMath); delete astMath; // Returns the created SBMLDocument object. // The returned object must be explicitly deleted by the caller, // otherwise memory leak will happen. return sbmlDoc; }
QString DeclarationNavigationContext::html(bool shorten) { clear(); m_shorten = shorten; modifyHtml() += "<html><body><p>" + fontSizePrefix(shorten); addExternalHtml(m_prefix); if(!m_declaration.data()) { modifyHtml() += i18n("<br /> lost declaration <br />"); return currentHtml(); } if( m_previousContext ) { QString link = createLink( m_previousContext->name(), m_previousContext->name(), NavigationAction(m_previousContext) ); modifyHtml() += navigationHighlight(i18n("Back to %1<br />", link)); } QExplicitlySharedDataPointer<IDocumentation> doc; if( !shorten ) { doc = ICore::self()->documentationController()->documentationForDeclaration(m_declaration.data()); const AbstractFunctionDeclaration* function = dynamic_cast<const AbstractFunctionDeclaration*>(m_declaration.data()); if( function ) { htmlFunction(); } else if( m_declaration->isTypeAlias() || m_declaration->kind() == Declaration::Instance ) { if( m_declaration->isTypeAlias() ) modifyHtml() += importantHighlight("type "); if(m_declaration->type<EnumeratorType>()) modifyHtml() += i18n("enumerator "); if( !m_declaration->isTypeAlias()) modifyHtml() += ' ' + identifierHighlight(declarationName(m_declaration).toHtmlEscaped(), m_declaration) + " "; AbstractType::Ptr useType = m_declaration->abstractType(); if(m_declaration->isTypeAlias()) { //Do not show the own name as type of typedefs if(useType.cast<TypeAliasType>()) useType = useType.cast<TypeAliasType>()->type(); } eventuallyMakeTypeLinks( useType ); modifyHtml() += "<br>"; }else{ if( m_declaration->kind() == Declaration::Type && m_declaration->abstractType().cast<StructureType>()) { htmlClass(); } if ( m_declaration->kind() == Declaration::Namespace ) { modifyHtml() += i18n("namespace %1 ", identifierHighlight(m_declaration->qualifiedIdentifier().toString().toHtmlEscaped(), m_declaration)); } if(m_declaration->type<EnumerationType>()) { EnumerationType::Ptr enumeration = m_declaration->type<EnumerationType>(); modifyHtml() += i18n("enumeration %1 ", identifierHighlight(m_declaration->identifier().toString().toHtmlEscaped(), m_declaration)); } if(m_declaration->isForwardDeclaration()) { ForwardDeclaration* forwardDec = static_cast<ForwardDeclaration*>(m_declaration.data()); Declaration* resolved = forwardDec->resolve(m_topContext.data()); if(resolved) { modifyHtml() += i18n("( resolved forward-declaration: "); makeLink(resolved->identifier().toString(), KDevelop::DeclarationPointer(resolved), NavigationAction::NavigateDeclaration ); modifyHtml() += i18n(") "); }else{ modifyHtml() += i18n("(unresolved forward-declaration) "); QualifiedIdentifier id = forwardDec->qualifiedIdentifier(); uint count; const IndexedDeclaration* decls; PersistentSymbolTable::self().declarations(id, count, decls); for(uint a = 0; a < count; ++a) { if(decls[a].isValid() && !decls[a].data()->isForwardDeclaration()) { modifyHtml() += "<br />"; makeLink(i18n("possible resolution from"), KDevelop::DeclarationPointer(decls[a].data()), NavigationAction::NavigateDeclaration); modifyHtml() += ' ' + decls[a].data()->url().str(); } } } } modifyHtml() += "<br />"; } }else{ AbstractType::Ptr showType = m_declaration->abstractType(); if(showType && showType.cast<FunctionType>()) { showType = showType.cast<FunctionType>()->returnType(); if(showType) modifyHtml() += labelHighlight(i18n("Returns: ")); }else if(showType) { modifyHtml() += labelHighlight(i18n("Type: ")); } if(showType) { eventuallyMakeTypeLinks(showType); modifyHtml() += " "; } } QualifiedIdentifier identifier = m_declaration->qualifiedIdentifier(); if( identifier.count() > 1 ) { if( m_declaration->context() && m_declaration->context()->owner() ) { Declaration* decl = m_declaration->context()->owner(); FunctionDefinition* definition = dynamic_cast<FunctionDefinition*>(decl); if(definition && definition->declaration()) decl = definition->declaration(); if(decl->abstractType().cast<EnumerationType>()) modifyHtml() += labelHighlight(i18n("Enum: ")); else modifyHtml() += labelHighlight(i18n("Container: ")); makeLink( declarationName(DeclarationPointer(decl)), DeclarationPointer(decl), NavigationAction::NavigateDeclaration ); modifyHtml() += " "; } else { QualifiedIdentifier parent = identifier; parent.pop(); modifyHtml() += labelHighlight(i18n("Scope: %1 ", typeHighlight(parent.toString().toHtmlEscaped()))); } } if( shorten && !m_declaration->comment().isEmpty() ) { QString comment = QString::fromUtf8(m_declaration->comment()); if( comment.length() > 60 ) { comment.truncate(60); comment += "..."; } comment.replace('\n', " "); comment.replace("<br />", " "); comment.replace("<br/>", " "); modifyHtml() += commentHighlight(comment.toHtmlEscaped()) + " "; } QString access = stringFromAccess(m_declaration); if( !access.isEmpty() ) modifyHtml() += labelHighlight(i18n("Access: %1 ", propertyHighlight(access.toHtmlEscaped()))); ///@todo Enumerations QString detailsHtml; QStringList details = declarationDetails(m_declaration); if( !details.isEmpty() ) { bool first = true; foreach( const QString &str, details ) { if( !first ) detailsHtml += ", "; first = false; detailsHtml += propertyHighlight(str); } }
/** * * @param function_def function that contains function calls that will be inlined. * This means that this function will is actually the callsite * of the called functions, and that this is the place were * the code (from the inlined functions) will be written to * @param scope_link */ void InlinePhase::find_functions(FunctionDefinition function_def, ScopeLink scope_link) { FunctionCallsPred function_calls_pred(scope_link); Statement function_body = function_def.get_function_body(); ObjectList<AST_t> list_of_calls = function_body.get_ast().depth_subtrees(function_calls_pred); for (ObjectList<AST_t>::iterator it = list_of_calls.begin(); it != list_of_calls.end(); it++, _callNum++) { // cout<<_callNum<<endl; AST_t element = *it; Expression expr(element, scope_link); // We already know it is a function call, no need to check again Expression _function_call = expr.get_called_expression(); Expression last_function_call = _function_call; set_FCall(&_function_call); // cin.get(); if (_function_call.is_id_expression()) { IdExpression id_expr = _function_call.get_id_expression(); Symbol called_sym = id_expr.get_symbol(); Symbol last_called_sym = called_sym; set_FSym(&called_sym); if (called_sym.is_valid() && called_sym.is_function() && called_sym.is_defined()) { // cout << "\nFinding if necessary forward inline for function '" << id_expr << "' in " << element.get_locus() << "\n"; _functionName = called_sym.get_name(); _rowOfCall = element.get_line(); int fnd = 0; for(int fN = 0; fN<_inlinedFunctions.size(); ++fN) { if(_inlinedFunctions[fN].get_name().compare(std::string(_functionName))==0) { fnd = 1; break; } } if(!fnd) { _inlinedFunctions.push_back(called_sym); // cout << "\nForward inline of "<<called_sym.get_name()<<" called on: "<<function_def.get_function_name().get_symbol().get_name()<<" \n"; ObjectList<AST_t> list_of_fun_defs = _translation_unit.depth_subtrees(_function_def_pred); for (ObjectList<AST_t>::iterator it = list_of_fun_defs.begin(); it != list_of_fun_defs.end(); it++) { FunctionDefinition function_defNF(*it, scope_link); TL::Symbol function_sym = function_defNF.get_function_symbol(); if(function_sym.get_name().compare(called_sym.get_name())==0) { find_functions(function_defNF,scope_link); set_FCall(&last_function_call); set_FSym(&last_called_sym); } } } // cout << "\nApplying inlining for function" << called_sym.get_name() << "\n {"; inlineFunction(called_sym, expr); // cout<<"} \n"; } else if(called_sym.is_defined()) { cerr << "************************************"<< "\n You can not use "<<called_sym.get_name()<<"inside HMPP codelet.\n" << "************************************"; exit(-1); } } } if(list_of_calls.size()==0) { cout<<"No function calls in : "<<function_def.get_function_name().get_symbol().get_name()<<endl; } else { cout<<function_def.get_function_name().get_symbol().get_name()<< " finished -------------"<<endl; } }