static VALUE rb_thrift_union_write(VALUE self, VALUE protocol) { // call validate rb_funcall(self, validate_method_id, 0); // write struct begin default_write_struct_begin(protocol, rb_class_name(CLASS_OF(self))); VALUE struct_fields = STRUCT_FIELDS(self); VALUE setfield = rb_ivar_get(self, setfield_id); VALUE setvalue = rb_ivar_get(self, setvalue_id); VALUE field_id = rb_funcall(self, name_to_id_method_id, 1, rb_funcall(setfield, to_s_method_id, 0)); VALUE field_info = rb_hash_aref(struct_fields, field_id); VALUE ttype_value = rb_hash_aref(field_info, type_sym); int ttype = FIX2INT(ttype_value); default_write_field_begin(protocol, setfield, ttype_value, field_id); write_anything(ttype, setvalue, protocol, field_info); default_write_field_end(protocol); default_write_field_stop(protocol); // write struct end default_write_struct_end(protocol); return Qnil; }
static VALUE union_write(VALUE self, VALUE protocol, protocol_method_table *pmt) { DEBUG_FUNCTION_ENTRY(); // call validate rb_funcall(self, validate_method_id, 0); // write struct begin fastcall_call(pmt->write_struct_begin, protocol, rb_class_name(CLASS_OF(self))); struct_metadata* md = getStructMetadata(CLASS_OF(self)); VALUE setfield = rb_ivar_get(self, setfield_id); VALUE setvalue = rb_ivar_get(self, setvalue_id); field_metadata* fmd = getFieldMetadataByName(md, RSTRING_PTR(rb_funcall(setfield, to_s_method_id, 0))); int ttype = fmd->type; int field_id = fmd->id; fastcall_call(pmt->write_field_begin, protocol, setfield, INT2NUM(ttype), INT2NUM(field_id)); write_anything(setvalue, protocol, fmd, pmt); fastcall_call(pmt->write_field_end, protocol, Qnil); fastcall_call(pmt->write_field_stop, protocol, Qnil); // write struct end fastcall_call(pmt->write_struct_end, protocol, Qnil); fastcall_call(pmt->flush, protocol, Qnil); DEBUG_FUNCTION_EXIT(); return Qnil; }
void rb_print_undef_str(VALUE klass, VALUE name) { rb_name_error_str(name, "undefined method `%"PRIsVALUE"' for %s `%"PRIsVALUE"'", QUOTE(name), (RB_TYPE_P(klass, T_MODULE)) ? "module" : "class", rb_class_name(klass)); }
static VALUE exc_to_s(VALUE exc) { VALUE mesg = rb_attr_get(exc, rb_intern("mesg")); if (NIL_P(mesg)) return rb_class_name(CLASS_OF(exc)); return rb_String(mesg); }
/* * call-seq: to_json_raw_object() * * This method creates a raw object hash, that can be nested into * other data structures and will be unparsed as a raw string. This * method should be used, if you want to convert raw strings to JSON * instead of UTF-8 strings, e. g. binary data. */ static VALUE mString_to_json_raw_object(VALUE self) { VALUE ary; VALUE result = rb_hash_new(); rb_hash_aset(result, rb_funcall(mJSON, i_create_id, 0), rb_class_name(rb_obj_class(self))); ary = rb_funcall(self, i_unpack, 1, rb_str_new2("C*")); rb_hash_aset(result, rb_str_new2("raw"), ary); return result; }
static void print_errinfo(const VALUE eclass, const VALUE errat, const VALUE emesg) { const char *einfo = ""; long elen = 0; VALUE mesg; if (emesg != Qundef) { if (NIL_P(errat) || RARRAY_LEN(errat) == 0 || NIL_P(mesg = RARRAY_AREF(errat, 0))) { error_pos(); } else { warn_print_str(mesg); warn_print(": "); } if (!NIL_P(emesg)) { einfo = RSTRING_PTR(emesg); elen = RSTRING_LEN(emesg); } } if (eclass == rb_eRuntimeError && elen == 0) { warn_print("unhandled exception\n"); } else { VALUE epath; epath = rb_class_name(eclass); if (elen == 0) { warn_print_str(epath); warn_print("\n"); } else { const char *tail = 0; long len = elen; if (RSTRING_PTR(epath)[0] == '#') epath = 0; if ((tail = memchr(einfo, '\n', elen)) != 0) { len = tail - einfo; tail++; /* skip newline */ } warn_print_str(tail ? rb_str_subseq(emesg, 0, len) : emesg); if (epath) { warn_print(" ("); warn_print_str(epath); warn_print(")\n"); } if (tail) { warn_print_str(rb_str_subseq(emesg, tail - einfo, elen - len - 1)); } if (tail ? einfo[elen-1] != '\n' : !epath) warn_print2("\n", 1); } } }
static VALUE exc_to_s(VALUE exc) { VALUE mesg = rb_attr_get(exc, rb_intern("mesg")); if (NIL_P(mesg)) return rb_class_name(CLASS_OF(exc)); if (OBJ_TAINTED(exc)) OBJ_TAINT(mesg); return mesg; }
void rb_print_undef(VALUE klass, ID id, int scope) { const char *v = method_scope_name(scope); rb_name_error(id, "undefined%s method `%"PRIsVALUE"' for %s `% "PRIsVALUE"'", v, QUOTE_ID(id), (RB_TYPE_P(klass, T_MODULE)) ? "module" : "class", rb_class_name(klass)); }
static VALUE name_err_to_s(VALUE exc) { VALUE mesg = rb_attr_get(exc, rb_intern("mesg")); VALUE str = mesg; if (NIL_P(mesg)) return rb_class_name(CLASS_OF(exc)); StringValue(str); return str; }
VALUE rb_Fonts_define_shadow_color(VALUE self, VALUE id, VALUE color) { if(rb_obj_is_kind_of(color, rb_cColor) != Qtrue) { rb_raise(rb_eTypeError, "Expected Color got %s.", RSTRING_PTR(rb_class_name(CLASS_OF(color)))); return self; } rb_ary_store(rb_ivar_get(rb_mFonts, rb_Fonts_ivSColor), rb_num2long(id), color); return self; }
static struct uwsgi_buffer *uwsgi_ruby_exception_class(struct wsgi_request *wsgi_req) { VALUE err = rb_errinfo(); VALUE e = rb_class_name(rb_class_of(err)); struct uwsgi_buffer *ub = uwsgi_buffer_new(RSTRING_LEN(e)); if (uwsgi_buffer_append(ub, RSTRING_PTR(e), RSTRING_LEN(e))) { uwsgi_buffer_destroy(ub); return NULL; } return ub; }
void rb_print_inaccessible(VALUE klass, ID id, int scope) { const char *v = method_scope_name(scope); rb_name_error(id, "method `%"PRIsVALUE"' for %s `% "PRIsVALUE"' is %s", QUOTE_ID(id), (RB_TYPE_P(klass, T_MODULE)) ? "module" : "class", rb_class_name(klass), v); }
static VALUE exc_inspect(VALUE exc) { VALUE str, klass; klass = CLASS_OF(exc); exc = rb_obj_as_string(exc); if (RSTRING_LEN(exc) == 0) { return rb_str_dup(rb_class_name(klass)); } str = rb_str_buf_new2("#<"); klass = rb_class_name(klass); rb_str_buf_append(str, klass); rb_str_buf_cat(str, ": ", 2); rb_str_buf_append(str, exc); rb_str_buf_cat(str, ">", 1); return str; }
static VALUE exc_to_s(VALUE exc) { VALUE mesg = rb_attr_get(exc, rb_intern("mesg")); VALUE r = Qnil; if (NIL_P(mesg)) return rb_class_name(CLASS_OF(exc)); r = rb_String(mesg); OBJ_INFECT(r, exc); return r; }
static VALUE name_err_to_s(VALUE exc) { VALUE mesg = rb_attr_get(exc, rb_intern("mesg")), str = mesg; if (NIL_P(mesg)) return rb_class_name(CLASS_OF(exc)); StringValue(str); if (str != mesg) { rb_iv_set(exc, "mesg", mesg = str); } if (OBJ_TAINTED(exc)) OBJ_TAINT(mesg); return mesg; }
static VALUE struct_write(VALUE self, VALUE protocol, protocol_method_table* pmt) { DEBUG_FUNCTION_ENTRY(); // call validate rb_funcall(self, validate_method_id, 0); // write struct begin fastcall_call(pmt->write_struct_begin, protocol, rb_class_name(CLASS_OF(self))); // iterate through all the fields here struct_metadata* md = getStructMetadata(CLASS_OF(self)); int i = 0; for (i=0; i < getMetadataFieldCount(md); i++) { field_metadata* fmd = getFieldMetadataByIndex(md, i); DEBUGF("name=%s", fmd->name); VALUE field_value = rb_ivar_get(self, fmd->name_id); VALUE field_name = rb_str_new_cstr(fmd->name); DEBUGF("type=%d", TYPE(field_value)); DEBUG_FUNCTION_PROGRESS(); if (!NIL_P(field_value)) { DEBUG_FUNCTION_PROGRESS(); fastcall_call(pmt->write_field_begin, protocol, field_name, INT2NUM(fmd->type), INT2NUM(fmd->id)); DEBUG_FUNCTION_PROGRESS(); write_anything(field_value, protocol, fmd, pmt); DEBUG_FUNCTION_PROGRESS(); fastcall_call(pmt->write_field_end, protocol, Qnil); DEBUG_FUNCTION_PROGRESS(); } } DEBUG_FUNCTION_PROGRESS(); fastcall_call(pmt->write_field_stop, protocol, Qnil); DEBUG_FUNCTION_PROGRESS(); // write struct end fastcall_call(pmt->write_struct_end, protocol, Qnil); DEBUG_FUNCTION_PROGRESS(); fastcall_call(pmt->flush, protocol, Qnil); DEBUG_FUNCTION_EXIT(); return Qnil; }
void rb_print_undef(VALUE klass, ID id, int scope) { const char *v; switch (scope) { default: case NOEX_PUBLIC: v = ""; break; case NOEX_PRIVATE: v = " private"; break; case NOEX_PROTECTED: v = " protected"; break; } rb_name_error(id, "undefined%s method `%"PRIsVALUE"' for %s `%"PRIsVALUE"'", v, QUOTE_ID(id), (RB_TYPE_P(klass, T_MODULE)) ? "module" : "class", rb_class_name(klass)); }
// simulate ruby_error_print (this is sad... but it works well) static void uwsgi_ruby_exception_log(struct wsgi_request *wsgi_req) { VALUE err = rb_errinfo(); VALUE eclass = rb_class_name(rb_class_of(err)); VALUE msg = rb_funcall(err, rb_intern("message"), 0, 0); VALUE ary = rb_funcall(err, rb_intern("backtrace"), 0); int i; for (i=0; i<RARRAY_LEN(ary); i++) { if (i == 0) { uwsgi_log("%s: %s (%s)\n", RSTRING_PTR(RARRAY_PTR(ary)[i]), RSTRING_PTR(msg), RSTRING_PTR(eclass)); } else { uwsgi_log("\tfrom %s\n", RSTRING_PTR(RARRAY_PTR(ary)[i])); } } }
static VALUE inspect_struct(VALUE s, VALUE dummy, int recur) { VALUE cname = rb_class_name(rb_obj_class(s)); VALUE members, str = rb_str_new2("#<struct "); VALUE *ptr, *ptr_members; long i, len; char first = RSTRING_PTR(cname)[0]; if (recur || first != '#') { rb_str_append(str, cname); } if (recur) { return rb_str_cat2(str, ":...>"); } members = rb_struct_members(s); ptr_members = RARRAY_PTR(members); ptr = RSTRUCT_PTR(s); len = RSTRUCT_LEN(s); for (i=0; i<len; i++) { VALUE slot; ID id; if (i > 0) { rb_str_cat2(str, ", "); } else if (first != '#') { rb_str_cat2(str, " "); } slot = ptr_members[i]; id = SYM2ID(slot); if (rb_is_local_id(id) || rb_is_const_id(id)) { rb_str_append(str, rb_id2str(id)); } else { rb_str_append(str, rb_inspect(slot)); } rb_str_cat2(str, "="); rb_str_append(str, rb_inspect(ptr[i])); } rb_str_cat2(str, ">"); OBJ_INFECT(str, s); return str; }
/* :nodoc: */ static VALUE name_err_mesg_to_str(VALUE obj) { VALUE *ptr, mesg; TypedData_Get_Struct(obj, VALUE, &name_err_mesg_data_type, ptr); mesg = ptr[0]; if (NIL_P(mesg)) return Qnil; else { const char *desc = 0; VALUE d = 0, args[NAME_ERR_MESG_COUNT]; int state = 0; obj = ptr[1]; switch (obj) { case Qnil: desc = "nil"; break; case Qtrue: desc = "true"; break; case Qfalse: desc = "false"; break; default: d = rb_protect(rb_inspect, obj, &state); if (state) rb_set_errinfo(Qnil); if (NIL_P(d) || RSTRING_LEN(d) > 65) { d = rb_any_to_s(obj); } desc = RSTRING_PTR(d); break; } if (desc && desc[0] != '#') { d = d ? rb_str_dup(d) : rb_str_new2(desc); rb_str_cat2(d, ":"); rb_str_append(d, rb_class_name(CLASS_OF(obj))); } args[0] = mesg; args[1] = ptr[2]; args[2] = d; mesg = rb_f_sprintf(NAME_ERR_MESG_COUNT, args); } return mesg; }
static VALUE rb_thrift_struct_write(VALUE self, VALUE protocol) { // call validate rb_funcall(self, validate_method_id, 0); // check_native_proto_method_table(protocol); // write struct begin mt->write_struct_begin(protocol, rb_class_name(CLASS_OF(self))); // iterate through all the fields here VALUE struct_fields = STRUCT_FIELDS(self); VALUE struct_field_ids_unordered = rb_funcall(struct_fields, keys_method_id, 0); VALUE struct_field_ids_ordered = rb_funcall(struct_field_ids_unordered, sort_method_id, 0); int i = 0; for (i=0; i < RARRAY_LEN(struct_field_ids_ordered); i++) { VALUE field_id = rb_ary_entry(struct_field_ids_ordered, i); VALUE field_info = rb_hash_aref(struct_fields, field_id); VALUE ttype_value = rb_hash_aref(field_info, type_sym); int ttype = FIX2INT(ttype_value); VALUE field_name = rb_hash_aref(field_info, name_sym); VALUE field_value = get_field_value(self, field_name); if (!NIL_P(field_value)) { mt->write_field_begin(protocol, field_name, ttype_value, field_id); write_anything(ttype, field_value, protocol, field_info); mt->write_field_end(protocol); } } mt->write_field_stop(protocol); // write struct end mt->write_struct_end(protocol); return Qnil; }
/* * call-seq: to_native(value, ctx) * @param [nil, Struct] value * @param [nil] ctx * @return [AbstractMemory] Pointer on +value+. */ static VALUE sbr_to_native(VALUE self, VALUE value, VALUE ctx) { StructByReference* sbr; Struct* s; if (unlikely(value == Qnil)) { return rbffi_NullPointerSingleton; } Data_Get_Struct(self, StructByReference, sbr); if (!rb_obj_is_kind_of(value, sbr->rbStructClass)) { rb_raise(rb_eTypeError, "wrong argument type %s (expected %s)", rb_obj_classname(value), RSTRING_PTR(rb_class_name(sbr->rbStructClass))); } Data_Get_Struct(value, Struct, s); return s->rbPointer; }
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); }
VALUE rb_thread_current_status(const rb_thread_t *th) { const rb_control_frame_t *cfp = th->cfp; VALUE str = Qnil; if (cfp->iseq != 0) { if (cfp->pc != 0) { rb_iseq_t *iseq = cfp->iseq; int line_no = rb_vm_get_sourceline(cfp); char *file = RSTRING_PTR(iseq->filename); str = rb_sprintf("%s:%d:in `%s'", file, line_no, RSTRING_PTR(iseq->name)); } } else if (cfp->me->def->original_id) { str = rb_sprintf("`%s#%s' (cfunc)", RSTRING_PTR(rb_class_name(cfp->me->klass)), rb_id2name(cfp->me->def->original_id)); } return str; }
static VALUE class_spec_rb_class_name(VALUE self, VALUE klass) { return rb_class_name(klass); }
void rb_threadptr_error_print(rb_thread_t *th, VALUE errinfo) { volatile VALUE errat = Qundef; int raised_flag = th->raised_flag; volatile VALUE eclass = Qundef, e = Qundef; const char *volatile einfo; volatile long elen; VALUE mesg; if (NIL_P(errinfo)) return; rb_thread_raised_clear(th); TH_PUSH_TAG(th); if (TH_EXEC_TAG() == 0) { errat = rb_get_backtrace(errinfo); } else if (errat == Qundef) { errat = Qnil; } else if (eclass == Qundef || e != Qundef) { goto error; } else { goto no_message; } if (NIL_P(errat) || RARRAY_LEN(errat) == 0 || NIL_P(mesg = RARRAY_AREF(errat, 0))) { error_pos(); } else { warn_print_str(mesg); warn_print(": "); } eclass = CLASS_OF(errinfo); if (eclass != Qundef && (e = rb_check_funcall(errinfo, rb_intern("message"), 0, 0)) != Qundef && (RB_TYPE_P(e, T_STRING) || !NIL_P(e = rb_check_string_type(e)))) { einfo = RSTRING_PTR(e); elen = RSTRING_LEN(e); } else { no_message: einfo = ""; elen = 0; } if (eclass == rb_eRuntimeError && elen == 0) { warn_print("unhandled exception\n"); } else { VALUE epath; epath = rb_class_name(eclass); if (elen == 0) { warn_print_str(epath); warn_print("\n"); } else { const char *tail = 0; long len = elen; if (RSTRING_PTR(epath)[0] == '#') epath = 0; if ((tail = memchr(einfo, '\n', elen)) != 0) { len = tail - einfo; tail++; /* skip newline */ } warn_print_str(tail ? rb_str_subseq(e, 0, len) : e); if (epath) { warn_print(" ("); warn_print_str(epath); warn_print(")\n"); } if (tail) { warn_print_str(rb_str_subseq(e, tail - einfo, elen - len - 1)); } if (tail ? einfo[elen-1] != '\n' : !epath) warn_print2("\n", 1); } } if (!NIL_P(errat)) { long i; long len = RARRAY_LEN(errat); int skip = eclass == rb_eSysStackError; #define TRACE_MAX (TRACE_HEAD+TRACE_TAIL+5) #define TRACE_HEAD 8 #define TRACE_TAIL 5 for (i = 1; i < len; i++) { VALUE line = RARRAY_AREF(errat, i); if (RB_TYPE_P(line, T_STRING)) { warn_print_str(rb_sprintf("\tfrom %"PRIsVALUE"\n", line)); } if (skip && i == TRACE_HEAD && len > TRACE_MAX) { warn_print_str(rb_sprintf("\t ... %ld levels...\n", len - TRACE_HEAD - TRACE_TAIL)); i = len - TRACE_TAIL; } } } error: TH_POP_TAG(); th->errinfo = errinfo; rb_thread_raised_set(th, raised_flag); }
const char * rb_class2name(VALUE klass) { return RSTRING_PTR(rb_class_name(klass)); }
const char * rb_class2name(VALUE klass) { VALUE name = rb_class_name(klass); return RSTRING_PTR(name); }
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; }
static void error_print(void) { volatile VALUE errat = Qnil; /* OK */ VALUE errinfo = GET_THREAD()->errinfo; volatile VALUE eclass, e; const char *volatile einfo; volatile long elen; if (NIL_P(errinfo)) return; PUSH_TAG(); if (EXEC_TAG() == 0) { errat = get_backtrace(errinfo); } else { errat = Qnil; } if (EXEC_TAG()) goto error; if (NIL_P(errat)) { const char *file = rb_sourcefile(); int line = rb_sourceline(); if (!file) warn_printf("%d", line); else if (!line) warn_printf("%s", file); else warn_printf("%s:%d", file, line); } else if (RARRAY_LEN(errat) == 0) { error_pos(); } else { VALUE mesg = RARRAY_PTR(errat)[0]; if (NIL_P(mesg)) error_pos(); else { warn_print2(RSTRING_PTR(mesg), RSTRING_LEN(mesg)); } } eclass = CLASS_OF(errinfo); if (EXEC_TAG() == 0) { e = rb_funcall(errinfo, rb_intern("message"), 0, 0); StringValue(e); einfo = RSTRING_PTR(e); elen = RSTRING_LEN(e); } else { einfo = ""; elen = 0; } if (EXEC_TAG()) goto error; if (eclass == rb_eRuntimeError && elen == 0) { warn_print(": unhandled exception\n"); } else { VALUE epath; epath = rb_class_name(eclass); if (elen == 0) { warn_print(": "); warn_print2(RSTRING_PTR(epath), RSTRING_LEN(epath)); warn_print("\n"); } else { char *tail = 0; long len = elen; if (RSTRING_PTR(epath)[0] == '#') epath = 0; if ((tail = memchr(einfo, '\n', elen)) != 0) { len = tail - einfo; tail++; /* skip newline */ } warn_print(": "); warn_print2(einfo, len); if (epath) { warn_print(" ("); warn_print2(RSTRING_PTR(epath), RSTRING_LEN(epath)); warn_print(")\n"); } if (tail) { warn_print2(tail, elen - len - 1); if (einfo[elen-1] != '\n') warn_print2("\n", 1); } } } if (!NIL_P(errat)) { long i; long len = RARRAY_LEN(errat); VALUE *ptr = RARRAY_PTR(errat); int skip = eclass == rb_eSysStackError; #define TRACE_MAX (TRACE_HEAD+TRACE_TAIL+5) #define TRACE_HEAD 8 #define TRACE_TAIL 5 for (i = 1; i < len; i++) { if (TYPE(ptr[i]) == T_STRING) { warn_printf("\tfrom %s\n", RSTRING_PTR(ptr[i])); } if (skip && i == TRACE_HEAD && len > TRACE_MAX) { warn_printf("\t ... %ld levels...\n", len - TRACE_HEAD - TRACE_TAIL); i = len - TRACE_TAIL; } } } error: POP_TAG(); }