CollectRuntimeStats(JSRuntime *rt, RuntimeStats *rtStats, ObjectPrivateVisitor *opv) { if (!rtStats->compartmentStatsVector.reserve(rt->compartments.length())) return false; rtStats->gcHeapChunkTotal = size_t(JS_GetGCParameter(rt, JSGC_TOTAL_CHUNKS)) * gc::ChunkSize; rtStats->gcHeapUnusedChunks = size_t(JS_GetGCParameter(rt, JSGC_UNUSED_CHUNKS)) * gc::ChunkSize; // This just computes rtStats->gcHeapDecommittedArenas. IterateChunks(rt, rtStats, StatsChunkCallback); // Take the per-compartment measurements. IteratorClosure closure(rtStats, opv); if (!closure.init()) return false; rtStats->runtime.scriptSources = 0; IterateCompartmentsArenasCells(rt, &closure, StatsCompartmentCallback, StatsArenaCallback, StatsCellCallback); // Take the "explicit/js/runtime/" measurements. rt->sizeOfIncludingThis(rtStats->mallocSizeOf, &rtStats->runtime); rtStats->gcHeapGcThings = 0; for (size_t i = 0; i < rtStats->compartmentStatsVector.length(); i++) { CompartmentStats &cStats = rtStats->compartmentStatsVector[i]; rtStats->totals.add(cStats); rtStats->gcHeapGcThings += cStats.gcHeapThingsSize(); } size_t numDirtyChunks = (rtStats->gcHeapChunkTotal - rtStats->gcHeapUnusedChunks) / gc::ChunkSize; size_t perChunkAdmin = sizeof(gc::Chunk) - (sizeof(gc::Arena) * gc::ArenasPerChunk); rtStats->gcHeapChunkAdmin = numDirtyChunks * perChunkAdmin; rtStats->gcHeapUnusedArenas -= rtStats->gcHeapChunkAdmin; // |gcHeapUnusedArenas| is the only thing left. Compute it in terms of // all the others. See the comment in RuntimeStats for explanation. rtStats->gcHeapUnusedArenas = rtStats->gcHeapChunkTotal - rtStats->gcHeapDecommittedArenas - rtStats->gcHeapUnusedChunks - rtStats->totals.gcHeapUnusedGcThings - rtStats->gcHeapChunkAdmin - rtStats->totals.gcHeapArenaAdmin - rtStats->gcHeapGcThings; return true; }
void CFG::constructCanonicalLR0Collection() { if(!augmented) { augmentGrammar(); } canonicalLR0Collection.clear(); canonicalLR0Collection = vector<vector<LR0Item>>( { closure( vector<LR0Item>( { LR0Item( find_if( p.begin(), p.end(), [this](const Production& pr) { return pr.left == s; } ) - p.begin(), 0 ) }) ) }); bool updated = false; vector<string> symbols = v; symbols.insert(symbols.end(), t.begin(), t.end()); do { updated = false; for(size_t i = 0; i < canonicalLR0Collection.size(); ++i) { for(size_t j = 0; j < symbols.size(); ++j) { vector<LR0Item> goToIX = goTo(canonicalLR0Collection[i], symbols[j]); if(goToIX.size() != 0 && !in(goToIX, canonicalLR0Collection)) { canonicalLR0Collection.push_back(goToIX); updated = true; } } } }while(updated); }
static void print_core (FILE *out, state *s) { size_t i; item_number *sitems = s->items; size_t snritems = s->nitems; symbol *previous_lhs = NULL; /* Output all the items of a state, not only its kernel. */ if (report_flag & report_itemsets) { closure (sitems, snritems); sitems = itemset; snritems = nitemset; } if (!snritems) return; fputc ('\n', out); for (i = 0; i < snritems; i++) { item_number *sp; item_number *sp1; rule_number r; sp1 = sp = ritem + sitems[i]; while (*sp >= 0) sp++; r = item_number_as_rule_number (*sp); rule_lhs_print (&rules[r], previous_lhs, out); previous_lhs = rules[r].lhs; for (sp = rules[r].rhs; sp < sp1; sp++) fprintf (out, " %s", symbols[*sp]->tag); fputs (" .", out); for (/* Nothing */; *sp >= 0; ++sp) fprintf (out, " %s", symbols[*sp]->tag); /* Display the lookahead tokens? */ if (report_flag & report_lookahead_tokens && item_number_is_rule_number (*sp1)) state_rule_lookahead_tokens_print (s, &rules[r], out); fputc ('\n', out); } }
struct cons_t* environment_t::define(const std::string& name, lambda_t f, bool syntactic) { /* * TODO: Are redefinitions legal? */ bool warn_mul_defs = false; if ( warn_mul_defs ) fprintf(stderr, "WARNING: Already have a definition for %s\n", name.c_str()); symbols[name] = closure(f, this, syntactic); return symbols[name]; }
/* * @NAME: collection_any_satisfy2 * @DESC: Igual a funcion any_satisfy de Haskell */ bool collection_any_satisfy2( t_list* list, char (*closure)(void*, ...),...){ va_list args_list; va_start(args_list,*closure); t_link_element *element = list->head; sem_wait( &list->semaforo ); while( element != NULL ){ if(closure(element->data, args_list)){ return(1); } element = element->next; } sem_post( &list->semaforo ); return(0); }
void CLRItemCollectionFamily::build(const BNFInstance& bnf) { for (auto &sym : bnf.symbolSet) { if (sym.type == SyntaxSymbol::T_Terminal) { term2ID[sym.value] = (int)ID2Term.size(); ID2Term.push_back(sym.value); } } vector<int> unhanldedState; { CLRItemCollection col; CLRItem item = {0, 0, term2ID[END_TERM]}; col.items.insert(item.toInt()); closure(bnf, col); int ns; addCollection(col, ns); unhanldedState.push_back(0); } while (!unhanldedState.empty()) { int state = unhanldedState.back(); unhanldedState.pop_back(); for (auto &sym : bnf.symbolSet) { const CLRItemCollection& col(ID2Collection[state]); CLRItemCollection newCol; transToNewItemCollection(bnf, col, newCol, sym); closure(bnf, newCol); if (!newCol.items.empty()) { int ns; if (addCollection(newCol, ns)) { unhanldedState.push_back(ns); } dfa[state][sym] = ns; } } } }
//---------------------------------------------------------------------- // 構造体比較関数 tTJSVariant ScriptsAdd::clone(tTJSVariant obj) { // タイプがオブジェクトなら細かく判定 if (obj.Type() == tvtObject) { tTJSVariantClosure &o1 = obj.AsObjectClosureNoAddRef(); // Arrayの複製 if (o1.IsInstanceOf(0, NULL, NULL, L"Array", NULL)== TJS_S_TRUE) { iTJSDispatch2 *array = TJSCreateArrayObject(); tTJSVariant o1Count; (void)o1.PropGet(0, L"count", &countHint, &o1Count, NULL); tjs_int count = o1Count; tTJSVariant val; tTJSVariant *args[] = {&val}; for (tjs_int i = 0; i < count; i++) { (void)o1.PropGetByNum(TJS_IGNOREPROP, i, &val, NULL); val = ScriptsAdd::clone(val); static tjs_uint addHint = 0; (void)array->FuncCall(0, TJS_W("add"), &addHint, 0, 1, args, array); } tTJSVariant result(array, array); array->Release(); return result; } // Dictionaryの複製 if (o1.IsInstanceOf(0, NULL, NULL, L"Dictionary", NULL)== TJS_S_TRUE) { iTJSDispatch2 *dict = TJSCreateDictionaryObject(); DictMemberCloneCaller *caller = new DictMemberCloneCaller(dict); tTJSVariantClosure closure(caller); o1.EnumMembers(TJS_IGNOREPROP, &closure, NULL); caller->Release(); tTJSVariant result(dict, dict); dict->Release(); return result; } // cloneメソッドの呼び出しに成功すればそれを返す tTJSVariant result; static tjs_uint cloneHint = 0; if (o1.FuncCall(0, L"clone", &cloneHint, &result, 0, NULL, NULL)== TJS_S_TRUE) { return result; } } return obj; }
vector<const pddl_type *> TypeHierarchy::accumulateAll(const pddl_type * t) { vector<const pddl_type *> nds(1,t); PTypeRef tt(t); GI gi = downGraph.find(&tt); if(gi == downGraph.end()) return nds; Nodes ns; PTypeRef pt(0); closure(downGraph,gi,ns,gi,&pt); for(Nodes::const_iterator i = ns.begin();i != ns.end();++i) { nds.push_back(***i); }; return nds; };
/** * Replace closure that point to oldEnv with closure on newEnv */ static void updateClosures(vector<Tree>& clos, Tree oldEnv, Tree newEnv) { for(unsigned int i = 0; i < clos.size(); i++) { Tree exp, genv, visited, lenv; if(isClosure(clos[i], exp, genv, visited, lenv)) { if(lenv == oldEnv) { clos[i] = closure(exp, genv, visited, newEnv); } } } }
/* * @NAME: collection_filter * @DESC: Igual a la funcion filter de haskell */ void *collection_filter( t_list* list, char (*closure)(void*, void*),void *arg){ t_list *listaAux=collection_list_create(); t_link_element *element = list->head; sem_wait( &list->semaforo ); while( element != NULL ){ if(closure(element->data, arg)){ void *newData=malloc(sizeof(element->data)); memcpy(newData,element->data,sizeof(element->data)); //newData=element->data; collection_list_add(listaAux,newData); } element = element->next; } sem_post( &list->semaforo ); return(listaAux); }
/* * @NAME: collection_map2 * @DESC: Igual a la funcion map de haskell pero con argumentos variables */ void *collection_map2( t_list* list, void *(*closure)(void*, ...),...){ va_list args_list; va_start(args_list,*closure); t_list *listaAux=collection_list_create(); t_link_element *element = list->head; sem_wait( &list->semaforo ); while( element != NULL ){ void *newData=malloc(sizeof(*closure)); //newData=closure(element->data, args_list); memcpy(newData,closure(element->data, args_list),sizeof(*closure)); collection_list_add(listaAux,newData); element = element->next; } sem_post( &list->semaforo ); return(listaAux); }
void closure( const Entity & e_from , std::vector<Entity*> & eset ) { PairIterRelation rel = e_from.relations(); for ( ; rel ; ++rel ) { if ( rel->forward() ) { Entity * const e = rel->entity(); std::vector<Entity*>::iterator i = eset.begin(); std::vector<Entity*>::iterator j = eset.end(); i = std::lower_bound( i , j , e , LessEntityPointer() ); if ( i == j || e != *i ) { eset.push_back( e ); closure( *e , eset ); } } } }
bool GR_CocoaImage::convertFromBuffer(const UT_ByteBuf* pBB, const std::string & mimetype, UT_sint32 iDisplayWidth, UT_sint32 iDisplayHeight) { const char *buffer = (const char *) pBB->getPointer(0); UT_uint32 buflen = pBB->getLength(); if(mimetype == "image/png") { if (buflen < 6) { return false; } char str1[10] = "\211PNG"; char str2[10] = "<89>PNG"; if ( !(strncmp(buffer, str1, 4)) || !(strncmp(buffer, str2, 6)) ) { m_grtype = GRT_Raster; if(m_surface) { cairo_surface_destroy(m_surface); } _PNG_read_state closure(pBB); m_surface = cairo_image_surface_create_from_png_stream (&_UT_ByteBuf_PNG_read, &closure); if(CAIRO_SURFACE_TYPE_IMAGE == cairo_surface_get_type(m_surface)) { if((cairo_image_surface_get_width(m_surface) != iDisplayWidth) || (cairo_image_surface_get_height(m_surface) != iDisplayHeight)) { // needs resize. cairo_surface_t *rescaled = _rescaleTo(m_surface, iDisplayWidth, iDisplayHeight); cairo_surface_destroy(m_surface); m_surface = rescaled; } } setDisplaySize(iDisplayWidth, iDisplayHeight); return true; } } // Otherwise, assume SVG. Do scaling when drawing; save size for then: m_grtype = GRT_Vector; setDisplaySize(iDisplayWidth, iDisplayHeight); return true; }
vector<LR0Item> CFG::goTo(const vector<LR0Item>& is, const string& x) { vector<LR0Item> js; for(size_t i = 0; i < is.size(); ++i) { Production pr = p[is[i].productionIndex]; if(!(pr.right.size() == 1 && pr.right[0] == "") && is[i].dotPosition < pr.right.size() && pr.right[is[i].dotPosition] == x) { js.push_back(LR0Item(is[i].productionIndex, is[i].dotPosition + 1)); } } return closure(js); }
/** * メンバ名一覧の取得 */ tjs_error TJS_INTF_METHOD ScriptsAdd::getKeys(tTJSVariant *result, tjs_int numparams, tTJSVariant **param, iTJSDispatch2 *objthis) { if (numparams < 1) return TJS_E_BADPARAMCOUNT; if (result) { iTJSDispatch2 *array = TJSCreateArrayObject(); DictMemberGetCaller *caller = new DictMemberGetCaller(array); tTJSVariantClosure closure(caller); param[0]->AsObjectClosureNoAddRef().EnumMembers(TJS_IGNOREPROP, &closure, NULL); caller->Release(); *result = tTJSVariant(array, array); array->Release(); } return TJS_S_OK; }
//---------------------------------------------------------------- string prawyArgument(const string & text) { if(text.empty()) { return ""; } if(text[0] == '(') { size_t pozycja = closure(text, 0); return text.substr(0, pozycja); } else { size_t pozycja = text.find_first_of("*/+-()"); return text.substr(0, pozycja - 1); } }
/** * 吉里吉里クラスから Javascript クラスを生成 * @param args 引数 * @return 結果 */ void TJSInstance::createTJSClass(const FunctionCallbackInfo<Value>& args) { Isolate *isolate = args.GetIsolate(); HandleScope handle_scope(isolate); if (args.Length() < 1) { args.GetReturnValue().Set(isolate->ThrowException(String::NewFromUtf8(isolate, "invalid param"))); return; } // TJSクラス情報取得 String::Value tjsClassName(args[0]); tTJSVariant tjsClassObj; TVPExecuteExpression(*tjsClassName, &tjsClassObj); if (tjsClassObj.Type() != tvtObject || TJS_FAILED(tjsClassObj.AsObjectClosureNoAddRef().IsInstanceOf(0,NULL,NULL,L"Class",NULL))) { args.GetReturnValue().Set(isolate->ThrowException(String::NewFromUtf8(isolate, "invalid param"))); return; } // クラステンプレートを生成 Local<FunctionTemplate> classTemplate = FunctionTemplate::New(isolate, tjsConstructor, TJSObject::toJSObject(isolate, tjsClassObj)); classTemplate->SetClassName(args[0]->ToString()); // 表示名 // メンバ登録処理 for (int i=args.Length()-1;i>=0;i--) { String::Value className(args[i]); tTJSVariant classObj; TVPExecuteExpression(*className, &classObj); if (classObj.Type() == tvtObject && TJS_SUCCEEDED(classObj.AsObjectClosureNoAddRef().IsInstanceOf(0,NULL,NULL,L"Class",NULL))) { MemberRegister *caller = new MemberRegister(isolate, classTemplate); tTJSVariantClosure closure(caller); classObj.AsObjectClosureNoAddRef().EnumMembers(TJS_IGNOREPROP, &closure, NULL); caller->Release(); } } // TJS機能メソッドを登録 Local<ObjectTemplate> protoTemplate = classTemplate->PrototypeTemplate(); protoTemplate->Set(String::NewFromUtf8(isolate, "tjsIsValid"), FunctionTemplate::New(isolate, tjsIsValid)); protoTemplate->Set(String::NewFromUtf8(isolate, "tjsOverride"), FunctionTemplate::New(isolate, tjsOverride)); args.GetReturnValue().Set(classTemplate->GetFunction()); }
void Dfa::tr_nfa_to_dfa(const Nfa &nfa){ State start_state; closure(nfa.get_start(), start_state, true); auto start_hash_code = hash_code(start_state); map<HashCodeType, State*> node_set_map; map<HashCodeType, Node*> node_map; queue<HashCodeType> node_set_queue; node_set_map[start_hash_code] = &start_state; node_map[start_hash_code] = new Node(); node_set_queue.push(start_hash_code); while(!node_set_queue.empty()){ auto code_now = node_set_queue.front(); node_set_queue.pop(); auto set_now = node_set_map[code_now]; auto node_now = node_map[code_now]; for(char path_char=PATH_BEGIN;path_char<PATH_END;++path_char){ auto set_next = new State(); next(*set_now, *set_next, path_char); if(set_next->size() == 0) continue; auto code_next = hash_code(*set_next); bool is_new_set = false; if(node_map.end() == node_map.find(code_next)){ node_map[code_next] = new Node(contain_end_node(*set_next)); node_set_map[code_next] = set_next; node_set_queue.push(code_next); is_new_set = true; } auto node_next = node_map[code_next]; node_now->set_path(node_next, path_char); if(!is_new_set){ safe_delete(set_next); } } } _start = node_map[start_hash_code]; }
void closure(int nfa[][20],int k,int n) { int i,d; for(i=0;i<=n;i++) { d=nfa[k][i]; if(d==1) { if(i!=k) { closure(nfa,i,n); } else { printf("[%d]",i+1); } } } }
int main() { FSM* fsm = concat(closure(alternative(createCharacter('a'), createCharacter('b'))), concat(createCharacter('a'), concat(createCharacter('b'), createCharacter('b')))); printFsm(fsm); char buffer[100]; do { printf("String: "); scanf("%s", buffer); if (simulate(fsm, buffer)) { printf("%s wurde akzeptiert.\n", buffer); } else { printf("%s wurde nicht akzeptiert.\n", buffer); } } while (buffer[1]); freeFsm(fsm); }
void generate_states (void) { item_number initial_core = 0; state_list *list = NULL; allocate_storage (); new_closure (nritems); /* Create the initial state. The 0 at the lhs is the index of the item of this initial rule. */ state_list_append (0, 1, &initial_core); /* States are queued when they are created; process them all. */ for (list = first_state; list; list = list->next) { state *s = list->state; if (trace_flag & trace_automaton) fprintf (stderr, "Processing state %d (reached by %s)\n", s->number, symbols[s->accessing_symbol]->tag); /* Set up itemset for the transitions out of this state. itemset gets a vector of all the items that could be accepted next. */ closure (s->items, s->nitems); /* Record the reductions allowed out of this state. */ save_reductions (s); /* Find the itemsets of the states that shifts can reach. */ new_itemsets (s); /* Find or create the core structures for those states. */ append_states (s); /* Create the shifts structures for the shifts to those states, now that the state numbers transitioning to are known. */ state_transitions_set (s, nshifts, shiftset); } /* discard various storage */ free_closure (); free_storage (); /* Set up STATES. */ set_states (); }
static void generate_states(void) { allocate_storage(); itemset = NEW2(nitems, Value_t); ruleset = NEW2(WORDSIZE(nrules), unsigned); set_first_derives(); initialize_states(); while (this_state) { closure(this_state->items, this_state->nitems); save_reductions(); new_itemsets(); append_states(); if (nshifts > 0) save_shifts(); this_state = this_state->next; } free_storage(); }
/* * @NAME: collection_filter2 * @DESC: Igual a la funcion filter de haskell con argumentos variables */ void *collection_filter2( t_list* list, char (*closure)(void*, ...),...){ va_list args_list; va_start(args_list,*closure); t_list *listaAux=collection_list_create(); t_link_element *element = list->head; sem_wait( &list->semaforo ); while( element != NULL ){ if(closure(element->data, args_list)){ //unsigned long *a; //a=element->data; void *newData=malloc(sizeof(element->data)); memcpy(newData,element->data,sizeof(element->data));//Si pasara pos donde apuntan punteros seria mas liviano //printf("Añado el sector ** %ld ** a la lista\n",*a); //newData=element->data; collection_list_add(listaAux,newData); } element = element->next; } sem_post( &list->semaforo ); return(listaAux); }
void graph(void) { int i; int j; shifts *sp; int sn; int as; if (!gflag) return; for (i = 0; i < nstates; ++i) { closure(state_table[i]->items, state_table[i]->nitems); graph_state(i); } fprintf(graph_file, "\n\n"); for (i = 0; i < nstates; ++i) { sp = shift_table[i]; if (sp) for (j = 0; j < sp->nshifts; ++j) { sn = sp->shift[j]; as = accessing_symbol[sn]; fprintf(graph_file, "\tq%d -> q%d [label=\"%s\"];\n", i, sn, symbol_pname[as]); } } fprintf(graph_file, "}\n"); for (i = 0; i < nsyms; ++i) FREE(symbol_pname[i]); FREE(symbol_pname); }
bool GR_CocoaImage::convertFromBuffer(const UT_ByteBuf* pBB, const std::string & mimetype, UT_sint32 iDisplayWidth, UT_sint32 iDisplayHeight) { const char *buffer = (const char *) pBB->getPointer(0); UT_uint32 buflen = pBB->getLength(); // We explicitely do not scale the image on load, since cairo can do // that during rendering. Scaling during loading will result in lost // image information, which in turns results in bugs like // in bugs like #12183. // So simply remember the display size for drawing later. setDisplaySize(iDisplayWidth, iDisplayHeight); if(mimetype == "image/png") { if (buflen < 6) { return false; } char str1[10] = "\211PNG"; char str2[10] = "<89>PNG"; if ( !(strncmp(buffer, str1, 4)) || !(strncmp(buffer, str2, 6)) ) { m_grtype = GRT_Raster; if(m_surface) { cairo_surface_destroy(m_surface); } _PNG_read_state closure(pBB); m_surface = cairo_image_surface_create_from_png_stream (&_UT_ByteBuf_PNG_read, &closure); } } else { m_grtype = GRT_Vector; } return true; }
/** * Push a new layer with multiple definitions creating the appropriate closures * @param ldefs list of pairs (symbol id x definition) to be binded to the symbol id * @param visited set of visited symbols (used for recursive definition detection) * @param lenv the environment where to push the layer and add all the definitions * @return the new environment */ Tree pushMultiClosureDefs(Tree ldefs, Tree visited, Tree lenv) { Tree lenv2 = pushNewLayer(lenv); while(!isNil(ldefs)) { Tree def = hd(ldefs); Tree id = hd(def); Tree rhs = tl(def); Tree cl = closure(tl(def), nil, visited, lenv2); stringstream s; s << boxpp(id); if(!isBoxCase(rhs)) setDefNameProperty(cl, s.str()); addLayerDef(id, cl, lenv2); ldefs = tl(ldefs); } return lenv2; }
jvmtiError JvmtiGetLoadedClasses::getClassLoaderClasses(JvmtiEnv *env, jobject initiatingLoader, jint* classCountPtr, jclass** classesPtr) { // Since SystemDictionary::classes_do only takes a function pointer // and doesn't call back with a closure data pointer, // we can only pass static methods. JvmtiGetLoadedClassesClosure closure(initiatingLoader); { // To get a consistent list of classes we need MultiArray_lock to ensure // array classes aren't created, and SystemDictionary_lock to ensure that // classes aren't added to the system dictionary, MutexLocker ma(MultiArray_lock); MutexLocker sd(SystemDictionary_lock); // First, count the classes in the system dictionary which have this loader recorded // as an initiating loader. For basic type arrays this information is not recorded // so GetClassLoaderClasses will return all of the basic type arrays. This is okay // because the defining loader for basic type arrays is always the boot class loader // and these classes are "visible" to all loaders. SystemDictionary::classes_do(&JvmtiGetLoadedClassesClosure::increment_with_loader); Universe::basic_type_classes_do(&JvmtiGetLoadedClassesClosure::increment_for_basic_type_arrays); // Next, fill in the classes closure.allocate(); SystemDictionary::classes_do(&JvmtiGetLoadedClassesClosure::add_with_loader); Universe::basic_type_classes_do(&JvmtiGetLoadedClassesClosure::add_for_basic_type_arrays); // Drop the SystemDictionary_lock, so the results could be wrong from here, // but we still have a snapshot. } // Post results jclass* result_list; jvmtiError err = env->Allocate(closure.get_count() * sizeof(jclass), (unsigned char**)&result_list); if (err != JVMTI_ERROR_NONE) { return err; } closure.extract(env, result_list); *classCountPtr = closure.get_count(); *classesPtr = result_list; return JVMTI_ERROR_NONE; }
int main() { int nfa[20][20],i,j,n,k,tk,t; printf("\nEnter the no. of states : "); scanf("%d",&n); n--; printf("\nEnter the transition table\n"); for(i=0;i<=n;i++) { for(j=0;j<=n;j++) { scanf("%d",&nfa[i][j]); } printf("\n"); } printf("\nThe Transition Table :\n"); for(i=0;i<=n;i++) { printf("\n"); for(j=0;j<=n;j++) { printf("%d\t",nfa[i][j]); } } /* printf("\nE-Closure \nEnter the state : \t"); scanf("%d",&k); printf("\nE-Closure of %d :\n",k); k--; */ for(i=0;i<=n;i++) { printf("\n\nE-Closure of %d :\n",i+1); closure(nfa,i,n); } }
Expr* PrimInliner::primitiveFailure(symbolOop failureCode) { // compile a failing primitive if (CompilerDebug) cout(PrintInlining)->print("%*sprimitive %s will fail: %s\n", _scope->depth + 2, "", _pdesc->name(), failureCode->as_string()); if (_failure_block == NULL) { error("\nPotential compiler bug: compiler believes primitive %s will fail\nwith error %s, but primitive has no failure block.\n", _pdesc->name(), failureCode->as_string()); return NULL; } // The byte code compiler stores the primitive result in a temporary (= the parameter of // the inlined failure block). Thus, we store res in the corresponding temp Expr so that // its value isn't forgotten (the default Expr for temps is UnknownExpr) and restore the // temp's original value afterwards. This is safe because within the failure block that // temporary is treated as a parameter and therefore is read-only. AssignmentFinder closure(_failure_block); assert(closure.interval != NULL, "no assignment found"); Expr* old_temp = _scope->temporary(closure.tempNo); // save temp Expr* res = new ConstantExpr(failureCode, new_ConstPReg(_scope, failureCode), _gen->current()); _scope->set_temporary(closure.tempNo, res); closure.set_prim_failure(false); // allow inlining sends in failure branch _gen->generate_subinterval(closure.interval, true); _scope->set_temporary(closure.tempNo, old_temp); return _gen->exprStack()->pop(); // restore temp }
bool TypeHierarchy::reachable(const TypeRef & t1,const TypeRef & t2) { if(t1 == t2) return true; Graph::iterator i = graph.find(&t1); if(i == graph.end()) { return false; }; Graph::const_iterator j = graph.find(&t2); if(j == graph.end() && t2.expected()) { return false; }; t2.addContents(this); j = graph.find(&t2); if(i->second.find(j->first) != i->second.end()) return true; Nodes ns; return closure(graph,i,ns,i,j->first); };