void Init_escape_utils() { rb_eEncodingCompatibilityError = rb_const_get(rb_cEncoding, rb_intern("CompatibilityError")); ID_new = rb_intern("new"); ID_at_html_safe = rb_intern("@html_safe"); rb_global_variable(&rb_html_safe_string_class); rb_global_variable(&rb_html_safe_string_template_object); rb_mEscapeUtils = rb_define_module("EscapeUtils"); rb_define_method(rb_mEscapeUtils, "escape_html_as_html_safe", rb_eu_escape_html_as_html_safe, 1); rb_define_method(rb_mEscapeUtils, "escape_html", rb_eu_escape_html, -1); rb_define_method(rb_mEscapeUtils, "unescape_html", rb_eu_unescape_html, 1); rb_define_method(rb_mEscapeUtils, "escape_xml", rb_eu_escape_xml, 1); rb_define_method(rb_mEscapeUtils, "escape_javascript", rb_eu_escape_js, 1); rb_define_method(rb_mEscapeUtils, "unescape_javascript", rb_eu_unescape_js, 1); rb_define_method(rb_mEscapeUtils, "escape_url", rb_eu_escape_url, 1); rb_define_method(rb_mEscapeUtils, "unescape_url", rb_eu_unescape_url, 1); rb_define_method(rb_mEscapeUtils, "escape_uri", rb_eu_escape_uri, 1); rb_define_method(rb_mEscapeUtils, "unescape_uri", rb_eu_unescape_uri, 1); rb_define_method(rb_mEscapeUtils, "escape_uri_component", rb_eu_escape_uri_component, 1); rb_define_method(rb_mEscapeUtils, "unescape_uri_component", rb_eu_unescape_uri_component, 1); rb_define_singleton_method(rb_mEscapeUtils, "html_secure=", rb_eu_set_html_secure, 1); rb_define_singleton_method(rb_mEscapeUtils, "html_safe_string_class=", rb_eu_set_html_safe_string_class, 1); }
void rbffi_Struct_Init(VALUE moduleFFI) { VALUE StructClass; rbffi_StructLayout_Init(moduleFFI); rbffi_StructClass = StructClass = rb_define_class_under(moduleFFI, "Struct", rb_cObject); rb_global_variable(&rbffi_StructClass); rbffi_StructInlineArrayClass = rb_define_class_under(rbffi_StructClass, "InlineArray", rb_cObject); rb_global_variable(&rbffi_StructInlineArrayClass); rbffi_StructLayoutCharArrayClass = rb_define_class_under(rbffi_StructLayoutClass, "CharArray", rbffi_StructInlineArrayClass); rb_global_variable(&rbffi_StructLayoutCharArrayClass); rb_define_alloc_func(StructClass, struct_allocate); rb_define_method(StructClass, "initialize", struct_initialize, -1); rb_define_method(StructClass, "order", struct_order, -1); rb_define_alias(rb_singleton_class(StructClass), "alloc_in", "new"); rb_define_alias(rb_singleton_class(StructClass), "alloc_out", "new"); rb_define_alias(rb_singleton_class(StructClass), "alloc_inout", "new"); rb_define_alias(rb_singleton_class(StructClass), "new_in", "new"); rb_define_alias(rb_singleton_class(StructClass), "new_out", "new"); rb_define_alias(rb_singleton_class(StructClass), "new_inout", "new"); rb_define_method(StructClass, "pointer", struct_get_pointer, 0); rb_define_private_method(StructClass, "pointer=", struct_set_pointer, 1); rb_define_method(StructClass, "layout", struct_get_layout, 0); rb_define_private_method(StructClass, "layout=", struct_set_layout, 1); rb_define_method(StructClass, "[]", struct_aref, 1); rb_define_method(StructClass, "[]=", struct_aset, 2); rb_define_method(StructClass, "null?", struct_null_p, 0); rb_include_module(rbffi_StructInlineArrayClass, rb_mEnumerable); rb_define_alloc_func(rbffi_StructInlineArrayClass, inline_array_allocate); rb_define_method(rbffi_StructInlineArrayClass, "initialize", inline_array_initialize, 2); rb_define_method(rbffi_StructInlineArrayClass, "[]", inline_array_aref, 1); rb_define_method(rbffi_StructInlineArrayClass, "[]=", inline_array_aset, 2); rb_define_method(rbffi_StructInlineArrayClass, "each", inline_array_each, 0); rb_define_method(rbffi_StructInlineArrayClass, "size", inline_array_size, 0); rb_define_method(rbffi_StructInlineArrayClass, "to_a", inline_array_to_a, 0); rb_define_method(rbffi_StructInlineArrayClass, "to_ptr", inline_array_to_ptr, 0); rb_define_method(rbffi_StructLayoutCharArrayClass, "to_s", inline_array_to_s, 0); rb_define_alias(rbffi_StructLayoutCharArrayClass, "to_str", "to_s"); id_pointer_ivar = rb_intern("@pointer"); id_layout_ivar = rb_intern("@layout"); id_layout = rb_intern("layout"); id_get = rb_intern("get"); id_put = rb_intern("put"); id_to_ptr = rb_intern("to_ptr"); id_to_s = rb_intern("to_s"); }
/* * Document-class: Byebug * * == Summary * * This is a singleton class allows controlling byebug. Use it to start/stop * byebug, set/remove breakpoints, etc. */ void Init_byebug() { mByebug = rb_define_module("Byebug"); rb_define_module_function(mByebug, "add_catchpoint", Add_catchpoint, 1); rb_define_module_function(mByebug, "breakpoints", Breakpoints, 0); rb_define_module_function(mByebug, "catchpoints", Catchpoints, 0); rb_define_module_function(mByebug, "contexts", Contexts, 0); rb_define_module_function(mByebug, "current_context", Current_context, 0); rb_define_module_function(mByebug, "debug_load", Debug_load, -1); rb_define_module_function(mByebug, "post_mortem?", Post_mortem, 0); rb_define_module_function(mByebug, "post_mortem=", Set_post_mortem, 1); rb_define_module_function(mByebug, "raised_exception", Raised_exception, 0); rb_define_module_function(mByebug, "start", Start, 0); rb_define_module_function(mByebug, "started?", Started, 0); rb_define_module_function(mByebug, "stop", Stop, 0); rb_define_module_function(mByebug, "thread_context", Thread_context, 1); rb_define_module_function(mByebug, "tracing?", Tracing, 0); rb_define_module_function(mByebug, "tracing=", Set_tracing, 1); rb_define_module_function(mByebug, "verbose?", Verbose, 0); rb_define_module_function(mByebug, "verbose=", Set_verbose, 1); Init_threads_table(mByebug); Init_context(mByebug); Init_breakpoint(mByebug); rb_global_variable(&breakpoints); rb_global_variable(&catchpoints); rb_global_variable(&tracepoints); rb_global_variable(&raised_exception); rb_global_variable(&threads); idPuts = rb_intern("puts"); }
void rbffi_DynamicLibrary_Init(VALUE moduleFFI) { LibraryClass = rb_define_class_under(moduleFFI, "DynamicLibrary", rb_cObject); rb_global_variable(&LibraryClass); SymbolClass = rb_define_class_under(LibraryClass, "Symbol", rbffi_PointerClass); rb_global_variable(&SymbolClass); rb_define_const(moduleFFI, "NativeLibrary", LibraryClass); // backwards compat library rb_define_alloc_func(LibraryClass, library_allocate); rb_define_singleton_method(LibraryClass, "open", library_open, 2); rb_define_singleton_method(LibraryClass, "last_error", library_dlerror, 0); rb_define_method(LibraryClass, "initialize", library_initialize, 2); rb_define_method(LibraryClass, "find_symbol", library_dlsym, 1); rb_define_method(LibraryClass, "find_function", library_dlsym, 1); rb_define_method(LibraryClass, "find_variable", library_dlsym, 1); rb_define_method(LibraryClass, "last_error", library_dlerror, 0); rb_define_attr(LibraryClass, "name", 1, 0); rb_define_alloc_func(SymbolClass, symbol_allocate); rb_undef_method(SymbolClass, "new"); rb_define_method(SymbolClass, "inspect", symbol_inspect, 0); #define DEF(x) rb_define_const(LibraryClass, "RTLD_" #x, UINT2NUM(RTLD_##x)) DEF(LAZY); DEF(NOW); DEF(GLOBAL); DEF(LOCAL); }
static void make_patterns(void) { static const char rat_pat_source[] = PATTERN; static const char an_e_pat_source[] = "[eE]"; static const char a_dot_pat_source[] = "\\."; static const char underscores_pat_source[] = "_+"; if (rat_pat) return; rat_pat = rb_reg_new(rat_pat_source, sizeof rat_pat_source - 1, 0); rb_global_variable(&rat_pat); // rb_gc_register_mark_object(rat_pat); an_e_pat = rb_reg_new(an_e_pat_source, sizeof an_e_pat_source - 1, 0); rb_global_variable(&an_e_pat); // rb_gc_register_mark_object(an_e_pat); a_dot_pat = rb_reg_new(a_dot_pat_source, sizeof a_dot_pat_source - 1, 0); rb_global_variable(&a_dot_pat); // rb_gc_register_mark_object(a_dot_pat); underscores_pat = rb_reg_new(underscores_pat_source, sizeof underscores_pat_source - 1, 0); rb_global_variable(&underscores_pat); // rb_gc_register_mark_object(underscores_pat); an_underscore = rb_usascii_str_new2("_"); rb_global_variable(&an_underscore); // rb_gc_register_mark_object(an_underscore); }
void Init_do_postgres() { data_objects_common_init(); mDO_Postgres = rb_define_module_under(mDO, "Postgres"); mDO_PostgresEncoding = rb_define_module_under(mDO_Postgres, "Encoding"); cDO_PostgresConnection = rb_define_class_under(mDO_Postgres, "Connection", cDO_Connection); rb_define_method(cDO_PostgresConnection, "initialize", do_postgres_cConnection_initialize, 1); rb_define_method(cDO_PostgresConnection, "dispose", do_postgres_cConnection_dispose, 0); rb_define_method(cDO_PostgresConnection, "character_set", data_objects_cConnection_character_set , 0); rb_define_method(cDO_PostgresConnection, "quote_string", do_postgres_cConnection_quote_string, 1); rb_define_method(cDO_PostgresConnection, "quote_byte_array", do_postgres_cConnection_quote_byte_array, 1); cDO_PostgresCommand = rb_define_class_under(mDO_Postgres, "Command", cDO_Command); rb_define_method(cDO_PostgresCommand, "set_types", data_objects_cCommand_set_types, -1); rb_define_method(cDO_PostgresCommand, "execute_non_query", do_postgres_cCommand_execute_non_query, -1); rb_define_method(cDO_PostgresCommand, "execute_reader", do_postgres_cCommand_execute_reader, -1); cDO_PostgresResult = rb_define_class_under(mDO_Postgres, "Result", cDO_Result); cDO_PostgresReader = rb_define_class_under(mDO_Postgres, "Reader", cDO_Reader); rb_define_method(cDO_PostgresReader, "close", do_postgres_cReader_close, 0); rb_define_method(cDO_PostgresReader, "next!", do_postgres_cReader_next, 0); rb_define_method(cDO_PostgresReader, "values", data_objects_cReader_values, 0); rb_define_method(cDO_PostgresReader, "fields", data_objects_cReader_fields, 0); rb_define_method(cDO_PostgresReader, "field_count", data_objects_cReader_field_count, 0); rb_global_variable(&cDO_PostgresResult); rb_global_variable(&cDO_PostgresReader); data_objects_define_errors(mDO_Postgres, do_postgres_errors); }
void Init_fast_xs(void) { assert(cp_1252[159 - 128] == 376); /* just in case I skipped a line */ unpack_id = rb_intern("unpack"); U_fmt = rb_str_new("U*", 2); C_fmt = rb_str_new("C*", 2); rb_global_variable(&U_fmt); rb_global_variable(&C_fmt); rb_define_method(rb_cString, "fast_xs", fast_xs, 0); }
void init_tinytds_result() { /* Data Classes */ cBigDecimal = rb_const_get(rb_cObject, rb_intern("BigDecimal")); cDate = rb_const_get(rb_cObject, rb_intern("Date")); /* Define TinyTds::Result */ cTinyTdsResult = rb_define_class_under(mTinyTds, "Result", rb_cObject); /* Define TinyTds::Result Public Methods */ rb_define_method(cTinyTdsResult, "fields", rb_tinytds_result_fields, 0); rb_define_method(cTinyTdsResult, "each", rb_tinytds_result_each, -1); rb_define_method(cTinyTdsResult, "cancel", rb_tinytds_result_cancel, 0); rb_define_method(cTinyTdsResult, "do", rb_tinytds_result_do, 0); rb_define_method(cTinyTdsResult, "affected_rows", rb_tinytds_result_affected_rows, 0); rb_define_method(cTinyTdsResult, "return_code", rb_tinytds_result_return_code, 0); rb_define_method(cTinyTdsResult, "insert", rb_tinytds_result_insert, 0); /* Intern String Helpers */ intern_new = rb_intern("new"); intern_utc = rb_intern("utc"); intern_local = rb_intern("local"); intern_merge = rb_intern("merge"); intern_localtime = rb_intern("localtime"); intern_civil = rb_intern("civil"); intern_new_offset = rb_intern("new_offset"); intern_plus = rb_intern("+"); intern_divide = rb_intern("/"); /* Symbol Helpers */ sym_symbolize_keys = ID2SYM(rb_intern("symbolize_keys")); sym_as = ID2SYM(rb_intern("as")); sym_array = ID2SYM(rb_intern("array")); sym_cache_rows = ID2SYM(rb_intern("cache_rows")); sym_first = ID2SYM(rb_intern("first")); sym_local = ID2SYM(intern_local); sym_utc = ID2SYM(intern_utc); sym_timezone = ID2SYM(rb_intern("timezone")); sym_empty_sets = ID2SYM(rb_intern("empty_sets")); /* Data Conversion Options */ opt_decimal_zero = rb_str_new2("0.0"); rb_global_variable(&opt_decimal_zero); opt_float_zero = rb_float_new((double)0); rb_global_variable(&opt_float_zero); opt_one = INT2NUM(1); opt_zero = INT2NUM(0); opt_four = INT2NUM(4); opt_19hdr = INT2NUM(1900); opt_onek = INT2NUM(1000); opt_tenk = INT2NUM(10000); opt_onemil = INT2NUM(1000000); opt_onebil = INT2NUM(1000000000); /* Encoding */ #ifdef HAVE_RUBY_ENCODING_H binaryEncoding = rb_enc_find("binary"); #endif }
void Init_gobject_gobject(void) { RG_TARGET_NAMESPACE = G_DEF_CLASS_WITH_GC_FUNC(G_TYPE_OBJECT, "Object", mGLib, gobj_mark, NULL); #ifdef G_TYPE_INITIALLY_UNOWNED G_DEF_CLASS(G_TYPE_INITIALLY_UNOWNED, "InitiallyUnowned", mGLib); #endif RUBY_GOBJECT_OBJ_KEY = g_quark_from_static_string("__ruby_gobject_object__"); rb_define_alloc_func(RG_TARGET_NAMESPACE, (VALUE(*)_((VALUE)))gobj_s_allocate); RG_DEF_SMETHOD_BANG(new, -1); rbg_define_singleton_method(RG_TARGET_NAMESPACE, "property", &gobj_s_property, 1); rbg_define_singleton_method(RG_TARGET_NAMESPACE, "properties", &gobj_s_properties, -1); RG_DEF_SMETHOD(install_property, -1); q_ruby_getter = g_quark_from_static_string("__ruby_getter"); q_ruby_setter = g_quark_from_static_string("__ruby_setter"); RG_DEF_METHOD(set_property, 2); RG_DEF_METHOD(get_property, 1); RG_DEF_METHOD(freeze_notify, 0); rb_undef_method(RG_TARGET_NAMESPACE, "notify"); RG_DEF_METHOD(notify, 1); RG_DEF_METHOD(thaw_notify, 0); RG_DEF_METHOD_P(destroyed, 0); RG_DEF_METHOD(initialize, -1); rbg_define_method(RG_TARGET_NAMESPACE, "ref_count", gobj_ref_count, 0); /* for debugging */ RG_DEF_METHOD(unref, 0); RG_DEF_METHOD(inspect, 0); RG_DEF_METHOD(type_name, 0); #if GLIB_CHECK_VERSION(2, 26, 0) RG_DEF_METHOD(bind_property, 4); G_DEF_CLASS(G_TYPE_BINDING_FLAGS, "BindingFlags", mGLib); #endif eNoPropertyError = rb_define_class_under(mGLib, "NoPropertyError", rb_eNameError); rb_global_variable(&type_to_prop_setter_table); rb_global_variable(&type_to_prop_getter_table); type_to_prop_setter_table = rb_hash_new(); type_to_prop_getter_table = rb_hash_new(); /* subclass */ RG_DEF_SMETHOD(type_register, -1); }
void init_tinytds_client() { cTinyTdsClient = rb_define_class_under(mTinyTds, "Client", rb_cObject); rb_define_alloc_func(cTinyTdsClient, allocate); /* Define TinyTds::Client Public Methods */ rb_define_method(cTinyTdsClient, "tds_version", rb_tinytds_tds_version, 0); rb_define_method(cTinyTdsClient, "close", rb_tinytds_close, 0); rb_define_method(cTinyTdsClient, "closed?", rb_tinytds_closed, 0); rb_define_method(cTinyTdsClient, "canceled?", rb_tinytds_canceled, 0); rb_define_method(cTinyTdsClient, "dead?", rb_tinytds_dead, 0); rb_define_method(cTinyTdsClient, "sqlsent?", rb_tinytds_sqlsent, 0); rb_define_method(cTinyTdsClient, "execute", rb_tinytds_execute, 1); rb_define_method(cTinyTdsClient, "charset", rb_tinytds_charset, 0); rb_define_method(cTinyTdsClient, "encoding", rb_tinytds_encoding, 0); rb_define_method(cTinyTdsClient, "escape", rb_tinytds_escape, 1); rb_define_method(cTinyTdsClient, "return_code", rb_tinytds_return_code, 0); rb_define_method(cTinyTdsClient, "identity_sql", rb_tinytds_identity_sql, 0); /* Define TinyTds::Client Protected Methods */ rb_define_protected_method(cTinyTdsClient, "connect", rb_tinytds_connect, 1); /* Symbols For Connect */ sym_username = ID2SYM(rb_intern("username")); sym_password = ID2SYM(rb_intern("password")); sym_dataserver = ID2SYM(rb_intern("dataserver")); sym_database = ID2SYM(rb_intern("database")); sym_appname = ID2SYM(rb_intern("appname")); sym_tds_version = ID2SYM(rb_intern("tds_version")); sym_login_timeout = ID2SYM(rb_intern("login_timeout")); sym_timeout = ID2SYM(rb_intern("timeout")); sym_encoding = ID2SYM(rb_intern("encoding")); sym_azure = ID2SYM(rb_intern("azure")); sym_contained = ID2SYM(rb_intern("contained")); sym_use_utf16 = ID2SYM(rb_intern("use_utf16")); sym_message_handler = ID2SYM(rb_intern("message_handler")); /* Intern TinyTds::Error Accessors */ intern_source_eql = rb_intern("source="); intern_severity_eql = rb_intern("severity="); intern_db_error_number_eql = rb_intern("db_error_number="); intern_os_error_number_eql = rb_intern("os_error_number="); /* Intern Misc */ intern_new = rb_intern("new"); intern_dup = rb_intern("dup"); intern_transpose_iconv_encoding = rb_intern("transpose_iconv_encoding"); intern_local_offset = rb_intern("local_offset"); intern_gsub = rb_intern("gsub"); intern_call = rb_intern("call"); /* Escape Regexp Global */ opt_escape_regex = rb_funcall(rb_cRegexp, intern_new, 1, rb_str_new2("\\\'")); opt_escape_dblquote = rb_str_new2("''"); rb_global_variable(&opt_escape_regex); rb_global_variable(&opt_escape_dblquote); }
void Init_perftools() { cPerfTools = rb_define_class("PerfTools", rb_cObject); eError = rb_define_class_under(cPerfTools, "Error", rb_eStandardError); cCpuProfiler = rb_define_class_under(cPerfTools, "CpuProfiler", rb_cObject); Iallocate = rb_intern("allocate"); I__send__ = rb_intern("__send__"); Isend = rb_intern("send"); bMethProfilerRunning = bObjProfilerRunning = bProfilerRunning = Qfalse; rb_define_singleton_method(cCpuProfiler, "running?", cpuprofiler_running_p, 0); rb_define_singleton_method(cCpuProfiler, "start", cpuprofiler_start, 1); rb_define_singleton_method(cCpuProfiler, "stop", cpuprofiler_stop, 0); gc_hook = Data_Wrap_Struct(cCpuProfiler, cpuprofiler_gc_mark, NULL, NULL); rb_global_variable(&gc_hook); if (ProfilingIsEnabledForAllThreads()) { // profiler is already running? bProfilerRunning = Qtrue; if (getenv("CPUPROFILE_OBJECTS")) { // want to profile objects objprofiler_setup(); } else if (getenv("CPUPROFILE_METHODS")) { methprofiler_setup(); } rb_set_end_proc(profiler_at_exit, 0); // make sure to cleanup before the VM shuts down } }
void Init_GC(void) { VALUE rb_mObSpace; rb_mGC = rb_define_module("GC"); rb_objc_define_method(*(VALUE *)rb_mGC, "start", rb_gc_start, 0); rb_objc_define_method(*(VALUE *)rb_mGC, "enable", rb_gc_enable, 0); rb_objc_define_method(*(VALUE *)rb_mGC, "disable", rb_gc_disable, 0); rb_objc_define_method(*(VALUE *)rb_mGC, "stress", gc_stress_get, 0); rb_objc_define_method(*(VALUE *)rb_mGC, "stress=", gc_stress_set, 1); rb_objc_define_method(*(VALUE *)rb_mGC, "count", gc_count, 0); rb_objc_define_method(rb_mGC, "garbage_collect", rb_gc_start, 0); rb_mObSpace = rb_define_module("ObjectSpace"); rb_objc_define_method(*(VALUE *)rb_mObSpace, "each_object", os_each_obj, -1); rb_objc_define_method(*(VALUE *)rb_mObSpace, "garbage_collect", rb_gc_start, 0); rb_objc_define_method(*(VALUE *)rb_mObSpace, "define_finalizer", define_final, -1); rb_objc_define_method(*(VALUE *)rb_mObSpace, "undefine_finalizer", undefine_final, 1); rb_objc_define_method(*(VALUE *)rb_mObSpace, "_id2ref", id2ref, 1); rb_global_variable(&nomem_error); nomem_error = rb_exc_new2(rb_eNoMemError, "failed to allocate memory"); rb_objc_define_method(rb_mKernel, "hash", rb_obj_id, 0); rb_objc_define_method(rb_mKernel, "__id__", rb_obj_id, 0); rb_objc_define_method(rb_mKernel, "object_id", rb_obj_id, 0); rb_objc_define_method(*(VALUE *)rb_mObSpace, "count_objects", count_objects, -1); }
void Init_http11() { VALUE mPuma = rb_define_module("Puma"); DEF_GLOBAL(request_method, "REQUEST_METHOD"); DEF_GLOBAL(request_uri, "REQUEST_URI"); DEF_GLOBAL(fragment, "FRAGMENT"); DEF_GLOBAL(query_string, "QUERY_STRING"); DEF_GLOBAL(http_version, "HTTP_VERSION"); DEF_GLOBAL(request_path, "REQUEST_PATH"); eHttpParserError = rb_define_class_under(mPuma, "HttpParserError", rb_eIOError); rb_global_variable(&eHttpParserError); VALUE cHttpParser = rb_define_class_under(mPuma, "HttpParser", rb_cObject); rb_define_alloc_func(cHttpParser, HttpParser_alloc); rb_define_method(cHttpParser, "initialize", HttpParser_init, 0); rb_define_method(cHttpParser, "reset", HttpParser_reset, 0); rb_define_method(cHttpParser, "finish", HttpParser_finish, 0); rb_define_method(cHttpParser, "execute", HttpParser_execute, 3); rb_define_method(cHttpParser, "error?", HttpParser_has_error, 0); rb_define_method(cHttpParser, "finished?", HttpParser_is_finished, 0); rb_define_method(cHttpParser, "nread", HttpParser_nread, 0); rb_define_method(cHttpParser, "body", HttpParser_body, 0); init_common_fields(); }
void Init_icunicode() { rb_define_method(rb_cString, "unicode_sort_key", unicode_sort_key, 0); rb_define_method(rb_cString, "transliterate", unicode_transliterate, -1); trans_hash = rb_hash_new(); rb_global_variable(&trans_hash); }
void rbffi_ArrayType_Init(VALUE moduleFFI) { VALUE ffi_Type; ffi_Type = rbffi_TypeClass; /* * Document-class: FFI::ArrayType < FFI::Type * * This is a typed array. The type is a {NativeType native type}. */ rbffi_ArrayTypeClass = rb_define_class_under(moduleFFI, "ArrayType", ffi_Type); /* * Document-variable: FFI::ArrayType */ rb_global_variable(&rbffi_ArrayTypeClass); /* * Document-constant: FFI::Type::Array */ rb_define_const(ffi_Type, "Array", rbffi_ArrayTypeClass); rb_define_alloc_func(rbffi_ArrayTypeClass, array_type_s_allocate); rb_define_method(rbffi_ArrayTypeClass, "initialize", array_type_initialize, 2); rb_define_method(rbffi_ArrayTypeClass, "length", array_type_length, 0); rb_define_method(rbffi_ArrayTypeClass, "elem_type", array_type_element_type, 0); }
void rbffi_FunctionInfo_Init(VALUE moduleFFI) { VALUE ffi_Type; ffi_Type = rbffi_TypeClass; /* * Document-class: FFI::FunctionType < FFI::Type */ rbffi_FunctionTypeClass = rb_define_class_under(moduleFFI, "FunctionType",ffi_Type); rb_global_variable(&rbffi_FunctionTypeClass); /* * Document-const: FFI::CallbackInfo = FFI::FunctionType */ rb_define_const(moduleFFI, "CallbackInfo", rbffi_FunctionTypeClass); /* * Document-const: FFI::FunctionInfo = FFI::FunctionType */ rb_define_const(moduleFFI, "FunctionInfo", rbffi_FunctionTypeClass); /* * Document-const: FFI::Type::Function = FFI::FunctionType */ rb_define_const(ffi_Type, "Function", rbffi_FunctionTypeClass); rb_define_alloc_func(rbffi_FunctionTypeClass, fntype_allocate); rb_define_method(rbffi_FunctionTypeClass, "initialize", fntype_initialize, -1); rb_define_method(rbffi_FunctionTypeClass, "result_type", fntype_result_type, 0); rb_define_method(rbffi_FunctionTypeClass, "param_types", fntype_param_types, 0); }
void rbffi_Pointer_Init(VALUE moduleFFI) { VALUE rbNullAddress = ULL2NUM(0); rbffi_PointerClass = rb_define_class_under(moduleFFI, "Pointer", rbffi_AbstractMemoryClass); 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); rb_define_const(rbffi_PointerClass, "NULL", rbffi_NullPointerSingleton); }
void Init_terminfo() { putfunc_output = Qnil; rb_global_variable(&putfunc_output); cTermInfo = rb_define_class("TermInfo", rb_cData); eTermInfoError = rb_define_class_under(cTermInfo, "TermInfoError", rb_eRuntimeError); rb_define_alloc_func(cTermInfo, rt_alloc); rb_define_method(cTermInfo, "setupterm", rt_setupterm, 2); rb_define_method(cTermInfo, "tigetflag", rt_tigetflag, 1); rb_define_method(cTermInfo, "tigetnum", rt_tigetnum, 1); rb_define_method(cTermInfo, "tigetstr", rt_tigetstr, 1); rb_define_method(cTermInfo, "tparm", rt_tparm, -1); rb_define_method(cTermInfo, "tputs", rt_tputs, 2); rb_define_module_function(cTermInfo, "tiocgwinsz", rt_tiocgwinsz, 1); rb_define_module_function(cTermInfo, "tiocswinsz", rt_tiocswinsz, 3); rb_define_module_function(cTermInfo, "ctermid", rt_ctermid, 0); rb_define_module_function(cTermInfo, "wcswidth", rt_wcswidth, 1); }
void rbffi_MemoryPointer_Init(VALUE moduleFFI) { VALUE ffi_Pointer; ffi_Pointer = rbffi_PointerClass; /* * Document-class: FFI::MemoryPointer < FFI::Pointer * A MemoryPointer is a specific {Pointer}. It points to a memory composed of cells. All cells have the * same size. * * @example Create a new MemoryPointer * mp = FFI::MemoryPointer.new(:long, 16) # Create a pointer on a memory of 16 long ints. * @example Create a new MemoryPointer from a String * mp1 = FFI::MemoryPointer.from_string("this is a string") * # same as: * mp2 = FFI::MemoryPointer.new(:char,16) * mp2.put_string("this is a string") */ rbffi_MemoryPointerClass = rb_define_class_under(moduleFFI, "MemoryPointer", ffi_Pointer); rb_global_variable(&rbffi_MemoryPointerClass); rb_define_alloc_func(rbffi_MemoryPointerClass, memptr_allocate); rb_define_method(rbffi_MemoryPointerClass, "initialize", memptr_initialize, -1); rb_define_singleton_method(rbffi_MemoryPointerClass, "from_string", memptr_s_from_string, 1); }
void Init_ffi_c(void) { /* * Document-module: FFI * * This module embbed type constants from {FFI::NativeType}. */ rbffi_FFIModule = moduleFFI = rb_define_module("FFI"); rb_global_variable(&rbffi_FFIModule); /* FFI::Type needs to be initialized before most other classes */ rbffi_Type_Init(moduleFFI); rbffi_DataConverter_Init(moduleFFI); rbffi_ArrayType_Init(moduleFFI); rbffi_LastError_Init(moduleFFI); rbffi_Call_Init(moduleFFI); rbffi_ClosurePool_Init(moduleFFI); rbffi_MethodHandle_Init(moduleFFI); rbffi_Platform_Init(moduleFFI); rbffi_AbstractMemory_Init(moduleFFI); rbffi_Pointer_Init(moduleFFI); rbffi_Function_Init(moduleFFI); rbffi_MemoryPointer_Init(moduleFFI); rbffi_Buffer_Init(moduleFFI); rbffi_StructByValue_Init(moduleFFI); rbffi_StructByReference_Init(moduleFFI); rbffi_Struct_Init(moduleFFI); rbffi_DynamicLibrary_Init(moduleFFI); rbffi_Variadic_Init(moduleFFI); rbffi_Types_Init(moduleFFI); rbffi_MappedType_Init(moduleFFI); }
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); }
void oci8_do_parse_connect_string(VALUE conn_str, VALUE *user, VALUE *pass, VALUE *dbname, VALUE *mode) { static VALUE re = Qnil; if (NIL_P(re)) { re = rb_eval_string(CONN_STR_REGEX); rb_global_variable(&re); } OCI8SafeStringValue(conn_str); if (RTEST(rb_reg_match(re, conn_str))) { *user = rb_reg_nth_match(1, rb_backref_get()); *pass = rb_reg_nth_match(2, rb_backref_get()); *dbname = rb_reg_nth_match(3, rb_backref_get()); *mode = rb_reg_nth_match(4, rb_backref_get()); if (RSTRING_LEN(*user) == 0 && RSTRING_LEN(*pass) == 0) { /* external credential */ *user = Qnil; *pass = Qnil; } if (!NIL_P(*mode)) { char *ptr; SafeStringValue(*mode); ptr = RSTRING_PTR(*mode); if (strcasecmp(ptr, "SYSDBA") == 0) { *mode = sym_SYSDBA; } else if (strcasecmp(ptr, "SYSOPER") == 0) { *mode = sym_SYSOPER; } } } else { rb_raise(rb_eArgError, "invalid connect string \"%s\" (expect \"username/password[@(tns_name|//host[:port]/service_name)][ as (sysdba|sysoper)]\"", RSTRING_PTR(conn_str)); } }
void Init_grpc_c() { if (!grpc_rb_load_core()) { rb_raise(rb_eLoadError, "Couldn't find or load gRPC's dynamic C core"); return; } rb_global_variable(&bg_thread_init_rb_mu); bg_thread_init_rb_mu = rb_mutex_new(); grpc_rb_mGRPC = rb_define_module("GRPC"); grpc_rb_mGrpcCore = rb_define_module_under(grpc_rb_mGRPC, "Core"); grpc_rb_sNewServerRpc = rb_struct_define( "NewServerRpc", "method", "host", "deadline", "metadata", "call", NULL); grpc_rb_sStatus = rb_struct_define("Status", "code", "details", "metadata", NULL); sym_code = ID2SYM(rb_intern("code")); sym_details = ID2SYM(rb_intern("details")); sym_metadata = ID2SYM(rb_intern("metadata")); Init_grpc_channel(); Init_grpc_call(); Init_grpc_call_credentials(); Init_grpc_channel_credentials(); Init_grpc_server(); Init_grpc_server_credentials(); Init_grpc_status_codes(); Init_grpc_time_consts(); Init_grpc_compression_options(); }
void init_mysql2_result() { cBigDecimal = rb_const_get(rb_cObject, rb_intern("BigDecimal")); cDate = rb_const_get(rb_cObject, rb_intern("Date")); cDateTime = rb_const_get(rb_cObject, rb_intern("DateTime")); cMysql2Result = rb_define_class_under(mMysql2, "Result", rb_cObject); rb_define_method(cMysql2Result, "each", rb_mysql_result_each, -1); rb_define_method(cMysql2Result, "fields", rb_mysql_result_fetch_fields, 0); rb_define_method(cMysql2Result, "count", rb_mysql_result_count, 0); rb_define_alias(cMysql2Result, "size", "count"); intern_encoding_from_charset = rb_intern("encoding_from_charset"); intern_encoding_from_charset_code = rb_intern("encoding_from_charset_code"); intern_new = rb_intern("new"); intern_utc = rb_intern("utc"); intern_local = rb_intern("local"); intern_merge = rb_intern("merge"); intern_localtime = rb_intern("localtime"); intern_local_offset = rb_intern("local_offset"); intern_civil = rb_intern("civil"); intern_new_offset = rb_intern("new_offset"); sym_symbolize_keys = ID2SYM(rb_intern("symbolize_keys")); sym_as = ID2SYM(rb_intern("as")); sym_array = ID2SYM(rb_intern("array")); sym_local = ID2SYM(rb_intern("local")); sym_utc = ID2SYM(rb_intern("utc")); sym_cast_booleans = ID2SYM(rb_intern("cast_booleans")); sym_database_timezone = ID2SYM(rb_intern("database_timezone")); sym_application_timezone = ID2SYM(rb_intern("application_timezone")); sym_cache_rows = ID2SYM(rb_intern("cache_rows")); sym_cast = ID2SYM(rb_intern("cast")); sym_stream = ID2SYM(rb_intern("stream")); opt_decimal_zero = rb_str_new2("0.0"); rb_global_variable(&opt_decimal_zero); //never GC opt_float_zero = rb_float_new((double)0); rb_global_variable(&opt_float_zero); opt_time_year = INT2NUM(2000); opt_time_month = INT2NUM(1); opt_utc_offset = INT2NUM(0); #ifdef HAVE_RUBY_ENCODING_H binaryEncoding = rb_enc_find("binary"); #endif }
void Init_fast_containers() { FastContainers = rb_define_module("FastContainers"); PriorityQueue = rb_define_class_under(FastContainers, "PriorityQueue", rb_cObject); rb_global_variable(&FastContainers); rb_global_variable(&PriorityQueue); rb_define_singleton_method(PriorityQueue, "new", RUBY_METHOD_FUNC(pq_new), 1); rb_define_method(PriorityQueue, "size", RUBY_METHOD_FUNC(pq_size), 0); rb_define_method(PriorityQueue, "push", RUBY_METHOD_FUNC(pq_push), 2); rb_define_method(PriorityQueue, "top", RUBY_METHOD_FUNC(pq_top), 0); rb_define_method(PriorityQueue, "top_key", RUBY_METHOD_FUNC(pq_top_key), 0); rb_define_method(PriorityQueue, "second_best_key", RUBY_METHOD_FUNC(pq_second_best_key), 0); rb_define_method(PriorityQueue, "pop", RUBY_METHOD_FUNC(pq_pop), 0); rb_define_method(PriorityQueue, "empty?", RUBY_METHOD_FUNC(pq_empty), 0); rb_define_method(PriorityQueue, "each", RUBY_METHOD_FUNC(pq_each), 0); rb_define_method(PriorityQueue, "pop_each", RUBY_METHOD_FUNC(pq_pop_each), 0); }
void Init_gobject_gobject() { VALUE cGObject; rbgobj_cObject = G_DEF_CLASS_WITH_GC_FUNC(G_TYPE_OBJECT, "Object", mGLib, gobj_mark, NULL); cGObject = rbgobj_cObject; #ifdef G_TYPE_INITIALLY_UNOWNED G_DEF_CLASS(G_TYPE_INITIALLY_UNOWNED, "InitiallyUnowned", mGLib); #endif RUBY_GOBJECT_OBJ_KEY = g_quark_from_static_string("__ruby_gobject_object__"); rb_define_alloc_func(cGObject, (VALUE(*)_((VALUE)))gobj_s_allocate); rb_define_singleton_method(cGObject, "new!", gobj_s_gobject_new, -1); rb_define_singleton_method(cGObject, "property", &gobj_s_property, 1); rb_define_singleton_method(cGObject, "properties", &gobj_s_properties, -1); rb_define_singleton_method(cGObject, "install_property", gobj_s_install_property, -1); q_ruby_getter = g_quark_from_static_string("__ruby_getter"); q_ruby_setter = g_quark_from_static_string("__ruby_setter"); rb_define_method(cGObject, "set_property", gobj_set_property, 2); rb_define_method(cGObject, "get_property", gobj_get_property, 1); rb_define_method(cGObject, "freeze_notify", gobj_freeze_notify, 0); rb_undef_method(cGObject, "notify"); rb_define_method(cGObject, "notify", gobj_notify, 1); rb_define_method(cGObject, "thaw_notify", gobj_thaw_notify, 0); rb_define_method(cGObject, "destroyed?", gobj_is_destroyed, 0); rb_define_method(cGObject, "initialize", gobj_initialize, -1); rb_define_method(cGObject, "ref_count", gobj_ref_count, 0); /* for debugging */ rb_define_method(cGObject, "inspect", gobj_inspect, 0); eNoPropertyError = rb_define_class_under(mGLib, "NoPropertyError", rb_eNameError); rb_global_variable(&type_to_prop_setter_table); rb_global_variable(&type_to_prop_getter_table); type_to_prop_setter_table = rb_hash_new(); type_to_prop_getter_table = rb_hash_new(); Init_gobject_subclass(); }
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); }
static void init( MessageHandler *handler) { VALUE load_path; InitMONFUNC(RubyConv, JSON_PackValue, JSON_UnPackValue, JSON_SizeValue); ruby_init(); ruby_init_loadpath(); load_path = rb_eval_string("$LOAD_PATH"); if (handler->loadpath == NULL) { handler->loadpath = getenv("APS_RUBY_PATH"); } if (handler->loadpath == NULL) { handler->loadpath = getenv("RUBYLIB"); } if (handler->loadpath == NULL) { handler->loadpath = MONTSUQI_LOAD_PATH; } rb_ary_push(load_path, rb_str_new2(handler->loadpath)); application_classes = rb_hash_new(); rb_gc_register_address(&application_classes); rb_global_variable(&application_classes); node_info = rb_hash_new(); rb_gc_register_address(&node_info); rb_global_variable(&node_info); rb_define_global_function("monfunc", monfunc, 2); rb_define_global_const("MCP_OK" ,INT2NUM(MCP_OK)); rb_define_global_const("MCP_EOF" ,INT2NUM(MCP_EOF)); rb_define_global_const("MCP_NONFATAL" ,INT2NUM(MCP_NONFATAL)); rb_define_global_const("MCP_BAD_ARG" ,INT2NUM(MCP_BAD_ARG)); rb_define_global_const("MCP_BAD_FUNC" ,INT2NUM(MCP_BAD_FUNC)); rb_define_global_const("MCP_BAD_OTHER" ,INT2NUM(MCP_BAD_OTHER)); rb_define_global_const("MCP_BAD_CONN" ,INT2NUM(MCP_BAD_CONN)); }
void Init_module(void) { rb_require("internal/node"); rb_cNode = rb_const_get(rb_cObject, rb_intern("Node")); rb_mMarshal = rb_const_get(rb_cObject, rb_intern("Marshal")); /* For rdoc: rb_cModule = rb_define_class("Module", rb_cObject) */ rb_cModule = rb_const_get(rb_cObject, rb_intern("Module")); rb_define_method(rb_cModule, "add_method", module_add_method, 3); rb_define_private_method(rb_cModule, "uninclude", module_uninclude, -1); rb_define_private_method(rb_cModule, "remove_features", module_remove_features, 1); rb_define_private_method(rb_cModule, "unincluded", module_unincluded, 1); rb_define_method(rb_cModule, "real_superclass", module_real_superclass, 0); lookup_module_proc = rb_eval_string(lookup_module_str); rb_global_variable(&lookup_module_proc); outer_module_proc = rb_eval_string(outer_module_str); rb_global_variable(&outer_module_proc); module_name_proc = rb_eval_string(module_name_str); rb_global_variable(&module_name_proc); #if RUBY_VERSION_CODE >= 180 { VALUE rb_mInternal = rb_define_module("Internal"); rb_cClass_Restorer = rb_define_class_under(rb_mInternal, "ClassRestorer", rb_cObject); rb_define_method(rb_cClass_Restorer, "_dump", class_restorer_dump, 1); rb_define_singleton_method(rb_cClass_Restorer, "_load", class_restorer_load, 1); } #endif #if RUBY_VERSION_CODE == 180 rb_alias(CLASS_OF(rb_mMarshal), rb_intern("_Internal__orig_dump"), rb_intern("dump")); rb_define_singleton_method(rb_mMarshal, "dump", ruby180_marshal_dump, -1); #endif rb_define_method(rb_cModule, "_dump", module_dump, 1); rb_define_singleton_method(rb_cModule, "_load", module_load, 1); #ifdef HAVE_TYPE_STRUCT_RTYPEDDATA init_ruby_threadptr_data_type(); #endif }
static void Init_SysInfo() { hardware_list = rb_ary_new(); rb_global_variable(&hardware_list); rb_define_variable("$hardware", &hardware_list); rb_ary_push(hardware_list, rb_str_new2("DVD")); rb_ary_push(hardware_list, rb_str_new2("CDP1")); }