static void
rb_grn_init_version (VALUE mGrn)
{
VALUE build_version, bindings_version;
rb_grn_init_runtime_version(mGrn);
build_version = rb_ary_new3(3,
INT2NUM(GRN_MAJOR_VERSION),
INT2NUM(GRN_MINOR_VERSION),
INT2NUM(GRN_MICRO_VERSION));
rb_obj_freeze(build_version);
/*
* ビルドしたgroongaのバージョン。 @[メジャーバージョン,
* マイナーバージョン, マイクロバージョン]@ の配列。
*/
rb_define_const(mGrn, "BUILD_VERSION", build_version);
bindings_version = rb_ary_new3(3,
INT2NUM(RB_GRN_MAJOR_VERSION),
INT2NUM(RB_GRN_MINOR_VERSION),
INT2NUM(RB_GRN_MICRO_VERSION));
rb_obj_freeze(bindings_version);
/*
* rroongaのバージョン。 @[メジャーバージョン, マ
* イナーバージョン, マイクロバージョン]@ の配列。
*/
rb_define_const(mGrn, "BINDINGS_VERSION", bindings_version);
}
void
pg_define_coder( const char *name, void *func, VALUE klass, VALUE nsp )
{
VALUE type_obj = Data_Wrap_Struct( klass, NULL, NULL, func );
VALUE objname = rb_str_dup(rb_mod_name(nsp));
rb_str_cat2( objname, "::");
rb_str_cat2( objname, name);
rb_iv_set( type_obj, "@name", rb_obj_freeze(objname) );
rb_define_const( nsp, name, rb_obj_freeze(type_obj) );
RB_GC_GUARD(type_obj);
}
static int lookup_sig(VALUE sig)
{
static VALUE list;
const char *ptr;
long len;
sig = rb_obj_as_string(sig);
len = RSTRING_LEN(sig);
ptr = RSTRING_PTR(sig);
if (len > 3 && !memcmp("SIG", ptr, 3))
sig = rb_str_new(ptr + 3, len - 3);
if (!list) {
VALUE mSignal = rb_const_get(rb_cObject, rb_intern("Signal"));
list = rb_funcall(mSignal, rb_intern("list"), 0);
rb_obj_freeze(list);
rb_global_variable(&list);
}
sig = rb_hash_aref(list, sig);
if (NIL_P(sig))
rb_raise(rb_eArgError, "invalid signal: %s\n", ptr);
return NUM2INT(sig);
}
static VALUE
env_str_new(const char *ptr, long len)
{
VALUE str = rb_tainted_str_new(ptr, len);
rb_obj_freeze(str);
return str;
}
DLL_LOCAL VALUE _class_get(int argc,VALUE *argv,VALUE self)
{
VALUE size,family,style,weight,underlined;
rb_scan_args(argc, argv, "41",&size,&family,&style,&weight,&underlined);
//TODO add refcounting
wxFont *font = wxTheFontList->FindOrCreateFont(
RB_NUM2INT(size),
unwrapenum<wxFontFamily>(family),
unwrapenum<wxFontStyle>(style),
unwrapenum<wxFontWeight>(weight),
RTEST(underlined)
);
if(!font || !font->IsOk())
return Qnil;
//look in the FontList holder is font was already wrapped
fontlisttype::iterator it = fontlistholder.find(font);
if(it != fontlistholder.end()) {
return it->second;
} else {
//wrap wxFont pointer to ruby object
VALUE result = wrap(font);
//FontList objects should not be changed
rb_obj_freeze(result);
//Prevent FontList objects from been deleted
rwx_refobject(result);
//add wrapped font to the FontList holder to find it again
fontlistholder[font] = result;
return result;
}
}
VALUE layout_get_default(const upb_fielddef *field) {
switch (upb_fielddef_type(field)) {
case UPB_TYPE_FLOAT: return DBL2NUM(upb_fielddef_defaultfloat(field));
case UPB_TYPE_DOUBLE: return DBL2NUM(upb_fielddef_defaultdouble(field));
case UPB_TYPE_BOOL:
return upb_fielddef_defaultbool(field) ? Qtrue : Qfalse;
case UPB_TYPE_MESSAGE: return Qnil;
case UPB_TYPE_ENUM: {
const upb_enumdef *enumdef = upb_fielddef_enumsubdef(field);
int32_t num = upb_fielddef_defaultint32(field);
const char *label = upb_enumdef_iton(enumdef, num);
if (label) {
return ID2SYM(rb_intern(label));
} else {
return INT2NUM(num);
}
}
case UPB_TYPE_INT32: return INT2NUM(upb_fielddef_defaultint32(field));
case UPB_TYPE_INT64: return LL2NUM(upb_fielddef_defaultint64(field));;
case UPB_TYPE_UINT32: return UINT2NUM(upb_fielddef_defaultuint32(field));
case UPB_TYPE_UINT64: return ULL2NUM(upb_fielddef_defaultuint64(field));
case UPB_TYPE_STRING:
case UPB_TYPE_BYTES: {
size_t size;
const char *str = upb_fielddef_defaultstr(field, &size);
VALUE str_rb = rb_str_new(str, size);
rb_enc_associate(str_rb, (upb_fielddef_type(field) == UPB_TYPE_BYTES) ?
kRubyString8bitEncoding : kRubyStringUtf8Encoding);
rb_obj_freeze(str_rb);
return str_rb;
}
default: return Qnil;
}
}
// View#getInverseTransform()
// View#get_inverse_transform()
// View#inverse_transform()
VALUE rbView::GetInverseTransform( VALUE aSelf )
{
const sf::Transform& transform = rbMacros::ToSFML< sf::View >( aSelf, rbView::Class )->getInverseTransform();
VALUE obj = rbMacros::ToRuby( const_cast< sf::Transform* >( &transform ), rbTransform::Class );
rb_iv_set( obj, "@__ref__owner", aSelf );
rb_obj_freeze( obj );
return obj;
}
void
Init_version()
{
VALUE v = rb_obj_freeze(rb_str_new2(ruby_version));
VALUE d = rb_obj_freeze(rb_str_new2(ruby_release_date));
VALUE p = rb_obj_freeze(rb_str_new2(ruby_platform));
rb_define_global_const("RUBY_VERSION", v);
rb_define_global_const("RUBY_RELEASE_DATE", d);
rb_define_global_const("RUBY_PLATFORM", p);
rb_define_global_const("RUBY_PATCHLEVEL", INT2FIX(RUBY_PATCHLEVEL));
/* obsolete constants */
rb_define_global_const("VERSION", v);
rb_define_global_const("RELEASE_DATE", d);
rb_define_global_const("PLATFORM", p);
}
// RenderTexture#texture
// RenderTexture#get_texture
// RenderTexture#getTexture
VALUE rbRenderTexture::GetTexture( VALUE aSelf )
{
const sf::Texture& texture = rbMacros::ToSFML< sf::RenderTexture >( aSelf, rbRenderTexture::Class )->getTexture();
VALUE object = rbMacros::ToRubyNoGC( const_cast< sf::Texture* >( &texture ), rbTexture::Class );
rb_iv_set( object, "@__ref__owner", aSelf );
rb_obj_freeze( object );
return object;
}
/*
* call-seq:
* buf.to_s => String
*
* Returns a String (binary) representation of the buffer.
*
* === Examples
* buf = ArrayBuffer.new("buffer") => ArrayBuffer
* buf.byte_length => 6
* buf.to_s => "buffer"
*
*/
VALUE rb_array_buffer_to_s(VALUE obj)
{
VALUE str;
GetArrayBuffer(obj);
str = rb_str_new((const char*)buf->buf, buf->length);
ArrayBufferEncode(str);
return rb_obj_freeze(str);
}
static void
set_rack_input(VALUE env, struct evbuffer* evbuffer)
{
VALUE str = rb_str_new((const char*)EVBUFFER_DATA(evbuffer),
EVBUFFER_LENGTH(evbuffer));
rb_obj_freeze(str);
volatile VALUE ret = rb_funcall(rb_cStringIO, rb_intern("new"), 1, str);
rb_hash_aset(env, global_envs[GE_RACK_INPUT], ret);
}
VALUE Init_oci8(void)
{
#if 0
oci8_cOCIHandle = rb_define_class("OCIHandle", rb_cObject);
cOCI8 = rb_define_class("OCI8", oci8_cOCIHandle);
#endif
cOCI8 = oci8_define_class("OCI8", &oci8_svcctx_class);
cSession = oci8_define_class_under(cOCI8, "Session", &oci8_svcctx_associate_class);
cServer = oci8_define_class_under(cOCI8, "Server", &oci8_svcctx_associate_class);
id_at_session_handle = rb_intern("@session_handle");
id_at_server_handle = rb_intern("@server_handle");
oracle_client_vernum = INT2FIX(oracle_client_version);
if (have_OCIClientVersion) {
sword major, minor, update, patch, port_update;
OCIClientVersion(&major, &minor, &update, &patch, &port_update);
oracle_client_vernum = INT2FIX(ORAVERNUM(major, minor, update, patch, port_update));
}
sym_SYSDBA = ID2SYM(rb_intern("SYSDBA"));
sym_SYSOPER = ID2SYM(rb_intern("SYSOPER"));
id_at_prefetch_rows = rb_intern("@prefetch_rows");
id_set_prefetch_rows = rb_intern("prefetch_rows=");
rb_define_const(cOCI8, "VERSION", rb_obj_freeze(rb_usascii_str_new_cstr(OCI8LIB_VERSION)));
rb_define_singleton_method_nodoc(cOCI8, "oracle_client_vernum", oci8_s_oracle_client_vernum, 0);
rb_define_singleton_method_nodoc(cOCI8, "__set_property", oci8_s_set_property, 2);
if (have_OCIMessageOpen && have_OCIMessageGet) {
rb_define_singleton_method(cOCI8, "error_message", oci8_s_error_message, 1);
}
rb_define_private_method(cOCI8, "parse_connect_string", oci8_parse_connect_string, 1);
rb_define_private_method(cOCI8, "logon", oci8_logon, 3);
rb_define_private_method(cOCI8, "allocate_handles", oci8_allocate_handles, 0);
rb_define_private_method(cOCI8, "session_handle", oci8_get_session_handle, 0);
rb_define_private_method(cOCI8, "server_handle", oci8_get_server_handle, 0);
rb_define_private_method(cOCI8, "server_attach", oci8_server_attach, 2);
rb_define_private_method(cOCI8, "session_begin", oci8_session_begin, 2);
rb_define_method(cOCI8, "logoff", oci8_svcctx_logoff, 0);
rb_define_method(cOCI8, "parse", oci8_svcctx_parse, 1);
rb_define_method(cOCI8, "commit", oci8_commit, 0);
rb_define_method(cOCI8, "rollback", oci8_rollback, 0);
rb_define_method(cOCI8, "non_blocking?", oci8_non_blocking_p, 0);
rb_define_method(cOCI8, "non_blocking=", oci8_set_non_blocking, 1);
rb_define_method(cOCI8, "autocommit?", oci8_autocommit_p, 0);
rb_define_method(cOCI8, "autocommit=", oci8_set_autocommit, 1);
rb_define_method(cOCI8, "long_read_len", oci8_long_read_len, 0);
rb_define_method(cOCI8, "long_read_len=", oci8_set_long_read_len, 1);
rb_define_method(cOCI8, "break", oci8_break, 0);
rb_define_method(cOCI8, "prefetch_rows=", oci8_set_prefetch_rows, 1);
rb_define_private_method(cOCI8, "oracle_server_vernum", oci8_oracle_server_vernum, 0);
rb_define_method(cOCI8, "ping", oci8_ping, 0);
rb_define_method(cOCI8, "client_identifier=", oci8_set_client_identifier, 1);
rb_define_method(cOCI8, "module=", oci8_set_module, 1);
rb_define_method(cOCI8, "action=", oci8_set_action, 1);
rb_define_method(cOCI8, "client_info=", oci8_set_client_info, 1);
return cOCI8;
}
void Init_wkhtml_native() {
//Global initialization of library and when Ruby shuts down
wkhtmltopdf_init(USE_GRAPHICS_INT);
wkhtmltoimage_init(USE_GRAPHICS_INT);
rb_set_end_proc(Deinit_wkhtml_native, Qnil);
idReady = rb_intern("ready");
mWkHtml = rb_define_module("WkHtml");
rb_define_const(mWkHtml, "LIBRARY_VERSION", rb_obj_freeze(rb_str_new_cstr(wkhtmltopdf_version())));
rb_define_const(mWkHtml, "USE_GRAPHICS", INT2BOOL(USE_GRAPHICS_INT));
mWkHtmlToPdf = rb_define_module_under(mWkHtml, "ToPdf");
cWkHtmlToPdfGlobalSettings = rb_define_class_under(mWkHtmlToPdf, "GlobalSettings", rb_cObject);
rb_define_alloc_func(cWkHtmlToPdfGlobalSettings, wkhtml_topdf_globalsettings_alloc);
rb_define_method(cWkHtmlToPdfGlobalSettings, "[]=", wkhtml_topdf_globalsettings_aset, 2);
rb_define_method(cWkHtmlToPdfGlobalSettings, "[]", wkhtml_topdf_globalsettings_aref, 1);
cWkHtmlToPdfObjectSettings = rb_define_class_under(mWkHtmlToPdf, "ObjectSettings", rb_cObject);
rb_define_alloc_func(cWkHtmlToPdfObjectSettings, wkhtml_topdf_objectsettings_alloc);
rb_define_method(cWkHtmlToPdfObjectSettings, "[]=", wkhtml_topdf_objectsettings_aset, 2);
rb_define_method(cWkHtmlToPdfObjectSettings, "[]", wkhtml_topdf_objectsettings_aref, 1);
cWkHtmlToPdfConverter = rb_define_class_under(mWkHtmlToPdf, "Converter", rb_cObject);
/*
TODO
rb_define_singleton_method(klass, "new", constructor, 1); //Uses Data_Wrap_Struct -> rb_obj_call_init(t_data, 1, argv);
rb_define_method(klass, "initialize", initialize, 1);
*/
rb_define_singleton_method(cWkHtmlToPdfConverter, "create", wkhtml_topdf_converter_create, 1);
rb_define_method(cWkHtmlToPdfConverter, "add_object", wkhtml_topdf_converter_add_object, 2);
rb_define_method(cWkHtmlToPdfConverter, "convert", wkhtml_topdf_converter_convert, 0);
rb_define_method(cWkHtmlToPdfConverter, "http_error_code", wkhtml_topdf_converter_http_error_code, 0);
rb_define_method(cWkHtmlToPdfConverter, "get_output", wkhtml_topdf_converter_get_output, 0);
//Force use of factory method
rb_undef_alloc_func(cWkHtmlToPdfConverter);
rb_undef_method(rb_singleton_class(cWkHtmlToPdfConverter), "new");
mWkHtmlToImage = rb_define_module_under(mWkHtml, "ToImage");
cWkHtmlToImageGlobalSettings = rb_define_class_under(mWkHtmlToImage, "GlobalSettings", rb_cObject);
rb_define_alloc_func(cWkHtmlToImageGlobalSettings, wkhtml_toimage_globalsettings_alloc);
rb_define_method(cWkHtmlToImageGlobalSettings, "[]=", wkhtml_toimage_globalsettings_aset, 2);
rb_define_method(cWkHtmlToImageGlobalSettings, "[]", wkhtml_toimage_globalsettings_aref, 1);
cWkHtmlToImageConverter = rb_define_class_under(mWkHtmlToImage, "Converter", rb_cObject);
rb_define_singleton_method(cWkHtmlToImageConverter, "create", wkhtml_toimage_converter_create, 2);
rb_define_method(cWkHtmlToImageConverter, "convert", wkhtml_toimage_converter_convert, 0);
rb_define_method(cWkHtmlToImageConverter, "http_error_code", wkhtml_toimage_converter_http_error_code, 0);
rb_define_method(cWkHtmlToImageConverter, "get_output", wkhtml_toimage_converter_get_output, 0);
//Force use of factory method
rb_undef_alloc_func(cWkHtmlToImageConverter);
rb_undef_method(rb_singleton_class(cWkHtmlToImageConverter), "new");
}
static void
add_modules(VALUE *req_list, const char *mod)
{
VALUE list = *req_list;
if (!list) {
*req_list = list = rb_ary_new();
RBASIC(list)->klass = 0;
}
rb_ary_push(list, rb_obj_freeze(rb_str_new2(mod)));
}
static void
add_modules(struct cmdline_options *opt, const char *mod)
{
VALUE list = opt->req_list;
if (!list) {
opt->req_list = list = rb_ary_new();
RBASIC(list)->klass = 0;
}
rb_ary_push(list, rb_obj_freeze(rb_str_new2(mod)));
}
// Transform#matrix
// Transform#get_matrix
// Transform#getMatrix
VALUE rbTransform::GetMatrix( VALUE aSelf )
{
const float* values = rbMacros::ToSFML< sf::Transform >( aSelf, rbTransform::Class )->getMatrix();
VALUE array = rb_ary_new2( 16 );
for( unsigned int index = 0; index < 16; index++ )
{
rb_ary_store( array, index, rb_float_new( values[ index ] ) );
}
rb_obj_freeze( array );
return array;
}
static inline VALUE sandbox(const char * name, uint64_t flags) {
VALUE obj = rb_sandbox_s_alloc(rb_cSandbox);
rb_sandbox_t * box;
Data_Get_Struct(obj, rb_sandbox_t, box);
box->profile = strcpy(malloc(strlen(name)), name);
box->flags = flags;
return rb_obj_freeze(obj);
}
// RenderStates#initialize_copy(state)
VALUE rbRenderStates::InitializeCopy( VALUE aSelf, VALUE aState )
{
sf::RenderStates* states = rbRenderStates::ToSFML( aSelf );
*states = *rbRenderStates::ToSFML( aState );
VALUE transform = rbMacros::ToRubyNoGC( &states->transform, rbTransform::Class );
rb_iv_set( aSelf, "@__ref__transform", transform );
rb_iv_set( transform, "@__ref__state_owner", aSelf );
rb_obj_freeze( transform );
VALUE texture = rbMacros::ToRubyNoGC( const_cast< sf::Texture* >( states->texture ), rbTexture::Class );
rb_iv_set( aSelf, "@__ref__texture", texture );
rb_iv_set( texture, "@__ref__state_owner", aSelf );
rb_obj_freeze( texture );
VALUE shader = rbMacros::ToRubyNoGC( const_cast< sf::Shader* >( states->shader ), rbShader::Class );
rb_iv_set( aSelf, "@__ref__shader", shader );
rb_iv_set( shader, "@__ref__state_owner", aSelf );
rb_obj_freeze( shader );
return aSelf;
}
void Init_thin_backend()
{
/* Intern some Ruby strings and symbols */
cStringIO = rb_define_class("StringIO", rb_cData);
sInternedCall = rb_intern("call");
sInternedKeys = rb_intern("keys");
sRackInput = rb_obj_freeze(rb_str_new2("rack.input"));
rb_gc_register_address(&sRackInput);
/* Initialize internal stuff */
backend_define();
parser_callbacks_define();
}
void
Init_pkcs11_protect_server_ext()
{
VALUE eError;
mPKCS11 = rb_const_get(rb_cObject, rb_intern("PKCS11"));
mProtectServer = rb_define_module_under(mPKCS11, "ProtectServer");
/* Library version */
rb_define_const( mProtectServer, "VERSION", rb_str_new2(VERSION) );
eError = rb_const_get(mPKCS11, rb_intern("Error"));
/* Document-class: PKCS11::ProtectServer::Error
*
* Base class for all ProtectServer specific exceptions (CKR_*) */
eProtectServerError = rb_define_class_under(mProtectServer, "Error", eError);
cPkcs11CStruct = rb_const_get(mPKCS11, rb_intern("CStruct")); \
cProtectServerCStruct = rb_define_class_under(mProtectServer, "CStruct", cPkcs11CStruct);
#include "pk11s_struct_def.inc"
vOBJECT_CLASSES = rb_hash_new();
vATTRIBUTES = rb_hash_new();
vMECHANISMS = rb_hash_new();
vRETURN_VALUES = rb_hash_new();
rb_define_const(mProtectServer, "OBJECT_CLASSES", vOBJECT_CLASSES);
rb_define_const(mProtectServer, "ATTRIBUTES", vATTRIBUTES);
rb_define_const(mProtectServer, "MECHANISMS", vMECHANISMS);
rb_define_const(mProtectServer, "RETURN_VALUES", vRETURN_VALUES);
#include "pk11s_const_def.inc"
rb_obj_freeze(vOBJECT_CLASSES);
rb_obj_freeze(vATTRIBUTES);
rb_obj_freeze(vMECHANISMS);
rb_obj_freeze(vRETURN_VALUES);
}
static void Init_grpc_error_codes() {
/* Constants representing the error codes of grpc_call_error in grpc.h */
VALUE grpc_rb_mRpcErrors =
rb_define_module_under(grpc_rb_mGrpcCore, "RpcErrors");
rb_define_const(grpc_rb_mRpcErrors, "OK", UINT2NUM(GRPC_CALL_OK));
rb_define_const(grpc_rb_mRpcErrors, "ERROR", UINT2NUM(GRPC_CALL_ERROR));
rb_define_const(grpc_rb_mRpcErrors, "NOT_ON_SERVER",
UINT2NUM(GRPC_CALL_ERROR_NOT_ON_SERVER));
rb_define_const(grpc_rb_mRpcErrors, "NOT_ON_CLIENT",
UINT2NUM(GRPC_CALL_ERROR_NOT_ON_CLIENT));
rb_define_const(grpc_rb_mRpcErrors, "ALREADY_ACCEPTED",
UINT2NUM(GRPC_CALL_ERROR_ALREADY_ACCEPTED));
rb_define_const(grpc_rb_mRpcErrors, "ALREADY_INVOKED",
UINT2NUM(GRPC_CALL_ERROR_ALREADY_INVOKED));
rb_define_const(grpc_rb_mRpcErrors, "NOT_INVOKED",
UINT2NUM(GRPC_CALL_ERROR_NOT_INVOKED));
rb_define_const(grpc_rb_mRpcErrors, "ALREADY_FINISHED",
UINT2NUM(GRPC_CALL_ERROR_ALREADY_FINISHED));
rb_define_const(grpc_rb_mRpcErrors, "TOO_MANY_OPERATIONS",
UINT2NUM(GRPC_CALL_ERROR_TOO_MANY_OPERATIONS));
rb_define_const(grpc_rb_mRpcErrors, "INVALID_FLAGS",
UINT2NUM(GRPC_CALL_ERROR_INVALID_FLAGS));
/* Add the detail strings to a Hash */
rb_error_code_details = rb_hash_new();
rb_hash_aset(rb_error_code_details, UINT2NUM(GRPC_CALL_OK),
rb_str_new2("ok"));
rb_hash_aset(rb_error_code_details, UINT2NUM(GRPC_CALL_ERROR),
rb_str_new2("unknown error"));
rb_hash_aset(rb_error_code_details, UINT2NUM(GRPC_CALL_ERROR_NOT_ON_SERVER),
rb_str_new2("not available on a server"));
rb_hash_aset(rb_error_code_details, UINT2NUM(GRPC_CALL_ERROR_NOT_ON_CLIENT),
rb_str_new2("not available on a client"));
rb_hash_aset(rb_error_code_details,
UINT2NUM(GRPC_CALL_ERROR_ALREADY_ACCEPTED),
rb_str_new2("call is already accepted"));
rb_hash_aset(rb_error_code_details, UINT2NUM(GRPC_CALL_ERROR_ALREADY_INVOKED),
rb_str_new2("call is already invoked"));
rb_hash_aset(rb_error_code_details, UINT2NUM(GRPC_CALL_ERROR_NOT_INVOKED),
rb_str_new2("call is not yet invoked"));
rb_hash_aset(rb_error_code_details,
UINT2NUM(GRPC_CALL_ERROR_ALREADY_FINISHED),
rb_str_new2("call is already finished"));
rb_hash_aset(rb_error_code_details,
UINT2NUM(GRPC_CALL_ERROR_TOO_MANY_OPERATIONS),
rb_str_new2("outstanding read or write present"));
rb_hash_aset(rb_error_code_details, UINT2NUM(GRPC_CALL_ERROR_INVALID_FLAGS),
rb_str_new2("a bad flag was given"));
rb_define_const(grpc_rb_mRpcErrors, "ErrorMessages", rb_error_code_details);
rb_obj_freeze(rb_error_code_details);
}
/*
* :nodoc:
* Utility function to allocate a new ArrayBuffer instance of given length. An optional pointer to an existing chunk
* of memory may be passed, which becomes the buffer contents. This is useful for reading raw binary data from
* standard I/O or sockets as binary strings.
*
*/
VALUE rb_alloc_array_buffer(unsigned long length, void *data)
{
VALUE buffer;
rb_array_buffer_t *buf = NULL;
if (length == 0) rb_raise(rb_eRangeError, "ArrayBuffer is not a small enough positive integer");
buffer = Data_Make_Struct(rb_cArrayBuffer, rb_array_buffer_t, 0, rb_free_array_buffer, buf);
buf->length = length;
buf->buf = xcalloc(buf->length, 1);
if (!buf->buf) rb_raise(rb_eRangeError, "Unable to allocate ArrayBuffer");
if (data) memmove(buf->buf, data, length);
rb_obj_call_init(buffer, 0, NULL);
rb_obj_freeze(buffer);
return buffer;
}
void
Init_version()
{
static char description[128];
static char copyright[128];
VALUE e = MKSTR(engine);
VALUE v = MKSTR(version);
VALUE d = MKSTR(release_date);
VALUE p = MKSTR(platform);
VALUE tmp;
rb_define_global_const("RUBY_ENGINE", e);
rb_define_global_const("RUBY_VERSION", v);
rb_define_global_const("RUBY_RELEASE_DATE", d);
rb_define_global_const("RUBY_PLATFORM", p);
rb_define_global_const("RUBY_PATCHLEVEL", INT2FIX(RUBY_PATCHLEVEL));
snprintf(description, sizeof(description),
"ruby %s (%s %s %d) [%s], MBARI 0x%x, Ruby Enterprise Edition %s",
RUBY_VERSION, RUBY_RELEASE_DATE, RUBY_RELEASE_STR,
RUBY_RELEASE_NUM, RUBY_PLATFORM,
STACK_WIPE_SITES, REE_VERSION);
ruby_description = description;
tmp = rb_obj_freeze(rb_str_new2(description));
rb_define_global_const("RUBY_DESCRIPTION", tmp);
snprintf(copyright, sizeof(copyright), "ruby - Copyright (C) %d-%d %s",
RUBY_BIRTH_YEAR, RUBY_RELEASE_YEAR, RUBY_AUTHOR);
ruby_copyright = copyright;
tmp = rb_obj_freeze(rb_str_new2(copyright));
rb_define_global_const("RUBY_COPYRIGHT", tmp);
/* obsolete constants */
rb_define_global_const("VERSION", v);
rb_define_global_const("RELEASE_DATE", d);
rb_define_global_const("PLATFORM", p);
}
/*
* call-seq:
* unixsocket.path => path
*
* Returns the path of the local address of unixsocket.
*
* s = UNIXServer.new("/tmp/sock")
* p s.path #=> "/tmp/sock"
*
*/
static VALUE
unix_path(VALUE sock)
{
rb_io_t *fptr;
GetOpenFile(sock, fptr);
if (NIL_P(fptr->pathv)) {
struct sockaddr_un addr;
socklen_t len = (socklen_t)sizeof(addr);
if (getsockname(fptr->fd, (struct sockaddr*)&addr, &len) < 0)
rb_sys_fail(0);
fptr->pathv = rb_obj_freeze(rb_str_new_cstr(rsock_unixpath(&addr, len)));
}
return rb_str_dup(fptr->pathv);
}
/* Construct expanded load path and store it to cache.
We rebuild load path partially if the cache is invalid.
We don't cache non string object and expand it every time. We ensure that
string objects in $LOAD_PATH are frozen.
*/
static void
rb_construct_expanded_load_path(int type, int *has_relative, int *has_non_cache)
{
rb_vm_t *vm = GET_VM();
VALUE load_path = vm->load_path;
VALUE expanded_load_path = vm->expanded_load_path;
VALUE ary;
long i;
int level = rb_safe_level();
ary = rb_ary_tmp_new(RARRAY_LEN(load_path));
for (i = 0; i < RARRAY_LEN(load_path); ++i) {
VALUE path, as_str, expanded_path;
int is_string, non_cache;
char *as_cstr;
as_str = path = RARRAY_AREF(load_path, i);
is_string = RB_TYPE_P(path, T_STRING) ? 1 : 0;
non_cache = !is_string ? 1 : 0;
as_str = rb_get_path_check_to_string(path, level);
as_cstr = RSTRING_PTR(as_str);
if (!non_cache) {
if ((type == EXPAND_RELATIVE &&
rb_is_absolute_path(as_cstr)) ||
(type == EXPAND_HOME &&
(!as_cstr[0] || as_cstr[0] != '~')) ||
(type == EXPAND_NON_CACHE)) {
/* Use cached expanded path. */
rb_ary_push(ary, RARRAY_AREF(expanded_load_path, i));
continue;
}
}
if (!*has_relative && !rb_is_absolute_path(as_cstr))
*has_relative = 1;
if (!*has_non_cache && non_cache)
*has_non_cache = 1;
/* Freeze only string object. We expand other objects every time. */
if (is_string)
rb_str_freeze(path);
as_str = rb_get_path_check_convert(path, as_str, level);
expanded_path = rb_file_expand_path_fast(as_str, Qnil);
rb_str_freeze(expanded_path);
rb_ary_push(ary, rb_fstring(expanded_path));
}
rb_obj_freeze(ary);
vm->expanded_load_path = ary;
rb_ary_replace(vm->load_path_snapshot, vm->load_path);
}
void Init_spidermonkey()
{
JS_SetCStringsAreUTF8();
VALUE johnson = rb_const_get(rb_mKernel, rb_intern("Johnson"));
VALUE spidermonkey = rb_define_module_under(johnson, "SpiderMonkey");
init_Johnson_SpiderMonkey_Context(spidermonkey);
init_Johnson_SpiderMonkey_Proxy(spidermonkey);
init_Johnson_SpiderMonkey_Debugger(spidermonkey);
init_Johnson_SpiderMonkey_Immutable_Node(spidermonkey);
init_Johnson_SpiderMonkey_Runtime(spidermonkey);
rb_define_const(spidermonkey, "VERSION",
rb_obj_freeze(rb_str_new2(JS_GetImplementationVersion())));
}
VALUE
rb_get_expanded_load_path(void)
{
VALUE load_path = rb_get_load_path();
VALUE ary;
long i;
ary = rb_ary_new2(RARRAY_LEN(load_path));
for (i = 0; i < RARRAY_LEN(load_path); ++i) {
VALUE path = rb_file_expand_path(RARRAY_PTR(load_path)[i], Qnil);
rb_str_freeze(path);
rb_ary_push(ary, path);
}
rb_obj_freeze(ary);
return ary;
}
/*
* The package database is opened, but transactional processing
* (@see RPM::DB#transaction) cannot be done for when +writable+ is false.
* When +writable+ is +false+ then the generated object gets freezed.
* @param [Boolean] writable Whether the database is writable. Default is +false+.
* @param [String] root Root path for the database, default is empty.
* @return [RPM::DB]
*
* @example
* db = RPM::DB.open
* db.each do |pkg|
* puts pkg.name
* end
*/
static VALUE
db_s_open(int argc, VALUE* argv, VALUE obj)
{
VALUE db;
rpm_db_t* rdb;
int writable = 0;
const char* root = "";
switch (argc) {
case 0:
break;
case 1:
writable = RTEST(argv[0]);
break;
case 2:
if (!NIL_P(argv[1])) {
if (TYPE(argv[1]) != T_STRING) {
rb_raise(rb_eTypeError, "illegal argument type");
}
root = RSTRING_PTR(argv[1]);
}
writable = RTEST(argv[0]);
break;
default:
rb_raise(rb_eArgError, "too many argument(0..2)");
}
rdb = ALLOC_N(rpm_db_t,1);
if (rpmdbOpen(root, &(rdb->db), writable ? O_RDWR | O_CREAT : O_RDONLY, 0644)) {
free(rdb);
rb_raise(rb_eRuntimeError, "can not open database in %s",
RSTRING_PTR(rb_str_concat(rb_str_new2(root),
rb_str_new2("/var/lib/rpm"))));
}
rdb->ref_count = 0;
db_ref(rdb);
db = Data_Wrap_Struct(rpm_cDB, NULL, db_free, rdb);
if (!writable) {
rb_obj_freeze(db);
}
return db;
}
static void
rb_grn_init_runtime_version (VALUE mGrn)
{
const char *component_start, *component_end;
int component_length;
VALUE runtime_version;
VALUE major, minor, micro, tag;
runtime_version = rb_ary_new();
component_start = grn_get_version();
component_end = strstr(component_start, ".");
component_length = component_end - component_start;
major = rb_str_new(component_start, component_length);
rb_ary_push(runtime_version, rb_Integer(major));
component_start = component_end + 1;
component_end = strstr(component_start, ".");
component_length = component_end - component_start;
minor = rb_str_new(component_start, component_length);
rb_ary_push(runtime_version, rb_Integer(minor));
component_start = component_end + 1;
component_end = strstr(component_start, "-");
if (component_end) {
component_length = component_end - component_start;
} else {
component_length = strlen(component_start);
}
micro = rb_str_new(component_start, component_length);
rb_ary_push(runtime_version, rb_Integer(micro));
if (component_end) {
tag = rb_str_new2(component_end + 1);
} else {
tag = Qnil;
}
rb_ary_push(runtime_version, tag);
rb_obj_freeze(runtime_version);
/*
* 利用しているgroongaのバージョン。 @[メジャーバージョ
* ン, マイナーバージョン, マイクロバージョン, タグ]@ の
* 配列。
*/
rb_define_const(mGrn, "VERSION", runtime_version);
}
/**
* call-seq:
* servers() → an_array
*
* Returns an array of all server URLs for this database.
*/
static VALUE get_servers(VALUE self)
{
alpm_db_t* p_db = NULL;
alpm_list_t* p_servers = NULL;
alpm_list_t* p_item = NULL;
VALUE result = rb_ary_new();
Data_Get_Struct(self, alpm_db_t, p_db);
p_servers = alpm_db_get_servers(p_db);
if (!p_servers)
return result;
for(p_item = p_servers; p_item; p_item = alpm_list_next(p_item)) {
rb_ary_push(result, rb_str_new2((char*) p_item->data));
}
return rb_obj_freeze(result); /* Modifying this in Ruby land would be nonsense */
}
