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"));
}
