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()))); }
static VALUE cov_generate_coverage_info(VALUE self) { VALUE cover; if(rb_const_defined_at(mRCOV__, id_cover)) { rb_mod_remove_const(mRCOV__, ID2SYM(id_cover)); } cover = rb_hash_new(); if(coverinfo) st_foreach(coverinfo, populate_cover, cover); rb_define_const(mRCOV__, "COVER", cover); return cover; }
void Init_session_ext() { curl_global_init(CURL_GLOBAL_ALL); rb_require("patron/error"); mPatron = rb_define_module("Patron"); ePatronError = rb_const_get(mPatron, rb_intern("Error")); eUnsupportedProtocol = rb_const_get(mPatron, rb_intern("UnsupportedProtocol")); eURLFormatError = rb_const_get(mPatron, rb_intern("URLFormatError")); eHostResolutionError = rb_const_get(mPatron, rb_intern("HostResolutionError")); eConnectionFailed = rb_const_get(mPatron, rb_intern("ConnectionFailed")); ePartialFileError = rb_const_get(mPatron, rb_intern("PartialFileError")); eTimeoutError = rb_const_get(mPatron, rb_intern("TimeoutError")); eTooManyRedirects = rb_const_get(mPatron, rb_intern("TooManyRedirects")); rb_define_module_function(mPatron, "libcurl_version", libcurl_version, 0); cSession = rb_define_class_under(mPatron, "Session", rb_cObject); cRequest = rb_define_class_under(mPatron, "Request", rb_cObject); rb_define_alloc_func(cSession, session_alloc); rb_define_method(cSession, "ext_initialize", session_ext_initialize, 0); rb_define_method(cSession, "escape", session_escape, 1); rb_define_method(cSession, "unescape", session_unescape, 1); rb_define_method(cSession, "handle_request", session_handle_request, 1); rb_define_method(cSession, "enable_cookie_session", enable_cookie_session, 1); rb_define_const(cRequest, "AuthBasic", INT2FIX(CURLAUTH_BASIC)); rb_define_const(cRequest, "AuthDigest", INT2FIX(CURLAUTH_DIGEST)); rb_define_const(cRequest, "AuthAny", INT2FIX(CURLAUTH_ANY)); mProxyType = rb_define_module_under(mPatron, "ProxyType"); rb_define_const(mProxyType, "HTTP", INT2FIX(CURLPROXY_HTTP)); rb_define_const(mProxyType, "HTTP_1_0", INT2FIX(CURLPROXY_HTTP_1_0)); rb_define_const(mProxyType, "SOCKS4", INT2FIX(CURLPROXY_SOCKS4)); rb_define_const(mProxyType, "SOCKS5", INT2FIX(CURLPROXY_SOCKS5)); rb_define_const(mProxyType, "SOCKS4A", INT2FIX(CURLPROXY_SOCKS4A)); rb_define_const(mProxyType, "SOCKS5_HOSTNAME", INT2FIX(CURLPROXY_SOCKS5_HOSTNAME)); }
static void interp_register_builtin() { VALUE hVIPSInterpolators = rb_hash_new(); /* Hash of available interpolators. Keys are the symbols, and values are * interpolator objects. */ rb_define_const(cVIPSInterpolator, "INTERPOLATORS", hVIPSInterpolators); vips_class_map_concrete_all( g_type_from_name( "VipsInterpolate" ), (void *) interp_register, (void *) hVIPSInterpolators ); }
/** * Document-module: MessagePack * * MessagePack is a binary-based efficient object serialization library. * It enables to exchange structured objects between many languages like JSON. * But unlike JSON, it is very fast and small. * * You can install MessagePack with rubygems. * * gem install msgpack * * Simple usage is as follows: * * require 'msgpack' * msg = [1,2,3].to_msgpack #=> "\x93\x01\x02\x03" * MessagePack.unpack(msg) #=> [1,2,3] * * Use Unpacker class for streaming deserialization. * */ void Init_msgpack(void) { mMessagePack = rb_define_module("MessagePack"); rb_define_const(mMessagePack, "VERSION", rb_str_new2(MESSAGEPACK_VERSION)); #ifdef COMPAT_HAVE_ENCODING s_enc_ascii8bit = rb_ascii8bit_encindex(); s_enc_utf8 = rb_utf8_encindex(); s_enc_usascii = rb_usascii_encindex(); s_enc_utf8_value = rb_enc_from_encoding(rb_utf8_encoding()); #endif Init_msgpack_unpack(mMessagePack); Init_msgpack_pack(mMessagePack); }
void Init_gtk_textview() { VALUE cTextView = G_DEF_CLASS(GTK_TYPE_TEXT_VIEW, "TextView", mGtk); id_buffer = rb_intern("buffer"); rb_define_method(cTextView, "initialize", textview_initialize, -1); G_REPLACE_SET_PROPERTY(cTextView, "buffer", textview_set_buffer, 1); G_REPLACE_GET_PROPERTY(cTextView, "buffer", textview_get_buffer, 0); rb_define_method(cTextView, "scroll_to_mark", textview_scroll_to_mark, 5); rb_define_method(cTextView, "scroll_to_iter", textview_scroll_to_iter, 5); rb_define_method(cTextView, "scroll_mark_onscreen", textview_scroll_mark_onscreen, 1); rb_define_method(cTextView, "move_mark_onscreen", textview_move_mark_onscreen, 1); rb_define_method(cTextView, "place_cursor_onscreen", textview_place_cursor_onscreen, 0); rb_define_method(cTextView, "visible_rect", textview_get_visible_rect, 0); rb_define_method(cTextView, "get_iter_location", textview_get_iter_location, 1); rb_define_method(cTextView, "get_line_at_y", textview_get_line_at_y, 1); rb_define_method(cTextView, "get_line_yrange", textview_get_line_yrange, 1); rb_define_method(cTextView, "get_iter_at_location", textview_get_iter_at_location, 2); #if GTK_CHECK_VERSION(2,6,0) rb_define_method(cTextView, "get_iter_at_position", textview_get_iter_at_position, 2); #endif rb_define_method(cTextView, "buffer_to_window_coords", textview_buffer_to_window_coords, 3); rb_define_method(cTextView, "window_to_buffer_coords", textview_window_to_buffer_coords, 3); rb_define_method(cTextView, "get_window", textview_get_window, 1); rb_define_method(cTextView, "get_window_type", textview_get_window_type, 1); rb_define_method(cTextView, "set_border_window_size", textview_set_border_window_size, 2); G_DEF_SETTER(cTextView, "border_window_size"); rb_define_method(cTextView, "get_border_window_size", textview_get_border_window_size, 1); rb_define_method(cTextView, "forward_display_line", textview_forward_display_line, 1); rb_define_method(cTextView, "backward_display_line", textview_backward_display_line, 1); rb_define_method(cTextView, "forward_display_line_end", textview_forward_display_line_end, 1); rb_define_method(cTextView, "backward_display_line_start", textview_backward_display_line_start, 1); rb_define_method(cTextView, "starts_display_line", textview_starts_display_line, 1); rb_define_method(cTextView, "move_visually", textview_move_visually, 2); rb_define_method(cTextView, "add_child_at_anchor", textview_add_child_at_anchor, 2); rb_define_method(cTextView, "add_child_in_window", textview_add_child_in_window, 4); rb_define_method(cTextView, "move_child", textview_move_child, 3); rb_define_method(cTextView, "default_attributes", textview_get_default_attributes, 0); /* GtkTextWindowType */ G_DEF_CLASS(GTK_TYPE_TEXT_WINDOW_TYPE, "WindowType", cTextView); G_DEF_CONSTANTS(cTextView, GTK_TYPE_TEXT_WINDOW_TYPE, "GTK_TEXT_"); rb_define_const(cTextView, "PRIORITY_VALIDATE", INT2FIX(GTK_TEXT_VIEW_PRIORITY_VALIDATE)); }
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); }
void Init_hashpipe() { VALUE mHashpipe; VALUE cStatus; mHashpipe = rb_define_module("Hashpipe"); cStatus = rb_define_class_under(mHashpipe, "Status", rb_cObject); // RECORD_SIZE constant rb_define_const(cStatus, "RECORD_SIZE", INT2FIX(HASHPIPE_STATUS_RECORD_SIZE)); rb_define_alloc_func(cStatus, rb_hps_alloc); rb_define_singleton_method(cStatus, "exists?", rb_hps_exists, 1); rb_define_method(cStatus, "initialize", rb_hps_init, -1); rb_define_method(cStatus, "attach", rb_hps_attach, -1); rb_define_method(cStatus, "detach", rb_hps_detach, 0); rb_define_method(cStatus, "attached?", rb_hps_attached_p, 0); rb_define_method(cStatus, "instance_id", rb_hps_instance_id, 0); rb_define_method(cStatus, "unlock", rb_hps_unlock, 0); rb_define_method(cStatus, "lock", rb_hps_lock, 0); rb_define_method(cStatus, "clear!", rb_hps_clear_bang, 0); rb_define_method(cStatus, "delete", rb_hps_delete, 1); rb_define_method(cStatus, "buf", rb_hps_buf, 0); rb_define_method(cStatus, "length", rb_hps_length, 0); // hget methods HGET_METHOD(cStatus, i2); HGET_METHOD(cStatus, i4); HGET_METHOD(cStatus, i8); HGET_METHOD(cStatus, u4); HGET_METHOD(cStatus, u8); HGET_METHOD(cStatus, r4); HGET_METHOD(cStatus, r8); HGET_METHOD(cStatus, s); // hput methods HPUT_METHOD(cStatus, i2); HPUT_METHOD(cStatus, i4); HPUT_METHOD(cStatus, i8); HPUT_METHOD(cStatus, u4); HPUT_METHOD(cStatus, u8); HPUT_METHOD(cStatus, r4); HPUT_METHOD(cStatus, r8); HPUT_METHOD(cStatus, s); }
void Init_gtk_paper_size() { #if GTK_CHECK_VERSION(2,10,0) VALUE gPaperSize = G_DEF_CLASS(GTK_TYPE_PAPER_SIZE, "PaperSize", mGtk); rb_define_singleton_method(gPaperSize, "default", ps_s_get_default, 0); rb_define_const(gPaperSize, "A3", rb_str_new2(GTK_PAPER_NAME_A3)); rb_define_const(gPaperSize, "A4", rb_str_new2(GTK_PAPER_NAME_A4)); rb_define_const(gPaperSize, "A5", rb_str_new2(GTK_PAPER_NAME_A5)); rb_define_const(gPaperSize, "B5", rb_str_new2(GTK_PAPER_NAME_B5)); rb_define_const(gPaperSize, "LETTER", rb_str_new2(GTK_PAPER_NAME_LETTER)); rb_define_const(gPaperSize, "EXECUTIVE", rb_str_new2(GTK_PAPER_NAME_EXECUTIVE)); rb_define_const(gPaperSize, "LEGAL", rb_str_new2(GTK_PAPER_NAME_LEGAL)); rb_define_method(gPaperSize, "initialize", ps_initialize, -1); rb_define_method(gPaperSize, "==", ps_is_equal, 1); rb_define_method(gPaperSize, "name", ps_get_name, 0); rb_define_method(gPaperSize, "display_name", ps_get_display_name, 0); rb_define_method(gPaperSize, "ppd_name", ps_get_ppd_name, 0); rb_define_method(gPaperSize, "get_width", ps_get_width, 1); rb_define_method(gPaperSize, "get_height", ps_get_height, 1); rb_define_method(gPaperSize, "custom?", ps_is_custom, 0); rb_define_method(gPaperSize, "set_size", ps_set_size, 3); rb_define_method(gPaperSize, "get_default_top_margin", ps_get_default_top_margin, 1); rb_define_method(gPaperSize, "get_default_bottom_margin", ps_get_default_bottom_margin, 1); rb_define_method(gPaperSize, "get_default_left_margin", ps_get_default_left_margin, 1); rb_define_method(gPaperSize, "get_default_right_margin", ps_get_default_right_margin, 1); G_DEF_SETTERS(gPaperSize); /* GtkUnit */ G_DEF_CLASS(GTK_TYPE_UNIT, "Unit", gPaperSize); G_DEF_CONSTANTS(gPaperSize, GTK_TYPE_UNIT, "GTK_"); #endif }
void rbffi_NullPointer_Init(VALUE moduleFFI) { rbffi_NullPointerClass = rb_define_class_under(moduleFFI, "NullPointer", rbffi_PointerClass); rb_global_variable(&rbffi_NullPointerClass); NullPointerErrorClass = rb_define_class_under(moduleFFI, "NullPointerError", rb_eRuntimeError); rb_global_variable(&NullPointerErrorClass); rb_define_alloc_func(rbffi_NullPointerClass, nullptr_allocate); rb_define_method(rbffi_NullPointerClass, "inspect", nullptr_inspect, 0); rb_define_method(rbffi_NullPointerClass, "+", nullptr_op, -1); rb_define_method(rbffi_NullPointerClass, "null?", nullptr_null_p, 0); rb_define_method(rbffi_NullPointerClass, "address", nullptr_address, 0); rb_define_method(rbffi_NullPointerClass, "==", nullptr_equals, 1); #define NOP(name) \ rb_define_method(rbffi_NullPointerClass, "get_" #name, nullptr_op, -1); \ rb_define_method(rbffi_NullPointerClass, "put_" #name, nullptr_op, -1); \ rb_define_method(rbffi_NullPointerClass, "get_array_of_" #name, nullptr_op, -1); \ rb_define_method(rbffi_NullPointerClass, "put_array_of_" #name, nullptr_op, -1); \ NOP(int8); NOP(uint8); NOP(int16); NOP(uint16); NOP(int32); NOP(uint32); NOP(int64); NOP(uint64); NOP(long); NOP(ulong); NOP(float32); NOP(float64); NOP(char); NOP(uchar); NOP(short); NOP(ushort); NOP(int); NOP(uint); NOP(long_long); NOP(ulong_long); NOP(float); NOP(double); #undef NOP #define NOP(name) \ rb_define_method(rbffi_NullPointerClass, "get_" #name, nullptr_op, -1); \ rb_define_method(rbffi_NullPointerClass, "put_" #name, nullptr_op, -1); NOP(string); NOP(bytes); NOP(pointer); NOP(callback); rb_define_method(rbffi_NullPointerClass, "clear", nullptr_op, -1); \ rb_define_method(rbffi_NullPointerClass, "total", nullptr_op, -1); // Create a singleton instance of NullPointer that can be shared rbffi_NullPointerSingleton = nullptr_allocate(rbffi_NullPointerClass); rb_global_variable(&rbffi_NullPointerSingleton); rb_define_const(rbffi_PointerClass, "NULL", rbffi_NullPointerSingleton); }
void init_ruby_class() { #if 0 // For documentation using YARD VALUE opencv = rb_define_module("OpenCV"); VALUE cvseq = rb_define_class_under(opencv, "CvSeq"); VALUE curve = rb_define_module_under(opencv, "Curve"); VALUE pointset = rb_define_module_under(opencv, "PointSet"); #endif if (rb_klass) return; VALUE opencv = rb_module_opencv(); VALUE cvseq = cCvSeq::rb_class(); VALUE curve = mCurve::rb_module(); VALUE pointset = mPointSet::rb_module(); rb_klass = rb_define_class_under(opencv, "CvContour", cvseq); rb_include_module(rb_klass, curve); rb_include_module(rb_klass, pointset); rb_define_alloc_func(rb_klass, rb_allocate); VALUE approx_option = rb_hash_new(); rb_define_const(rb_klass, "APPROX_OPTION", approx_option); rb_hash_aset(approx_option, ID2SYM(rb_intern("method")), INT2FIX(CV_POLY_APPROX_DP)); rb_hash_aset(approx_option, ID2SYM(rb_intern("accuracy")), rb_float_new(1.0)); rb_hash_aset(approx_option, ID2SYM(rb_intern("recursive")), Qfalse); rb_define_method(rb_klass, "initialize", RUBY_METHOD_FUNC(rb_initialize), -1); rb_define_method(rb_klass, "rect", RUBY_METHOD_FUNC(rb_rect), 0); rb_define_method(rb_klass, "color", RUBY_METHOD_FUNC(rb_color), 0); rb_define_method(rb_klass, "color=", RUBY_METHOD_FUNC(rb_set_color), 1); rb_define_method(rb_klass, "reserved", RUBY_METHOD_FUNC(rb_reserved), 0); rb_define_method(rb_klass, "approx_poly", RUBY_METHOD_FUNC(rb_approx_poly), -1); rb_define_alias(rb_klass, "approx", "approx_poly"); rb_define_method(rb_klass, "bounding_rect", RUBY_METHOD_FUNC(rb_bounding_rect), 0); rb_define_method(rb_klass, "create_tree", RUBY_METHOD_FUNC(rb_create_tree), -1); rb_define_method(rb_klass, "in?", RUBY_METHOD_FUNC(rb_in_q), 1); rb_define_method(rb_klass, "measure_distance", RUBY_METHOD_FUNC(rb_measure_distance), 1); rb_define_method(rb_klass, "point_polygon_test", RUBY_METHOD_FUNC(rb_point_polygon_test), 2); rb_define_method(rb_klass, "match_shapes", RUBY_METHOD_FUNC(rb_match_shapes), -1); }
static void add_obj_name_const(VALUE klass, struct objlist *nobj, const char *name) { const char *obj_name; char str[64]; VALUE val; if (nobj == NULL) { val = Qnil; } else { obj_name = ngraph_get_object_name(nobj); strncpy(str, obj_name, sizeof(str) - 1); str[sizeof(str) - 1] = '\0'; str[0] = toupper(str[0]); val = ID2SYM(rb_intern(str)); } rb_define_const(klass, name, val); }
void Init_pango_main() { rb_define_module_function(mPango, "reorder_items", rpango_reorder_items, 1); #if PANGO_CHECK_VERSION(1,4,0) rb_define_module_function(mPango, "unichar_direction", rpango_unichar_direction, 1); rb_define_module_function(mPango, "find_base_dir", rpango_find_base_dir, 1); #endif rb_define_module_function(mPango, "break", rpango_break, 2); rb_define_module_function(mPango, "get_log_attrs", rpango_get_log_attrs, 3); rb_define_module_function(mPango, "find_paragraph_boundary", rpango_find_paragraph_boundary, 1); rb_define_module_function(mPango, "shape", rpango_shape, 2); rb_define_module_function(mPango, "parse_markup", rpango_parse_markup, -1); rb_define_module_function(mPango, "pixels", rpango_pixels, 1); rb_define_const(mPango, "SCALE", INT2FIX(PANGO_SCALE)); }
void Init_ca_obj_unbound_repeat () { /* rb_cCAUnboudRepeat, CA_OBJ_UNBOUND_REPEAT are defined in rb_carray.c */ rb_define_const(rb_cObject, "CA_OBJ_UNBOUND_REPEAT", INT2NUM(CA_OBJ_UNBOUND_REPEAT)); rb_define_method(rb_cCArray, "unbound_repeat", rb_ca_unbound_repeat, -1); rb_define_alloc_func(rb_cCAUnboundRepeat, rb_ca_ubrep_s_allocate); rb_define_method(rb_cCAUnboundRepeat, "initialize_copy", rb_ca_ubrep_initialize_copy, 1); rb_define_method(rb_cCAUnboundRepeat, "bind", rb_ca_ubrep_bind, -1); rb_define_method(rb_cCAUnboundRepeat, "bind_with", ca_ubrep_bind_with, 1); rb_define_method(rb_cCAUnboundRepeat, "spec", rb_ca_ubrep_spec, 0); }
void Init_gdk_atom(VALUE mGdk) { VALUE none; VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GDK_TYPE_ATOM, "Atom", mGdk); RG_DEF_SMETHOD(intern, -1); RG_DEF_METHOD(initialize, 1); RG_DEF_METHOD(name, 0); RG_DEF_METHOD(to_i, 0); RG_DEF_METHOD_OPERATOR("==", equal, 1); /* This is a trick to define GDK_NONE as a BOXED object */ none = GDKATOM2RVAL((gpointer)1); rb_define_const(RG_TARGET_NAMESPACE, "NONE", none); _SELF(none) = GDK_NONE; }
/* * Verse::MaterialNode class */ void rbverse_init_verse_materialnode( void ) { rbverse_log( "debug", "Initializing Verse::MaterialNode" ); /* Class methods */ rbverse_cVerseMaterialNode = rb_define_class_under( rbverse_mVerse, "MaterialNode", rbverse_cVerseNode ); /* Constants */ rb_define_const( rbverse_cVerseMaterialNode, "TYPE_NUMBER", rb_uint2inum(V_NT_MATERIAL) ); /* Initializer */ rb_define_method( rbverse_cVerseMaterialNode, "initialize", rbverse_verse_materialnode_initialize, 0 ); /* Tell Verse::Node about this subclass */ rbverse_nodetype_to_nodeclass[ V_NT_MATERIAL ] = rbverse_cVerseMaterialNode; node_mark_funcs[ V_NT_MATERIAL ] = &rbverse_materialnode_gc_mark; node_free_funcs[ V_NT_MATERIAL ] = &rbverse_materialnode_gc_free; }
static void Init_grpc_op_codes() { /* Constants representing operation type codes in grpc.h */ VALUE grpc_rb_mCallOps = rb_define_module_under(grpc_rb_mGrpcCore, "CallOps"); rb_define_const(grpc_rb_mCallOps, "SEND_INITIAL_METADATA", UINT2NUM(GRPC_OP_SEND_INITIAL_METADATA)); rb_define_const(grpc_rb_mCallOps, "SEND_MESSAGE", UINT2NUM(GRPC_OP_SEND_MESSAGE)); rb_define_const(grpc_rb_mCallOps, "SEND_CLOSE_FROM_CLIENT", UINT2NUM(GRPC_OP_SEND_CLOSE_FROM_CLIENT)); rb_define_const(grpc_rb_mCallOps, "SEND_STATUS_FROM_SERVER", UINT2NUM(GRPC_OP_SEND_STATUS_FROM_SERVER)); rb_define_const(grpc_rb_mCallOps, "RECV_INITIAL_METADATA", UINT2NUM(GRPC_OP_RECV_INITIAL_METADATA)); rb_define_const(grpc_rb_mCallOps, "RECV_MESSAGE", UINT2NUM(GRPC_OP_RECV_MESSAGE)); rb_define_const(grpc_rb_mCallOps, "RECV_STATUS_ON_CLIENT", UINT2NUM(GRPC_OP_RECV_STATUS_ON_CLIENT)); rb_define_const(grpc_rb_mCallOps, "RECV_CLOSE_ON_SERVER", UINT2NUM(GRPC_OP_RECV_CLOSE_ON_SERVER)); }
void Init_grpc_call() { /* CallError inherits from Exception to signal that it is non-recoverable */ rb_eCallError = rb_define_class_under(rb_mGrpcCore, "CallError", rb_eException); rb_cCall = rb_define_class_under(rb_mGrpcCore, "Call", rb_cObject); /* Prevent allocation or inialization of the Call class */ rb_define_alloc_func(rb_cCall, grpc_rb_cannot_alloc); rb_define_method(rb_cCall, "initialize", grpc_rb_cannot_init, 0); rb_define_method(rb_cCall, "initialize_copy", grpc_rb_cannot_init_copy, 1); /* Add ruby analogues of the Call methods. */ rb_define_method(rb_cCall, "server_accept", grpc_rb_call_server_accept, 2); rb_define_method(rb_cCall, "server_end_initial_metadata", grpc_rb_call_server_end_initial_metadata, -1); rb_define_method(rb_cCall, "add_metadata", grpc_rb_call_add_metadata, -1); rb_define_method(rb_cCall, "cancel", grpc_rb_call_cancel, 0); rb_define_method(rb_cCall, "invoke", grpc_rb_call_invoke, -1); rb_define_method(rb_cCall, "start_read", grpc_rb_call_start_read, 1); rb_define_method(rb_cCall, "start_write", grpc_rb_call_start_write, -1); rb_define_method(rb_cCall, "start_write_status", grpc_rb_call_start_write_status, 3); rb_define_method(rb_cCall, "writes_done", grpc_rb_call_writes_done, 1); rb_define_method(rb_cCall, "status", grpc_rb_call_get_status, 0); rb_define_method(rb_cCall, "status=", grpc_rb_call_set_status, 1); rb_define_method(rb_cCall, "metadata", grpc_rb_call_get_metadata, 0); rb_define_method(rb_cCall, "metadata=", grpc_rb_call_set_metadata, 1); /* Ids used to support call attributes */ id_metadata = rb_intern("metadata"); id_status = rb_intern("status"); /* Ids used by the c wrapping internals. */ id_cq = rb_intern("__cq"); id_flags = rb_intern("__flags"); id_input_md = rb_intern("__input_md"); /* The hash for reference counting calls, to ensure they can't be destroyed * more than once */ hash_all_calls = rb_hash_new(); rb_define_const(rb_cCall, "INTERNAL_ALL_CALLs", hash_all_calls); Init_grpc_error_codes(); }
static void define_const(VALUE klass1, VALUE klass2) { rb_define_const(klass1, "CONJUGATE_FR", INT2FIX(GSL_FDFMINIMIZER_CONJUGATE_FR)); rb_define_const(klass1, "CONJUGATE_PR", INT2FIX(GSL_FDFMINIMIZER_CONJUGATE_PR)); rb_define_const(klass1, "VECTOR_BFGS", INT2FIX(GSL_FDFMINIMIZER_VECTOR_BFGS)); rb_define_const(klass1, "STEEPEST_DESCENT", INT2FIX(GSL_FDFMINIMIZER_STEEPEST_DESCENT)); rb_define_const(klass2, "NMSIMPLEX", INT2FIX(GSL_FMINIMIZER_NMSIMPLEX)); rb_define_const(klass1, "VECTOR_BFGS2", INT2FIX(GSL_FDFMINIMIZER_VECTOR_BFGS2)); rb_define_const(klass2, "NMSIMPLEX2RAND", INT2FIX(GSL_FMINIMIZER_NMSIMPLEX2RAND)); }
/* Document-class: LDAP::Entry * * These methods can be used to probe the entries returned by LDAP searches. */ void Init_ldap_entry () { rb_cLDAP_Entry = rb_define_class_under (rb_mLDAP, "Entry", rb_cObject); rb_define_const (rb_mLDAP, "Message", rb_cLDAP_Entry); /* for compatibility */ rb_undef_method (CLASS_OF (rb_cLDAP_Entry), "new"); rb_undef_alloc_func (rb_cLDAP_Entry); rb_ldap_entry_define_method ("get_dn", rb_ldap_entry_get_dn, 0); rb_ldap_entry_define_method ("get_values", rb_ldap_entry_get_values, 1); rb_ldap_entry_define_method ("get_attributes", rb_ldap_entry_get_attributes, 0); rb_alias (rb_cLDAP_Entry, rb_intern ("dn"), rb_intern ("get_dn")); rb_alias (rb_cLDAP_Entry, rb_intern ("vals"), rb_intern ("get_values")); rb_alias (rb_cLDAP_Entry, rb_intern ("[]"), rb_intern ("get_values")); rb_alias (rb_cLDAP_Entry, rb_intern ("attrs"), rb_intern ("get_attributes")); rb_ldap_entry_define_method ("to_hash", rb_ldap_entry_to_hash, 0); rb_ldap_entry_define_method ("inspect", rb_ldap_entry_inspect, 0); }
void rbffi_Pointer_Init(VALUE moduleFFI) { VALUE rbNullAddress = ULL2NUM(0); /* * Document-class: FFI::Pointer < FFI::AbstractMemory * Pointer class is used to manage C pointers with ease. A {Pointer} object is defined by his * {#address} (as a C pointer). It permits additions with an integer for pointer arithmetic. * * ==Autorelease * A pointer object may autorelease his contents when freed (by default). This behaviour may be * changed with {#autorelease=} method. */ rbffi_PointerClass = rb_define_class_under(moduleFFI, "Pointer", rbffi_AbstractMemoryClass); /* * Document-variable: Pointer */ rb_global_variable(&rbffi_PointerClass); rb_define_alloc_func(rbffi_PointerClass, ptr_allocate); rb_define_method(rbffi_PointerClass, "initialize", ptr_initialize, -1); rb_define_method(rbffi_PointerClass, "initialize_copy", ptr_initialize_copy, 1); rb_define_method(rbffi_PointerClass, "inspect", ptr_inspect, 0); rb_define_method(rbffi_PointerClass, "to_s", ptr_inspect, 0); rb_define_method(rbffi_PointerClass, "+", ptr_plus, 1); rb_define_method(rbffi_PointerClass, "slice", ptr_slice, 2); rb_define_method(rbffi_PointerClass, "null?", ptr_null_p, 0); rb_define_method(rbffi_PointerClass, "address", ptr_address, 0); rb_define_alias(rbffi_PointerClass, "to_i", "address"); rb_define_method(rbffi_PointerClass, "==", ptr_equals, 1); rb_define_method(rbffi_PointerClass, "order", ptr_order, -1); rb_define_method(rbffi_PointerClass, "autorelease=", ptr_autorelease, 1); rb_define_method(rbffi_PointerClass, "autorelease?", ptr_autorelease_p, 0); rb_define_method(rbffi_PointerClass, "free", ptr_free, 0); rbffi_NullPointerSingleton = rb_class_new_instance(1, &rbNullAddress, rbffi_PointerClass); /* * NULL pointer */ rb_define_const(rbffi_PointerClass, "NULL", rbffi_NullPointerSingleton); }
void Init_gtk_paper_size(VALUE mGtk) { #if GTK_CHECK_VERSION(2,10,0) VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GTK_TYPE_PAPER_SIZE, "PaperSize", mGtk); RG_DEF_SMETHOD(default, 0); rb_define_const(RG_TARGET_NAMESPACE, "A3", CSTR2RVAL(GTK_PAPER_NAME_A3)); rb_define_const(RG_TARGET_NAMESPACE, "A4", CSTR2RVAL(GTK_PAPER_NAME_A4)); rb_define_const(RG_TARGET_NAMESPACE, "A5", CSTR2RVAL(GTK_PAPER_NAME_A5)); rb_define_const(RG_TARGET_NAMESPACE, "B5", CSTR2RVAL(GTK_PAPER_NAME_B5)); rb_define_const(RG_TARGET_NAMESPACE, "LETTER", CSTR2RVAL(GTK_PAPER_NAME_LETTER)); rb_define_const(RG_TARGET_NAMESPACE, "EXECUTIVE", CSTR2RVAL(GTK_PAPER_NAME_EXECUTIVE)); rb_define_const(RG_TARGET_NAMESPACE, "LEGAL", CSTR2RVAL(GTK_PAPER_NAME_LEGAL)); RG_DEF_METHOD(initialize, -1); RG_DEF_METHOD_OPERATOR("==", equal, 1); RG_DEF_METHOD(name, 0); RG_DEF_METHOD(display_name, 0); RG_DEF_METHOD(ppd_name, 0); RG_DEF_METHOD(get_width, 1); RG_DEF_METHOD(get_height, 1); RG_DEF_METHOD_P(custom, 0); RG_DEF_METHOD(set_size, 3); RG_DEF_METHOD(get_default_top_margin, 1); RG_DEF_METHOD(get_default_bottom_margin, 1); RG_DEF_METHOD(get_default_left_margin, 1); RG_DEF_METHOD(get_default_right_margin, 1); G_DEF_SETTERS(RG_TARGET_NAMESPACE); /* GtkUnit */ G_DEF_CLASS(GTK_TYPE_UNIT, "Unit", RG_TARGET_NAMESPACE); G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, GTK_TYPE_UNIT, "GTK_"); #endif }
void init_pg_errors() { rb_hErrors = rb_hash_new(); rb_define_const( rb_mPG, "ERROR_CLASSES", rb_hErrors ); rb_ePGerror = rb_define_class_under( rb_mPG, "Error", rb_eStandardError ); /************************* * PG::Error *************************/ rb_define_alias( rb_ePGerror, "error", "message" ); rb_define_attr( rb_ePGerror, "connection", 1, 0 ); rb_define_attr( rb_ePGerror, "result", 1, 0 ); rb_eServerError = rb_define_class_under( rb_mPG, "ServerError", rb_ePGerror ); rb_eUnableToSend = rb_define_class_under( rb_mPG, "UnableToSend", rb_ePGerror ); rb_eConnectionBad = rb_define_class_under( rb_mPG, "ConnectionBad", rb_ePGerror ); #include "errorcodes.def" }
void Init_libdislocker() { VALUE rb_mDislocker = rb_define_module("Dislocker"); dis_rb_classes[DIS_RB_CLASS_DISLOCKER] = rb_mDislocker; Init_metadata(rb_mDislocker); Init_accesses(rb_mDislocker); rb_define_method(rb_mDislocker, "initialize", rb_init_dislocker, 1); rb_define_method(rb_mDislocker, "dislock", rb_dislock, 3); rb_define_method(rb_mDislocker, "enlock", rb_enlock, 3); rb_define_method(rb_mDislocker, "destroy", rb_destroy_dislocker, 0); VALUE rb_mDisSignatures = rb_define_module_under(rb_mDislocker, "Signatures"); VALUE signatures = rb_ary_new3( 2, rb_str_new(BITLOCKER_SIGNATURE, BITLOCKER_SIGNATURE_SIZE), rb_str_new(BITLOCKER_TO_GO_SIGNATURE, BITLOCKER_TO_GO_SIGNATURE_SIZE) ); rb_define_const(rb_mDisSignatures, "BitLocker", signatures); }
void Init_despotify(void) { if (!despotify_init()) { printf("despotify_init() failed\n"); return; } VALUE mDespotify = rb_define_module("Despotify"); rb_define_singleton_method(mDespotify, "id2uri", rb_despotify_id2uri, 1); rb_define_singleton_method(mDespotify, "uri2id", rb_despotify_uri2id, 1); rb_define_const(mDespotify, "MAX_SEARCH_RESULTS", INT2NUM(MAX_SEARCH_RESULTS)); cSession = Init_despotify_session(mDespotify); cPlaylist = Init_despotify_playlist(mDespotify); cTrack = Init_despotify_track(mDespotify); cArtist = Init_despotify_artist(mDespotify); cAlbum = Init_despotify_album(mDespotify); eDespotifyError = rb_define_class_under(mDespotify, "DespotifyError", rb_eException); }
void rxml_init_schema_type(void) { /* Add in infinity support for ruby 1.8.7 */ #if !defined(RUBY_VM) && defined(INFINITY) ID infinityId = rb_intern("INFINITY"); if (rb_const_defined(rb_cFloat, infinityId) == Qfalse) rb_define_const(rb_cFloat, "INFINITY", rb_float_new(INFINITY)); #endif cXMLSchemaType = rb_define_class_under(cXMLSchema, "Type", rb_cObject); rb_define_method(cXMLSchemaType, "namespace", rxml_schema_type_namespace, 0); rb_define_method(cXMLSchemaType, "name", rxml_schema_type_name, 0); rb_define_method(cXMLSchemaType, "elements", rxml_schema_type_elements, 0); rb_define_method(cXMLSchemaType, "attributes", rxml_schema_type_attributes, 0); rb_define_method(cXMLSchemaType, "base", rxml_schema_type_base, 0); rb_define_method(cXMLSchemaType, "kind", rxml_schema_type_kind, 0); rb_define_method(cXMLSchemaType, "node", rxml_schema_type_node, 0); rb_define_method(cXMLSchemaType, "facets", rxml_schema_type_facets, 0); rb_define_method(cXMLSchemaType, "annotation", rxml_schema_type_annot, 0); }
void Init_vte3(void) { VALUE RG_TARGET_NAMESPACE; RG_TARGET_NAMESPACE = rb_define_module("Vte"); rb_define_const(RG_TARGET_NAMESPACE, "BUILD_VERSION", rb_ary_new3(3, INT2FIX(VTE_MAJOR_VERSION), INT2FIX(VTE_MINOR_VERSION), INT2FIX(VTE_MICRO_VERSION))); G_DEF_CLASS(VTE_TYPE_TERMINAL_ANTI_ALIAS, "TerminalAntiAlias", RG_TARGET_NAMESPACE); Init_vte_access(RG_TARGET_NAMESPACE); Init_vte_reaper(RG_TARGET_NAMESPACE); Init_vte_terminal(RG_TARGET_NAMESPACE); Init_vte_charattributes(RG_TARGET_NAMESPACE); Init_vte_pty(RG_TARGET_NAMESPACE); }
void Init_sfcc() { const char *conn; VALUE cEnvironment; /* class */ VALUE value; /* wrapped value */ int rc; char *msg; /** * SBLIM sfcc ruby API */ mSfcc = rb_define_module("Sfcc"); /** * SBLIM sfcc CIMC API */ mSfccCim= rb_define_module_under(mSfcc, "Cim"); /** * alloc CimcEnvironment once, store as const */ cEnvironment = rb_define_class_under(mSfccCim, "CimcEnvironment", rb_cObject); conn = getenv("RUBY_SFCC_CONNECTION"); /* "SfcbLocal" or "XML" */ if (!conn) conn = "XML"; cimcEnv = NewCIMCEnv(conn,0,&rc,&msg); if (!cimcEnv) { rb_raise(rb_eLoadError, "Cannot local %s cim client library. %d:%s", conn, rc, msg ? msg : ""); } value = Data_Wrap_Struct(cEnvironment, NULL, Exit_sfcc, cimcEnv); rb_define_const(mSfccCim, "CIMC_ENV", value); /** * Init other sub-classes */ init_cim_string(); init_cim_object_path(); init_cim_enumeration(); init_cim_class(); init_cim_instance(); init_cim_client(); }
void Init_drizzle() { VALUE mNet = rb_define_module("Net"); VALUE cDrizzle = rb_define_class_under(mNet, "Drizzle", rb_cObject); rb_define_alloc_func(cDrizzle, rb_drizzle_alloc); rb_define_method(cDrizzle, "con_create", rb_drizzle_con_create, 0); rb_define_method(cDrizzle, "query_run_all", rb_drizzle_query_run_all, 0); VALUE cConnection = rb_define_class_under(cDrizzle, "Connection", rb_cObject); rb_define_alloc_func(cConnection, rb_drizzle_con_alloc); rb_define_method(cConnection, "initialize", rb_drizzle_con_initialize, 1); rb_define_method(cConnection, "add_options", rb_drizzle_con_add_options, 1); rb_define_method(cConnection, "set_db", rb_drizzle_con_set_db, 1); rb_define_method(cConnection, "host", rb_drizzle_con_host, 0); rb_define_method(cConnection, "port", rb_drizzle_con_port, 0); rb_define_method(cConnection, "set_tcp", rb_drizzle_con_set_tcp, 2); rb_define_method(cConnection, "query_add", rb_drizzle_con_query_add, 1); rb_define_method(cConnection, "clone", rb_drizzle_con_clone, 0); VALUE mOptions = rb_define_module_under(cConnection, "Options"); rb_define_const(mOptions, "NONE", INT2FIX(DRIZZLE_CON_NONE)); rb_define_const(mOptions, "ALLOCATED", INT2FIX(DRIZZLE_CON_ALLOCATED)); rb_define_const(mOptions, "MYSQL", INT2FIX((DRIZZLE_CON_MYSQL))); rb_define_const(mOptions, "RAW_PACKET", INT2FIX(DRIZZLE_CON_RAW_PACKET)); rb_define_const(mOptions, "RAW_SCRAMBLE", INT2FIX(DRIZZLE_CON_RAW_SCRAMBLE)); rb_define_const(mOptions, "READY", INT2FIX(DRIZZLE_CON_READY)); rb_define_const(mOptions, "NO_RESULT_READ", INT2FIX(DRIZZLE_CON_NO_RESULT_READ)); rb_define_const(mOptions, "IO_READY", INT2FIX(DRIZZLE_CON_IO_READY)); VALUE cQuery = rb_define_class_under(cDrizzle, "Query", rb_cObject); rb_define_alloc_func(cQuery, rb_drizzle_query_alloc); rb_define_method(cQuery, "initialize", rb_drizzle_query_initialize, 1); rb_define_method(cQuery, "set_con", rb_drizzle_query_set_con, 1); rb_define_method(cQuery, "error_code", rb_drizzle_query_error_code, 0); rb_define_method(cQuery, "row_next", rb_drizzle_query_row_next, 0); }
void Init_native_support() { struct sockaddr_un addr; /* */ mPassenger = rb_define_module("PhusionPassenger"); // Do not remove the above comment. We want the Passenger module's rdoc to be empty. /* * Utility functions for accessing system functionality. */ mNativeSupport = rb_define_module_under(mPassenger, "NativeSupport"); rb_define_singleton_method(mNativeSupport, "send_fd", send_fd, 2); rb_define_singleton_method(mNativeSupport, "recv_fd", recv_fd, 1); rb_define_singleton_method(mNativeSupport, "create_unix_socket", create_unix_socket, 2); rb_define_singleton_method(mNativeSupport, "accept", f_accept, 1); rb_define_singleton_method(mNativeSupport, "close_all_file_descriptors", close_all_file_descriptors, 1); rb_define_singleton_method(mNativeSupport, "disable_stdio_buffering", disable_stdio_buffering, 0); /* The maximum length of a Unix socket path, including terminating null. */ rb_define_const(mNativeSupport, "UNIX_PATH_MAX", INT2NUM(sizeof(addr.sun_path))); }