static VALUE Buffer_initialize(int argc, VALUE* argv, VALUE self)
{
VALUE io = Qnil;
VALUE options = Qnil;
if(argc == 0 || (argc == 1 && argv[0] == Qnil)) {
/* Qnil */
} else if(argc == 1) {
VALUE v = argv[0];
if(rb_type(v) == T_HASH) {
options = v;
} else {
io = v;
}
} else if(argc == 2) {
io = argv[0];
options = argv[1];
if(rb_type(options) != T_HASH) {
rb_raise(rb_eArgError, "expected Hash but found %s.", rb_obj_classname(io));
}
} else {
rb_raise(rb_eArgError, "wrong number of arguments (%d for 0..1)", argc);
}
BUFFER(self, b);
MessagePack_Buffer_initialize(b, io, options);
return self;
}
octave_value OR_Variable::to_octave()
{
if (ruby_val == Qtrue) {
return true;
} else if (ruby_val == Qfalse) {
return false;
} else if (ruby_val == Qnil) {
return octave_NaN;
} else if (rb_type(ruby_val) == T_FLOAT) {
return RFLOAT_VALUE(ruby_val);
} else if (rb_type(ruby_val) == T_FIXNUM) {
return FIX2LONG(ruby_val);
} else if (rb_obj_is_kind_of(ruby_val, rb_path2class("Array")) == Qtrue) {
return OR_Array(ruby_val).to_octave();
} else if (rb_obj_is_kind_of(ruby_val, rb_path2class("Hash")) == Qtrue) {
return OR_Hash(ruby_val).to_octave();
} else if (rb_obj_is_kind_of(ruby_val, rb_path2class("Octave::StructMatrix")) == Qtrue) {
return OR_StructMatrix(ruby_val).to_octave();
} else if (rb_obj_is_kind_of(ruby_val, rb_path2class("Octave::CellMatrix")) == Qtrue) {
return OR_CellMatrix(ruby_val).to_octave();
} else if (rb_obj_is_kind_of(ruby_val, rb_path2class("Octave::Matrix")) == Qtrue) {
return OR_Matrix(ruby_val).to_octave();
} else {
return OR_String(ruby_val).to_octave();
}
}
octave_value OR_Matrix::to_octave()
{
int row_index, column_index;
int number_of_rows = FIX2INT(rb_iv_get(ruby_val, "@m"));
int number_of_columns = FIX2INT(rb_iv_get(ruby_val, "@n"));
VALUE cells = rb_iv_get(ruby_val, "@cells");
VALUE row, cell;
Matrix matrix = Matrix(number_of_rows, number_of_columns);
for (row_index = 0; row_index < number_of_rows; row_index++) {
row = RARRAY_PTR(cells)[row_index];
for (column_index = 0; column_index < number_of_columns; column_index++) {
cell = RARRAY_PTR(row)[column_index];
if (rb_type(cell) == T_FLOAT) {
matrix(row_index, column_index) = RFLOAT_VALUE(cell);
} else if (rb_type(cell) == T_FIXNUM) {
matrix(row_index, column_index) = FIX2LONG(cell);
} else {
matrix(row_index, column_index) = octave_NaN;
}
}
}
return matrix;
}
VALUE smatrix_rb_set(VALUE self, VALUE x, VALUE y, VALUE value) {
smatrix_t* smatrix = NULL;
smatrix_rb_gethandle(self, &smatrix);
if (!smatrix) {
rb_raise(rb_eTypeError, "smatrix @handle is Nil, something is very bad :'(");
return Qnil;
}
if (rb_type(x) != RUBY_T_FIXNUM) {
rb_raise(rb_eTypeError, "first argument (x) must be a Fixnum");
return Qnil;
}
if (rb_type(y) != RUBY_T_FIXNUM) {
rb_raise(rb_eTypeError, "second argument (y) must be a Fixnum");
return Qnil;
}
if (rb_type(value) != RUBY_T_FIXNUM) {
rb_raise(rb_eTypeError, "third argument must be a Fixnum");
return Qnil;
}
return INT2NUM(smatrix_set(smatrix, NUM2INT(x), NUM2INT(y), NUM2INT(value)));
}
MQ_BFL NS(argv2bufl) (struct MqS * const mqctx, struct MqBufferLS * args, int argc, VALUE *argv)
{
if (argc != 0) {
int i = 0;
if (args == NULL) args = MqBufferLCreate (argc);
if (argc >= 2) {
VALUE v = rb_type(argv[1]) == T_ARRAY ? RARRAY_PTR(argv[1])[0] : argv[1];
if (!strcmp(VAL2CST(v), MqFactoryCtxIdentGet(mqctx))) {
argc--;
argv++;
}
}
for (i=0; i < argc; i++, argv++) {
const VALUE argv2 = *argv;
if (rb_type(argv2) == T_ARRAY) {
int j;
const int argv2l = RARRAY_LEN(argv2);
VALUE *argv2P = RARRAY_PTR(argv2);
for (j=0; j<argv2l; j++, argv2P++) {
MqBufferLAppendC (args, VAL2CST(*argv2P));
}
} else {
MqBufferLAppendC (args, VALP2CST(argv));
}
}
}
return args;
}
VALUE
subextSubletSend(VALUE self,
VALUE value)
{
VALUE id = Qnil;
/* Check ruby object */
rb_check_frozen(self);
GET_ATTR(self, "@id", id);
/* Check object type */
if(T_STRING == rb_type(value))
{
char *list = NULL;
SubMessageData data = { { 0, 0, 0, 0, 0 } };
/* Store data */
list = strdup(RSTRING_PTR(value));
subSharedPropertySetStrings(display, DefaultRootWindow(display),
XInternAtom(display, "SUBTLE_DATA", False), &list, 1);
free(list);
data.l[0] = FIX2INT(id);
subSharedMessage(display, DefaultRootWindow(display),
"SUBTLE_SUBLET_DATA", data, 32, True);
}
else rb_raise(rb_eArgError, "Unexpected value-type `%s'",
rb_obj_classname(value));
return self;
} /* }}} */
/* SubletFind {{{ */
static VALUE
SubletFind(VALUE value,
int first)
{
int flags = 0;
VALUE parsed = Qnil;
char buf[50] = { 0 };
subextSubtlextConnect(NULL); ///< Implicit open connection
/* Check object type */
switch(rb_type(parsed = subextSubtlextParse(
value, buf, sizeof(buf), &flags)))
{
case T_SYMBOL:
if(CHAR2SYM("all") == parsed)
return subextSubletSingList(Qnil);
break;
case T_OBJECT:
if(rb_obj_is_instance_of(value, rb_const_get(mod, rb_intern("Sublet"))))
return parsed;
}
return subextSubtlextFindObjectsGeometry("SUBTLE_SUBLET_LIST",
"Sublet", buf, flags, first);
} /* }}} */
static VALUE dh_control_write_transfer(int argc, VALUE *argv, VALUE self)
{
VALUE obmRequestType, obRequest, owValue, owIndex, oData;
rb_scan_args(argc, argv, "41", &obmRequestType, &obRequest, &owValue, &owIndex, &oData);
unsigned int timeout = 300; // TODO: make this a settable option
unsigned char * buffer = 0;
unsigned int wLength = 0;
if (oData != Qnil)
{
if (rb_type(oData) != RUBY_T_STRING)
{
rb_raise(rb_eTypeError, "Expected data to be a string or nil.");
}
buffer = RSTRING_PTR(oData);
wLength = RSTRING_LEN(oData);
if (wLength > 0xFFFF)
{
rb_raise(rb_eRangeError, "Expected length of data to be at most 65535.");
}
}
int result = libusb_control_transfer
(dh_extract(self),
FIX2INT(obmRequestType), FIX2INT(obRequest),
FIX2INT(owValue), FIX2INT(owIndex),
buffer, wLength, timeout);
if (result < 0){ raise_usb_exception(result); }
return Qnil;
}
VALUE
subSubtleSingSpawn(VALUE self,
VALUE cmd)
{
VALUE ret = Qnil;
/* Check object type */
if(T_STRING == rb_type(cmd))
{
pid_t pid = 0;
subSubtlextConnect(NULL); ///< Implicit open connection
/* Create client with empty window id since we cannot
* know the real window id at this point (race) */
if(0 < (pid = subSharedSpawn(RSTRING_PTR(cmd))))
{
ret = subClientInstantiate((int)pid);
rb_iv_set(ret, "@pid", INT2FIX((int)pid));
}
}
else rb_raise(rb_eArgError, "Unexpected value-type `%s'",
rb_obj_classname(cmd));
return ret;
} /* }}} */
static VALUE Scalar_init(VALUE self, VALUE v)
{
vx_scalar scalar = 0;
int type = rb_type(v);
switch (type)
{
case T_FIXNUM: // int32_t or int64_t based on ARCH depth
{
#if defined(ARCH_16) // microcontrollers?
vx_int16 value = FIX2INT(v);
scalar = vxCreateScalar(context, VX_TYPE_INT16, &value);
#elif defined(ARCH_32) // ARM, mobile processors
vx_int32 value = FIX2INT(v);
scalar = vxCreateScalar(context, VX_TYPE_INT32, &value);
#elif defined(ARCH_64) // Desktops
vx_int64 value = FIX2INT(v);
scalar = vxCreateScalar(context, VX_TYPE_INT64, &value);
#endif
break;
}
case T_BIGNUM: // "infinite" length, don't know what to do with this...
Check_Type(v, T_FIXNUM);
break;
case T_FLOAT: // doubles
{
vx_float64 value = NUM2DBL(v);
scalar = vxCreateScalar(context, VX_TYPE_FLOAT64, &value);
break;
}
}
DATA_PTR(self) = (void *)scalar;
return Qnil;
}
VALUE
subGravitySingFind(VALUE self,
VALUE value)
{
int flags = 0;
VALUE parsed = Qnil;
char buf[50] = { 0 };
subSubtlextConnect(NULL); ///< Implicit open connection
/* Check object type */
switch(rb_type(parsed = subSubtlextParse(
value, buf, sizeof(buf), &flags)))
{
case T_SYMBOL:
if(CHAR2SYM("all") == parsed)
return subGravitySingAll(Qnil);
break;
case T_OBJECT:
if(rb_obj_is_instance_of(value, rb_const_get(mod, rb_intern("Gravity"))))
return parsed;
}
return GravityFind(buf, flags);
} /* }}} */
static void decode_lat_lon(VALUE vlat, VALUE vlon, GeographicLib::Math::real &lat, GeographicLib::Math::real &lon)
{
std::string slat, slon;
if (rb_type(vlat) == T_STRING && rb_type(vlon) == T_STRING) {
slat = rb_string_value_cstr(&vlat);
slon = rb_string_value_cstr(&vlon);
try {
GeographicLib::DMS::DecodeLatLon(slat, slon, lat, lon);
} catch (GeographicLib::GeographicErr e) {
rb_raise(rb_eRuntimeError, "This is not a valid position.");
}
} else {
lat = rb_num2dbl(vlat);
lon = rb_num2dbl(vlon);
}
}
static VALUE stringForceUTF8(VALUE arg)
{
if (rb_type(arg) == RUBY_T_STRING && ENCODING_IS_ASCII8BIT(arg))
rb_enc_associate_index(arg, rb_utf8_encindex());
return arg;
}
/* ViewFind {{{ */
static VALUE
ViewFind(VALUE value,
int first)
{
int flags = 0;
VALUE parsed = Qnil;
char buf[50] = { 0 };
subextSubtlextConnect(NULL); ///< Implicit open connection
/* Check object type */
switch(rb_type(parsed = subextSubtlextParse(
value, buf, sizeof(buf), &flags)))
{
case T_SYMBOL:
if(CHAR2SYM("visible") == parsed)
return subextViewSingVisible(Qnil);
else if(CHAR2SYM("all") == parsed)
return subextViewSingList(Qnil);
else if(CHAR2SYM("current") == parsed)
return subextViewSingCurrent(Qnil);
break;
case T_OBJECT:
if(rb_obj_is_instance_of(value, rb_const_get(mod, rb_intern("View"))))
return parsed;
}
return subextSubtlextFindObjects("_NET_DESKTOP_NAMES", "View",
buf, flags, first);
} /* }}} */
static int formadd_files(VALUE data_key, VALUE data_value, VALUE self) {
struct curl_state *state;
Data_Get_Struct(self, struct curl_state, state);
VALUE name = rb_obj_as_string(data_key);
VALUE filename;
VALUE filepath;
if (rb_type(data_value) == T_HASH) {
VALUE ary;
ary = rb_ary_new();
rb_hash_foreach(data_value, convert_hash_to_a, ary);
filename = rb_ary_entry(ary, 0);
filepath = rb_ary_entry(ary, 1);
} else {
filename = name;
filepath = rb_obj_as_string(data_value);
}
curl_formadd(&state->post, &state->last,
CURLFORM_PTRNAME, RSTRING_PTR(name),
CURLFORM_FILE, RSTRING_PTR(filepath),
CURLFORM_FILENAME, RSTRING_PTR(filename),
CURLFORM_END);
return 0;
}
static VALUE application_initialize(VALUE self, VALUE args) {
if (rb_thread_main() != rb_thread_current()) {
rb_raise(rb_eThreadError, "Initializing QML::Application outside the main thread");
}
application_t *data;
TypedData_Get_Struct(self, application_t, &data_type, data);
if (rb_type(args) != T_ARRAY) {
rb_raise(rb_eTypeError, "Expected Array");
}
args = rb_ary_concat(rb_ary_new_from_args(1, rb_argv0), args);
int argc = RARRAY_LEN(args);
char **argv = malloc(argc * sizeof(char *));
for (int i = 0; i < argc; ++i) {
VALUE arg = RARRAY_AREF(args, i);
argv[i] = rb_string_value_cstr(&arg);
}
data->application = qmlbind_application_new(argc, argv);
return self;
}
grn_obj *
rb_grn_value_from_ruby_object (VALUE object, grn_ctx *context,
grn_obj *value, grn_id type_id, grn_obj *type)
{
grn_bool string_p, table_type_p;
string_p = rb_type(object) == T_STRING;
table_type_p = (GRN_TABLE_HASH_KEY <= type->header.type &&
type->header.type <= GRN_TABLE_NO_KEY);
if (!string_p) {
return RVAL2GRNBULK_WITH_TYPE(object, context, value, type_id, type);
}
if (table_type_p && RSTRING_LEN(object) == 0) {
if (value) {
if (value->header.domain != type_id) {
grn_obj_reinit(context, value, type_id, 0);
}
} else {
value = grn_obj_open(context, GRN_BULK, 0, type_id);
rb_grn_context_check(context, object);
}
GRN_RECORD_SET(context, value, GRN_ID_NIL);
return value;
}
return RVAL2GRNBULK(object, context, value);
}
VALUE smatrix_rb_initialize(VALUE self, VALUE filename) {
smatrix_t* smatrix = NULL;
VALUE smatrix_handle;
switch (rb_type(filename)) {
case RUBY_T_STRING:
smatrix = smatrix_open(RSTRING_PTR(filename));
break;
case RUBY_T_NIL:
smatrix = smatrix_open(NULL);
break;
default:
rb_raise(rb_eTypeError, "first argument (filename) must be nil or a string");
break;
}
if (smatrix) {
smatrix_handle = Data_Wrap_Struct(rb_cObject, NULL, smatrix_rb_free, smatrix);
rb_iv_set(self, "@handle", smatrix_handle);
}
return self;
}
VALUE MessagePack_Unpacker_initialize(int argc, VALUE* argv, VALUE self)
{
VALUE io = Qnil;
VALUE options = Qnil;
if(argc == 0 || (argc == 1 && argv[0] == Qnil)) {
/* Qnil */
} else if(argc == 1) {
VALUE v = argv[0];
if(rb_type(v) == T_HASH) {
options = v;
if(rb_type(options) != T_HASH) {
rb_raise(rb_eArgError, "expected Hash but found %s.", rb_obj_classname(options));
}
} else {
io = v;
}
} else if(argc == 2) {
io = argv[0];
options = argv[1];
if(rb_type(options) != T_HASH) {
rb_raise(rb_eArgError, "expected Hash but found %s.", rb_obj_classname(options));
}
} else {
rb_raise(rb_eArgError, "wrong number of arguments (%d for 0..2)", argc);
}
UNPACKER(self, uk);
MessagePack_Buffer_set_options(UNPACKER_BUFFER_(uk), io, options);
if(options != Qnil) {
VALUE v;
v = rb_hash_aref(options, ID2SYM(rb_intern("symbolize_keys")));
msgpack_unpacker_set_symbolized_keys(uk, RTEST(v));
v = rb_hash_aref(options, ID2SYM(rb_intern("allow_unknown_ext")));
msgpack_unpacker_set_allow_unknown_ext(uk, RTEST(v));
}
return self;
}
/*
* Gives us access to the mkfifo system call so that
* we don't need to rely on exec.
*/
static VALUE
rb_yaram_mbox_mkfifo(VALUE self, VALUE name)
{
if (rb_type(name) != T_STRING)
rb_raise(rb_eArgError, "name must be a string");
if (mkfifo(RSTRING_PTR(name), S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP) < 0)
rb_raise(rb_eException, "can't create named pipe");
return name;
}
static void
parse_options(VALUE ropts, Options copts) {
struct _YesNoOpt ynos[] = {
{ circular_sym, &copts->circular },
{ auto_define_sym, &copts->auto_define },
{ symbol_keys_sym, &copts->sym_key },
{ ascii_only_sym, &copts->ascii_only },
{ Qnil, 0 }
};
YesNoOpt o;
if (rb_cHash == rb_obj_class(ropts)) {
VALUE v;
if (Qnil != (v = rb_hash_lookup(ropts, indent_sym))) {
if (rb_cFixnum != rb_obj_class(v)) {
rb_raise(rb_eArgError, ":indent must be a Fixnum.\n");
}
copts->indent = NUM2INT(v);
}
#ifdef HAVE_RUBY_ENCODING_H
if (Qnil != (v = rb_hash_lookup(ropts, encoding_sym))) {
if (T_STRING == rb_type(v)) {
oj_default_options.encoding = rb_enc_find(StringValuePtr(v));
} else if (rb_cEncoding == rb_obj_class(v)) {
oj_default_options.encoding = rb_to_encoding(v);
} else {
rb_raise(rb_eArgError, ":encoding must be nil, a String, or an Encoding.\n");
}
}
#endif
if (Qnil != (v = rb_hash_lookup(ropts, mode_sym))) {
if (object_sym == v) {
copts->mode = ObjectMode;
} else if (strict_sym == v) {
copts->mode = StrictMode;
} else if (compat_sym == v) {
copts->mode = CompatMode;
} else if (null_sym == v) {
copts->mode = NullMode;
} else {
rb_raise(rb_eArgError, ":mode must be :object, :strict, :compat, or :null.\n");
}
}
for (o = ynos; 0 != o->attr; o++) {
if (Qnil != (v = rb_hash_lookup(ropts, o->sym))) {
if (Qtrue == v) {
*o->attr = Yes;
} else if (Qfalse == v) {
*o->attr = No;
} else {
rb_raise(rb_eArgError, "%s must be true or false.\n", rb_id2name(SYM2ID(o->sym)));
}
}
}
}
}
void smatrix_rb_gethandle(VALUE self, smatrix_t** handle) {
VALUE handle_wrapped = rb_iv_get(self, "@handle");
if (rb_type(handle_wrapped) != RUBY_T_DATA) {
rb_raise(rb_eTypeError, "smatrix @handle is of the wrong type, something went horribly wrong :(");
return;
}
Data_Get_Struct(handle_wrapped, smatrix_t, *handle);
}
VALUE
subSubtleSingDisplayWriter(VALUE self,
VALUE display_string)
{
/* Explicit open connection */
subSubtlextConnect(T_STRING == rb_type(display_string) ?
RSTRING_PTR(display_string) : NULL);
return Qnil;
} /* }}} */
VALUE MessagePack_unpack(int argc, VALUE* argv)
{
VALUE src;
switch(argc) {
case 1:
src = argv[0];
break;
default:
rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)", argc);
}
VALUE io = Qnil;
if(rb_type(src) != T_STRING) {
io = src;
src = Qnil;
}
VALUE self = Unpacker_alloc(cMessagePack_Unpacker);
UNPACKER(self, uk);
//msgpack_unpacker_reset(s_unpacker);
//msgpack_buffer_reset_io(UNPACKER_BUFFER_(s_unpacker));
/* prefer reference than copying */
msgpack_buffer_set_write_reference_threshold(UNPACKER_BUFFER_(uk), 0);
if(io != Qnil) {
MessagePack_Buffer_initialize(UNPACKER_BUFFER_(uk), io, Qnil);
}
if(src != Qnil) {
/* prefer reference than copying; see MessagePack_Unpacker_module_init */
msgpack_buffer_append_string(UNPACKER_BUFFER_(uk), src);
}
int r = msgpack_unpacker_read(uk, 0);
if(r < 0) {
raise_unpacker_error(r);
}
/* raise if extra bytes follow */
if(msgpack_buffer_top_readable_size(UNPACKER_BUFFER_(uk)) > 0) {
rb_raise(eMalformedFormatError, "extra bytes follow after a deserialized object");
}
#ifdef RB_GC_GUARD
/* This prevents compilers from optimizing out the `self` variable
* from stack. Otherwise GC free()s it. */
RB_GC_GUARD(self);
#endif
return msgpack_unpacker_get_last_object(uk);
}
static void curl_multi_free(ruby_curl_multi *rbcm) {
if (rbcm && !rbcm->requests == Qnil && rb_type(rbcm->requests) == T_HASH && RHASH_LEN(rbcm->requests) > 0) {
rb_hash_foreach( rbcm->requests, (int (*)())curl_multi_flush_easy, (VALUE)rbcm );
rb_hash_foreach(rbcm->requests, rb_hash_clear_i, 0); //rb_hash_clear(rbcm->requests);
rbcm->requests = Qnil;
}
curl_multi_cleanup(rbcm->handle);
free(rbcm);
}
VALUE smatrix_rb_get(VALUE self, VALUE x, VALUE y) {
smatrix_t* smatrix = NULL;
smatrix_rb_gethandle(self, &smatrix);
if (!smatrix) {
rb_raise(rb_eTypeError, "smatrix @handle is Nil, something went horribly wrong :(");
return Qnil;
}
if (rb_type(x) != RUBY_T_FIXNUM) {
rb_raise(rb_eTypeError, "first argument (x) must be a Fixnum");
return Qnil;
}
if (rb_type(y) != RUBY_T_FIXNUM) {
rb_raise(rb_eTypeError, "second argument (y) must be a Fixnum");
return Qnil;
}
return INT2NUM(smatrix_get(smatrix, NUM2INT(x), NUM2INT(y)));
}
static int
check_breakpoint_by_method(VALUE rb_breakpoint, VALUE klass, ID mid, VALUE self)
{
breakpoint_t *breakpoint;
if (NIL_P(rb_breakpoint))
return 0;
Data_Get_Struct(rb_breakpoint, breakpoint_t, breakpoint);
if (Qfalse == breakpoint->enabled || breakpoint->type != BP_METHOD_TYPE
|| breakpoint->pos.mid != mid)
return 0;
if (classname_cmp(breakpoint->source, klass)
|| ((rb_type(self) == T_CLASS || rb_type(self) == T_MODULE)
&& classname_cmp(breakpoint->source, self)))
return 1;
return 0;
}
static VALUE
load_with_opts(VALUE input, Options copts) {
char *json;
size_t len;
VALUE obj;
if (rb_type(input) == T_STRING) {
// the json string gets modified so make a copy of it
len = RSTRING_LEN(input) + 1;
if (SMALL_JSON < len) {
json = ALLOC_N(char, len);
} else {
VALUE MessagePack_Packer_initialize(int argc, VALUE* argv, VALUE self)
{
VALUE io = Qnil;
VALUE options = Qnil;
if(argc == 0 || (argc == 1 && argv[0] == Qnil)) {
/* Qnil */
} else if(argc == 1) {
VALUE v = argv[0];
if(rb_type(v) == T_HASH) {
options = v;
} else {
io = v;
}
} else if(argc == 2) {
io = argv[0];
options = argv[1];
if(rb_type(options) != T_HASH) {
rb_raise(rb_eArgError, "expected Hash but found %s.", rb_obj_classname(options));
}
} else {
rb_raise(rb_eArgError, "wrong number of arguments (%d for 0..2)", argc);
}
PACKER(self, pk);
MessagePack_Buffer_set_options(PACKER_BUFFER_(pk), io, options);
if(options != Qnil) {
VALUE v;
v = rb_hash_aref(options, ID2SYM(rb_intern("compatibility_mode")));
msgpack_packer_set_compat(pk, RTEST(v));
}
return self;
}
VALUE
oj_compat_parse(int argc, VALUE *argv, VALUE self) {
struct _ParseInfo pi;
pi.options = oj_default_options;
oj_set_compat_callbacks(&pi);
if (T_STRING == rb_type(*argv)) {
return oj_pi_parse(argc, argv, &pi, 0, 0, 1);
} else {
return oj_pi_sparse(argc, argv, &pi, 0);
}
}
