set<string> get_parents(Function f, int stage) { set<string> parents; if (f.has_extern_definition()) { internal_assert(stage == 0); for (const ExternFuncArgument &arg : f.extern_arguments()) { if (arg.is_func()) { string prod_name = Function(arg.func).name(); parents.insert(prod_name); } else if (arg.is_expr()) { FindAllCalls find; arg.expr.accept(&find); parents.insert(find.funcs_called.begin(), find.funcs_called.end()); } else if (arg.is_image_param() || arg.is_buffer()) { Buffer<> buf; if (arg.is_image_param()) { buf = arg.image_param.buffer(); } else { buf = arg.buffer; } parents.insert(buf.name()); } } } else { FindAllCalls find; Definition def = get_stage_definition(f, stage); def.accept(&find); parents.insert(find.funcs_called.begin(), find.funcs_called.end()); } return parents; }
static void readGrammar(ifstream& infile, map<string, Definition>& grammar) { // Keep parsing until EOF is reached. while(infile.good()) { // Ignore all chars until '{' is reached. infile.ignore(numeric_limits<streamsize>::max(), '{'); // Ignore all chars until '\n' is reached. infile.ignore(numeric_limits<streamsize>::max(), '<'); if(infile.good()) { // Beginning of a definition; parse into program. Definition myDefinition = Definition(infile); // Fill map. string myNonTerminal = myDefinition.getNonterminal(); pair<string, Definition> myPair(myNonTerminal, myDefinition); grammar.insert(myPair); } } infile.close(); }
void SubtitleFile::Parse(InputStream& s) { m_segments.RemoveAll(); __super::Parse(s, s_predef); // TODO: check file.format == "ssf" and file.version == 1 CAtlList<Definition*> defs; GetRootRef()->GetChildDefs(defs, L"subtitle"); StringMapW<float> offset; POSITION pos = defs.GetHeadPosition(); while(pos) { Definition* pDef = defs.GetNext(pos); try { Definition::Time time; if(pDef->GetAsTime(time, offset) && (*pDef)[L"@"].IsValue()) { m_segments.Insert(time.start.value, time.stop.value, pDef); } } catch(Exception&) { } } }
// Prints out an expression. void Expression::Print(Calculator *calculator, PrintMode mode) { if(!head) throw PrintException("Expression has no head."); // In standard print mode, let operator decide how expression should be printed. // (E.g. print Plus[a,b] as a+b.) if(mode == pmStandard) { Definition *def = FunctionDefinition(calculator); if(def && def->Predef()) { def->Predef()->PrintExpression(this, calculator, mode); return; } } // If expression has no linked operator or print mode is FullForm, simply print // head and leaves. If head is no Atom, we have to put it in parentheses. if(!head->IsAtom() && !dynamic_cast<Atom*>(head)) cout << "("; head->Print(calculator, mode); if(!head->IsAtom() && !dynamic_cast<Atom*>(head)) cout << ")"; if(!dynamic_cast<Atom*>(head)) { cout << "["; for(ExprVector::const_iterator leaf = leaves.begin(); leaf != leaves.end(); ++leaf) { if(leaf != leaves.begin()) cout << ", "; (*leaf)->Print(calculator, mode); } cout << "]"; } }
Definition& Definition::operator[](LPCWSTR type) { Definition* pRetDef = NULL; if(m_type2def.Lookup(type, pRetDef)) return *pRetDef; pRetDef = DNew Definition(m_pnf, L""); pRetDef->m_priority = PLow; pRetDef->m_type = type; m_type2def[type] = pRetDef; CAtlList<Definition*> l; GetChildDefs(l, type); while(!l.IsEmpty()) { Definition* pDef = l.RemoveHead(); pRetDef->m_priority = pDef->m_priority; pRetDef->m_parent = pDef->m_parent; if(pDef->IsValue()) { pRetDef->SetAsValue(pDef->m_status, pDef->m_value, pDef->m_unit); } else { pRetDef->m_status = node; pRetDef->m_nodes.AddTailList(&pDef->m_nodes); } } return *pRetDef; }
double Cos(Definition &def1, Definition &def2) { std::map<unsigned long long, int>::iterator itr; std::set<unsigned long long> words; std::set<unsigned long long>::iterator itrSet; double numerator = 0.0; double denominatorA = 0.0; double denominatorB = 0.0; int numeratorInt = 0; int denominatorAInt = 0; int denominatorBInt = 0; double a,b; int aInt,bInt; for(itr = def1.mappedWords.begin(); itr != def1.mappedWords.end(); ++itr) words.insert(itr->first); for(itr = def2.mappedWords.begin(); itr != def2.mappedWords.end(); ++itr) words.insert(itr->first); unsigned long long wrd; //if (globalArgs.normalizationType == TF_IDF || globalArgs.normalizationType == UnitLenght || globalArgs.normalizationType == LogEntropy) if (globalArgs.normalizationType != None) { for(itrSet = words.begin(); itrSet != words.end(); ++itrSet) { wrd = *itrSet; a = ((double)def1.Frequency(wrd))/0x0FFFFFF; b = ((double)def2.Frequency(wrd))/0x0FFFFFF; numerator += a*b; denominatorA += a*a; denominatorB += b*b; } double denominator = sqrt((double)denominatorA) * sqrt((double)denominatorB); return numerator / denominator; } else { for(itrSet = words.begin(); itrSet != words.end(); ++itrSet) { wrd = *itrSet; aInt = def1.Frequency(wrd); bInt = def2.Frequency(wrd); numeratorInt += aInt*bInt; denominatorAInt += aInt*aInt; denominatorBInt += bInt*bInt; } double denominator = sqrt((double)denominatorAInt) * sqrt((double)denominatorBInt); return numeratorInt / denominator; } }
void register_function(Context& ctx, Signature sig, Native_Function f, size_t arity, Env* env) { Definition* def = make_native_function(sig, f, ctx); stringstream ss; ss << def->name() << "[f]" << arity; def->environment(env); (*env)[ss.str()] = def; }
void extract_constant_macro_info(Token const& name, Definition const& definition) { if (definition.size() != 1 || !is_constant_integer(detail::to_string(definition.front().get_value()))) { std::cout << name.get_value() << " is not constant" << std::endl; return; } constant_macros_.emplace_back(detail::to_string(name.get_value()), detail::to_string(definition.front().get_value())); }
Definition* Definition::SetChildAsNumber(CStringW path, CStringW v, CStringW u) { Definition* pDef = SetChildAsValue(path, number, v, u); Number<float> n; pDef->GetAsNumber(n); // will throw an exception if not a number return pDef; }
Statement* Expand::operator()(Definition* d) { Definition* dd = new (ctx.mem) Definition(*d); env->current_frame()[d->name() + (d->type() == Definition::MIXIN ? "[m]" : "[f]")] = dd; // set the static link so we can have lexical scoping dd->environment(env); return 0; }
static void generateRandomSentences(const map<string, Definition>& grammar, int numSentencesNeeded) { for (int i = 0; i < numSentencesNeeded; ++i) { Definition defin = grammar.at("<start>"); Production prod = defin.getRandomProduction(); expendProduction(prod, grammar); cout << endl; } }
Predefined *Expression::PredefFunc(Calculator *calculator) { if(head) { Definition *def = FunctionDefinition(calculator); if(def) return def->Predef(); } return 0; }
vector<Dim> &get_stage_dims(const Function &f, int stage_num) { static vector<Dim> outermost_only = {{Var::outermost().name(), ForType::Serial, DeviceAPI::None, Dim::Type::PureVar}}; if (f.has_extern_definition()) { return outermost_only; } Definition def = get_stage_definition(f, stage_num); internal_assert(def.defined()); return def.schedule().dims(); }
void register_c_function(Context& ctx, Env* env, Sass_C_Function_Callback descr) { Definition* def = make_c_function( sass_function_get_signature(descr), sass_function_get_function(descr), sass_function_get_cookie(descr), ctx ); def->environment(env); (*env)[def->name() + "[f]"] = def; }
static void expandOn(const map<string, Definition>& grammar, int aNonTerminalPos, vector<string>& aResult) { if(aNonTerminalPos == -1) { // Base case // return; } else { // Recursive case // auto iterator = grammar.find(aResult[aNonTerminalPos]); // If non-terminal is not defined then display error msg and exit. if(iterator == grammar.end()) { cout << "Could not find \"" << aResult[aNonTerminalPos] << "\" in the grammar file." << endl; exit (EXIT_FAILURE); } Definition myDefinition = iterator->second; Production myRandProduction = myDefinition.getRandomProduction(); // Get iterator 1 passed pos to insert. auto resultIterator = aResult.begin()+aNonTerminalPos+1; aResult.insert(resultIterator, myRandProduction.begin(), myRandProduction.end()); // Get new valid iterator and delete expanded non-terminal. resultIterator = aResult.begin()+aNonTerminalPos; aResult.erase(resultIterator); // Iterate through result vector to expand on non-terminals. // Start from previously expanded position. int newNonTerminalPos = -1; int pos = aNonTerminalPos; for(auto start = aResult.begin()+aNonTerminalPos; start != aResult.end(); start++) { // Check if non-terminal. if( (*start)[0] == '<') { newNonTerminalPos = pos; break; } pos++; } // Recurse. expandOn(grammar, newNonTerminalPos, aResult); } }
QCString Definition::qualifiedName() const { static int count=0; count++; makeResident(); if (!m_impl->qualifiedName.isEmpty()) { count--; return m_impl->qualifiedName; } #if 0 if (count>20) { printf("Definition::qualifiedName() Infinite recursion detected! Type=%d\n",definitionType()); printf("Trace:\n"); Definition *d = (Definition *)this; for (int i=0;d && i<20;i++) { printf(" %s\n",d->name().data()); d = d->getOuterScope(); } } #endif //printf("start %s::qualifiedName() localName=%s\n",name().data(),m_impl->localName.data()); if (m_impl->outerScope==0) { if (m_impl->localName=="<globalScope>") { count--; return ""; } else { count--; return m_impl->localName; } } if (m_impl->outerScope->name()=="<globalScope>") { m_impl->qualifiedName = m_impl->localName; } else { m_impl->qualifiedName = m_impl->outerScope->qualifiedName()+"::"+m_impl->localName; } //printf("end %s::qualifiedName()=%s\n",name().data(),m_impl->qualifiedName.data()); count--; return m_impl->qualifiedName; };
static void expendProduction(Production& production, const map<string, Definition>& grammar) { for (auto iter = production.begin(); iter < production.end(); ++iter) { string str = *iter; if (str.find('<') == std::string::npos) { cout << str << " "; } else { Definition def = grammar.at(str); Production prod = def.getRandomProduction(); expendProduction(prod, grammar); } } }
// Check if the dimension at index 'dim_idx' is always pure (i.e. equal to 'dim') // in the definition (including in its specializations) bool is_dim_always_pure(const Definition &def, const string& dim, int dim_idx) { const Variable *var = def.args()[dim_idx].as<Variable>(); if ((!var) || (var->name != dim)) { return false; } for (const auto &s : def.specializations()) { bool pure = is_dim_always_pure(s.definition, dim, dim_idx); if (!pure) { return false; } } return true; }
void TreeContext::updateDecl(JSAtom *atom, ParseNode *pn) { Definition *oldDecl = decls_.lookupFirst(atom); pn->setDefn(true); Definition *newDecl = (Definition *)pn; decls_.updateFirst(atom, newDecl); if (!sc->inFunction()) { JS_ASSERT(newDecl->isFreeVar()); return; } JS_ASSERT(oldDecl->isBound()); JS_ASSERT(!oldDecl->pn_cookie.isFree()); newDecl->pn_cookie = oldDecl->pn_cookie; newDecl->pn_dflags |= PND_BOUND; if (JOF_OPTYPE(oldDecl->getOp()) == JOF_QARG) { newDecl->setOp(JSOP_GETARG); JS_ASSERT(args_[oldDecl->pn_cookie.slot()] == oldDecl); args_[oldDecl->pn_cookie.slot()] = newDecl; } else { JS_ASSERT(JOF_OPTYPE(oldDecl->getOp()) == JOF_LOCAL); newDecl->setOp(JSOP_GETLOCAL); JS_ASSERT(vars_[oldDecl->pn_cookie.slot()] == oldDecl); vars_[oldDecl->pn_cookie.slot()] = newDecl; } }
void File::ParseDefs(InputStream& s, Reference* pParentRef) { while(s.SkipWhiteSpace(L";") != '}' && s.PeekChar() != Stream::EOS) { NodePriority priority = PNormal; CAtlList<CStringW> types; CStringW name; int c = s.SkipWhiteSpace(); if(c == '*') {s.GetChar(); priority = PLow;} else if(c == '!') {s.GetChar(); priority = PHigh;} ParseTypes(s, types); if(s.SkipWhiteSpace() == '#') { s.GetChar(); ParseName(s, name); } if(types.IsEmpty()) { if(name.IsEmpty()) s.ThrowError(_T("syntax error")); types.AddTail(L"?"); } Reference* pRef = pParentRef; while(types.GetCount() > 1) pRef = CreateRef(CreateDef(pRef, types.RemoveHead())); Definition* pDef = NULL; if(!types.IsEmpty()) pDef = CreateDef(pRef, types.RemoveHead(), name, priority); c = s.SkipWhiteSpace(L":="); if(c == '"' || c == '\'') ParseQuotedString(s, pDef); else if(iswdigit(c) || c == '+' || c == '-') ParseNumber(s, pDef); else if(pDef->IsType(L"@")) ParseBlock(s, pDef); else ParseRefs(s, pDef); } s.GetChar(); }
Definition* Definition::SetChildAsValue(CStringW path, status_t s, CStringW v, CStringW u) { Definition* pDef = this; Split split('.', path); for(size_t i = 0, j = split - 1; i <= j; i++) { CStringW type = split[i]; if(pDef->m_nodes.IsEmpty() || !dynamic_cast<Reference*>(pDef->m_nodes.GetTail())) { EXECUTE_ASSERT(m_pnf->CreateRef(pDef) != NULL); } if(Reference* pRef = dynamic_cast<Reference*>(pDef->m_nodes.GetTail())) { pDef = NULL; POSITION pos = pRef->m_nodes.GetTailPosition(); while(pos) { Definition* pChildDef = dynamic_cast<Definition*>(pRef->m_nodes.GetPrev(pos)); if(pChildDef->IsType(type)) { if(pChildDef->IsNameUnknown()) pDef = pChildDef; break; } } if(!pDef) { pDef = m_pnf->CreateDef(pRef, type); } if(i == j) { pDef->SetAsValue(s, v, u); return pDef; } } } return NULL; }
Bookmark::Definition* Bookmark::Find(BFont* font) const { font_family family; font_style style; float size; font->GetFamilyAndStyle(&family, &style); size = font->Size(); for (int i = 0; i < fDefinitions.CountItems(); i++) { Definition* definition = fDefinitions.ItemAt(i); if (definition->Matches(&family, &style, size)) { return definition; } } return NULL; }
Definition* NodeFactory::CreateDef(Reference* pParentRef, CStringW type, CStringW name, NodePriority priority) { Definition* pDef = NULL; if(name.IsEmpty()) { name = GenName(); } else { pDef = GetDefByName(name); if(pDef) { if(!pDef->m_predefined) { throw Exception(_T("redefinition of '%s' is not allowed"), CString(name)); } if(!pDef->IsTypeUnknown() && !pDef->IsType(type)) { throw Exception(_T("cannot redefine type of %s to %s"), CString(name), CString(type)); } } } if(!pDef) { pDef = DNew Definition(this, name); m_nodes.SetAt(name, pDef); m_newnodes.AddTail(name); if(pParentRef) { pParentRef->AddTail(pDef); pDef->m_parent = pParentRef; } } pDef->m_type = type; pDef->m_priority = priority; pDef->m_predefined = m_predefined; return pDef; }
static void writeLineNumber(CodeOutputInterface &ol,FileDef *fd,uint line) { Definition *d = fd ? fd->getSourceDefinition(line) : 0; if (d && d->isLinkable()) { g_currentDefinition=d; g_currentLine=line; MemberDef *md = fd->getSourceMember(line); if (md && md->isLinkable()) // link to member { if (g_currentMemberDef!=md) // new member, start search for body { g_searchForBody=TRUE; g_insideBody=FALSE; g_bracketCount=0; } g_currentMemberDef=md; ol.writeLineNumber(md->getReference(), md->getOutputFileBase(), md->anchor(), line); } else // link to compound { g_currentMemberDef=0; ol.writeLineNumber(d->getReference(), d->getOutputFileBase(), d->anchor(), line); } } else // no link { ol.writeLineNumber(0,0,0,line); } // set search page target if (Doxygen::searchIndex) { QCString lineAnchor; lineAnchor.sprintf("l%05d",line); ol.setCurrentDoc(fd,lineAnchor,TRUE); } //printf("writeLineNumber(%d) g_searchForBody=%d\n",line,g_searchForBody); }
void ClangParser::linkIdentifier(CodeOutputInterface &ol,FileDef *fd, uint &line,uint &column,const char *text,int tokenIndex) { CXCursor c = p->cursors[tokenIndex]; CXCursor r = clang_getCursorReferenced(c); if (!clang_equalCursors(r, c)) { c=r; // link to referenced location } CXCursor t = clang_getSpecializedCursorTemplate(c); if (!clang_Cursor_isNull(t) && !clang_equalCursors(t,c)) { c=t; // link to template } CXString usr = clang_getCursorUSR(c); const char *usrStr = clang_getCString(usr); Definition *d = usrStr ? Doxygen::clangUsrMap->find(usrStr) : 0; //CXCursorKind kind = clang_getCursorKind(c); //if (d==0) //{ // printf("didn't find definition for '%s' usr='******' kind=%d\n", // text,usrStr,kind); //} //else //{ // printf("found definition for '%s' usr='******' name='%s'\n", // text,usrStr,d->name().data()); //} if (d && d->isLinkable()) { if (g_insideBody && g_currentMemberDef && d->definitionType()==Definition::TypeMember && (g_currentMemberDef!=d || g_currentLine<line)) // avoid self-reference { addDocCrossReference(g_currentMemberDef,(MemberDef*)d); } writeMultiLineCodeLink(ol,fd,line,column,d,text); } else { codifyLines(ol,fd,text,line,column); } clang_disposeString(usr); }
void PYGenerator::generate() { std::string fn = gOptions.output_ + gOptions.inputFS_ + ".py"; CodeFile f(fn); f.output("from bintalk import protocol_writer"); f.output("from bintalk import protocol_reader"); for(std::set<std::string>::iterator iter = gContext.imported_.begin(); iter != gContext.imported_.end(); ++iter) { std::string incFilename = *iter; incFilename = incFilename.substr(0,incFilename.find('.')); f.output("from %s import *", incFilename.c_str()); } for(size_t i = 0; i < gContext.definitions_.size(); i++) { Definition* definition = gContext.definitions_[i]; if(definition->file_ != gOptions.inputFN_) continue; if (definition->getEnum()) generateEnum(f, definition->getEnum()); else if (definition->getStruct()) generateStruct(f, definition->getStruct()); else if (definition->getService()) generateService(f, definition->getService()); } }
void SubtitleFile::Append(InputStream& s, float start, float stop, bool fSetTime) { Reference* pRootRef = GetRootRef(); ParseDefs(s, pRootRef); CAtlList<Definition*> defs; GetNewDefs(defs); POSITION pos = defs.GetHeadPosition(); while(pos) { Definition* pDef = defs.GetNext(pos); if(pDef->m_parent == pRootRef && pDef->m_type == L"subtitle" && (*pDef)[L"@"].IsValue()) { m_segments.Insert(start, stop, pDef); if(fSetTime) { try { Definition::Time time; StringMapW<float> offset; pDef->GetAsTime(time, offset); if(time.start.value == start && time.stop.value == stop) continue; } catch(Exception&) { } CStringW str; str.Format(L"%.3f", start); pDef->SetChildAsNumber(L"time.start", str, L"s"); str.Format(L"%.3f", stop); pDef->SetChildAsNumber(L"time.stop", str, L"s"); } } } Commit(); }
DimBounds get_stage_bounds(Function f, int stage_num, const DimBounds &pure_bounds) { DimBounds bounds; Definition def = get_stage_definition(f, stage_num); // Assume that the domain of the pure vars across all the update // definitions is the same. This may not be true and can result in // over estimation of the extent. for (const auto &b : pure_bounds) { bounds[b.first] = b.second; } for (const auto &rvar : def.schedule().rvars()) { Expr lower = SubstituteVarEstimates().mutate(rvar.min); Expr upper = SubstituteVarEstimates().mutate(rvar.min + rvar.extent - 1); bounds.emplace(rvar.var, Interval(simplify(lower),simplify(upper))); } return bounds; }
bool check() { for (const auto& topic : fBmhParser.fTopicMap) { Definition* topicDef = topic.second; if (topicDef->fParent) { continue; } if (!topicDef->isRoot()) { return fBmhParser.reportError<bool>("expected root topic"); } fRoot = topicDef->asRoot(); if (!this->checkSeeAlso()) { return false; } // report functions that are not covered by related hierarchy if (!this->checkRelatedFunctions()) { return false; } } return true; }
double Overlap(Definition &def1, Definition &def2) { int numShareWord = def1.Overlap(def2); #ifdef I_AM_PARANOIK int as = def1.wordCount + def2.wordCount; if (!as) return 0; return numShareWord/((double)as); #else return numShareWord/((double)(def1.wordCount + def2.wordCount)); #endif }