/*
* 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;
}
