static void rb_export_method(VALUE klass, ID name, rb_method_flag_t noex) { rb_method_entry_t *me; VALUE defined_class; me = search_method(klass, name, &defined_class); if (!me && RB_TYPE_P(klass, T_MODULE)) { me = search_method(rb_cObject, name, &defined_class); } if (UNDEFINED_METHOD_ENTRY_P(me) || UNDEFINED_REFINED_METHOD_P(me->def)) { rb_print_undef(klass, name, 0); } if (me->flag != noex) { rb_vm_check_redefinition_opt_method(me, klass); if (klass == defined_class || RCLASS_ORIGIN(klass) == defined_class) { me->flag = noex; if (me->def->type == VM_METHOD_TYPE_REFINED) { me->def->body.orig_me->flag = noex; } rb_clear_method_cache_by_class(klass); } else { rb_add_method(klass, name, VM_METHOD_TYPE_ZSUPER, 0, noex); } } }
void rb_alias(VALUE klass, ID name, ID def) { VALUE target_klass = klass; rb_method_entry_t *orig_me; rb_method_flag_t flag = NOEX_UNDEF; if (NIL_P(klass)) { rb_raise(rb_eTypeError, "no class to make alias"); } rb_frozen_class_p(klass); if (klass == rb_cObject) { rb_secure(4); } again: orig_me = search_method(klass, def); if (UNDEFINED_METHOD_ENTRY_P(orig_me)) { if ((!RB_TYPE_P(klass, T_MODULE)) || (orig_me = search_method(rb_cObject, def), UNDEFINED_METHOD_ENTRY_P(orig_me))) { rb_print_undef(klass, def, 0); } } if (orig_me->def->type == VM_METHOD_TYPE_ZSUPER) { klass = RCLASS_SUPER(klass); def = orig_me->def->original_id; flag = orig_me->flag; goto again; } if (flag == NOEX_UNDEF) flag = orig_me->flag; rb_method_entry_set(target_klass, name, orig_me, flag); }
static void rb_export_method(VALUE klass, ID name, rb_method_flag_t noex) { rb_method_entry_t *me; if (klass == rb_cObject) { rb_secure(4); } me = search_method(klass, name); if (!me && RB_TYPE_P(klass, T_MODULE)) { me = search_method(rb_cObject, name); } if (UNDEFINED_METHOD_ENTRY_P(me)) { rb_print_undef(klass, name, 0); } if (me->flag != noex) { rb_vm_check_redefinition_opt_method(me, klass); if (klass == me->klass) { me->flag = noex; } else { rb_add_method(klass, name, VM_METHOD_TYPE_ZSUPER, 0, noex); } } }
static void rb_export_method(VALUE klass, ID name, ID noex) { NODE *fbody; VALUE origin; if (klass == rb_cObject) { rb_secure(4); } fbody = search_method(klass, name, &origin); if (!fbody && TYPE(klass) == T_MODULE) { fbody = search_method(rb_cObject, name, &origin); } if (!fbody || !fbody->nd_body) { rb_print_undef(klass, name, 0); } if (fbody->nd_body->nd_noex != noex) { if (nd_type(fbody->nd_body->nd_body) == NODE_CFUNC) { rb_vm_check_redefinition_opt_method(fbody); } if (klass == origin) { fbody->nd_body->nd_noex = noex; } else { rb_add_method(klass, name, NEW_ZSUPER(), noex); } } }
void rb_alias(VALUE klass, ID name, ID def) { NODE *orig_fbody, *node, *method; VALUE singleton = 0; st_data_t data; rb_frozen_class_p(klass); if (klass == rb_cObject) { rb_secure(4); } orig_fbody = search_method(klass, def, 0); if (!orig_fbody || !orig_fbody->nd_body) { if (TYPE(klass) == T_MODULE) { orig_fbody = search_method(rb_cObject, def, 0); } } if (!orig_fbody || !orig_fbody->nd_body) { rb_print_undef(klass, def, 0); } if (FL_TEST(klass, FL_SINGLETON)) { singleton = rb_iv_get(klass, "__attached__"); } orig_fbody->nd_cnt++; if (st_lookup(RCLASS_M_TBL(klass), name, &data)) { node = (NODE *)data; if (node) { if (RTEST(ruby_verbose) && node->nd_cnt == 0 && node->nd_body) { rb_warning("discarding old %s", rb_id2name(name)); } if (nd_type(node->nd_body->nd_body) == NODE_CFUNC) { rb_vm_check_redefinition_opt_method(node); } } } st_insert(RCLASS_M_TBL(klass), name, (st_data_t) NEW_FBODY( method = NEW_METHOD(orig_fbody->nd_body->nd_body, orig_fbody->nd_body->nd_clss, NOEX_WITH_SAFE(orig_fbody->nd_body->nd_noex)), def)); method->nd_file = (void *)def; rb_clear_cache_by_id(name); if (!ruby_running) return; if (singleton) { rb_funcall(singleton, singleton_added, 1, ID2SYM(name)); } else { rb_funcall(klass, added, 1, ID2SYM(name)); } }
EC_API EC_OBJ EcFindMethod( EC_OBJ obj, EC_OBJ *at_class, EcUInt methodid ) { EC_OBJ classobj; EcInt at; ASSERT( EC_OBJECTP(obj) ); /*ec_fprintf( stderr, "EcFindMethod methodid: %ld %k\n", (long)methodid, methodid );*/ if (at_class && EC_NNULLP(*at_class)) classobj = *at_class; else classobj = EC_OBJECTCLASS(obj); while (EC_NNULLP(classobj)) { at = search_method( EC_CLASSNMETHODS(classobj), EC_CLASSMTABLE(classobj), methodid ); if (at >= 0) { if (at_class) *at_class = classobj; return EC_CLASSMTABLE(classobj)[at].impl; } classobj = EC_CLASSSUPER(classobj); } if (at_class) *at_class = EC_NIL; return EC_NIL; }
jobject convert_vector_to_jobject(JNIEnv *env, std::vector<std::unique_ptr<T>>& array, const char *ctor_prototype) { unsigned int array_size = array.size(); jmethodID arraylist_add; jobject result = get_new_arraylist(env, array_size, &arraylist_add); if (array_size == 0) { return result; } jclass clazz = search_class(env, T::java_class().c_str()); jmethodID clazz_ctor = search_method(env, clazz, "<init>", ctor_prototype, false); for (unsigned int i = 0; i < array_size; ++i) { T *elem = array.at(i).release(); jobject object = env->NewObject(clazz, clazz_ctor, (jlong)elem); if (!object) { throw std::runtime_error("cannot create instance of class\n"); } env->CallBooleanMethod(result, arraylist_add, object); } return result; }
TEST (ROPSFeature, FeatureExtraction) { float support_radius = 0.0285f; unsigned int number_of_partition_bins = 5; unsigned int number_of_rotations = 3; pcl::search::KdTree<pcl::PointXYZ>::Ptr search_method (new pcl::search::KdTree<pcl::PointXYZ>); search_method->setInputCloud (cloud); pcl::ROPSEstimation <pcl::PointXYZ, pcl::Histogram <135> > feature_estimator; feature_estimator.setSearchMethod (search_method); feature_estimator.setSearchSurface (cloud); feature_estimator.setInputCloud (cloud); feature_estimator.setIndices (indices); feature_estimator.setTriangles (triangles); feature_estimator.setRadiusSearch (support_radius); feature_estimator.setNumberOfPartitionBins (number_of_partition_bins); feature_estimator.setNumberOfRotations (number_of_rotations); feature_estimator.setSupportRadius (support_radius); pcl::PointCloud<pcl::Histogram <135> >::Ptr histograms (new pcl::PointCloud <pcl::Histogram <135> > ()); feature_estimator.compute (*histograms); EXPECT_NE (0, histograms->points.size ()); }
void rb_undef(VALUE klass, ID id) { // TODO #if 0 VALUE origin; NODE *body; #if 0 // TODO if (rb_vm_cbase() == rb_cObject && klass == rb_cObject) { rb_secure(4); } #endif if (rb_safe_level() >= 4 && !OBJ_TAINTED(klass)) { rb_raise(rb_eSecurityError, "Insecure: can't undef `%s'", rb_id2name(id)); } rb_frozen_class_p(klass); if (id == object_id || id == __send__ || id == idInitialize) { rb_warn("undefining `%s' may cause serious problem", rb_id2name(id)); } /* TODO: warn if a very important method of NSObject is undefined * by default, pure objc methods are not exposed by introspections API */ body = search_method(klass, id, &origin); if (!body || !body->nd_body) { const char *s0 = " class"; VALUE c = klass; if (RCLASS_SINGLETON(c)) { VALUE obj = rb_iv_get(klass, "__attached__"); switch (TYPE(obj)) { case T_MODULE: case T_CLASS: c = obj; s0 = ""; } } else if (TYPE(c) == T_MODULE) { s0 = " module"; } rb_name_error(id, "undefined method `%s' for%s `%s'", rb_id2name(id), s0, rb_class2name(c)); } rb_add_method(klass, id, 0, NOEX_PUBLIC); if (RCLASS_SINGLETON(klass)) { rb_funcall(rb_iv_get(klass, "__attached__"), singleton_undefined, 1, ID2SYM(id)); } else { rb_funcall(klass, undefined, 1, ID2SYM(id)); } #endif }
static VALUE rb_mod_modfunc(int argc, VALUE *argv, VALUE module) { int i; ID id; NODE *fbody; if (TYPE(module) != T_MODULE) { rb_raise(rb_eTypeError, "module_function must be called for modules"); } secure_visibility(module); if (argc == 0) { SCOPE_SET(NOEX_MODFUNC); return module; } set_method_visibility(module, argc, argv, NOEX_PRIVATE); for (i = 0; i < argc; i++) { VALUE m = module; id = rb_to_id(argv[i]); for (;;) { fbody = search_method(m, id, &m); if (fbody == 0) { fbody = search_method(rb_cObject, id, &m); } if (fbody == 0 || fbody->nd_body == 0) { rb_bug("undefined method `%s'; can't happen", rb_id2name(id)); } if (nd_type(fbody->nd_body->nd_body) != NODE_ZSUPER) { break; /* normal case: need not to follow 'super' link */ } m = RCLASS_SUPER(m); if (!m) break; } rb_add_method(rb_singleton_class(module), id, fbody->nd_body->nd_body, NOEX_PUBLIC); } return module; }
void QGenieGetRouterWlanInfoThread::run() { if(0==m_soapapi #ifdef PLATFORM_WIN32 && 0==setupapi_inf #endif ) { emit getwlaninfo_complete(false,QString(),QString(),QString(),QString()); return; } //initialize m_bstart_ok = false; m_bgetssid_ok = false; m_bgetkey_ok = false; m_bcontinue = true; m_strnicguid.clear(); m_strprofilename.clear(); m_strssid.clear(); m_strkey.clear(); //initialize end if(false/*setupapi_inf && setupapi_inf->get_export_information(m_strnicguid,m_strssid,m_strprofilename)*/) { emit getwlaninfo_complete(true,m_strssid,QString(),m_strnicguid,m_strprofilename); } else { QString str_session("f8018c9f-5431-497e-ac5d-511dd0ae7402"); //get wlan exporting information from router // //Start // QString start_module("DeviceConfig"); // QString start_method("ConfigurationStarted"); // QMap<QString,QString> start_param; // QUuid uuid_start ("{14E65BB7-0D3B-4c90-871E-187E58D6712C}"); // start_param.insert(QString("NewSessionID"), QString("99999999999")); // m_soapapi->submitrequest(start_module,start_method ,start_param,uuid_start, // str_session ); // GeniePlugin_WSetupPlugin::output_log(QString("submit:DeviceConfig ConfigurationStarted UUID:{14E65BB7-0D3B-4c90-871E-187E58D6712C}")); QMap<QString,QString> search_param; QString search_module("WLANConfiguration"); QString search_method("GetSSID"); QUuid uuid_ssid( "{CFE911FE-C5E8-4a0e-A073-6FD28B017E41}"); m_soapapi->submitrequest(search_module,search_method , search_param,uuid_ssid,str_session); GeniePlugin_WSetupPlugin::output_log(QString("submit:WLANConfiguration GetSSID UUID:{CFE911FE-C5E8-4a0e-A073-6FD28B017E41}")); search_method = "GetWPASecurityKeys"; QUuid uuid_key("{B8D2DCFD-0A58-4e46-882A-5EB1DC77EBB4}"); m_soapapi->submitrequest(search_module,search_method , search_param,uuid_key,str_session); GeniePlugin_WSetupPlugin::output_log(QString("submit:WLANConfiguration GetWPASecurityKeys UUID:{B8D2DCFD-0A58-4e46-882A-5EB1DC77EBB4}")); } }
static VALUE rb_mod_modfunc(int argc, VALUE *argv, VALUE module) { int i; ID id; const rb_method_entry_t *me; if (!RB_TYPE_P(module, T_MODULE)) { rb_raise(rb_eTypeError, "module_function must be called for modules"); } secure_visibility(module); if (argc == 0) { SCOPE_SET(NOEX_MODFUNC); return module; } set_method_visibility(module, argc, argv, NOEX_PRIVATE); for (i = 0; i < argc; i++) { VALUE m = module; id = rb_to_id(argv[i]); for (;;) { me = search_method(m, id); if (me == 0) { me = search_method(rb_cObject, id); } if (UNDEFINED_METHOD_ENTRY_P(me)) { rb_print_undef(module, id, 0); } if (me->def->type != VM_METHOD_TYPE_ZSUPER) { break; /* normal case: need not to follow 'super' link */ } m = RCLASS_SUPER(m); if (!m) break; } rb_method_entry_set(rb_singleton_class(module), id, me, NOEX_PUBLIC); } return module; }
void rb_alias(VALUE klass, ID name, ID def) { rb_method_entry_t *orig_me; rb_frozen_class_p(klass); if (klass == rb_cObject) { rb_secure(4); } orig_me = search_method(klass, def); if (UNDEFINED_METHOD_ENTRY_P(orig_me)) { if ((TYPE(klass) != T_MODULE) || (orig_me = search_method(rb_cObject, def), UNDEFINED_METHOD_ENTRY_P(orig_me))) { rb_print_undef(klass, def, 0); } } rb_add_method_me(klass, name, orig_me, orig_me->flag); }
void rb_alias(VALUE klass, ID name, ID def) { VALUE target_klass = klass; VALUE defined_class; rb_method_entry_t *orig_me; rb_method_flag_t flag = NOEX_UNDEF; if (NIL_P(klass)) { rb_raise(rb_eTypeError, "no class to make alias"); } rb_frozen_class_p(klass); again: orig_me = search_method(klass, def, &defined_class); if (UNDEFINED_METHOD_ENTRY_P(orig_me) || UNDEFINED_REFINED_METHOD_P(orig_me->def)) { if ((!RB_TYPE_P(klass, T_MODULE)) || (orig_me = search_method(rb_cObject, def, 0), UNDEFINED_METHOD_ENTRY_P(orig_me))) { rb_print_undef(klass, def, 0); } } if (orig_me->def->type == VM_METHOD_TYPE_ZSUPER) { klass = RCLASS_SUPER(klass); def = orig_me->def->original_id; flag = orig_me->flag; goto again; } if (RB_TYPE_P(defined_class, T_ICLASS)) { VALUE real_class = RBASIC_CLASS(defined_class); if (real_class && RCLASS_ORIGIN(real_class) == defined_class) defined_class = real_class; } if (flag == NOEX_UNDEF) flag = orig_me->flag; method_entry_set(target_klass, name, orig_me, flag, defined_class); }
static EcBool does_class_understand( EC_OBJ classobj, EcUInt methodid ) { ASSERT( EC_CLASSP(classobj) ); while (EC_NNULLP(classobj)) { if (search_method( EC_CLASSNCMETHODS(classobj), EC_CLASSCMTABLE(classobj), methodid ) >= 0) return TRUE; classobj = EC_CLASSSUPER(classobj); } return FALSE; }
EC_API EC_OBJ EcDispatchObjectMessage( EC_OBJ obj, EC_OBJ at_class, EcUInt methodid, EC_OBJ stack ) { EC_OBJ classobj, callable; EcInt at; ASSERT( EC_OBJECTP(obj) ); /* ec_fprintf( stderr, "EcDispatchObjectMessage receiver: %w.%w method: %k nargs: %ld\n", at_class, obj, methodid, EC_NNULLP(stack) ? (long)EC_STACKNARGS_LOGICAL(stack) : 0 );*/ if (EC_BOOLP(at_class)) classobj = EC_OBJECTCLASS(obj); else classobj = at_class; while (EC_NNULLP(classobj)) { at = search_method( EC_CLASSNMETHODS(classobj), EC_CLASSMTABLE(classobj), methodid ); /* ec_fprintf( stderr, " in class %w at: %ld\n", classobj, (long)at );*/ if (at >= 0) { callable = EC_CLASSMTABLE(classobj)[at].impl; switch (EC_TYPE(callable)) { case tc_primitive: return EC_PRIMITIVE(callable)( stack, EC_PRIMITIVEUSERDATA(callable) ); break; case tc_cmethod: return EC_CMETHOD(callable)( obj, classobj, stack ); break; default: if (EC_COMPILEDP(callable)) return EcExecute( obj, classobj, callable, stack ); ASSERT( FALSE ); } } classobj = EC_CLASSSUPER(classobj); } /* No such a method. Invoke doesNotUnderstand if available */ return EcUnknownMethod( obj, at_class, methodid, stack ); /* TODO: Should raise an exception */ ASSERT( FALSE ); return Ec_ERROR; }
void rb_undef(VALUE klass, ID id) { VALUE origin; NODE *body; if (rb_vm_cbase() == rb_cObject && klass == rb_cObject) { rb_secure(4); } if (rb_safe_level() >= 4 && !OBJ_TAINTED(klass)) { rb_raise(rb_eSecurityError, "Insecure: can't undef `%s'", rb_id2name(id)); } rb_frozen_class_p(klass); if (id == object_id || id == __send__ || id == idInitialize) { rb_warn("undefining `%s' may cause serious problem", rb_id2name(id)); } body = search_method(klass, id, &origin); if (!body || !body->nd_body) { const char *s0 = " class"; VALUE c = klass; if (FL_TEST(c, FL_SINGLETON)) { VALUE obj = rb_iv_get(klass, "__attached__"); switch (TYPE(obj)) { case T_MODULE: case T_CLASS: c = obj; s0 = ""; } } else if (TYPE(c) == T_MODULE) { s0 = " module"; } rb_name_error(id, "undefined method `%s' for%s `%s'", rb_id2name(id), s0, rb_class2name(c)); } rb_add_method(klass, id, 0, NOEX_PUBLIC); if (FL_TEST(klass, FL_SINGLETON)) { rb_funcall(rb_iv_get(klass, "__attached__"), singleton_undefined, 1, ID2SYM(id)); } else { rb_funcall(klass, undefined, 1, ID2SYM(id)); } }
jobject generic_clone(JNIEnv *env, jobject obj) { T *obj_generic = getInstance<T>(env, obj); T *copy_generic = new T(*obj_generic); jclass generic_class = search_class(env, *copy_generic); jmethodID generic_ctor = search_method(env, generic_class, "<init>", "(J)V", false); jobject result = env->NewObject(generic_class, generic_ctor, (jlong)copy_generic); if (!result) { throw std::runtime_error("cannot create instance of class\n"); } return result; }
void rb_undef(VALUE klass, ID id) { rb_method_entry_t *me; if (NIL_P(klass)) { rb_raise(rb_eTypeError, "no class to undef method"); } if (rb_vm_cbase() == rb_cObject && klass == rb_cObject) { rb_secure(4); } if (rb_safe_level() >= 4 && !OBJ_UNTRUSTED(klass)) { rb_raise(rb_eSecurityError, "Insecure: can't undef `%s'", rb_id2name(id)); } rb_frozen_class_p(klass); if (id == object_id || id == id__send__ || id == idInitialize) { rb_warn("undefining `%s' may cause serious problems", rb_id2name(id)); } me = search_method(klass, id); if (UNDEFINED_METHOD_ENTRY_P(me)) { const char *s0 = " class"; VALUE c = klass; if (FL_TEST(c, FL_SINGLETON)) { VALUE obj = rb_ivar_get(klass, attached); switch (TYPE(obj)) { case T_MODULE: case T_CLASS: c = obj; s0 = ""; } } else if (RB_TYPE_P(c, T_MODULE)) { s0 = " module"; } rb_name_error(id, "undefined method `%s' for%s `%s'", rb_id2name(id), s0, rb_class2name(c)); } rb_add_method(klass, id, VM_METHOD_TYPE_UNDEF, 0, NOEX_PUBLIC); CALL_METHOD_HOOK(klass, undefined, id); }
static EcBool does_object_understand( EC_OBJ obj, EcUInt methodid ) { EC_OBJ classobj; ASSERT( EC_OBJECTP(obj) ); classobj = EC_OBJECTCLASS(obj); while (EC_NNULLP(classobj)) { if (search_method( EC_CLASSNMETHODS(classobj), EC_CLASSMTABLE(classobj), methodid ) >= 0) return TRUE; classobj = EC_CLASSSUPER(classobj); } return FALSE; }
/* * search method entry without the method cache. * * if you need method entry with method cache (normal case), use * rb_method_entry() simply. */ rb_method_entry_t * rb_method_entry_get_without_cache(VALUE klass, ID id, VALUE *defined_class_ptr) { VALUE defined_class; rb_method_entry_t *me = search_method(klass, id, &defined_class); if (me && me->klass) { switch (BUILTIN_TYPE(me->klass)) { case T_CLASS: if (RBASIC(klass)->flags & FL_SINGLETON) break; /* fall through */ case T_ICLASS: defined_class = me->klass; } } if (ruby_running) { if (OPT_GLOBAL_METHOD_CACHE) { struct cache_entry *ent; ent = GLOBAL_METHOD_CACHE(klass, id); ent->class_serial = RCLASS_SERIAL(klass); ent->method_state = GET_GLOBAL_METHOD_STATE(); ent->defined_class = defined_class; ent->mid = id; if (UNDEFINED_METHOD_ENTRY_P(me)) { ent->me = 0; me = 0; } else { ent->me = me; } } else if (UNDEFINED_METHOD_ENTRY_P(me)) { me = 0; } } if (defined_class_ptr) *defined_class_ptr = defined_class; return me; }
TEST (ROPSFeature, InvalidParameters) { float support_radius = 0.0285f; unsigned int number_of_partition_bins = 5; unsigned int number_of_rotations = 3; pcl::search::KdTree<pcl::PointXYZ>::Ptr search_method (new pcl::search::KdTree<pcl::PointXYZ>); search_method->setInputCloud (cloud); pcl::ROPSEstimation <pcl::PointXYZ, pcl::Histogram <135> > feature_estimator; feature_estimator.setSearchMethod (search_method); feature_estimator.setSearchSurface (cloud); feature_estimator.setInputCloud (cloud); feature_estimator.setIndices (indices); feature_estimator.setTriangles (triangles); feature_estimator.setRadiusSearch (support_radius); feature_estimator.setNumberOfPartitionBins (number_of_partition_bins); feature_estimator.setNumberOfRotations (number_of_rotations); feature_estimator.setSupportRadius (support_radius); pcl::PointCloud<pcl::Histogram <135> >::Ptr histograms (new pcl::PointCloud <pcl::Histogram <135> > ()); support_radius = -support_radius; feature_estimator.setSupportRadius (support_radius); support_radius = feature_estimator.getSupportRadius (); EXPECT_LT (0.0f, support_radius); number_of_partition_bins = 0; feature_estimator.setNumberOfPartitionBins (number_of_partition_bins); number_of_partition_bins = feature_estimator.getNumberOfPartitionBins (); EXPECT_LT (0, number_of_partition_bins); number_of_rotations = 0; feature_estimator.setNumberOfRotations (number_of_rotations); number_of_rotations = feature_estimator.getNumberOfRotations (); EXPECT_LT (0, number_of_rotations); std::vector <pcl::Vertices> empty_triangles; feature_estimator.setTriangles (empty_triangles); feature_estimator.compute (*histograms); EXPECT_EQ (0, histograms->points.size ()); }
EC_API EC_OBJ EcFindClassMethod( EC_OBJ classobj, EC_OBJ *at_class, EcUInt methodid ) { EcInt at; ASSERT( EC_CLASSP(classobj) ); while (EC_NNULLP(classobj)) { at = search_method( EC_CLASSNCMETHODS(classobj), EC_CLASSCMTABLE(classobj), methodid ); if (at >= 0) { if (at_class) *at_class = classobj; return EC_CLASSCMTABLE(classobj)[at].impl; } classobj = EC_CLASSSUPER(classobj); } return EC_NIL; }
/* * search method body (NODE_METHOD) * with : klass and id * without : method cache * * if you need method node with method cache, use * rb_method_node() */ NODE * rb_get_method_body(VALUE klass, ID id, ID *idp) { NODE *volatile fbody, *body; NODE *method; if ((fbody = search_method(klass, id, 0)) == 0 || !fbody->nd_body) { /* store empty info in cache */ struct cache_entry *ent; ent = cache + EXPR1(klass, id); ent->klass = klass; ent->mid = ent->mid0 = id; ent->method = 0; ent->oklass = 0; return 0; } method = fbody->nd_body; if (ruby_running) { /* store in cache */ struct cache_entry *ent; ent = cache + EXPR1(klass, id); ent->klass = klass; ent->mid = id; ent->mid0 = fbody->nd_oid; ent->method = body = method; ent->oklass = method->nd_clss; } else { body = method; } if (idp) { *idp = fbody->nd_oid; } return body; }
void rb_undef(VALUE klass, ID id) { rb_method_entry_t *me; if (NIL_P(klass)) { rb_raise(rb_eTypeError, "no class to undef method"); } rb_frozen_class_p(klass); if (id == object_id || id == id__send__ || id == idInitialize) { rb_warn("undefining `%s' may cause serious problems", rb_id2name(id)); } me = search_method(klass, id, 0); if (UNDEFINED_METHOD_ENTRY_P(me) || UNDEFINED_REFINED_METHOD_P(me->def)) { const char *s0 = " class"; VALUE c = klass; if (FL_TEST(c, FL_SINGLETON)) { VALUE obj = rb_ivar_get(klass, attached); if (RB_TYPE_P(obj, T_MODULE) || RB_TYPE_P(obj, T_CLASS)) { c = obj; s0 = ""; } } else if (RB_TYPE_P(c, T_MODULE)) { s0 = " module"; } rb_name_error(id, "undefined method `%"PRIsVALUE"' for%s `%"PRIsVALUE"'", QUOTE_ID(id), s0, rb_class_name(c)); } rb_add_method(klass, id, VM_METHOD_TYPE_UNDEF, 0, NOEX_PUBLIC); CALL_METHOD_HOOK(klass, undefined, id); }
EC_API EC_OBJ EcDispatchClassMessage( EC_OBJ obj, EcUInt methodid, EC_OBJ stack ) { EcInt at; EC_OBJ callable; ASSERT( EC_CLASSP(obj) ); while (EC_NNULLP(obj)) { at = search_method( EC_CLASSNCMETHODS(obj), EC_CLASSCMTABLE(obj), methodid ); if (at >= 0) { callable = EC_CLASSCMTABLE(obj)[at].impl; switch (EC_TYPE(callable)) { case tc_primitive: return EC_PRIMITIVE(callable)( stack, EC_PRIMITIVEUSERDATA(callable) ); break; case tc_cmethod: return EC_CMETHOD(callable)( obj, EC_NIL, stack ); break; default: if (EC_COMPILEDP(callable)) return EcExecute( EC_NIL, obj, callable, stack ); ASSERT( FALSE ); } } obj = EC_CLASSSUPER(obj); } /* No such a method. Invoke doesNotUnderstand if available */ return EcUnknownMethod( obj, EC_NIL, methodid, stack ); /* TODO: Should raise an exception */ ASSERT( FALSE ); return Ec_ERROR; }
/* * search method entry without method cache. * * if you need method entry with method cache, use * rb_method_entry() */ rb_method_entry_t * rb_get_method_entry(VALUE klass, ID id) { rb_method_entry_t *me = search_method(klass, id); if (ruby_running) { struct cache_entry *ent; ent = cache + EXPR1(klass, id); ent->klass = klass; if (UNDEFINED_METHOD_ENTRY_P(me)) { ent->mid = id; ent->me = 0; me = 0; } else { ent->mid = id; ent->me = me; } } return me; }
/* * search method entry without the method cache. * * if you need method entry with method cache (normal case), use * rb_method_entry() simply. */ rb_method_entry_t * rb_method_entry_get_without_cache(VALUE klass, ID id) { rb_method_entry_t *me = search_method(klass, id); if (ruby_running) { struct cache_entry *ent; ent = cache + EXPR1(klass, id); ent->filled_version = GET_VM_STATE_VERSION(); ent->klass = klass; if (UNDEFINED_METHOD_ENTRY_P(me)) { ent->mid = id; ent->me = 0; me = 0; } else { ent->mid = id; ent->me = me; } } return me; }
static rb_method_entry_t * rb_method_entry_make(VALUE klass, ID mid, rb_method_type_t type, rb_method_definition_t *def, rb_method_flag_t noex, VALUE defined_class) { rb_method_entry_t *me; #if NOEX_NOREDEF VALUE rklass; #endif st_table *mtbl; st_data_t data; int make_refined = 0; if (NIL_P(klass)) { klass = rb_cObject; } if (!FL_TEST(klass, FL_SINGLETON) && type != VM_METHOD_TYPE_NOTIMPLEMENTED && type != VM_METHOD_TYPE_ZSUPER) { switch (mid) { case idInitialize: case idInitialize_copy: case idInitialize_clone: case idInitialize_dup: case idRespond_to_missing: noex |= NOEX_PRIVATE; } } rb_frozen_class_p(klass); #if NOEX_NOREDEF rklass = klass; #endif if (FL_TEST(klass, RMODULE_IS_REFINEMENT)) { VALUE refined_class = rb_refinement_module_get_refined_class(klass); rb_add_refined_method_entry(refined_class, mid); } if (type == VM_METHOD_TYPE_REFINED) { rb_method_entry_t *old_me = lookup_method_table(RCLASS_ORIGIN(klass), mid); if (old_me) rb_vm_check_redefinition_opt_method(old_me, klass); } else { klass = RCLASS_ORIGIN(klass); } mtbl = RCLASS_M_TBL(klass); /* check re-definition */ if (st_lookup(mtbl, mid, &data)) { rb_method_entry_t *old_me = (rb_method_entry_t *)data; rb_method_definition_t *old_def = old_me->def; if (rb_method_definition_eq(old_def, def)) return old_me; #if NOEX_NOREDEF if (old_me->flag & NOEX_NOREDEF) { rb_raise(rb_eTypeError, "cannot redefine %"PRIsVALUE"#%"PRIsVALUE, rb_class_name(rklass), rb_id2str(mid)); } #endif rb_vm_check_redefinition_opt_method(old_me, klass); if (old_def->type == VM_METHOD_TYPE_REFINED) make_refined = 1; if (RTEST(ruby_verbose) && type != VM_METHOD_TYPE_UNDEF && old_def->alias_count == 0 && old_def->type != VM_METHOD_TYPE_UNDEF && old_def->type != VM_METHOD_TYPE_ZSUPER) { rb_iseq_t *iseq = 0; rb_warning("method redefined; discarding old %"PRIsVALUE, rb_id2str(mid)); switch (old_def->type) { case VM_METHOD_TYPE_ISEQ: iseq = old_def->body.iseq; break; case VM_METHOD_TYPE_BMETHOD: iseq = rb_proc_get_iseq(old_def->body.proc, 0); break; default: break; } if (iseq && !NIL_P(iseq->location.path)) { int line = iseq->line_info_table ? FIX2INT(rb_iseq_first_lineno(iseq->self)) : 0; rb_compile_warning(RSTRING_PTR(iseq->location.path), line, "previous definition of %"PRIsVALUE" was here", rb_id2str(old_def->original_id)); } } rb_unlink_method_entry(old_me); } me = ALLOC(rb_method_entry_t); rb_clear_method_cache_by_class(klass); me->flag = NOEX_WITH_SAFE(noex); me->mark = 0; me->called_id = mid; RB_OBJ_WRITE(klass, &me->klass, defined_class); me->def = def; if (def) { def->alias_count++; switch(def->type) { case VM_METHOD_TYPE_ISEQ: RB_OBJ_WRITTEN(klass, Qundef, def->body.iseq->self); break; case VM_METHOD_TYPE_IVAR: RB_OBJ_WRITTEN(klass, Qundef, def->body.attr.location); break; case VM_METHOD_TYPE_BMETHOD: RB_OBJ_WRITTEN(klass, Qundef, def->body.proc); break; default:; /* ignore */ } } /* check mid */ if (klass == rb_cObject && mid == idInitialize) { rb_warn("redefining Object#initialize may cause infinite loop"); } /* check mid */ if (mid == object_id || mid == id__send__) { if (type == VM_METHOD_TYPE_ISEQ && search_method(klass, mid, 0)) { rb_warn("redefining `%s' may cause serious problems", rb_id2name(mid)); } } if (make_refined) { make_method_entry_refined(me); } st_insert(mtbl, mid, (st_data_t) me); return me; }
/* * search method body (NODE_METHOD) * with : klass and id * without : method cache * * if you need method node with method cache, use * rb_method_node() */ NODE * rb_get_method_body(VALUE klass, ID id, ID *idp) { return search_method(klass, id, NULL); }