VALUE
rb_class_path(VALUE klass)
{
VALUE path = classname(klass);
st_data_t n = (st_data_t)path;
if (!NIL_P(path)) return path;
if (RCLASS_IV_TBL(klass) && st_lookup(RCLASS_IV_TBL(klass),
(st_data_t)tmp_classpath, &n)) {
return (VALUE)n;
}
else {
const char *s = "Class";
if (TYPE(klass) == T_MODULE) {
if (rb_obj_class(klass) == rb_cModule) {
s = "Module";
}
else {
s = rb_class2name(RBASIC(klass)->klass);
}
}
path = rb_sprintf("#<%s:%p>", s, (void*)klass);
OBJ_FREEZE(path);
rb_ivar_set(klass, tmp_classpath, path);
return path;
}
}
VALUE
rb_class_path(VALUE klass)
{
VALUE path = classname(klass);
if (!NIL_P(path)) return path;
if ((path = rb_attr_get(klass, tmp_classpath)) != Qnil) {
return path;
}
else {
const char *s = "Class";
if (TYPE(klass) == T_MODULE) {
if (rb_obj_class(klass) == rb_cModule) {
s = "Module";
}
else {
s = rb_class2name(RBASIC(klass)->klass);
}
}
path = rb_sprintf("#<%s:%p>", s, (void*)klass);
OBJ_FREEZE(path);
rb_ivar_set(klass, tmp_classpath, path);
return path;
}
}
static VALUE rd_die_inspect(VALUE self)
{
rd_die_t *die = GetDie(self);
char *name;
Dwarf_Off dieoff = 0;
Dwarf_Error err;
dwarf_dieoffset(die->die, &dieoff, &err);
switch (dwarf_diename(die->die, &name, &err)) {
case DW_DLV_OK:
return rb_sprintf("#<%s:(%llu) '%s'>", rb_obj_classname(self), dieoff, name);
default:
return rb_sprintf("#<%s:(%llu)>", rb_obj_classname(self), dieoff);
}
}
static int
load_encoding(const char *name)
{
VALUE enclib = rb_sprintf("enc/%s.so", name);
VALUE verbose = ruby_verbose;
VALUE debug = ruby_debug;
VALUE errinfo;
char *s = RSTRING_PTR(enclib) + 4, *e = RSTRING_END(enclib) - 3;
int loaded;
int idx;
while (s < e) {
if (!ISALNUM(*s)) *s = '_';
else if (ISUPPER(*s)) *s = (char)TOLOWER(*s);
++s;
}
FL_UNSET(enclib, FL_TAINT);
enclib = rb_fstring(enclib);
ruby_verbose = Qfalse;
ruby_debug = Qfalse;
errinfo = rb_errinfo();
loaded = rb_require_internal(enclib, rb_safe_level());
ruby_verbose = verbose;
ruby_debug = debug;
rb_set_errinfo(errinfo);
if (loaded < 0 || 1 < loaded) return -1;
if ((idx = rb_enc_registered(name)) < 0) return -1;
if (enc_autoload_p(enc_table.list[idx].enc)) return -1;
return idx;
}
/* :nodoc: */
static VALUE
path_inspect(VALUE self)
{
const char *c = rb_obj_classname(self);
VALUE str = get_strpath(self);
return rb_sprintf("#<%s:%"PRIsVALUE">", c, str);
}
static int
load_encoding(const char *name)
{
VALUE enclib = rb_sprintf("enc/%s.so", name);
VALUE verbose = ruby_verbose;
VALUE debug = ruby_debug;
VALUE loaded;
char *s = RSTRING_PTR(enclib) + 4, *e = RSTRING_END(enclib) - 3;
int idx;
while (s < e) {
if (!ISALNUM(*s)) *s = '_';
else if (ISUPPER(*s)) *s = TOLOWER(*s);
++s;
}
OBJ_FREEZE(enclib);
ruby_verbose = Qfalse;
ruby_debug = Qfalse;
loaded = rb_protect(require_enc, enclib, 0);
ruby_verbose = verbose;
ruby_debug = debug;
rb_set_errinfo(Qnil);
if (NIL_P(loaded)) return -1;
if ((idx = rb_enc_registered(name)) < 0) return -1;
if (enc_autoload_p(enc_table.list[idx].enc)) return -1;
return idx;
}
// View#inspect
// View#to_s
VALUE rbView::Inspect( VALUE aSelf )
{
VALUE viewportString = rb_funcall( rbView::GetViewport( aSelf ), rb_intern( "insepct" ), 0 );
return rb_sprintf( "%s(%s)",
rb_obj_classname( aSelf ),
StringValueCStr( viewportString ) );
}
/*
* call-seq:
* inspect -> String
*
* Human-readable description.
* ===Return value
* String
*/
DLL_LOCAL VALUE _inspect(VALUE self)
{
return rb_sprintf( "%s(%d, %d)",
rb_obj_classname( self ),
RB_NUM2INT(_getWidth(self)),
RB_NUM2INT(_getHeight(self)));
}
/* :nodoc: */
static VALUE
path_inspect(VALUE self)
{
const char *c = rb_obj_classname(self);
VALUE str = get_strpath(self);
return rb_sprintf("#<%s:%s>", c, RSTRING_PTR(str));
}
/*
* m_ison added by Darren Reed 13/8/91 to act as an efficent user indicator
* with respect to cpu/bandwidth used. Implemented for NOTIFY feature in
* clients. Designed to reduce number of whois requests. Can process
* nicknames in batches as long as the maximum buffer length.
*
* format:
* ISON :nicklist
*/
static int
m_ison(struct Client *client_p, struct Client *source_p, int parc, const char *parv[])
{
struct Client *target_p;
char *nick;
char *p;
char *current_insert_point, *current_insert_point2;
int len;
int i;
int done = 0;
current_insert_point2 = buf2;
*buf2 = '\0';
rb_sprintf(buf, form_str(RPL_ISON), me.name, source_p->name);
len = strlen(buf);
current_insert_point = buf + len;
/* rfc1489 is ambigious about how to handle ISON
* this should handle both interpretations.
*/
for(i = 1; i < parc; i++)
{
char *cs = LOCAL_COPY(parv[i]);
for(nick = rb_strtok_r(cs, " ", &p); nick; nick = rb_strtok_r(NULL, " ", &p))
{
target_p = find_named_client(nick);
if(target_p != NULL)
{
len = strlen(target_p->name);
if((current_insert_point + (len + 5)) < (buf + sizeof(buf)))
{
memcpy(current_insert_point, target_p->name, len);
current_insert_point += len;
*current_insert_point++ = ' ';
}
else
{
done = 1;
break;
}
}
}
if(done)
break;
}
/* current_insert_point--;
* Do NOT take out the trailing space, it breaks ircII
* --Rodder */
*current_insert_point = '\0';
*current_insert_point2 = '\0';
sendto_one_buffer(source_p, buf);
return 0;
}
static VALUE
tracepoint_inspect(VALUE self)
{
rb_tp_t *tp = tpptr(self);
rb_trace_arg_t *trace_arg = GET_THREAD()->trace_arg;
if (trace_arg) {
switch (trace_arg->event) {
case RUBY_EVENT_LINE:
case RUBY_EVENT_SPECIFIED_LINE:
{
VALUE sym = rb_tracearg_method_id(trace_arg);
if (NIL_P(sym))
goto default_inspect;
return rb_sprintf("#<TracePoint:%"PRIsVALUE"@%"PRIsVALUE":%d in `%"PRIsVALUE"'>",
rb_tracearg_event(trace_arg),
rb_tracearg_path(trace_arg),
FIX2INT(rb_tracearg_lineno(trace_arg)),
sym);
}
case RUBY_EVENT_CALL:
case RUBY_EVENT_C_CALL:
case RUBY_EVENT_RETURN:
case RUBY_EVENT_C_RETURN:
return rb_sprintf("#<TracePoint:%"PRIsVALUE" `%"PRIsVALUE"'@%"PRIsVALUE":%d>",
rb_tracearg_event(trace_arg),
rb_tracearg_method_id(trace_arg),
rb_tracearg_path(trace_arg),
FIX2INT(rb_tracearg_lineno(trace_arg)));
case RUBY_EVENT_THREAD_BEGIN:
case RUBY_EVENT_THREAD_END:
return rb_sprintf("#<TracePoint:%"PRIsVALUE" %"PRIsVALUE">",
rb_tracearg_event(trace_arg),
rb_tracearg_self(trace_arg));
default:
default_inspect:
return rb_sprintf("#<TracePoint:%"PRIsVALUE"@%"PRIsVALUE":%d>",
rb_tracearg_event(trace_arg),
rb_tracearg_path(trace_arg),
FIX2INT(rb_tracearg_lineno(trace_arg)));
}
}
else {
return rb_sprintf("#<TracePoint:%s>", tp->tracing ? "enabled" : "disabled");
}
}
static int ov_http_client_add_header(VALUE name, VALUE value, struct curl_slist** headers) {
VALUE header = Qnil;
header = rb_sprintf("%"PRIsVALUE": %"PRIsVALUE"", name, value);
*headers = curl_slist_append(*headers, StringValueCStr(header));
return ST_CONTINUE;
}
static VALUE
iow_inspect(VALUE self)
{
VALUE obj = (VALUE)DATA_PTR(self);
VALUE type = type2sym(BUILTIN_TYPE(obj));
return rb_sprintf("#<InternalObject:%p %s>", (void *)obj, rb_id2name(SYM2ID(type)));
}
static VALUE
esignal_init(int argc, VALUE *argv, VALUE self)
{
int argnum = 1;
VALUE sig = Qnil;
int signo;
const char *signm;
if (argc > 0) {
sig = rb_check_to_integer(argv[0], "to_int");
if (!NIL_P(sig)) argnum = 2;
else sig = argv[0];
}
rb_check_arity(argc, 1, argnum);
if (argnum == 2) {
signo = NUM2INT(sig);
if (signo < 0 || signo > NSIG) {
rb_raise(rb_eArgError, "invalid signal number (%d)", signo);
}
if (argc > 1) {
sig = argv[1];
}
else {
signm = signo2signm(signo);
if (signm) {
sig = rb_sprintf("SIG%s", signm);
}
else {
sig = rb_sprintf("SIG%u", signo);
}
}
}
else {
signm = SYMBOL_P(sig) ? rb_id2name(SYM2ID(sig)) : StringValuePtr(sig);
if (strncmp(signm, "SIG", 3) == 0) signm += 3;
signo = signm2signo(signm);
if (!signo) {
rb_raise(rb_eArgError, "unsupported name `SIG%s'", signm);
}
sig = rb_sprintf("SIG%s", signm);
}
rb_call_super(1, &sig);
rb_iv_set(self, "signo", INT2NUM(signo));
return self;
}
/* See Object#inspect. */
static VALUE
iow_inspect(VALUE self)
{
VALUE obj = (VALUE)DATA_PTR(self);
VALUE type = type2sym(BUILTIN_TYPE(obj));
return rb_sprintf("#<InternalObject:%p %"PRIsVALUE">", (void *)obj, rb_sym2str(type));
}
// RenderTexture#inspect
// RenderTexture#to_s
VALUE rbRenderTexture::Inspect( VALUE aSelf )
{
return rb_sprintf( "%s(%ix%i, %p)",
rb_obj_classname( aSelf ),
rbMacros::ToSFML< sf::RenderTexture >( aSelf, rbRenderTexture::Class )->getSize().x,
rbMacros::ToSFML< sf::RenderTexture >( aSelf, rbRenderTexture::Class )->getSize().y,
rbMacros::ToSFML< sf::RenderTexture >( aSelf, rbRenderTexture::Class ) );
}
static void showExc(VALUE exc, const BacktraceData &btData)
{
VALUE bt = rb_funcall2(exc, rb_intern("backtrace"), 0, NULL);
VALUE msg = rb_funcall2(exc, rb_intern("message"), 0, NULL);
VALUE bt0 = rb_ary_entry(bt, 0);
VALUE name = rb_class_path(rb_obj_class(exc));
VALUE ds = rb_sprintf("%" PRIsVALUE ": %" PRIsVALUE " (%" PRIsVALUE ")",
bt0, exc, name);
/* omit "useless" last entry (from ruby:1:in `eval') */
for (long i = 1, btlen = RARRAY_LEN(bt) - 1; i < btlen; ++i)
rb_str_catf(ds, "\n\tfrom %" PRIsVALUE, rb_ary_entry(bt, i));
Debug() << StringValueCStr(ds);
char *s = RSTRING_PTR(bt0);
char line[16];
std::string file(512, '\0');
char *p = s + strlen(s);
char *e;
while (p != s)
if (*--p == ':')
break;
e = p;
while (p != s)
if (*--p == ':')
break;
/* s p e
* SectionXXX:YY: in 'blabla' */
*e = '\0';
strncpy(line, *p ? p+1 : p, sizeof(line));
line[sizeof(line)-1] = '\0';
*e = ':';
e = p;
/* s e
* SectionXXX:YY: in 'blabla' */
*e = '\0';
strncpy(&file[0], s, file.size());
*e = ':';
/* Shrink to fit */
file.resize(strlen(file.c_str()));
file = btData.scriptNames.value(file, file);
std::string ms(640, '\0');
snprintf(&ms[0], ms.size(), "Script '%s' line %s: %s occured.\n\n%s",
file.c_str(), line, RSTRING_PTR(name), RSTRING_PTR(msg));
showMsg(ms);
}
/*
* call-seq:
* enc.inspect -> string
*
* Returns a string which represents the encoding for programmers.
*
* Encoding::UTF_8.inspect #=> "#<Encoding:UTF-8>"
* Encoding::ISO_2022_JP.inspect #=> "#<Encoding:ISO-2022-JP (dummy)>"
*/
static VALUE
enc_inspect(VALUE self)
{
VALUE str = rb_sprintf("#<%s:%s%s>", rb_obj_classname(self),
rb_enc_name((rb_encoding*)DATA_PTR(self)),
(enc_dummy_p(self) ? " (dummy)" : ""));
ENCODING_CODERANGE_SET(str, rb_usascii_encindex(), ENC_CODERANGE_7BIT);
return str;
}
static VALUE
ossl_engine_inspect(VALUE self)
{
ENGINE *e;
GetEngine(self, e);
return rb_sprintf("#<%"PRIsVALUE" id=\"%s\" name=\"%s\">",
RB_OBJ_CLASSNAME(self), ENGINE_get_id(e), ENGINE_get_name(e));
}
/*
* call-seq:
* inspect -> String
*
* Human-readable description.
* ===Return value
* String
*/
VALUE _inspect(VALUE self)
{
rb_sprintf("%s(%f, %f, %f, %f)",
rb_obj_classname(self),
NUM2DBL(_get_left(self)),
NUM2DBL(_get_top(self)),
NUM2DBL(_get_width(self)),
NUM2DBL(_get_height(self)));
}
/*
* call-seq:
* inspect -> String
*
* Human-readable description.
* ===Return value
* String
*/
VALUE _inspect(VALUE self)
{
return rb_sprintf( "%s(%i, %i, %i, %i)",
rb_obj_classname( self ),
FIX2INT(_get_r(self)),
FIX2INT(_get_g(self)),
FIX2INT(_get_b(self)),
FIX2INT(_get_a(self)));
}
static char *
set_flags_to_string(struct Client *client_p)
{
/* XXX - list all flags that we have set on the client */
static char setflags[BUFSIZE + 1];
int i;
/* Clear it to begin with, we'll be doing a lot of rb_sprintf's */
setflags[0] = '\0';
/* Unlike unset_flags_to_string(), we don't have to care about oper
** flags and not showing them
*/
if(client_p->umodes & UMODE_OPERWALL)
{
rb_sprintf(setflags, "%s %s", setflags, "OWALLOPS");
}
for(i = 0; flag_table[i].name; i++)
{
if(client_p->umodes & flag_table[i].mode)
{
rb_sprintf(setflags, "%s %s", setflags, flag_table[i].name);
}
}
#if 0
if(IsOper(client_p) && IsOperN(client_p))
{
#endif
/* You can only be set +NICKCHANGES if you are an oper and
** IsOperN(client_p) is true
*/
if(client_p->umodes & UMODE_NCHANGE)
{
rb_sprintf(setflags, "%s %s", setflags, "NICKCHANGES");
}
#if 0
}
#endif
return setflags;
}
static char *
unset_flags_to_string(struct Client *client_p)
{
/* Inverse of above */
/* XXX - list all flags that we do NOT have set on the client */
static char setflags[BUFSIZE + 1];
int i, isoper;
/* Clear it to begin with, we'll be doing a lot of rb_sprintf's */
setflags[0] = '\0';
if(IsOper(client_p))
isoper = 1;
else
isoper = 0;
if(IsOper(client_p) && IsOperOperwall(client_p))
{
if(!(client_p->umodes & UMODE_OPERWALL))
{
rb_sprintf(setflags, "%s %s", setflags, "OWALLOPS");
}
}
for(i = 0; flag_table[i].name; i++)
{
if(!(client_p->umodes & flag_table[i].mode))
{
if(!isoper && flag_table[i].oper)
continue;
rb_sprintf(setflags, "%s %s", setflags, flag_table[i].name);
}
}
if(IsOper(client_p) && IsOperN(client_p))
{
if(!(client_p->umodes & UMODE_NCHANGE))
{
rb_sprintf(setflags, "%s %s", setflags, "NICKCHANGES");
}
}
return setflags;
}
VALUE rb_explain( VALUE klass, VALUE rb_rank ){
int rank = NUM2INT( rb_rank );
int category = rank >> 12;
int rank_in_category = rank & 0x00000FFF;
VALUE category_key = rb_category_key( klass, rb_rank );
VALUE result = rb_sprintf( "The hand is a %"PRIsVALUE"\nRank: %d Category: %d Rank in category: %d", category_key, rank, category, rank_in_category );
return result;
}
VALUE
rb_fairy_string_buffer_inspect(VALUE self)
{
fairy_string_buffer_t *sb;
VALUE str;
GetFairyStringBufferPtr(self, sb);
str = rb_sprintf("<%s:%x size=%d>", rb_obj_classname(self), (void*)self, sb->size);
return str;
}
static VALUE
syserr_initialize(int argc, VALUE *argv, VALUE self)
{
#if !defined(_WIN32)
char *strerror();
#endif
const char *err;
VALUE mesg, error;
VALUE klass = rb_obj_class(self);
if (klass == rb_eSystemCallError) {
st_data_t data = (st_data_t)klass;
rb_scan_args(argc, argv, "11", &mesg, &error);
if (argc == 1 && FIXNUM_P(mesg)) {
error = mesg; mesg = Qnil;
}
if (!NIL_P(error) && st_lookup(syserr_tbl, NUM2LONG(error), &data)) {
klass = (VALUE)data;
/* change class */
if (TYPE(self) != T_OBJECT) { /* insurance to avoid type crash */
rb_raise(rb_eTypeError, "invalid instance type");
}
RBASIC(self)->klass = klass;
}
}
else {
rb_scan_args(argc, argv, "01", &mesg);
error = rb_const_get(klass, rb_intern("Errno"));
}
if (!NIL_P(error)) err = strerror(NUM2INT(error));
else err = "unknown error";
if (!NIL_P(mesg)) {
rb_encoding *le = rb_locale_encoding();
VALUE str = mesg;
StringValue(str);
mesg = rb_sprintf("%s - %.*s", err,
(int)RSTRING_LEN(str), RSTRING_PTR(str));
if (le == rb_usascii_encoding()) {
rb_encoding *me = rb_enc_get(mesg);
if (le != me && rb_enc_asciicompat(me))
le = me;
}/* else assume err is non ASCII string. */
OBJ_INFECT(mesg, str);
rb_enc_associate(mesg, le);
}
else {
mesg = rb_str_new2(err);
rb_enc_associate(mesg, rb_locale_encoding());
}
rb_call_super(1, &mesg);
rb_iv_set(self, "errno", error);
return self;
}
// Vertex#inspect
// Vertex#to_s
VALUE rbVertex::Inspect( VALUE aSelf )
{
VALUE position = rb_funcall( rbVertex::GetPosition( aSelf ), rb_intern( "inspect" ), 0 );
VALUE color = rb_funcall( rbVertex::GetColor( aSelf ), rb_intern( "inspect" ), 0 );
VALUE texCoords = rb_funcall( rbVertex::GetTexCoords( aSelf ), rb_intern( "inspect" ), 0 );
return rb_sprintf( "%s(%s, %s, %s)",
rb_obj_classname( aSelf ),
StringValueCStr( position ),
StringValueCStr( color ),
StringValueCStr( texCoords ) );
}
static VALUE
inspect_struct(VALUE s, VALUE dummy, int recur)
{
const char *cname = rb_class2name(rb_obj_class(s));
VALUE str, members;
long i;
if (recur) {
return rb_sprintf("#<struct %s:...>", cname);
}
members = rb_struct_members(s);
if (cname[0] == '#') {
str = rb_str_new2("#<struct ");
}
else {
str = rb_sprintf("#<struct %s ", cname);
}
for (i=0; i<RSTRUCT_LEN(s); i++) {
VALUE slot;
ID id;
if (i > 0) {
rb_str_cat2(str, ", ");
}
slot = RARRAY_AT(members, i);
id = SYM2ID(slot);
if (rb_is_local_id(id) || rb_is_const_id(id)) {
rb_str_buf_append(str, rb_id2str(id));
}
else {
rb_str_buf_append(str, rb_inspect(slot));
}
rb_str_cat2(str, "=");
rb_str_buf_append(str, rb_inspect(RSTRUCT_PTR(s)[i]));
}
rb_str_cat2(str, ">");
OBJ_INFECT(str, s);
return str;
}
static VALUE rd_attr_inspect(VALUE self)
{
rd_attr_t *attr = GetAttr(self);
Dwarf_Half form;
Dwarf_Error err;
const char *form_name = "?";
if (dwarf_whatform(attr->attr, &form, &err) == DW_DLV_OK) {
dwarf_get_FORM_name(form, &form_name);
}
return rb_sprintf("#<%s: %s>", rb_obj_classname(self), form_name);
}
static VALUE
rb_rubype_assert_rtn_type(VALUE self, VALUE rtn)
{
VALUE target;
assing_ivars
if (unmatch_type_p(rtn, rtn_type)){
target = rb_sprintf("%"PRIsVALUE"#%"PRIsVALUE"'s return", meth_caller, meth);
rb_raise(rb_eRubypeReturnTypeError, error_fmt, target, expected_mes(rtn_type), rtn);
}
return rtn;
}
