static
VALUE ray_drawable_init_copy(VALUE self, VALUE orig) {
if (rb_obj_is_kind_of(self, rb_path2class("Ray::Text")) ||
rb_obj_is_kind_of(self, rb_path2class("Ray::Sprite")) ||
rb_obj_is_kind_of(self, rb_path2class("Ray::Polygon"))) {
rb_raise(rb_eTypeError, "can't get drawable pointer from %s",
RAY_OBJ_CLASSNAME(self));
}
ray_drawable *obj = NULL;
Data_Get_Struct(self, ray_drawable, obj);
ray_drawable *other = ray_rb2full_drawable(orig);
size_t vid = say_drawable_get_vertex_type(other->drawable);
obj->drawable = say_drawable_create(vid);
say_drawable_set_custom_data(obj->drawable, obj);
say_drawable_set_other_data(obj->drawable, (void*)self);
say_drawable_copy(obj->drawable, other->drawable);
say_drawable_set_changed(obj->drawable);
rb_iv_set(self, "@vertex_type_class", rb_iv_get(orig, "@vertex_type_class"));
obj->vsize = other->vsize;
ray_drawable_copy_attr(self, orig);
return self;
}
void Init_wongi_turtle() {
define_prelude();
define_parser();
cURI = rb_path2class("URI");
symResource = rb_intern( "resource" );
symDocument = rb_intern( "document" );
symRegister = rb_intern( "register" );
symBaseEQ = rb_intern( "base=" );
symLSHIFT = rb_intern( "<<" );
symCommonEXCL = rb_intern( "common!" );
symSplit = rb_intern( "split" );
symLookup = rb_intern( "lookup" );
symFragment = rb_intern( "fragment" );
symPLUS = rb_intern( "+" );
symEscape = rb_intern( "escape" );
symImportBlank = rb_intern( "import_blank" );
symBlank = rb_intern( "blank" );
symParse = rb_intern( "parse" );
symAbsoluteQ = rb_intern( "absolute?" );
symBase = rb_intern( "base" );
cCollector = rb_path2class("Wongi::RDF::Collector");
cStatement = rb_path2class( "Wongi::RDF::Statement" );
}
/*
* Classes for calculating message digests using the SHA-256/384/512
* Secure Hash Algorithm(s) by NIST (the US' National Institute of
* Standards and Technology), described in FIPS PUB 180-2.
*/
void
Init_sha2()
{
VALUE mDigest, cDigest_Base;
ID id_metadata;
#define DECLARE_ALGO_CLASS(bitlen) \
VALUE cDigest_SHA##bitlen;
FOREACH_BITLEN(DECLARE_ALGO_CLASS)
id_metadata = rb_intern("metadata");
mDigest = rb_path2class("Digest");
cDigest_Base = rb_path2class("Digest::Base");
#define DEFINE_ALGO_CLASS(bitlen) \
cDigest_SHA##bitlen = rb_define_class_under(mDigest, "SHA" #bitlen, cDigest_Base); \
\
rb_ivar_set(cDigest_SHA##bitlen, id_metadata, \
Data_Wrap_Struct(rb_cObject, 0, 0, (void *)&sha##bitlen));
FOREACH_BITLEN(DEFINE_ALGO_CLASS)
}
/*
@overload initialize(vertex_class = Ray::Vertex)
@param [Class] vertex_class Class of the vertices.
*/
static
VALUE ray_drawable_init(int argc, VALUE *argv, VALUE self) {
if (rb_obj_is_kind_of(self, rb_path2class("Ray::Text")) ||
rb_obj_is_kind_of(self, rb_path2class("Ray::Sprite")) ||
rb_obj_is_kind_of(self, rb_path2class("Ray::Polygon"))) {
rb_raise(rb_eTypeError, "can't get drawable pointer from %s",
RAY_OBJ_CLASSNAME(self));
}
ray_drawable *obj = NULL;
Data_Get_Struct(self, ray_drawable, obj);
VALUE arg = Qnil;
rb_scan_args(argc, argv, "01", &arg);
size_t id = NIL_P(arg) ? 0 : ray_get_vtype(arg);
obj->drawable = say_drawable_create(id);
say_drawable_set_custom_data(obj->drawable, obj);
say_drawable_set_other_data(obj->drawable, (void*)self);
say_drawable_set_fill_proc(obj->drawable, ray_drawable_fill_proc);
say_drawable_set_shader_proc(obj->drawable, ray_drawable_shader_proc);
say_drawable_set_render_proc(obj->drawable, ray_drawable_render_proc);
say_drawable_set_index_fill_proc(obj->drawable,
ray_drawable_indices_fill_proc);
say_drawable_set_changed(obj->drawable);
rb_iv_set(self, "@vertex_type_class", NIL_P(arg) ?
rb_path2class("Ray::Vertex") : arg);
obj->vsize = say_vertex_type_get_size(say_get_vertex_type(id));
return self;
}
/*
* Classes for calculating message digests using the SHA-256/384/512
* Secure Hash Algorithm(s) by NIST (the US' National Institute of
* Standards and Technology), described in FIPS PUB 180-2.
*/
void
Init_sha2(void)
{
VALUE mDigest, cDigest_Base;
ID id_metadata;
#define DECLARE_ALGO_CLASS(bitlen) \
VALUE cDigest_SHA##bitlen;
FOREACH_BITLEN(DECLARE_ALGO_CLASS)
rb_require("digest");
id_metadata = rb_intern("metadata");
mDigest = rb_path2class("Digest");
cDigest_Base = rb_path2class("Digest::Base");
#define DEFINE_ALGO_CLASS(bitlen) \
cDigest_SHA##bitlen = rb_define_class_under(mDigest, "SHA" #bitlen, cDigest_Base); \
\
rb_ivar_set(cDigest_SHA##bitlen, id_metadata, \
Data_Wrap_Struct(0, 0, 0, (void *)&sha##bitlen));
#undef RUBY_UNTYPED_DATA_WARNING
#define RUBY_UNTYPED_DATA_WARNING 0
FOREACH_BITLEN(DEFINE_ALGO_CLASS)
}
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();
}
}
say_drawable *ray_rb2drawable(VALUE obj) {
if (RAY_IS_A(obj, rb_path2class("Ray::Polygon")))
return ray_rb2polygon(obj)->drawable;
else if (RAY_IS_A(obj, rb_path2class("Ray::Sprite")))
return ray_rb2sprite(obj)->drawable;
else if (RAY_IS_A(obj, rb_path2class("Ray::Text")))
return ray_rb2text(obj)->drawable;
else {
return ray_rb2full_drawable(obj)->drawable;
}
}
say_audio_source *ray_rb2audio_source(VALUE obj) {
if (RAY_IS_A(obj, rb_path2class("Ray::Sound")))
return ray_rb2sound(obj)->src;
if (RAY_IS_A(obj, rb_path2class("Ray::Music")))
return ray_rb2music(obj)->src;
else {
rb_raise(rb_eTypeError, "can't get audio source pointer from %s",
RAY_OBJ_CLASSNAME(obj));
}
return NULL;
}
/*
* A class for calculating message digests using RIPEMD-160
* cryptographic hash function, designed by Hans Dobbertin, Antoon
* Bosselaers, and Bart Preneel.
*/
void
Init_rmd160()
{
VALUE mDigest, cDigest_Base, cDigest_RMD160;
rb_require("digest");
mDigest = rb_path2class("Digest");
cDigest_Base = rb_path2class("Digest::Base");
cDigest_RMD160 = rb_define_class_under(mDigest, "RMD160", cDigest_Base);
rb_ivar_set(cDigest_RMD160, rb_intern("metadata"),
Data_Wrap_Struct(rb_cObject, 0, 0, (void *)&rmd160));
}
void
Init_tiger()
{
VALUE mDigest, cDigest_Base, cDigest_Tiger;
rb_require("digest");
mDigest = rb_path2class("Digest");
cDigest_Base = rb_path2class("Digest::Base");
cDigest_Tiger = rb_define_class_under(mDigest, "Tiger", cDigest_Base);
rb_ivar_set(cDigest_Tiger, rb_intern("metadata"),
Data_Wrap_Struct(rb_cObject, 0, 0, &tiger));
}
/*
* A class for calculating message digests using the SHA-1 Secure Hash
* Algorithm by NIST (the US' National Institute of Standards and
* Technology), described in FIPS PUB 180-1.
*/
void
Init_sha1()
{
VALUE mDigest, cDigest_Base, cDigest_SHA1;
rb_require("digest");
mDigest = rb_path2class("Digest");
cDigest_Base = rb_path2class("Digest::Base");
cDigest_SHA1 = rb_define_class_under(mDigest, "SHA1", cDigest_Base);
rb_ivar_set(cDigest_SHA1, rb_intern("metadata"),
Data_Wrap_Struct(rb_cObject, 0, 0, &sha1));
}
/*
* A class for calculating message digests using the MD5
* Message-Digest Algorithm by RSA Data Security, Inc., described in
* RFC1321.
*/
void
Init_md5()
{
VALUE mDigest, cDigest_Base, cDigest_MD5;
rb_require("digest");
mDigest = rb_path2class("Digest");
cDigest_Base = rb_path2class("Digest::Base");
cDigest_MD5 = rb_define_class_under(mDigest, "MD5", cDigest_Base);
rb_ivar_set(cDigest_MD5, rb_intern("metadata"),
Data_Wrap_Struct(rb_cObject, 0, 0, (void *)&md5));
}
/*
* INIT
*/
void
Init_ossl_digest()
{
rb_require("digest");
#if 0 /* let rdoc know about mOSSL */
mOSSL = rb_define_module("OpenSSL");
#endif
cDigest = rb_define_class_under(mOSSL, "Digest", rb_path2class("Digest::Class"));
eDigestError = rb_define_class_under(cDigest, "DigestError", eOSSLError);
rb_objc_define_method(*(VALUE *)cDigest, "alloc", ossl_digest_alloc, 0);
rb_objc_define_method(cDigest, "initialize", ossl_digest_initialize, -1);
rb_define_copy_func(cDigest, ossl_digest_copy);
rb_objc_define_method(cDigest, "reset", ossl_digest_reset, 0);
rb_objc_define_method(cDigest, "update", ossl_digest_update, 1);
rb_define_alias(cDigest, "<<", "update");
rb_objc_define_private_method(cDigest, "finish", ossl_digest_finish, -1);
rb_objc_define_method(cDigest, "digest_length", ossl_digest_size, 0);
rb_objc_define_method(cDigest, "block_length", ossl_digest_block_length, 0);
rb_objc_define_method(cDigest, "name", ossl_digest_name, 0);
}
static void odp_raise(VALUE self, const char * msg) {
OdpMysql * conn;
Data_Get_Struct(self, OdpMysql, conn);
rb_raise(rb_path2class("Oedipus::ConnectionError"),
"%s. Error %u: %s", msg, mysql_errno(conn->ptr), mysql_error(conn->ptr));
}
static VALUE
class2path(VALUE klass)
{
VALUE path;
if (klass == rb_cNSObject) {
path = rb_str_new2("Object");
}
else if (klass == rb_cNSMutableString) {
path = rb_str_new2("String");
}
else {
path = rb_class_path(klass);
}
const char *n = RSTRING_PTR(path);
if (n[0] == '#') {
rb_raise(rb_eTypeError, "can't dump anonymous %s %s",
(TYPE(klass) == T_CLASS ? "class" : "module"),
n);
}
if (rb_path2class(n) != rb_class_real(klass, true)) {
rb_raise(rb_eTypeError, "%s can't be referred", n);
}
return path;
}
void Init_coverband_ext(void)
{
VALUE coverbandBase = rb_path2class("Coverband::Base");
rb_define_method(coverbandBase, "extended?", cb_extended, 0);
rb_define_method(coverbandBase, "set_tracer", cb_set_tracer, 0);
rb_define_method(coverbandBase, "unset_tracer", cb_unset_tracer, 0);
}
VALUE wrapColorClass(BYTE R, BYTE G, BYTE B, BYTE A = 255)
{
Color *color_obj;
color_obj = new Color(R, G, B, A);
VALUE newColor = Data_Wrap_Struct(rb_path2class("RGA::Color"), 0, color_Free, color_obj);
return newColor;
}
static VALUE rb_sigar_set_logger(VALUE obj, VALUE logger)
{
SIGAR_GET;
if (rb_obj_is_kind_of(logger, rb_cProc) ||
rb_respond_to(logger, rb_intern("call"))) {
sigar_log_impl_set(sigar, rbsigar, rb_sigar_proc_impl);
rbsigar->logger = logger;
return obj;
}
/* Have to load Logger to test for it properly */
rb_require("logger");
if (rb_obj_is_kind_of(logger, rb_path2class("Logger"))) {
sigar_log_impl_set(sigar, rbsigar, rb_sigar_logger_impl);
rbsigar->logger = logger;
}
else {
rb_raise(rb_eArgError,
"value is not a proc object or subclass of Logger");
}
return obj;
}
void
Init_stringbuffer(void)
{
VALUE mDigest, cDigest_Class, cDigest_StringBuffer;
/* Digest::Buffer is require that Digest module and Digest::Class class of CRuby built-in */
rb_require("digest");
mDigest = rb_path2class("Digest");
/* class Digest::Buffer < Digest::Class */
cDigest_StringBuffer = rb_define_class_under(mDigest, "StringBuffer", rb_cObject);
rb_define_alloc_func(cDigest_StringBuffer, buffer_alloc);
rb_define_singleton_method(cDigest_StringBuffer, "digest", buffer_s_digest, -1);
rb_define_singleton_method(cDigest_StringBuffer, "hexdigest", buffer_s_hexdigest, -1);
rb_define_method(cDigest_StringBuffer, "update", buffer_update, 1);
rb_define_alias(cDigest_StringBuffer, "<<", "update");
rb_define_private_method(cDigest_StringBuffer, "finish", buffer_finish, 0);
rb_define_method(cDigest_StringBuffer, "reset", buffer_reset, 0);
rb_define_method(cDigest_StringBuffer, "digest_length", buffer_digest_length, 0);
rb_define_alias(cDigest_StringBuffer, "length", "digest_length");
rb_define_alias(cDigest_StringBuffer, "size", "digest_length");
rb_define_method(cDigest_StringBuffer, "==", buffer_equal, 1);
rb_define_method(cDigest_StringBuffer, "initialize_copy", buffer_initialize_copy, 1);
rb_define_method(cDigest_StringBuffer, "digest", buffer_digest, -1);
rb_define_method(cDigest_StringBuffer, "digest!", buffer_digest_bang, 0);
rb_define_method(cDigest_StringBuffer, "hexdigest", buffer_hexdigest, -1);
rb_define_method(cDigest_StringBuffer, "hexdigest!", buffer_hexdigest_bang, 0);
rb_define_method(cDigest_StringBuffer, "to_s", buffer_to_s, 0);
rb_define_method(cDigest_StringBuffer, "buffer", buffer_get, 0);
}
/*
* A class for calculating message digests using the SHA-1 Secure Hash
* Algorithm by NIST (the US' National Institute of Standards and
* Technology), described in FIPS PUB 180-1.
*/
void
Init_sha1()
{
VALUE mDigest, cDigest_Base, cDigest_SHA1;
#if 0
mDigest = rb_define_module("Digest"); /* let rdoc know */
#endif
mDigest = rb_path2class("Digest");
cDigest_Base = rb_path2class("Digest::Base");
cDigest_SHA1 = rb_define_class_under(mDigest, "SHA1", cDigest_Base);
rb_ivar_set(cDigest_SHA1, rb_intern("metadata"),
Data_Wrap_Struct(rb_cObject, 0, 0, (void *)&sha1));
}
/** Find any Time/DateTime arguments and ensure they use the system time zone */
static void rdo_mysql_driver_normalize_date_times_bang(VALUE * args, int argc) {
int i = 0;
for (; i < argc; ++i) {
if (rb_funcall(args[i], rb_intern("kind_of?"), 1, rb_path2class("DateTime"))) {
VALUE offset = rb_funcall(
rb_funcall(rb_path2class("DateTime"), rb_intern("now"), 0),
rb_intern("offset"),
0);
args[i] = rb_funcall(args[i], rb_intern("new_offset"), 1, offset);
args[i] = rb_funcall(args[i], rb_intern("strftime"), 1, rb_str_new2("%Y-%m-%d %H:%M:%S"));
} else if (rb_funcall(args[i], rb_intern("kind_of?"), 1, rb_cTime)) {
args[i] = rb_funcall(args[i], rb_intern("localtime"), 0);
args[i] = rb_funcall(args[i], rb_intern("strftime"), 1, rb_str_new2("%Y-%m-%d %H:%M:%S"));
}
}
}
SEXP
R_rb_get_class(SEXP r_path)
{
VALUE klass;
const char * className = CHAR(STRING_ELT(r_path, 0));
klass = rb_path2class(className);
return(makeRubyObjectRef(klass));
}
static
void ray_gl_debug_proc(GLenum source,
GLenum type,
GLuint id,
GLenum severity,
GLsizei length,
const GLchar *message,
GLvoid *param) {
VALUE rb_source = Qnil;
switch (source) {
case GL_DEBUG_SOURCE_API_ARB:
rb_source = RAY_SYM("api"); break;
case GL_DEBUG_SOURCE_WINDOW_SYSTEM_ARB:
rb_source = RAY_SYM("window_system"); break;
case GL_DEBUG_SOURCE_SHADER_COMPILER_ARB:
rb_source = RAY_SYM("shader_compiler"); break;
case GL_DEBUG_SOURCE_THIRD_PARTY_ARB:
rb_source = RAY_SYM("third_party"); break;
case GL_DEBUG_SOURCE_APPLICATION_ARB:
rb_source = RAY_SYM("application"); break;
default:
rb_source = RAY_SYM("other"); break;
}
VALUE rb_type = Qnil;
switch (type) {
case GL_DEBUG_TYPE_ERROR_ARB:
rb_type = RAY_SYM("error"); break;
case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB:
rb_type = RAY_SYM("deprecated_behavior"); break;
case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB:
rb_type = RAY_SYM("undefined_behavior"); break;
case GL_DEBUG_TYPE_PORTABILITY_ARB:
rb_type = RAY_SYM("portability"); break;
case GL_DEBUG_TYPE_PERFORMANCE_ARB:
rb_type = RAY_SYM("performance"); break;
default:
rb_type = RAY_SYM("other"); break;
}
VALUE rb_id = ULONG2NUM(id);
VALUE rb_severity = Qnil;
switch (severity) {
case GL_DEBUG_SEVERITY_HIGH_ARB:
rb_severity = RAY_SYM("high"); break;
case GL_DEBUG_SEVERITY_MEDIUM_ARB:
rb_severity = RAY_SYM("medium"); break;
default:
rb_severity = RAY_SYM("low"); break;
}
VALUE rb_message = rb_str_new(message, length);
VALUE proc = rb_iv_get(rb_path2class("Ray::GL"), "@callback");
rb_funcall(proc, RAY_METH("call"), 5, rb_source, rb_type, rb_id, rb_severity,
rb_message);
}
ray_drawable *ray_rb2full_drawable(VALUE obj) {
if (rb_obj_is_kind_of(obj, rb_path2class("Ray::Text")) ||
rb_obj_is_kind_of(obj, rb_path2class("Ray::Sprite")) ||
rb_obj_is_kind_of(obj, rb_path2class("Ray::Polygon")) ||
!rb_obj_is_kind_of(obj, rb_path2class("Ray::Drawable"))) {
rb_raise(rb_eTypeError, "can't get drawable pointer from %s",
RAY_OBJ_CLASSNAME(obj));
}
ray_drawable *ptr = NULL;
Data_Get_Struct(obj, ray_drawable, ptr);
if (!ptr->drawable) {
rb_raise(rb_eRuntimeError, "trying to use an uninitialized drawable");
}
return ptr;
}
VALUE OR_Matrix::to_ruby()
{
Matrix matrix;
MArray<double> values;
double cell;
int i, number_of_values;
VALUE argv[2];
matrix = octave_val.matrix_value();
int number_of_rows = matrix.rows();
int number_of_columns = matrix.columns();
if ((number_of_rows == 0) && (number_of_columns == 0)) {
return rb_ary_new2(0);
} else if (number_of_columns == 1) {
values = matrix.column(0);
} else {
argv[0] = INT2FIX(number_of_rows);
argv[1] = INT2FIX(number_of_columns);
ruby_val = rb_class_new_instance(2, argv, rb_path2class("Octave::Matrix"));
int row_index, column_index = 0;
VALUE cells, row;
cells = rb_ary_new2(number_of_rows);
for (row_index = 0; row_index < number_of_rows; row_index++) {
row = rb_ary_new2(number_of_columns);
values = matrix.row(row_index);
for (column_index = 0; column_index < number_of_columns; column_index++) {
cell = values(column_index);
if (xisnan(cell) || octave_is_NA(cell)) {
rb_ary_push(row, Qnil);
} else {
rb_ary_push(row, rb_float_new(cell));
}
}
rb_ary_push(cells, row);
}
rb_iv_set(ruby_val, "@cells", cells);
return ruby_val;
}
number_of_values = values.length();
ruby_val = rb_ary_new2(number_of_values);
for (i = 0; i < number_of_values; i++) {
cell = values(i);
if (xisnan(cell) || octave_is_NA(cell)) {
rb_ary_push(ruby_val, Qnil);
} else {
rb_ary_push(ruby_val, rb_float_new(cell));
}
}
return ruby_val;
}
void rbqml_init_component() {
rbqml_cComponent = rb_define_class_under(rb_path2class("QML"), "Component", rb_cObject);
rb_define_alloc_func(rbqml_cComponent, &component_alloc);
rb_define_private_method(rbqml_cComponent, "initialize_impl", &component_initialize, 0);
rb_define_private_method(rbqml_cComponent, "load_path_impl", &component_load_path, 1);
rb_define_private_method(rbqml_cComponent, "load_data_impl", &component_load_data, 2);
rb_define_private_method(rbqml_cComponent, "error_string", &component_error_string, 0);
rb_define_private_method(rbqml_cComponent, "create_impl", &component_create, 0);
}
static VALUE rbkit_status_as_hash(VALUE self) {
VALUE status = rb_hash_new();
VALUE pid = rb_funcall(rb_path2class("Process"), rb_intern("pid"), 0, 0);
VALUE processName = rb_funcall(rb_path2class("Process"), rb_intern("argv0"), 0, 0);
VALUE rbkitModule = rb_define_module("Rbkit");
int object_trace_enabled = (logger && logger->enabled) ? 1 : 0;
int cpu_profiling_enabled = (logger && logger->sampling_profiler_enabled) ? 1 : 0;
rb_hash_aset(status, ID2SYM(rb_intern("rbkit_server_version")), rb_const_get(rbkitModule, rb_intern("VERSION")));
rb_hash_aset(status, ID2SYM(rb_intern("rbkit_protocol_version")), rbkit_protocol_version());
rb_hash_aset(status, ID2SYM(rb_intern("process_name")), processName);
rb_hash_aset(status, ID2SYM(rb_intern("pwd")), rb_dir_getwd());
rb_hash_aset(status, ID2SYM(rb_intern("pid")), pid);
rb_hash_aset(status, ID2SYM(rb_intern("object_trace_enabled")), INT2FIX(object_trace_enabled));
rb_hash_aset(status, ID2SYM(rb_intern("cpu_profiling_enabled")), INT2FIX(cpu_profiling_enabled));
rb_hash_aset(status, ID2SYM(rb_intern("clock_type")), rb_ivar_get(self, rb_intern("@clock_type")));
rb_hash_aset(status, ID2SYM(rb_intern("cpu_profiling_mode")), rb_ivar_get(self, rb_intern("@cpu_profiling_mode")));
return status;
}
static VALUE
compare(VALUE a, VALUE b)
{
double aD, bD;
ID minDistance;
minDistance = ID2SYM(rb_intern("min_distance"));
if (CLASS_OF(a) == rb_path2class("RubyVor::PriorityQueue::QueueItem"))
aD = NUM2DBL(rb_funcall(a, rb_intern("priority"), 0));
else
rb_raise(rb_eTypeError, "wrong argument type %s (expected %s)", rb_obj_classname(a), rb_obj_classname(rb_path2class("RubyVor::PriorityQueue::QueueItem")));
if (CLASS_OF(a) == rb_path2class("RubyVor::PriorityQueue::QueueItem"))
bD = NUM2DBL(rb_funcall(b, rb_intern("priority"), 0));
else
rb_raise(rb_eTypeError, "wrong argument type %s (expected %s)", rb_obj_classname(a), rb_obj_classname(rb_path2class("RubyVor::PriorityQueue::QueueItem")));
return RTEST(aD < bD);
}
/** Find any Set arguments and ensure they are formatted as Strings */
static void rdo_mysql_driver_normalize_sets_bang(VALUE * args, int argc) {
int i = 0;
for (; i < argc; ++i) {
if (rb_funcall(args[i], rb_intern("kind_of?"), 1, rb_path2class("Set")))
args[i] = rb_funcall(args[i], rb_intern("to_a"), 0);
if (rb_funcall(args[i], rb_intern("kind_of?"), 1, rb_cArray))
args[i] = rb_funcall(args[i], rb_intern("join"), 1, rb_str_new2(","));
}
}
/*
* A class for calculating message digests using RIPEMD-160
* cryptographic hash function, designed by Hans Dobbertin, Antoon
* Bosselaers, and Bart Preneel.
*/
void
Init_rmd160(void)
{
VALUE mDigest, cDigest_Base, cDigest_RMD160;
rb_require("digest");
#if 0
mDigest = rb_define_module("Digest"); /* let rdoc know */
#endif
mDigest = rb_path2class("Digest");
cDigest_Base = rb_path2class("Digest::Base");
cDigest_RMD160 = rb_define_class_under(mDigest, "RMD160", cDigest_Base);
#undef RUBY_UNTYPED_DATA_WARNING
#define RUBY_UNTYPED_DATA_WARNING 0
rb_ivar_set(cDigest_RMD160, rb_intern("metadata"),
Data_Wrap_Struct(0, 0, 0, (void *)&rmd160));
}
