/* * call-seq: configure(opts) * * Configure this State instance with the Hash _opts_, and return * itself. */ static inline VALUE cState_configure(VALUE self, VALUE opts) { VALUE tmp; GET_STATE(self); tmp = rb_convert_type(opts, T_HASH, "Hash", "to_hash"); if (NIL_P(tmp)) tmp = rb_convert_type(opts, T_HASH, "Hash", "to_h"); if (NIL_P(tmp)) { rb_raise(rb_eArgError, "opts has to be hash like or convertable into a hash"); } opts = tmp; tmp = rb_hash_aref(opts, ID2SYM(i_indent)); if (RTEST(tmp)) { Check_Type(tmp, T_STRING); state->indent = tmp; } tmp = rb_hash_aref(opts, ID2SYM(i_space)); if (RTEST(tmp)) { Check_Type(tmp, T_STRING); state->space = tmp; } tmp = rb_hash_aref(opts, ID2SYM(i_space_before)); if (RTEST(tmp)) { Check_Type(tmp, T_STRING); state->space_before = tmp; } tmp = rb_hash_aref(opts, ID2SYM(i_array_nl)); if (RTEST(tmp)) { Check_Type(tmp, T_STRING); state->array_nl = tmp; } tmp = rb_hash_aref(opts, ID2SYM(i_object_nl)); if (RTEST(tmp)) { Check_Type(tmp, T_STRING); state->object_nl = tmp; } tmp = ID2SYM(i_check_circular); if (st_lookup(RHASH_TBL(opts), tmp, 0)) { tmp = rb_hash_aref(opts, ID2SYM(i_check_circular)); state->check_circular = RTEST(tmp); } else { state->check_circular = 1; } tmp = ID2SYM(i_max_nesting); state->max_nesting = 19; if (st_lookup(RHASH_TBL(opts), tmp, 0)) { VALUE max_nesting = rb_hash_aref(opts, tmp); if (RTEST(max_nesting)) { Check_Type(max_nesting, T_FIXNUM); state->max_nesting = FIX2LONG(max_nesting); } else { state->max_nesting = 0; } } tmp = rb_hash_aref(opts, ID2SYM(i_allow_nan)); state->allow_nan = RTEST(tmp); return self; }
extern VALUE StringValueEx(VALUE vobj){ if (rb_respond_to(vobj, rb_intern("to_tokyo_tyrant"))) { return rb_convert_type(vobj, T_STRING, "String", "to_tokyo_tyrant"); } else if (rb_respond_to(vobj, rb_intern("to_s"))) { return rb_convert_type(vobj, T_STRING, "String", "to_s"); } else { rb_raise(rb_eArgError, "can't stringify object"); } return StringValue(vobj); }
static VALUE console_cursor_set(VALUE io, VALUE cpos) { cpos = rb_convert_type(cpos, T_ARRAY, "Array", "to_ary"); if (RARRAY_LEN(cpos) != 2) rb_raise(rb_eArgError, "expected 2D coordinate"); return console_goto(io, RARRAY_AREF(cpos, 0), RARRAY_AREF(cpos, 1)); }
// TODO: merge out and mout? static VALUE mTokyoMessenger_outlist(int argc, VALUE *argv, VALUE vself){ VALUE vkeys, vary, vvalue; TCLIST *list, *result; TCRDB *db = mTokyoMessenger_getdb(vself); rb_scan_args(argc, argv, "*", &vkeys); // I really hope there is a better way to do this if (RARRAY_LEN(vkeys) == 1) { vvalue = rb_ary_entry(vkeys, 0); switch (TYPE(vvalue)){ case T_STRING: case T_FIXNUM: break; case T_ARRAY: vkeys = vvalue; break; case T_OBJECT: vkeys = rb_convert_type(vvalue, T_ARRAY, "Array", "to_a"); break; } } Check_Type(vkeys, T_ARRAY); list = varytolist(vkeys); result = tcrdbmisc(db, "outlist", 0, list); tclistdel(list); vary = listtovary(result); tclistdel(result); return vary; }
/** * call-seq: * Coolio::StatWatcher.initialize(path, interval = 0) -> Coolio::StatWatcher * * Create a new Coolio::StatWatcher for the given path. This will monitor the * given path for changes at the filesystem level. The interval argument * specified how often in seconds the path should be polled for changes. * Setting interval to zero uses an "automatic" value (typically around 5 * seconds) which optimizes performance. Otherwise, values less than * 0.1 are not particularly meaningful. Where available (at present, on Linux) * high performance file monitoring interfaces will be used instead of polling. */ static VALUE Coolio_StatWatcher_initialize(int argc, VALUE *argv, VALUE self) { VALUE path, interval; struct Coolio_Watcher *watcher_data; rb_scan_args(argc, argv, "11", &path, &interval); if(interval != Qnil) interval = rb_convert_type(interval, T_FLOAT, "Float", "to_f"); path = rb_String(path); rb_iv_set(self, "@path", path); Data_Get_Struct(self, struct Coolio_Watcher, watcher_data); watcher_data->dispatch_callback = Coolio_StatWatcher_dispatch_callback; ev_stat_init( &watcher_data->event_types.ev_stat, Coolio_StatWatcher_libev_callback, RSTRING_PTR(path), interval == Qnil ? 0 : NUM2DBL(interval) ); watcher_data->event_types.ev_stat.data = (void *)self; return Qnil; }
static VALUE cDB_mget(int argc, VALUE *argv, VALUE vself){ VALUE vkeys, vhash, vvalue; TCRDB *db; TCMAP *recs; Data_Get_Struct(rb_iv_get(vself, RDBVNDATA), TCRDB, db); rb_scan_args(argc, argv, "*", &vkeys); // I really hope there is a better way to do this if (RARRAY_LEN(vkeys) == 1) { vvalue = rb_ary_entry(vkeys, 0); switch (TYPE(vvalue)){ case T_STRING: case T_FIXNUM: break; case T_ARRAY: vkeys = vvalue; break; case T_OBJECT: vkeys = rb_convert_type(vvalue, T_ARRAY, "Array", "to_a"); break; } } Check_Type(vkeys, T_ARRAY); recs = varytomap(vkeys); if(!tcrdbget3(db, recs)) return Qnil; vhash = maptovhash(recs); tcmapdel(recs); return vhash; }
static rb_event_flag_t symbol2event_flag(VALUE v) { static ID id; VALUE sym = rb_convert_type(v, T_SYMBOL, "Symbol", "to_sym"); #define C(name, NAME) CONST_ID(id, #name); if (sym == ID2SYM(id)) return RUBY_EVENT_##NAME C(line, LINE); C(class, CLASS); C(end, END); C(call, CALL); C(return, RETURN); C(c_call, C_CALL); C(c_return, C_RETURN); C(raise, RAISE); C(b_call, B_CALL); C(b_return, B_RETURN); C(thread_begin, THREAD_BEGIN); C(thread_end, THREAD_END); C(specified_line, SPECIFIED_LINE); #undef C CONST_ID(id, "a_call"); if (sym == ID2SYM(id)) return RUBY_EVENT_CALL | RUBY_EVENT_B_CALL | RUBY_EVENT_C_CALL; CONST_ID(id, "a_return"); if (sym == ID2SYM(id)) return RUBY_EVENT_RETURN | RUBY_EVENT_B_RETURN | RUBY_EVENT_C_RETURN; rb_raise(rb_eArgError, "unknown event: %s", rb_id2name(SYM2ID(sym))); }
/* * call-seq: new(opts = {}) * * Instantiates a new State object, configured by _opts_. * * _opts_ can have the following keys: * * * *indent*: a string used to indent levels (default: ''), * * *space*: a string that is put after, a : or , delimiter (default: ''), * * *space_before*: a string that is put before a : pair delimiter (default: ''), * * *object_nl*: a string that is put at the end of a JSON object (default: ''), * * *array_nl*: a string that is put at the end of a JSON array (default: ''), * * *check_circular*: true if checking for circular data structures * should be done, false (the default) otherwise. */ static VALUE cState_initialize(int argc, VALUE *argv, VALUE self) { VALUE opts; GET_STATE(self); rb_scan_args(argc, argv, "01", &opts); if (NIL_P(opts)) { state->indent = rb_str_new2(""); state->space = rb_str_new2(""); state->space_before = rb_str_new2(""); state->array_nl = rb_str_new2(""); state->object_nl = rb_str_new2(""); state->check_circular = 0; } else { VALUE tmp; opts = rb_convert_type(opts, T_HASH, "Hash", "to_hash"); tmp = rb_hash_aref(opts, ID2SYM(i_indent)); if (RTEST(tmp)) { Check_Type(tmp, T_STRING); state->indent = tmp; } else { state->indent = rb_str_new2(""); } tmp = rb_hash_aref(opts, ID2SYM(i_space)); if (RTEST(tmp)) { Check_Type(tmp, T_STRING); state->space = tmp; } else { state->space = rb_str_new2(""); } tmp = rb_hash_aref(opts, ID2SYM(i_space_before)); if (RTEST(tmp)) { Check_Type(tmp, T_STRING); state->space_before = tmp; } else { state->space_before = rb_str_new2(""); } tmp = rb_hash_aref(opts, ID2SYM(i_array_nl)); if (RTEST(tmp)) { Check_Type(tmp, T_STRING); state->array_nl = tmp; } else { state->array_nl = rb_str_new2(""); } tmp = rb_hash_aref(opts, ID2SYM(i_object_nl)); if (RTEST(tmp)) { Check_Type(tmp, T_STRING); state->object_nl = tmp; } else { state->object_nl = rb_str_new2(""); } tmp = rb_hash_aref(opts, ID2SYM(i_check_circular)); state->check_circular = RTEST(tmp); } state->seen = rb_hash_new(); state->memo = Qnil; state->depth = INT2FIX(0); return self; }
static VALUE bdb_sary_replace_m(VALUE obj, VALUE obj2) { bdb_DB *dbst; GetDB(obj, dbst); obj2 = rb_convert_type(obj2, T_ARRAY, "Array", "to_ary"); bdb_sary_replace(obj, 0, dbst->len, obj2); return obj; }
/** * call-seq: * Rev::Buffer#prepend(data) -> String * * Prepend the given data to the beginning of the buffer */ static VALUE Rev_Buffer_prepend(VALUE self, VALUE data) { struct buffer *buf; Data_Get_Struct(self, struct buffer, buf); data = rb_convert_type(data, T_STRING, "String", "to_str"); buffer_prepend(buf, RSTRING_PTR(data), RSTRING_LEN(data)); return data; }
/* * call-seq: * solver << var_or_lit_or_ary -> solver * * Almost same as Solver#add_caluse. This method receives Array of Variable * or Literal. * * solver << a # equivalent to solver.add_clause(a) * solver << [a, b, -c] # equivalent to solver.add_clause(a, b, -c) * */ static VALUE solver_add_clause_2(VALUE rslv, VALUE rcls) { if(TYPE(rcls) == T_DATA && RDATA(rcls)->dfree == (RUBY_DATA_FUNC)value_free) { return solver_add_clause(1, &rcls, rslv); } else { rcls = rb_convert_type(rcls, T_ARRAY, "Array", "to_ary"); return solver_add_clause((int) RARRAY_LEN(rcls), RARRAY_PTR(rcls), rslv); } }
/** * call-seq: * Rev::Buffer#append(data) -> String * * Append the given data to the end of the buffer */ static VALUE Rev_Buffer_append(VALUE self, VALUE data) { struct buffer *buf; Data_Get_Struct(self, struct buffer, buf); /* Is this needed? Never seen anyone else do it... */ data = rb_convert_type(data, T_STRING, "String", "to_str"); buffer_append(buf, RSTRING_PTR(data), RSTRING_LEN(data)); return data; }
static VALUE init(int argc, VALUE *argv, VALUE self) { VALUE debug, path, settings; rb_scan_args(argc, argv, "01", &settings); if (argc == 0) { debug = Qnil; path = Qnil; } else { settings = rb_convert_type(settings, T_HASH, "Hash", "to_hash"); debug = rb_hash_aref(settings, ID2SYM(DEBUG)); path = rb_hash_aref(settings, ID2SYM(USER_DIR)); } signal(SIGCHLD, SIG_IGN); signal(SIGPIPE, SIG_IGN); signal(SIGINT, sighandler); signal(SIGQUIT, sighandler); signal(SIGTERM, sighandler); data_hash_table = g_hash_table_new(NULL, NULL); fd_hash_table = g_hash_table_new(NULL, NULL); purple_debug_set_enabled(RTEST(debug) ? TRUE : FALSE); if (path != Qnil) { purple_util_set_user_dir(StringValueCStr(path)); } purple_core_set_ui_ops(&core_uiops); purple_eventloop_set_ui_ops(&glib_eventloops); if (!purple_core_init(UI_ID)) { rb_raise(rb_eRuntimeError, "libpurple initialization failed"); } /* Create and load the buddylist. */ purple_set_blist(purple_blist_new()); purple_blist_load(); /* Load the preferences. */ purple_prefs_load(); /* Load the pounces. */ purple_pounces_load(); return Qnil; }
void rbgio_gasyncinitable_new_async(GType type, VALUE parameters, VALUE io_priority, VALUE cancellable, VALUE block) { static ID s_id_length; struct rbgio_gasyncinitable_new_async_data data; if (s_id_length == 0) s_id_length = rb_intern("length"); if (!g_type_is_a(type, G_TYPE_OBJECT)) rb_raise(rb_eArgError, "%s is not a descendant of GObject", g_type_name(type)); if (NIL_P(parameters)) { SAVE_BLOCK(block); g_async_initable_newv_async(type, 0, NULL, RVAL2IOPRIORITYDEFAULT(io_priority), RVAL2GCANCELLABLE(cancellable), rbgio_async_ready_callback, (gpointer)block); return; } else { parameters = rb_convert_type(parameters, T_HASH, "Hash", "to_hash"); } data.gclass = G_OBJECT_CLASS(g_type_class_ref(type)); data.io_priority = RVAL2IOPRIORITYDEFAULT(io_priority); data.cancellable = RVAL2GCANCELLABLE(cancellable); data.block = block; data.rbparameters = parameters; data.index = 0; data.n_parameters = RVAL2GUINT(rb_funcall(parameters, s_id_length, 0)); data.parameters = ALLOCA_N(GParameter, data.n_parameters); rb_ensure(rbgio_gasyncinitable_new_async_body, (VALUE)&data, rbgio_gasyncinitable_new_async_ensure, (VALUE)&data); return; }
/** * call-seq: * Rev::Buffer#write_to(io) -> Integer * * Perform a nonblocking write of the buffer to the given IO object. * As much data as possible is written until the call would block. * Any data which is written is removed from the buffer. */ static VALUE Rev_Buffer_write_to(VALUE self, VALUE io) { struct buffer *buf; #if HAVE_RB_IO_T rb_io_t *fptr; #else OpenFile *fptr; #endif Data_Get_Struct(self, struct buffer, buf); GetOpenFile(rb_convert_type(io, T_FILE, "IO", "to_io"), fptr); rb_io_set_nonblock(fptr); return INT2NUM(buffer_write_to(buf, FPTR_TO_FD(fptr))); }
GObject * rbgio_ginitable_new(GType type, VALUE parameters, VALUE cancellable) { static ID s_id_length; GError *error = NULL; GObject *object; struct rbgio_ginitable_new_data data; if (s_id_length == 0) s_id_length = rb_intern("length"); if (!g_type_is_a(type, G_TYPE_OBJECT)) rb_raise(rb_eArgError, "%s is not a descendant of GObject", g_type_name(type)); if (NIL_P(parameters)) { object = g_initable_newv(type, 0, NULL, RVAL2GCANCELLABLE(cancellable), &error); if (object == NULL) rbgio_raise_error(error); return object; } else { parameters = rb_convert_type(parameters, T_HASH, "Hash", "to_hash"); } data.gclass = G_OBJECT_CLASS(g_type_class_ref(type)); data.cancellable = RVAL2GCANCELLABLE(cancellable); data.rbparameters = parameters; data.index = 0; data.n_parameters = RVAL2GUINT(rb_funcall(parameters, s_id_length, 0)); data.parameters = g_new(GParameter, data.n_parameters); data.error = NULL; object = (GObject *)rb_ensure(rbgio_ginitable_new_body, (VALUE)&data, rbgio_ginitable_new_ensure, (VALUE)&data); if (object == NULL) rbgio_raise_error(data.error); return object; }
/* * Return the entries (files and subdirectories) in the directory, each as a * Pathname object. * * The results contains just the names in the directory, without any trailing * slashes or recursive look-up. * * pp Pathname.new('/usr/local').entries * #=> [#<Pathname:share>, * # #<Pathname:lib>, * # #<Pathname:..>, * # #<Pathname:include>, * # #<Pathname:etc>, * # #<Pathname:bin>, * # #<Pathname:man>, * # #<Pathname:games>, * # #<Pathname:.>, * # #<Pathname:sbin>, * # #<Pathname:src>] * * The result may contain the current directory <code>#<Pathname:.></code> and * the parent directory <code>#<Pathname:..></code>. * * If you don't want +.+ and +..+ and * want directories, consider Pathname#children. */ static VALUE path_entries(VALUE self) { VALUE klass, str, ary; long i; klass = rb_obj_class(self); str = get_strpath(self); ary = rb_funcall(rb_cDir, rb_intern("entries"), 1, str); ary = rb_convert_type(ary, T_ARRAY, "Array", "to_ary"); for (i = 0; i < RARRAY_LEN(ary); i++) { VALUE elt = RARRAY_AREF(ary, i); elt = rb_class_new_instance(1, &elt, klass); rb_ary_store(ary, i, elt); } return ary; }
static VALUE bdb_sary_concat(VALUE obj, VALUE y) { bdb_DB *dbst; long i; VALUE tmp[2]; y = rb_convert_type(y, T_ARRAY, "Array", "to_ary"); GetDB(obj, dbst); for (i = 0; i < RARRAY_LEN(y); i++) { tmp[0] = INT2NUM(dbst->len); tmp[1] = RARRAY_PTR(y)[i]; bdb_put(2, tmp, obj); dbst->len++; } return obj; }
static VALUE bdb_sary_cmp(VALUE obj, VALUE obj2) { bdb_DB *dbst, *dbst2 = 0; VALUE a, a2, tmp, ary; long i, len; if (obj == obj2) return INT2FIX(0); GetDB(obj, dbst); len = dbst->len; if (!rb_obj_is_kind_of(obj2, bdb_cRecnum)) { obj2 = rb_convert_type(obj2, T_ARRAY, "Array", "to_ary"); if (len > RARRAY_LEN(obj2)) { len = RARRAY_LEN(obj2); } ary = Qtrue; } else { GetDB(obj2, dbst2); len = dbst->len; if (len > dbst2->len) { len = dbst2->len; } ary = Qfalse; } for (i = 0; i < len; i++) { tmp = INT2NUM(i); a = bdb_get(1, &tmp, obj); if (ary) { a2 = RARRAY_PTR(obj2)[i]; } else { a2 = bdb_get(1, &tmp, obj2); } tmp = rb_funcall(a, id_cmp, 1, a2); if (tmp != INT2FIX(0)) { return tmp; } } len = dbst->len - ary?RARRAY_LEN(obj2):dbst2->len; if (len == 0) return INT2FIX(0); if (len > 0) return INT2FIX(1); return INT2FIX(-1); }
/* * Returns or yields Pathname objects. * * Pathname.glob("config/" "*.rb") * #=> [#<Pathname:config/environment.rb>, #<Pathname:config/routes.rb>, ..] * * See Dir.glob. */ static VALUE path_s_glob(int argc, VALUE *argv, VALUE klass) { VALUE args[2]; int n; n = rb_scan_args(argc, argv, "11", &args[0], &args[1]); if (rb_block_given_p()) { return rb_block_call(rb_cDir, rb_intern("glob"), n, args, glob_i, klass); } else { VALUE ary; long i; ary = rb_funcallv(rb_cDir, rb_intern("glob"), n, args); ary = rb_convert_type(ary, T_ARRAY, "Array", "to_ary"); for (i = 0; i < RARRAY_LEN(ary); i++) { VALUE elt = RARRAY_AREF(ary, i); elt = rb_class_new_instance(1, &elt, klass); rb_ary_store(ary, i, elt); } return ary; } }
/** * call-seq: * Coolio::IOWatcher.initialize(IO, events = 'r') -> Coolio::IOWatcher * * Create a new Coolio::IOWatcher for the given IO object and add it to the given Coolio::Loop */ static VALUE Coolio_IOWatcher_initialize(int argc, VALUE *argv, VALUE self) { VALUE io, flags; char *flags_str; int events; struct Coolio_Watcher *watcher_data; #if HAVE_RB_IO_T rb_io_t *fptr; #else OpenFile *fptr; #endif rb_scan_args(argc, argv, "11", &io, &flags); if(flags != Qnil) flags_str = RSTRING_PTR(rb_String(flags)); else flags_str = "r"; if(!strcmp(flags_str, "r")) events = EV_READ; else if(!strcmp(flags_str, "w")) events = EV_WRITE; else if(!strcmp(flags_str, "rw")) events = EV_READ | EV_WRITE; else rb_raise(rb_eArgError, "invalid event type: '%s' (must be 'r', 'w', or 'rw')", flags_str); Data_Get_Struct(self, struct Coolio_Watcher, watcher_data); GetOpenFile(rb_convert_type(io, T_FILE, "IO", "to_io"), fptr); watcher_data->dispatch_callback = Coolio_IOWatcher_dispatch_callback; ev_io_init(&watcher_data->event_types.ev_io, Coolio_IOWatcher_libev_callback, FPTR_TO_FD(fptr), events); watcher_data->event_types.ev_io.data = (void *)self; return Qnil; }
/* (Private.) Called by #parse to prepare for lexing. */ VALUE cast_Parser_prepare_lexer(VALUE self, VALUE string) { cast_Parser *self_p; char *b, *e; Get_Struct(self, Parser, self_p); string = rb_convert_type(string, T_STRING, "String", "to_s"); b = RSTRING_PTR(string); e = b + RSTRING_LEN(string) + 1; self_p->file = split(b); self_p->bot = b; self_p->tok = b; self_p->ptr = b; self_p->cur = b; self_p->pos = b; self_p->lim = e; self_p->top = e; self_p->eof = e; self_p->lineno = 1; return Qnil; }
VALUE rb_hsh_push(VALUE hsh, VALUE obj) { if (rb_respond_to(obj, rb_intern("to_hash"))) { rb_hash_update(hsh, obj) /* env_update(hsh, obj) */ } else if (rb_respond_to(obj, rb_intern("to_ary"))) { VALUE ary = rb_convert_type(obj, T_ARRAY, "Array", "to_ary"); long size = RARRAY_LEN(ary); if(size & 1) { rb_raise(rb_eArgError, "odd number of arguments for Hash"); } else { /* TODO: would it be better to convert the array to a hash then use update? */ for (i=0; i<size; i+=2) { rb_hash_aset(hsh, RARRAY_PTR(ary)[i], RARRAY_PTR(ary)[i + 1]); } } } else { rb_raise(rb_eArgError, "attempt to merge object other then hash or array"); } return(hsh); }
static VALUE to_hash(VALUE hash) { return rb_convert_type(hash, T_HASH, "Hash", "to_hash"); }
static VALUE nucomp_s_convert(int argc, VALUE *argv, VALUE klass) { VALUE a1, a2, backref; rb_scan_args(argc, argv, "11", &a1, &a2); if (NIL_P(a1) || (argc == 2 && NIL_P(a2))) rb_raise(rb_eTypeError, "can't convert nil into Complex"); backref = rb_backref_get(); rb_match_busy(backref); if (RB_TYPE_P(a1, T_STRING)) { a1 = string_to_c_strict(a1); } if (RB_TYPE_P(a2, T_STRING)) { a2 = string_to_c_strict(a2); } rb_backref_set(backref); if (RB_TYPE_P(a1, T_COMPLEX)) { { get_dat1(a1); if (k_exact_zero_p(dat->imag)) a1 = dat->real; } } if (RB_TYPE_P(a2, T_COMPLEX)) { { get_dat1(a2); if (k_exact_zero_p(dat->imag)) a2 = dat->real; } } if (RB_TYPE_P(a1, T_COMPLEX)) { if (argc == 1 || (k_exact_zero_p(a2))) return a1; } if (argc == 1) { if (k_numeric_p(a1) && !f_real_p(a1)) return a1; /* should raise exception for consistency */ if (!k_numeric_p(a1)) return rb_convert_type(a1, T_COMPLEX, "Complex", "to_c"); } else { if ((k_numeric_p(a1) && k_numeric_p(a2)) && (!f_real_p(a1) || !f_real_p(a2))) return f_add(a1, f_mul(a2, f_complex_new_bang2(rb_cComplex, ZERO, ONE))); } { VALUE argv2[2]; argv2[0] = a1; argv2[1] = a2; return nucomp_s_new(argc, argv2, klass); } }
/* * call-seq: configure(opts) * * Configure this State instance with the Hash _opts_, and return * itself. */ static inline VALUE cState_configure(VALUE self, VALUE opts) { VALUE tmp; GET_STATE(self); tmp = rb_convert_type(opts, T_HASH, "Hash", "to_hash"); if (NIL_P(tmp)) tmp = rb_convert_type(opts, T_HASH, "Hash", "to_h"); if (NIL_P(tmp)) { rb_raise(rb_eArgError, "opts has to be hash like or convertable into a hash"); } opts = tmp; tmp = rb_hash_aref(opts, ID2SYM(i_indent)); if (RTEST(tmp)) { Check_Type(tmp, T_STRING); state->indent = tmp; } tmp = rb_hash_aref(opts, ID2SYM(i_space)); if (RTEST(tmp)) { Check_Type(tmp, T_STRING); state->space = tmp; } tmp = rb_hash_aref(opts, ID2SYM(i_space_before)); if (RTEST(tmp)) { Check_Type(tmp, T_STRING); state->space_before = tmp; } tmp = rb_hash_aref(opts, ID2SYM(i_array_nl)); if (RTEST(tmp)) { Check_Type(tmp, T_STRING); state->array_nl = tmp; } tmp = rb_hash_aref(opts, ID2SYM(i_object_nl)); if (RTEST(tmp)) { Check_Type(tmp, T_STRING); state->object_nl = tmp; } tmp = ID2SYM(i_check_circular); #if WITH_OBJC if (CFDictionaryGetValueIfPresent((CFDictionaryRef)opts, (const void *)RB2OC(tmp), 0)) { #else if (st_lookup(RHASH_TBL(opts), tmp, 0)) { #endif tmp = rb_hash_aref(opts, ID2SYM(i_check_circular)); state->check_circular = RTEST(tmp); } else { state->check_circular = 1; } tmp = ID2SYM(i_max_nesting); state->max_nesting = 19; #if WITH_OBJC if (CFDictionaryGetValueIfPresent((CFDictionaryRef)opts, (const void *)RB2OC(tmp), 0)) { #else if (st_lookup(RHASH_TBL(opts), tmp, 0)) { #endif VALUE max_nesting = rb_hash_aref(opts, tmp); if (RTEST(max_nesting)) { Check_Type(max_nesting, T_FIXNUM); state->max_nesting = FIX2LONG(max_nesting); } else { state->max_nesting = 0; } } tmp = rb_hash_aref(opts, ID2SYM(i_allow_nan)); state->allow_nan = RTEST(tmp); return self; } /* * call-seq: to_h * * Returns the configuration instance variables as a hash, that can be * passed to the configure method. */ static VALUE cState_to_h(VALUE self) { VALUE result = rb_hash_new(); GET_STATE(self); rb_hash_aset(result, ID2SYM(i_indent), state->indent); rb_hash_aset(result, ID2SYM(i_space), state->space); rb_hash_aset(result, ID2SYM(i_space_before), state->space_before); rb_hash_aset(result, ID2SYM(i_object_nl), state->object_nl); rb_hash_aset(result, ID2SYM(i_array_nl), state->array_nl); rb_hash_aset(result, ID2SYM(i_check_circular), state->check_circular ? Qtrue : Qfalse); rb_hash_aset(result, ID2SYM(i_allow_nan), state->allow_nan ? Qtrue : Qfalse); rb_hash_aset(result, ID2SYM(i_max_nesting), LONG2FIX(state->max_nesting)); return result; } /* * call-seq: new(opts = {}) * * Instantiates a new State object, configured by _opts_. * * _opts_ can have the following keys: * * * *indent*: a string used to indent levels (default: ''), * * *space*: a string that is put after, a : or , delimiter (default: ''), * * *space_before*: a string that is put before a : pair delimiter (default: ''), * * *object_nl*: a string that is put at the end of a JSON object (default: ''), * * *array_nl*: a string that is put at the end of a JSON array (default: ''), * * *check_circular*: true if checking for circular data structures * should be done, false (the default) otherwise. * * *allow_nan*: true if NaN, Infinity, and -Infinity should be * generated, otherwise an exception is thrown, if these values are * encountered. This options defaults to false. */ static VALUE cState_initialize(int argc, VALUE *argv, VALUE self) { VALUE opts; GET_STATE(self); rb_scan_args(argc, argv, "01", &opts); state->indent = rb_str_new2(""); state->space = rb_str_new2(""); state->space_before = rb_str_new2(""); state->array_nl = rb_str_new2(""); state->object_nl = rb_str_new2(""); if (NIL_P(opts)) { state->check_circular = 1; state->allow_nan = 0; state->max_nesting = 19; } else { cState_configure(self, opts); } state->seen = rb_hash_new(); state->memo = Qnil; state->depth = INT2FIX(0); return self; }
static VALUE nurat_s_convert(VALUE klass, SEL sel, int argc, VALUE *argv) { VALUE a1, a2, backref; rb_scan_args(argc, argv, "11", &a1, &a2); if (NIL_P(a1) || (argc == 2 && NIL_P(a2))) rb_raise(rb_eTypeError, "can't convert nil into Rational"); switch (TYPE(a1)) { case T_COMPLEX: if (k_exact_zero_p(RCOMPLEX(a1)->imag)) a1 = RCOMPLEX(a1)->real; } switch (TYPE(a2)) { case T_COMPLEX: if (k_exact_zero_p(RCOMPLEX(a2)->imag)) a2 = RCOMPLEX(a2)->real; } backref = rb_backref_get(); rb_match_busy(backref); switch (TYPE(a1)) { case T_FIXNUM: case T_BIGNUM: break; case T_FLOAT: a1 = f_to_r(a1); break; case T_STRING: a1 = string_to_r_strict(a1); break; } switch (TYPE(a2)) { case T_FIXNUM: case T_BIGNUM: break; case T_FLOAT: a2 = f_to_r(a2); break; case T_STRING: a2 = string_to_r_strict(a2); break; } rb_backref_set(backref); switch (TYPE(a1)) { case T_RATIONAL: if (argc == 1 || (k_exact_one_p(a2))) return a1; } if (argc == 1) { if (!(k_numeric_p(a1) && k_integer_p(a1))) return rb_convert_type(a1, T_RATIONAL, "Rational", "to_r"); } else { if ((k_numeric_p(a1) && k_numeric_p(a2)) && (!f_integer_p(a1) || !f_integer_p(a2))) return f_div(a1, a2); } { VALUE argv2[2]; argv2[0] = a1; argv2[1] = a2; return nurat_s_new(argc, argv2, klass); } }
VALUE rb_grn_convert_to_array (VALUE object) { return rb_convert_type(object, RUBY_T_ARRAY, "Array", "to_ary"); }
static VALUE so_convert_type(VALUE self, VALUE obj) { return rb_convert_type(obj, T_ARRAY, "Array", "to_ary"); }
/* * call-seq: configure(opts) * * Configure this State instance with the Hash _opts_, and return * itself. */ static VALUE cState_configure(VALUE self, VALUE opts) { VALUE tmp; GET_STATE(self); tmp = rb_convert_type(opts, T_HASH, "Hash", "to_hash"); if (NIL_P(tmp)) tmp = rb_convert_type(opts, T_HASH, "Hash", "to_h"); if (NIL_P(tmp)) { rb_raise(rb_eArgError, "opts has to be hash like or convertable into a hash"); } opts = tmp; tmp = rb_hash_aref(opts, ID2SYM(i_indent)); if (RTEST(tmp)) { unsigned long len; Check_Type(tmp, T_STRING); len = RSTRING_LEN(tmp); state->indent = fstrndup(RSTRING_PTR(tmp), len); state->indent_len = len; } tmp = rb_hash_aref(opts, ID2SYM(i_space)); if (RTEST(tmp)) { unsigned long len; Check_Type(tmp, T_STRING); len = RSTRING_LEN(tmp); state->space = fstrndup(RSTRING_PTR(tmp), len); state->space_len = len; } tmp = rb_hash_aref(opts, ID2SYM(i_space_before)); if (RTEST(tmp)) { unsigned long len; Check_Type(tmp, T_STRING); len = RSTRING_LEN(tmp); state->space_before = fstrndup(RSTRING_PTR(tmp), len); state->space_before_len = len; } tmp = rb_hash_aref(opts, ID2SYM(i_array_nl)); if (RTEST(tmp)) { unsigned long len; Check_Type(tmp, T_STRING); len = RSTRING_LEN(tmp); state->array_nl = fstrndup(RSTRING_PTR(tmp), len); state->array_nl_len = len; } tmp = rb_hash_aref(opts, ID2SYM(i_object_nl)); if (RTEST(tmp)) { unsigned long len; Check_Type(tmp, T_STRING); len = RSTRING_LEN(tmp); state->object_nl = fstrndup(RSTRING_PTR(tmp), len); state->object_nl_len = len; } tmp = ID2SYM(i_max_nesting); state->max_nesting = 19; if (option_given_p(opts, tmp)) { VALUE max_nesting = rb_hash_aref(opts, tmp); if (RTEST(max_nesting)) { Check_Type(max_nesting, T_FIXNUM); state->max_nesting = FIX2LONG(max_nesting); } else { state->max_nesting = 0; } } tmp = ID2SYM(i_depth); state->depth = 0; if (option_given_p(opts, tmp)) { VALUE depth = rb_hash_aref(opts, tmp); if (RTEST(depth)) { Check_Type(depth, T_FIXNUM); state->depth = FIX2LONG(depth); } else { state->depth = 0; } } tmp = ID2SYM(i_buffer_initial_length); if (option_given_p(opts, tmp)) { VALUE buffer_initial_length = rb_hash_aref(opts, tmp); if (RTEST(buffer_initial_length)) { long initial_length; Check_Type(buffer_initial_length, T_FIXNUM); initial_length = FIX2LONG(buffer_initial_length); if (initial_length > 0) state->buffer_initial_length = initial_length; } } tmp = rb_hash_aref(opts, ID2SYM(i_allow_nan)); state->allow_nan = RTEST(tmp); tmp = rb_hash_aref(opts, ID2SYM(i_ascii_only)); state->ascii_only = RTEST(tmp); tmp = rb_hash_aref(opts, ID2SYM(i_quirks_mode)); state->quirks_mode = RTEST(tmp); return self; }