void Init_ossl_engine() { cEngine = rb_define_class_under(mOSSL, "Engine", rb_cObject); eEngineError = rb_define_class_under(cEngine, "EngineError", eOSSLError); rb_define_alloc_func(cEngine, ossl_engine_s_alloc); rb_define_singleton_method(cEngine, "load", ossl_engine_s_load, -1); rb_define_singleton_method(cEngine, "cleanup", ossl_engine_s_cleanup, 0); rb_define_singleton_method(cEngine, "engines", ossl_engine_s_engines, 0); rb_define_singleton_method(cEngine, "by_id", ossl_engine_s_by_id, 1); rb_undef_method(CLASS_OF(cEngine), "new"); rb_define_method(cEngine, "id", ossl_engine_get_id, 0); rb_define_method(cEngine, "name", ossl_engine_get_name, 0); rb_define_method(cEngine, "finish", ossl_engine_finish, 0); rb_define_method(cEngine, "cipher", ossl_engine_get_cipher, 1); rb_define_method(cEngine, "digest", ossl_engine_get_digest, 1); rb_define_method(cEngine, "load_private_key", ossl_engine_load_privkey, -1); rb_define_method(cEngine, "load_public_key", ossl_engine_load_pubkey, -1); rb_define_method(cEngine, "set_default", ossl_engine_set_default, 1); rb_define_method(cEngine, "ctrl_cmd", ossl_engine_ctrl_cmd, -1); rb_define_method(cEngine, "cmds", ossl_engine_get_cmds, 0); rb_define_method(cEngine, "inspect", ossl_engine_inspect, 0); DefEngineConst(METHOD_RSA); DefEngineConst(METHOD_DSA); DefEngineConst(METHOD_DH); DefEngineConst(METHOD_RAND); #ifdef ENGINE_METHOD_BN_MOD_EXP DefEngineConst(METHOD_BN_MOD_EXP); #endif #ifdef ENGINE_METHOD_BN_MOD_EXP_CRT DefEngineConst(METHOD_BN_MOD_EXP_CRT); #endif #ifdef ENGINE_METHOD_CIPHERS DefEngineConst(METHOD_CIPHERS); #endif #ifdef ENGINE_METHOD_DIGESTS DefEngineConst(METHOD_DIGESTS); #endif DefEngineConst(METHOD_ALL); DefEngineConst(METHOD_NONE); }
void init_pg_result() { rb_cPGresult = rb_define_class_under( rb_mPG, "Result", rb_cObject ); rb_include_module(rb_cPGresult, rb_mEnumerable); rb_include_module(rb_cPGresult, rb_mPGconstants); /****** PG::Result INSTANCE METHODS: libpq ******/ rb_define_method(rb_cPGresult, "result_status", pgresult_result_status, 0); rb_define_method(rb_cPGresult, "res_status", pgresult_res_status, 1); rb_define_method(rb_cPGresult, "error_message", pgresult_error_message, 0); rb_define_alias( rb_cPGresult, "result_error_message", "error_message"); rb_define_method(rb_cPGresult, "error_field", pgresult_error_field, 1); rb_define_alias( rb_cPGresult, "result_error_field", "error_field" ); rb_define_method(rb_cPGresult, "clear", pg_result_clear, 0); rb_define_method(rb_cPGresult, "check", pg_result_check, 0); rb_define_alias (rb_cPGresult, "check_result", "check"); rb_define_method(rb_cPGresult, "ntuples", pgresult_ntuples, 0); rb_define_alias(rb_cPGresult, "num_tuples", "ntuples"); rb_define_method(rb_cPGresult, "nfields", pgresult_nfields, 0); rb_define_alias(rb_cPGresult, "num_fields", "nfields"); rb_define_method(rb_cPGresult, "fname", pgresult_fname, 1); rb_define_method(rb_cPGresult, "fnumber", pgresult_fnumber, 1); rb_define_method(rb_cPGresult, "ftable", pgresult_ftable, 1); rb_define_method(rb_cPGresult, "ftablecol", pgresult_ftablecol, 1); rb_define_method(rb_cPGresult, "fformat", pgresult_fformat, 1); rb_define_method(rb_cPGresult, "ftype", pgresult_ftype, 1); rb_define_method(rb_cPGresult, "fmod", pgresult_fmod, 1); rb_define_method(rb_cPGresult, "fsize", pgresult_fsize, 1); rb_define_method(rb_cPGresult, "getvalue", pgresult_getvalue, 2); rb_define_method(rb_cPGresult, "getisnull", pgresult_getisnull, 2); rb_define_method(rb_cPGresult, "getlength", pgresult_getlength, 2); rb_define_method(rb_cPGresult, "nparams", pgresult_nparams, 0); rb_define_method(rb_cPGresult, "paramtype", pgresult_paramtype, 1); rb_define_method(rb_cPGresult, "cmd_status", pgresult_cmd_status, 0); rb_define_method(rb_cPGresult, "cmd_tuples", pgresult_cmd_tuples, 0); rb_define_alias(rb_cPGresult, "cmdtuples", "cmd_tuples"); rb_define_method(rb_cPGresult, "oid_value", pgresult_oid_value, 0); /****** PG::Result INSTANCE METHODS: other ******/ rb_define_method(rb_cPGresult, "[]", pgresult_aref, 1); rb_define_method(rb_cPGresult, "each", pgresult_each, 0); rb_define_method(rb_cPGresult, "fields", pgresult_fields, 0); rb_define_method(rb_cPGresult, "each_row", pgresult_each_row, 0); rb_define_method(rb_cPGresult, "column_values", pgresult_column_values, 1); rb_define_method(rb_cPGresult, "field_values", pgresult_field_values, 1); }
void RepeatedField_register(VALUE module) { VALUE klass = rb_define_class_under( module, "RepeatedField", rb_cObject); rb_define_alloc_func(klass, RepeatedField_alloc); cRepeatedField = klass; rb_gc_register_address(&cRepeatedField); rb_define_method(klass, "initialize", RepeatedField_init, -1); rb_define_method(klass, "each", RepeatedField_each, 0); rb_define_method(klass, "[]", RepeatedField_index, 1); rb_define_method(klass, "[]=", RepeatedField_index_set, 2); rb_define_method(klass, "push", RepeatedField_push, 1); rb_define_method(klass, "<<", RepeatedField_push, 1); rb_define_method(klass, "pop", RepeatedField_pop, 0); rb_define_method(klass, "insert", RepeatedField_insert, -1); rb_define_method(klass, "replace", RepeatedField_replace, 1); rb_define_method(klass, "clear", RepeatedField_clear, 0); rb_define_method(klass, "length", RepeatedField_length, 0); rb_define_method(klass, "dup", RepeatedField_dup, 0); // Also define #clone so that we don't inherit Object#clone. rb_define_method(klass, "clone", RepeatedField_dup, 0); rb_define_method(klass, "==", RepeatedField_eq, 1); rb_define_method(klass, "to_ary", RepeatedField_to_ary, 0); rb_define_method(klass, "hash", RepeatedField_hash, 0); rb_define_method(klass, "inspect", RepeatedField_inspect, 0); rb_define_method(klass, "+", RepeatedField_plus, 1); rb_include_module(klass, rb_mEnumerable); }
void rb_define_attr_method(VALUE klass, std::string name, VALUE (*readfunc)(...), VALUE(*func)(...)) { rb_define_attr(klass, name.c_str(), 1, 1); rb_define_method(klass, (name + "=").c_str(), func, 1); rb_define_method(klass, name.c_str(), readfunc, 0); }
void Init_rdiscount() { rb_cRDiscount = rb_define_class("RDiscount", rb_cObject); rb_define_method(rb_cRDiscount, "to_html", rb_rdiscount_to_html, -1); rb_define_method(rb_cRDiscount, "toc_content", rb_rdiscount_toc_content, -1); }
void Init_gsl_blas1(VALUE module) { rb_define_module_function(module, "ddot", rb_gsl_blas_ddot, -1); rb_define_method(cgsl_vector, "blas_ddot", rb_gsl_blas_ddot, -1); rb_define_alias(cgsl_vector, "ddot", "blas_ddot"); /* rb_define_alias(cgsl_vector, "dot", "blas_ddot");*/ rb_define_module_function(module, "zdotu", rb_gsl_blas_zdotu, -1); rb_define_method(cgsl_vector_complex, "blas_zdotu", rb_gsl_blas_zdotu, -1); rb_define_alias(cgsl_vector_complex, "zdotu", "blas_zdotu"); rb_define_alias(cgsl_vector_complex, "dotu", "blas_zdotu"); rb_define_module_function(module, "zdotc", rb_gsl_blas_zdotc, -1); rb_define_method(cgsl_vector_complex, "blas_zdotc", rb_gsl_blas_zdotc, -1); rb_define_alias(cgsl_vector_complex, "zdotc", "blas_zdotc"); rb_define_alias(cgsl_vector_complex, "dotc", "blas_zdotc"); rb_define_module_function(module, "dnrm2", rb_gsl_blas_dnrm2, -1); rb_define_method(cgsl_vector, "blas_dnrm2", rb_gsl_blas_dnrm2, -1); rb_define_alias(cgsl_vector, "dnrm2", "blas_dnrm2"); rb_define_alias(cgsl_vector, "nrm2", "blas_dnrm2"); rb_define_alias(cgsl_vector, "norm", "blas_dnrm2"); rb_define_module_function(module, "dnrm", rb_gsl_blas_dnrm, -1); rb_define_method(cgsl_vector, "blas_dnrm", rb_gsl_blas_dnrm, -1); rb_define_alias(cgsl_vector, "dnrm", "blas_dnrm"); rb_define_alias(cgsl_vector, "nrm", "blas_dnrm"); rb_define_alias(cgsl_vector, "sumsq", "blas_dnrm"); rb_define_module_function(module, "dznrm2", rb_gsl_blas_dznrm2, -1); rb_define_method(cgsl_vector_complex, "blas_dznrm2", rb_gsl_blas_dznrm2, -1); rb_define_alias(cgsl_vector_complex, "dznrm2", "blas_dznrm2"); rb_define_alias(cgsl_vector_complex, "nrm2", "blas_dznrm2"); rb_define_module_function(module, "dasum", rb_gsl_blas_dasum, -1); rb_define_method(cgsl_vector, "blas_dasum", rb_gsl_blas_dasum, -1); rb_define_alias(cgsl_vector, "dasum", "blas_dasum"); rb_define_alias(cgsl_vector, "asum", "blas_dasum"); rb_define_module_function(module, "dzasum", rb_gsl_blas_dzasum, -1); rb_define_method(cgsl_vector_complex, "blas_dzasum", rb_gsl_blas_dzasum, -1); rb_define_alias(cgsl_vector_complex, "dzasum", "blas_dzasum"); rb_define_alias(cgsl_vector_complex, "asum", "blas_dzasum"); rb_define_module_function(module, "idamax", rb_gsl_blas_idamax, -1); rb_define_method(cgsl_vector, "blas_idamax", rb_gsl_blas_idamax, -1); rb_define_alias(cgsl_vector, "idamax", "blas_idamax"); rb_define_module_function(module, "izamax", rb_gsl_blas_izamax, -1); rb_define_method(cgsl_vector_complex, "blas_izamax", rb_gsl_blas_izamax, -1); rb_define_alias(cgsl_vector_complex, "izamax", "blas_izamax"); rb_define_module_function(module, "dswap", rb_gsl_blas_dswap, -1); rb_define_method(cgsl_vector, "blas_dswap", rb_gsl_blas_dswap, -1); rb_define_alias(cgsl_vector, "dswap", "blas_dswap"); rb_define_alias(cgsl_vector, "swap", "blas_dswap"); rb_define_module_function(module, "zswap", rb_gsl_blas_zswap, -1); rb_define_method(cgsl_vector_complex, "blas_zswap", rb_gsl_blas_zswap, -1); rb_define_alias(cgsl_vector_complex, "zswap", "blas_zswap"); rb_define_alias(cgsl_vector_complex, "swap", "blas_zswap"); rb_define_module_function(module, "dcopy", rb_gsl_blas_dcopy, -1); rb_define_method(cgsl_vector, "blas_dcopy", rb_gsl_blas_dcopy, -1); rb_define_alias(cgsl_vector, "dcopy", "blas_dcopy"); rb_define_alias(cgsl_vector, "copy", "blas_dcopy"); rb_define_module_function(module, "zcopy", rb_gsl_blas_zcopy, -1); rb_define_method(cgsl_vector_complex, "blas_zcopy", rb_gsl_blas_zcopy, -1); rb_define_alias(cgsl_vector_complex, "zcopy", "blas_zcopy"); rb_define_alias(cgsl_vector_complex, "copy", "blas_zcopy"); rb_define_module_function(module, "daxpy!", rb_gsl_blas_daxpy, -1); rb_define_method(cgsl_vector, "blas_daxpy!", rb_gsl_blas_daxpy, -1); rb_define_alias(cgsl_vector, "daxpy!", "blas_daxpy!"); rb_define_alias(cgsl_vector, "axpy!", "blas_daxpy!"); rb_define_module_function(module, "daxpy", rb_gsl_blas_daxpy2, -1); rb_define_method(cgsl_vector, "blas_daxpy", rb_gsl_blas_daxpy2, -1); rb_define_alias(cgsl_vector, "daxpy", "blas_daxpy"); rb_define_alias(cgsl_vector, "axpy", "blas_daxpy"); rb_define_module_function(module, "zaxpy!", rb_gsl_blas_zaxpy, -1); rb_define_method(cgsl_vector_complex, "blas_zaxpy!", rb_gsl_blas_zaxpy, -1); rb_define_alias(cgsl_vector_complex, "zaxpy!", "blas_zaxpy!"); rb_define_alias(cgsl_vector_complex, "axpy!", "blas_zaxpy!"); rb_define_module_function(module, "zaxpy", rb_gsl_blas_zaxpy2, -1); rb_define_method(cgsl_vector_complex, "blas_zaxpy", rb_gsl_blas_zaxpy2, -1); rb_define_alias(cgsl_vector_complex, "zaxpy", "blas_zaxpy"); rb_define_alias(cgsl_vector_complex, "axpy", "blas_zaxpy"); rb_define_module_function(module, "dscal!", rb_gsl_blas_dscal, -1); rb_define_method(cgsl_vector, "blas_dscal!", rb_gsl_blas_dscal, -1); rb_define_alias(cgsl_vector, "dscal!", "blas_dscal!"); rb_define_alias(cgsl_vector, "scal!", "blas_dscal!"); rb_define_module_function(module, "dscal", rb_gsl_blas_dscal2, -1); rb_define_method(cgsl_vector, "blas_dscal", rb_gsl_blas_dscal2, -1); rb_define_alias(cgsl_vector, "dscal", "blas_dscal"); rb_define_alias(cgsl_vector, "scal", "blas_dscal"); rb_define_module_function(module, "zdscal!", rb_gsl_blas_zdscal, -1); rb_define_method(cgsl_vector_complex, "blas_zdscal!", rb_gsl_blas_zdscal, -1); rb_define_alias(cgsl_vector_complex, "zdscal!", "blas_zdscal!"); rb_define_alias(cgsl_vector_complex, "scal!", "blas_zdscal!"); rb_define_module_function(module, "zdscal", rb_gsl_blas_zdscal2, -1); rb_define_method(cgsl_vector_complex, "blas_zdscal", rb_gsl_blas_zdscal2, -1); rb_define_alias(cgsl_vector_complex, "zdscal", "blas_zdscal"); rb_define_alias(cgsl_vector_complex, "scal", "blas_zdscal"); rb_define_module_function(module, "zscal!", rb_gsl_blas_zscal, -1); rb_define_method(cgsl_vector_complex, "blas_zscal!", rb_gsl_blas_zscal, -1); rb_define_alias(cgsl_vector_complex, "zscal!", "blas_zscal!"); rb_define_module_function(module, "zscal2", rb_gsl_blas_zscal2, -1); rb_define_method(cgsl_vector_complex, "blas_zscal2", rb_gsl_blas_zscal2, -1); rb_define_alias(cgsl_vector_complex, "zscal2", "blas_zscal2"); rb_define_alias(cgsl_vector_complex, "scal2", "blas_zscal2"); rb_define_module_function(module, "drot!", rb_gsl_blas_drot, 4); rb_define_module_function(module, "drot", rb_gsl_blas_drot2, 4); rb_define_module_function(module, "drotm!", rb_gsl_blas_drotm, 3); rb_define_module_function(module, "drotm", rb_gsl_blas_drotm2, 3); }
void Init_DNSSD_Service(void) { mDNSSD = rb_define_module("DNSSD"); dnssd_id_join = rb_intern("join"); dnssd_id_push = rb_intern("push"); dnssd_iv_continue = rb_intern("@continue"); dnssd_iv_records = rb_intern("@records"); dnssd_iv_replies = rb_intern("@replies"); dnssd_iv_service = rb_intern("@service"); dnssd_iv_thread = rb_intern("@thread"); dnssd_iv_type = rb_intern("@type"); cDNSSDFlags = rb_define_class_under(mDNSSD, "Flags", rb_cObject); cDNSSDRecord = rb_define_class_under(mDNSSD, "Record", rb_cObject); cDNSSDService = rb_define_class_under(mDNSSD, "Service", rb_cObject); cDNSSDTextRecord = rb_path2class("DNSSD::TextRecord"); cDNSSDReplyAddrInfo = rb_path2class("DNSSD::Reply::AddrInfo"); cDNSSDReplyBrowse = rb_path2class("DNSSD::Reply::Browse"); cDNSSDReplyDomain = rb_path2class("DNSSD::Reply::Domain"); cDNSSDReplyQueryRecord = rb_path2class("DNSSD::Reply::QueryRecord"); cDNSSDReplyRegister = rb_path2class("DNSSD::Reply::Register"); cDNSSDReplyResolve = rb_path2class("DNSSD::Reply::Resolve"); rb_cSocket = rb_path2class("Socket"); /* Maximum length for a domain name */ rb_define_const(cDNSSDService, "MAX_DOMAIN_NAME", ULONG2NUM(kDNSServiceMaxDomainName)); /* Maximum length for a service name */ rb_define_const(cDNSSDService, "MAX_SERVICE_NAME", ULONG2NUM(kDNSServiceMaxServiceName)); #ifdef kDNSServiceProperty_DaemonVersion /* DaemonVersion property value */ rb_define_const(cDNSSDService, "DaemonVersion", rb_str_new2(kDNSServiceProperty_DaemonVersion)); #endif #ifdef HAVE_DNSSERVICEGETPROPERTY /* IPv4 protocol for #getaddrinfo */ rb_define_const(cDNSSDService, "IPv4", ULONG2NUM(kDNSServiceProtocol_IPv4)); /* IPv6 protocol for #getaddrinfo */ rb_define_const(cDNSSDService, "IPv6", ULONG2NUM(kDNSServiceProtocol_IPv6)); /* HACK the below are only used by NAT, fix with proper HAVE_ */ /* TCP protocol for creating NAT port mappings */ rb_define_const(cDNSSDService, "TCP", ULONG2NUM(kDNSServiceProtocol_TCP)); /* UDP protocol for creating NAT port mappings */ rb_define_const(cDNSSDService, "UDP", ULONG2NUM(kDNSServiceProtocol_UDP)); #endif rb_define_alloc_func(cDNSSDService, dnssd_service_s_allocate); rb_define_singleton_method(cDNSSDService, "fullname", dnssd_service_s_fullname, 3); #ifdef HAVE_DNSSERVICEGETPROPERTY rb_define_singleton_method(cDNSSDService, "get_property", dnssd_service_s_get_property, 1); #endif rb_define_method(cDNSSDService, "stop", dnssd_service_stop, 0); rb_define_method(cDNSSDService, "stopped?", dnssd_service_stopped_p, 0); rb_define_method(cDNSSDService, "_add_record", dnssd_service_add_record, 4); rb_define_method(cDNSSDService, "_browse", dnssd_service_browse, 4); rb_define_method(cDNSSDService, "_enumerate_domains", dnssd_service_enumerate_domains, 2); #ifdef HAVE_DNSSERVICEGETADDRINFO rb_define_method(cDNSSDService, "_getaddrinfo", dnssd_service_getaddrinfo, 4); #endif rb_define_method(cDNSSDService, "_query_record", dnssd_service_query_record, 5); rb_define_method(cDNSSDService, "_register", dnssd_service_register, 8); rb_define_method(cDNSSDService, "_resolve", dnssd_service_resolve, 5); rb_define_method(cDNSSDService, "_process", dnssd_service_process, 0); }
void rsock_init_basicsocket(void) { /* * Document-class: BasicSocket < IO * * BasicSocket is the super class for all the Socket classes. */ rb_cBasicSocket = rb_define_class("BasicSocket", rb_cIO); rb_undef_method(rb_cBasicSocket, "initialize"); rb_define_singleton_method(rb_cBasicSocket, "do_not_reverse_lookup", bsock_do_not_rev_lookup, 0); rb_define_singleton_method(rb_cBasicSocket, "do_not_reverse_lookup=", bsock_do_not_rev_lookup_set, 1); rb_define_singleton_method(rb_cBasicSocket, "for_fd", bsock_s_for_fd, 1); rb_define_method(rb_cBasicSocket, "close_read", bsock_close_read, 0); rb_define_method(rb_cBasicSocket, "close_write", bsock_close_write, 0); rb_define_method(rb_cBasicSocket, "shutdown", bsock_shutdown, -1); rb_define_method(rb_cBasicSocket, "setsockopt", bsock_setsockopt, -1); rb_define_method(rb_cBasicSocket, "getsockopt", bsock_getsockopt, 2); rb_define_method(rb_cBasicSocket, "getsockname", bsock_getsockname, 0); rb_define_method(rb_cBasicSocket, "getpeername", bsock_getpeername, 0); rb_define_method(rb_cBasicSocket, "getpeereid", bsock_getpeereid, 0); rb_define_method(rb_cBasicSocket, "local_address", bsock_local_address, 0); rb_define_method(rb_cBasicSocket, "remote_address", bsock_remote_address, 0); rb_define_method(rb_cBasicSocket, "send", rsock_bsock_send, -1); rb_define_method(rb_cBasicSocket, "recv", bsock_recv, -1); rb_define_method(rb_cBasicSocket, "do_not_reverse_lookup", bsock_do_not_reverse_lookup, 0); rb_define_method(rb_cBasicSocket, "do_not_reverse_lookup=", bsock_do_not_reverse_lookup_set, 1); /* for ext/socket/lib/socket.rb use only: */ rb_define_private_method(rb_cBasicSocket, "__recv_nonblock", bsock_recv_nonblock, 4); /* in ancdata.c */ rb_define_private_method(rb_cBasicSocket, "__sendmsg", rsock_bsock_sendmsg, 4); rb_define_private_method(rb_cBasicSocket, "__sendmsg_nonblock", rsock_bsock_sendmsg_nonblock, 5); rb_define_private_method(rb_cBasicSocket, "__recvmsg", rsock_bsock_recvmsg, 4); rb_define_private_method(rb_cBasicSocket, "__recvmsg_nonblock", rsock_bsock_recvmsg_nonblock, 5); }
void Init_finfast() { VALUE module = rb_define_module("Finfast"); rb_define_method(module, "newton", method_newton, 5); }
void init_html_element_description() { VALUE nokogiri = rb_define_module("Nokogiri"); VALUE html = rb_define_module_under(nokogiri, "HTML"); VALUE klass = rb_define_class_under(html, "ElementDescription",rb_cObject); cNokogiriHtmlElementDescription = klass; rb_define_singleton_method(klass, "[]", get_description, 1); rb_define_method(klass, "name", name, 0); rb_define_method(klass, "implied_start_tag?", implied_start_tag_eh, 0); rb_define_method(klass, "implied_end_tag?", implied_end_tag_eh, 0); rb_define_method(klass, "save_end_tag?", save_end_tag_eh, 0); rb_define_method(klass, "empty?", empty_eh, 0); rb_define_method(klass, "deprecated?", deprecated_eh, 0); rb_define_method(klass, "inline?", inline_eh, 0); rb_define_method(klass, "description", description, 0); rb_define_method(klass, "sub_elements", sub_elements, 0); rb_define_method(klass, "default_sub_element", default_sub_element, 0); rb_define_method(klass, "optional_attributes", optional_attributes, 0); rb_define_method(klass, "deprecated_attributes", deprecated_attributes, 0); rb_define_method(klass, "required_attributes", required_attributes, 0); }
void rxml_init_document(void) { cXMLDocument = rb_define_class_under(mXML, "Document", rb_cObject); rb_define_alloc_func(cXMLDocument, rxml_document_alloc); rb_define_method(cXMLDocument, "initialize", rxml_document_initialize, -1); rb_define_method(cXMLDocument, "child", rxml_document_child_get, 0); rb_define_method(cXMLDocument, "child?", rxml_document_child_q, 0); rb_define_method(cXMLDocument, "compression", rxml_document_compression_get, 0); rb_define_method(cXMLDocument, "compression=", rxml_document_compression_set, 1); rb_define_method(cXMLDocument, "compression?", rxml_document_compression_q, 0); rb_define_method(cXMLDocument, "debug", rxml_document_debug, 0); rb_define_method(cXMLDocument, "encoding", rxml_document_encoding_get, 0); rb_define_method(cXMLDocument, "encoding=", rxml_document_encoding_set, 1); rb_define_method(cXMLDocument, "import", rxml_document_import, 1); rb_define_method(cXMLDocument, "last", rxml_document_last_get, 0); rb_define_method(cXMLDocument, "last?", rxml_document_last_q, 0); rb_define_method(cXMLDocument, "next", rxml_document_next_get, 0); rb_define_method(cXMLDocument, "next?", rxml_document_next_q, 0); rb_define_method(cXMLDocument, "node_type", rxml_document_node_type, 0); rb_define_method(cXMLDocument, "order_elements!", rxml_document_order_elements, 0); rb_define_method(cXMLDocument, "parent", rxml_document_parent_get, 0); rb_define_method(cXMLDocument, "parent?", rxml_document_parent_q, 0); rb_define_method(cXMLDocument, "prev", rxml_document_prev_get, 0); rb_define_method(cXMLDocument, "prev?", rxml_document_prev_q, 0); rb_define_method(cXMLDocument, "root", rxml_document_root_get, 0); rb_define_method(cXMLDocument, "root=", rxml_document_root_set, 1); rb_define_method(cXMLDocument, "save", rxml_document_save, -1); rb_define_method(cXMLDocument, "standalone?", rxml_document_standalone_q, 0); rb_define_method(cXMLDocument, "to_s", rxml_document_to_s, -1); rb_define_method(cXMLDocument, "url", rxml_document_url_get, 0); rb_define_method(cXMLDocument, "version", rxml_document_version_get, 0); rb_define_method(cXMLDocument, "xhtml?", rxml_document_xhtml_q, 0); rb_define_method(cXMLDocument, "xinclude", rxml_document_xinclude, 0); rb_define_method(cXMLDocument, "validate", rxml_document_validate_dtd, 1); rb_define_method(cXMLDocument, "validate_schema", rxml_document_validate_schema, 1); rb_define_method(cXMLDocument, "validate_relaxng", rxml_document_validate_relaxng, 1); }
void Init_ossl_ssl() { int i; VALUE ary; #if 0 /* let rdoc know about mOSSL */ mOSSL = rb_define_module("OpenSSL"); #endif ID_callback_state = rb_intern("@callback_state"); ossl_ssl_ex_vcb_idx = SSL_get_ex_new_index(0,"ossl_ssl_ex_vcb_idx",0,0,0); ossl_ssl_ex_store_p = SSL_get_ex_new_index(0,"ossl_ssl_ex_store_p",0,0,0); ossl_ssl_ex_ptr_idx = SSL_get_ex_new_index(0,"ossl_ssl_ex_ptr_idx",0,0,0); ossl_ssl_ex_client_cert_cb_idx = SSL_get_ex_new_index(0,"ossl_ssl_ex_client_cert_cb_idx",0,0,0); ossl_ssl_ex_tmp_dh_callback_idx = SSL_get_ex_new_index(0,"ossl_ssl_ex_tmp_dh_callback_idx",0,0,0); mSSL = rb_define_module_under(mOSSL, "SSL"); eSSLError = rb_define_class_under(mSSL, "SSLError", eOSSLError); Init_ossl_ssl_session(); /* class SSLContext * * The following attributes are available but don't show up in rdoc. * All attributes must be set before calling SSLSocket.new(io, ctx). * * ssl_version, cert, key, client_ca, ca_file, ca_path, timeout, * * verify_mode, verify_depth client_cert_cb, tmp_dh_callback, * * session_id_context, session_add_cb, session_new_cb, session_remove_cb */ cSSLContext = rb_define_class_under(mSSL, "SSLContext", rb_cObject); rb_define_alloc_func(cSSLContext, ossl_sslctx_s_alloc); for(i = 0; i < numberof(ossl_sslctx_attrs); i++) rb_attr(cSSLContext, rb_intern(ossl_sslctx_attrs[i]), 1, 1, Qfalse); rb_define_alias(cSSLContext, "ssl_timeout", "timeout"); rb_define_method(cSSLContext, "initialize", ossl_sslctx_initialize, -1); rb_define_method(cSSLContext, "ssl_version=", ossl_sslctx_set_ssl_version, 1); rb_define_method(cSSLContext, "ciphers", ossl_sslctx_get_ciphers, 0); rb_define_method(cSSLContext, "ciphers=", ossl_sslctx_set_ciphers, 1); rb_define_method(cSSLContext, "setup", ossl_sslctx_setup, 0); rb_define_const(cSSLContext, "SESSION_CACHE_OFF", LONG2FIX(SSL_SESS_CACHE_OFF)); rb_define_const(cSSLContext, "SESSION_CACHE_CLIENT", LONG2FIX(SSL_SESS_CACHE_CLIENT)); /* doesn't actually do anything in 0.9.8e */ rb_define_const(cSSLContext, "SESSION_CACHE_SERVER", LONG2FIX(SSL_SESS_CACHE_SERVER)); rb_define_const(cSSLContext, "SESSION_CACHE_BOTH", LONG2FIX(SSL_SESS_CACHE_BOTH)); /* no different than CACHE_SERVER in 0.9.8e */ rb_define_const(cSSLContext, "SESSION_CACHE_NO_AUTO_CLEAR", LONG2FIX(SSL_SESS_CACHE_NO_AUTO_CLEAR)); rb_define_const(cSSLContext, "SESSION_CACHE_NO_INTERNAL_LOOKUP", LONG2FIX(SSL_SESS_CACHE_NO_INTERNAL_LOOKUP)); rb_define_const(cSSLContext, "SESSION_CACHE_NO_INTERNAL_STORE", LONG2FIX(SSL_SESS_CACHE_NO_INTERNAL_STORE)); rb_define_const(cSSLContext, "SESSION_CACHE_NO_INTERNAL", LONG2FIX(SSL_SESS_CACHE_NO_INTERNAL)); rb_define_method(cSSLContext, "session_add", ossl_sslctx_session_add, 1); rb_define_method(cSSLContext, "session_remove", ossl_sslctx_session_remove, 1); rb_define_method(cSSLContext, "session_cache_mode", ossl_sslctx_get_session_cache_mode, 0); rb_define_method(cSSLContext, "session_cache_mode=", ossl_sslctx_set_session_cache_mode, 1); rb_define_method(cSSLContext, "session_cache_size", ossl_sslctx_get_session_cache_size, 0); rb_define_method(cSSLContext, "session_cache_size=", ossl_sslctx_set_session_cache_size, 1); rb_define_method(cSSLContext, "session_cache_stats", ossl_sslctx_get_session_cache_stats, 0); rb_define_method(cSSLContext, "flush_sessions", ossl_sslctx_flush_sessions, -1); ary = rb_ary_new2(numberof(ossl_ssl_method_tab)); for (i = 0; i < numberof(ossl_ssl_method_tab); i++) { rb_ary_push(ary, ID2SYM(rb_intern(ossl_ssl_method_tab[i].name))); } rb_obj_freeze(ary); /* holds a list of available SSL/TLS methods */ rb_define_const(cSSLContext, "METHODS", ary); /* class SSLSocket * * The following attributes are available but don't show up in rdoc. * * io, context, sync_close * */ cSSLSocket = rb_define_class_under(mSSL, "SSLSocket", rb_cObject); rb_define_alloc_func(cSSLSocket, ossl_ssl_s_alloc); for(i = 0; i < numberof(ossl_ssl_attr_readers); i++) rb_attr(cSSLSocket, rb_intern(ossl_ssl_attr_readers[i]), 1, 0, Qfalse); for(i = 0; i < numberof(ossl_ssl_attrs); i++) rb_attr(cSSLSocket, rb_intern(ossl_ssl_attrs[i]), 1, 1, Qfalse); rb_define_alias(cSSLSocket, "to_io", "io"); rb_define_method(cSSLSocket, "initialize", ossl_ssl_initialize, -1); rb_define_method(cSSLSocket, "connect", ossl_ssl_connect, 0); rb_define_method(cSSLSocket, "accept", ossl_ssl_accept, 0); rb_define_method(cSSLSocket, "sysread", ossl_ssl_read, -1); rb_define_method(cSSLSocket, "syswrite", ossl_ssl_write, 1); rb_define_method(cSSLSocket, "sysclose", ossl_ssl_close, 0); rb_define_method(cSSLSocket, "cert", ossl_ssl_get_cert, 0); rb_define_method(cSSLSocket, "peer_cert", ossl_ssl_get_peer_cert, 0); rb_define_method(cSSLSocket, "peer_cert_chain", ossl_ssl_get_peer_cert_chain, 0); rb_define_method(cSSLSocket, "cipher", ossl_ssl_get_cipher, 0); rb_define_method(cSSLSocket, "state", ossl_ssl_get_state, 0); rb_define_method(cSSLSocket, "pending", ossl_ssl_pending, 0); rb_define_method(cSSLSocket, "session_reused?", ossl_ssl_session_reused, 0); rb_define_method(cSSLSocket, "session=", ossl_ssl_set_session, 1); rb_define_method(cSSLSocket, "verify_result", ossl_ssl_get_verify_result, 0); #define ossl_ssl_def_const(x) rb_define_const(mSSL, #x, INT2FIX(SSL_##x)) ossl_ssl_def_const(VERIFY_NONE); ossl_ssl_def_const(VERIFY_PEER); ossl_ssl_def_const(VERIFY_FAIL_IF_NO_PEER_CERT); ossl_ssl_def_const(VERIFY_CLIENT_ONCE); /* Introduce constants included in OP_ALL. These constants are mostly for * unset some bits in OP_ALL such as; * ctx.options = OP_ALL & ~OP_DONT_INSERT_EMPTY_FRAGMENTS */ ossl_ssl_def_const(OP_MICROSOFT_SESS_ID_BUG); ossl_ssl_def_const(OP_NETSCAPE_CHALLENGE_BUG); ossl_ssl_def_const(OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG); ossl_ssl_def_const(OP_SSLREF2_REUSE_CERT_TYPE_BUG); ossl_ssl_def_const(OP_MICROSOFT_BIG_SSLV3_BUFFER); ossl_ssl_def_const(OP_MSIE_SSLV2_RSA_PADDING); ossl_ssl_def_const(OP_SSLEAY_080_CLIENT_DH_BUG); ossl_ssl_def_const(OP_TLS_D5_BUG); ossl_ssl_def_const(OP_TLS_BLOCK_PADDING_BUG); ossl_ssl_def_const(OP_DONT_INSERT_EMPTY_FRAGMENTS); ossl_ssl_def_const(OP_ALL); #if defined(SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION) ossl_ssl_def_const(OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION); #endif #if defined(SSL_OP_SINGLE_ECDH_USE) ossl_ssl_def_const(OP_SINGLE_ECDH_USE); #endif ossl_ssl_def_const(OP_SINGLE_DH_USE); ossl_ssl_def_const(OP_EPHEMERAL_RSA); #if defined(SSL_OP_CIPHER_SERVER_PREFERENCE) ossl_ssl_def_const(OP_CIPHER_SERVER_PREFERENCE); #endif ossl_ssl_def_const(OP_TLS_ROLLBACK_BUG); ossl_ssl_def_const(OP_NO_SSLv2); ossl_ssl_def_const(OP_NO_SSLv3); ossl_ssl_def_const(OP_NO_TLSv1); #if defined(SSL_OP_NO_TICKET) ossl_ssl_def_const(OP_NO_TICKET); #endif ossl_ssl_def_const(OP_PKCS1_CHECK_1); ossl_ssl_def_const(OP_PKCS1_CHECK_2); ossl_ssl_def_const(OP_NETSCAPE_CA_DN_BUG); ossl_ssl_def_const(OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG); }
void Init_Complex(void) { #undef rb_intern #define rb_intern(str) rb_intern_const(str) assert(fprintf(stderr, "assert() is now active\n")); id_abs = rb_intern("abs"); id_abs2 = rb_intern("abs2"); id_arg = rb_intern("arg"); id_cmp = rb_intern("<=>"); id_conj = rb_intern("conj"); id_convert = rb_intern("convert"); id_denominator = rb_intern("denominator"); id_divmod = rb_intern("divmod"); id_equal_p = rb_intern("=="); id_expt = rb_intern("**"); id_floor = rb_intern("floor"); id_hash = rb_intern("hash"); id_idiv = rb_intern("div"); id_inspect = rb_intern("inspect"); id_negate = rb_intern("-@"); id_numerator = rb_intern("numerator"); id_polar = rb_intern("polar"); id_quo = rb_intern("quo"); id_real_p = rb_intern("real?"); id_to_f = rb_intern("to_f"); id_to_i = rb_intern("to_i"); id_to_r = rb_intern("to_r"); id_to_s = rb_intern("to_s"); rb_cComplex = rb_define_class(COMPLEX_NAME, rb_cNumeric); rb_define_alloc_func(rb_cComplex, nucomp_s_alloc); rb_undef_method(CLASS_OF(rb_cComplex), "allocate"); #if 0 rb_define_private_method(CLASS_OF(rb_cComplex), "new!", nucomp_s_new_bang, -1); rb_define_private_method(CLASS_OF(rb_cComplex), "new", nucomp_s_new, -1); #else rb_undef_method(CLASS_OF(rb_cComplex), "new"); #endif rb_define_singleton_method(rb_cComplex, "rectangular", nucomp_s_new, -1); rb_define_singleton_method(rb_cComplex, "rect", nucomp_s_new, -1); rb_define_singleton_method(rb_cComplex, "polar", nucomp_s_polar, 2); rb_define_global_function(COMPLEX_NAME, nucomp_f_complex, -1); rb_undef_method(rb_cComplex, "<"); rb_undef_method(rb_cComplex, "<="); rb_undef_method(rb_cComplex, "<=>"); rb_undef_method(rb_cComplex, ">"); rb_undef_method(rb_cComplex, ">="); rb_undef_method(rb_cComplex, "between?"); rb_undef_method(rb_cComplex, "divmod"); rb_undef_method(rb_cComplex, "floor"); rb_undef_method(rb_cComplex, "ceil"); rb_undef_method(rb_cComplex, "modulo"); rb_undef_method(rb_cComplex, "round"); rb_undef_method(rb_cComplex, "step"); rb_undef_method(rb_cComplex, "truncate"); #if 0 /* NUBY */ rb_undef_method(rb_cComplex, "//"); #endif rb_define_method(rb_cComplex, "real", nucomp_real, 0); rb_define_method(rb_cComplex, "imaginary", nucomp_imag, 0); rb_define_method(rb_cComplex, "imag", nucomp_imag, 0); rb_define_method(rb_cComplex, "-@", nucomp_negate, 0); rb_define_method(rb_cComplex, "+", nucomp_add, 1); rb_define_method(rb_cComplex, "-", nucomp_sub, 1); rb_define_method(rb_cComplex, "*", nucomp_mul, 1); rb_define_method(rb_cComplex, "/", nucomp_div, 1); rb_define_method(rb_cComplex, "quo", nucomp_quo, 1); rb_define_method(rb_cComplex, "fdiv", nucomp_fdiv, 1); rb_define_method(rb_cComplex, "**", nucomp_expt, 1); rb_define_method(rb_cComplex, "==", nucomp_equal_p, 1); rb_define_method(rb_cComplex, "coerce", nucomp_coerce, 1); rb_define_method(rb_cComplex, "abs", nucomp_abs, 0); rb_define_method(rb_cComplex, "magnitude", nucomp_abs, 0); rb_define_method(rb_cComplex, "abs2", nucomp_abs2, 0); rb_define_method(rb_cComplex, "arg", nucomp_arg, 0); rb_define_method(rb_cComplex, "angle", nucomp_arg, 0); rb_define_method(rb_cComplex, "phase", nucomp_arg, 0); rb_define_method(rb_cComplex, "rectangular", nucomp_rect, 0); rb_define_method(rb_cComplex, "rect", nucomp_rect, 0); rb_define_method(rb_cComplex, "polar", nucomp_polar, 0); rb_define_method(rb_cComplex, "conjugate", nucomp_conj, 0); rb_define_method(rb_cComplex, "conj", nucomp_conj, 0); #if 0 rb_define_method(rb_cComplex, "~", nucomp_conj, 0); /* gcc */ #endif rb_define_method(rb_cComplex, "real?", nucomp_false, 0); #if 0 rb_define_method(rb_cComplex, "complex?", nucomp_true, 0); rb_define_method(rb_cComplex, "exact?", nucomp_exact_p, 0); rb_define_method(rb_cComplex, "inexact?", nucomp_inexact_p, 0); #endif rb_define_method(rb_cComplex, "numerator", nucomp_numerator, 0); rb_define_method(rb_cComplex, "denominator", nucomp_denominator, 0); rb_define_method(rb_cComplex, "hash", nucomp_hash, 0); rb_define_method(rb_cComplex, "eql?", nucomp_eql_p, 1); rb_define_method(rb_cComplex, "to_s", nucomp_to_s, 0); rb_define_method(rb_cComplex, "inspect", nucomp_inspect, 0); rb_define_method(rb_cComplex, "marshal_dump", nucomp_marshal_dump, 0); rb_define_method(rb_cComplex, "marshal_load", nucomp_marshal_load, 1); /* --- */ rb_define_method(rb_cComplex, "to_i", nucomp_to_i, 0); rb_define_method(rb_cComplex, "to_f", nucomp_to_f, 0); rb_define_method(rb_cComplex, "to_r", nucomp_to_r, 0); rb_define_method(rb_cNilClass, "to_c", nilclass_to_c, 0); rb_define_method(rb_cNumeric, "to_c", numeric_to_c, 0); make_patterns(); rb_define_method(rb_cString, "to_c", string_to_c, 0); rb_define_private_method(CLASS_OF(rb_cComplex), "convert", nucomp_s_convert, -1); /* --- */ rb_define_method(rb_cNumeric, "real", numeric_real, 0); rb_define_method(rb_cNumeric, "imaginary", numeric_imag, 0); rb_define_method(rb_cNumeric, "imag", numeric_imag, 0); rb_define_method(rb_cNumeric, "abs2", numeric_abs2, 0); rb_define_method(rb_cNumeric, "arg", numeric_arg, 0); rb_define_method(rb_cNumeric, "angle", numeric_arg, 0); rb_define_method(rb_cNumeric, "phase", numeric_arg, 0); rb_define_method(rb_cNumeric, "rectangular", numeric_rect, 0); rb_define_method(rb_cNumeric, "rect", numeric_rect, 0); rb_define_method(rb_cNumeric, "polar", numeric_polar, 0); rb_define_method(rb_cNumeric, "conjugate", numeric_conj, 0); rb_define_method(rb_cNumeric, "conj", numeric_conj, 0); rb_define_const(rb_cComplex, "I", f_complex_new_bang2(rb_cComplex, ZERO, ONE)); }
void Init_net_smbfile(void) { rb_cSMBFile = rb_define_class_under(rb_cSMB, "File", rb_cObject); rb_define_alloc_func(rb_cSMBFile, rb_smbfile_data_alloc); rb_define_method(rb_cSMBFile, "initialize", rb_smbfile_initialize, -1); rb_define_method(rb_cSMBFile, "smb", rb_smbfile_smb, 0); rb_define_method(rb_cSMBFile, "url", rb_smbfile_url, 0); rb_define_method(rb_cSMBFile, "read_buffer_size", rb_smbfile_read_buffer_size, 0); rb_define_method(rb_cSMBFile, "close", rb_smbfile_close, 0); rb_define_method(rb_cSMBFile, "closed?", rb_smbfile_closed_p, 0); rb_define_method(rb_cSMBFile, "stat", rb_smbfile_stat, 0); rb_define_method(rb_cSMBFile, "xattr", rb_smbfile_xattr_get, 1); rb_define_method(rb_cSMBFile, "pos", rb_smbfile_pos, 0); rb_define_alias(rb_cSMBFile, "tell", "pos"); rb_define_method(rb_cSMBFile, "seek", rb_smbfile_seek, -1); rb_define_method(rb_cSMBFile, "pos=", rb_smbfile_pos_set, 1); rb_define_method(rb_cSMBFile, "rewind", rb_smbfile_rewind, 0); rb_define_method(rb_cSMBFile, "eof?", rb_smbfile_eof_p, 0); rb_define_alias(rb_cSMBFile, "eof", "eof?"); rb_define_method(rb_cSMBFile, "read", rb_smbfile_read, -1); }
void Init_otama(void) { cOtama = rb_define_class("Otama", rb_cObject); cOtamaError = rb_define_class_under(cOtama, "Error", rb_eRuntimeError); cOtamaSystemError = rb_define_class_under(cOtama, "SystemError", cOtamaError); cOtamaNotImplemented = rb_define_class_under(cOtama, "NotImplemented", cOtamaError); cOtamaNoData = rb_define_class_under(cOtama, "NoData", cOtamaError); cOtamaArgumentError = rb_define_class_under(cOtama, "ArgumentError", cOtamaError); cOtamaAssertionFailure = rb_define_class_under(cOtama, "AssertionFailure", cOtamaError); rb_define_alloc_func(cOtama, otama_rb_alloc); rb_define_private_method(cOtama, "initialize", otama_rb_initialize, 1); rb_define_singleton_method(cOtama, "version_string", otama_rb_s_version_string, 0); rb_define_singleton_method(cOtama, "open", otama_rb_s_open, 1); rb_define_singleton_method(cOtama, "log_level=", otama_rb_s_set_log_level, 1); rb_define_singleton_method(cOtama, "set_log_file", otama_rb_s_set_log_file, 1); rb_define_singleton_method(cOtama, "id", otama_rb_s_id, 1); rb_define_const(cOtama, "LOG_LEVEL_DEBUG", INT2NUM(OTAMA_LOG_LEVEL_DEBUG)); rb_define_const(cOtama, "LOG_LEVEL_NOTICE", INT2NUM(OTAMA_LOG_LEVEL_NOTICE)); rb_define_const(cOtama, "LOG_LEVEL_ERROR", INT2NUM(OTAMA_LOG_LEVEL_ERROR)); rb_define_const(cOtama, "LOG_LEVEL_QUIET", INT2NUM(OTAMA_LOG_LEVEL_QUIET)); rb_define_method(cOtama, "close", otama_rb_close, 0); rb_define_method(cOtama, "search", otama_rb_search, 2); rb_define_method(cOtama, "similarity", otama_rb_similarity, 2); rb_define_method(cOtama, "insert", otama_rb_insert, 1); rb_define_method(cOtama, "set", otama_rb_set, 2); rb_define_method(cOtama, "unset", otama_rb_unset, 1); rb_define_method(cOtama, "get", otama_rb_get, 1); rb_define_method(cOtama, "invoke", otama_rb_invoke, 2); rb_define_method(cOtama, "feature_string", otama_rb_feature_string, 1); rb_define_method(cOtama, "feature_raw", otama_rb_feature_raw, 1); rb_define_method(cOtama, "remove", otama_rb_remove, 1); rb_define_method(cOtama, "pull", otama_rb_pull, 0); rb_define_method(cOtama, "create_database", otama_rb_create_database, 0); rb_define_method(cOtama, "drop_database", otama_rb_drop_database, 0); rb_define_method(cOtama, "drop_index", otama_rb_drop_index, 0); rb_define_method(cOtama, "active?", otama_rb_active, 0); rb_define_method(cOtama, "count", otama_rb_count, 0); rb_define_method(cOtama, "exists?", otama_rb_exists, 1); cOtamaRecord = rb_define_class_under(cOtama, "Record", rb_cObject); rb_define_private_method(cOtamaRecord, "initialize", otama_record_rb_initialize, 2); rb_define_method(cOtamaRecord, "id", otama_record_rb_id, 0); rb_define_method(cOtamaRecord, "value", otama_record_rb_value, 0); #if OTAMA_HAS_KVS cOtamaKVS = rb_define_class_under(cOtama, "KVS", rb_cObject); rb_define_alloc_func(cOtamaKVS, otama_kvs_rb_alloc); rb_define_singleton_method(cOtamaKVS, "open", otama_kvs_rb_s_open, 1); rb_define_private_method(cOtamaKVS, "initialize", otama_kvs_rb_initialize, 1); rb_define_method(cOtamaKVS, "set", otama_kvs_rb_set, 2); rb_define_method(cOtamaKVS, "get", otama_kvs_rb_get, 1); rb_define_method(cOtamaKVS, "[]=", otama_kvs_rb_set, 2); rb_define_method(cOtamaKVS, "[]", otama_kvs_rb_get, 1); rb_define_method(cOtamaKVS, "each", otama_kvs_rb_each_pair, 0); rb_define_method(cOtamaKVS, "each_key", otama_kvs_rb_each_key, 0); rb_define_method(cOtamaKVS, "each_value", otama_kvs_rb_each_value, 0); rb_define_method(cOtamaKVS, "delete", otama_kvs_rb_delete, 1); rb_define_method(cOtamaKVS, "clear", otama_kvs_rb_clear, 0); rb_define_method(cOtamaKVS, "close", otama_kvs_rb_close, 0); #endif cOtamaFeatureRaw = rb_define_class_under(cOtama, "FeatureRaw", rb_cObject); rb_define_alloc_func(cOtamaFeatureRaw, otama_raw_rb_alloc); rb_define_private_method(cOtamaFeatureRaw, "initialize", otama_raw_rb_initialize, 0); rb_define_method(cOtamaFeatureRaw, "dispose", otama_raw_rb_dispose, 0); }
void MessagePack_Buffer_module_init(VALUE mMessagePack) { s_read = rb_intern("read"); s_readpartial = rb_intern("readpartial"); s_write = rb_intern("write"); s_append = rb_intern("<<"); s_close = rb_intern("close"); msgpack_buffer_static_init(); cMessagePack_Buffer = rb_define_class_under(mMessagePack, "Buffer", rb_cObject); rb_define_alloc_func(cMessagePack_Buffer, Buffer_alloc); rb_define_method(cMessagePack_Buffer, "initialize", Buffer_initialize, -1); rb_define_method(cMessagePack_Buffer, "clear", Buffer_clear, 0); rb_define_method(cMessagePack_Buffer, "size", Buffer_size, 0); rb_define_method(cMessagePack_Buffer, "empty?", Buffer_empty_p, 0); rb_define_method(cMessagePack_Buffer, "write", Buffer_write, 1); rb_define_method(cMessagePack_Buffer, "<<", Buffer_append, 1); rb_define_method(cMessagePack_Buffer, "skip", Buffer_skip, 1); rb_define_method(cMessagePack_Buffer, "skip_all", Buffer_skip_all, 1); rb_define_method(cMessagePack_Buffer, "read", Buffer_read, -1); rb_define_method(cMessagePack_Buffer, "read_all", Buffer_read_all, -1); rb_define_method(cMessagePack_Buffer, "io", Buffer_io, 0); rb_define_method(cMessagePack_Buffer, "flush", Buffer_flush, 0); rb_define_method(cMessagePack_Buffer, "close", Buffer_close, 0); rb_define_method(cMessagePack_Buffer, "write_to", Buffer_write_to, 1); rb_define_method(cMessagePack_Buffer, "to_str", Buffer_to_str, 0); rb_define_alias(cMessagePack_Buffer, "to_s", "to_str"); rb_define_method(cMessagePack_Buffer, "to_a", Buffer_to_a, 0); }
void Init_intersys_cache() { rb_define_method(rb_cString, "to_wchar", string_to_wchar, 0); rb_define_method(rb_cString, "from_wchar", string_from_wchar, 0); cTime = rb_const_get(rb_cObject, rb_intern("Time")); cDate = rb_const_get(rb_cObject, rb_intern("Date")); mIntersys = rb_define_module("Intersys"); rb_define_singleton_method(mIntersys, "__wchar_t_size", wchar_t_size, 0); rb_define_singleton_method(mIntersys, "__wchar_t_size_type", wchar_t_size_type, 0); cIntersysException = rb_define_class_under(mIntersys, "IntersysException", rb_eStandardError); cObjectNotFound = rb_define_class_under(mIntersys, "ObjectNotFound", cIntersysException); cMarshallError = rb_define_class_under(mIntersys, "MarshallError", cIntersysException); cUnMarshallError = rb_define_class_under(mIntersys, "UnMarshallError", cIntersysException); cStatus = rb_define_class_under(mIntersys, "Status", cIntersysException); rb_define_alloc_func(cStatus, intersys_status_s_allocate); rb_define_method(cStatus, "initialize", intersys_status_initialize, 2); rb_define_method(cStatus, "code", intersys_status_code, 0); rb_define_method(cStatus, "message", intersys_status_message, 0); rb_define_method(cStatus, "to_s", intersys_status_to_s, 0); cDatabase = rb_define_class_under(mIntersys, "Database", rb_cObject); rb_define_alloc_func(cDatabase, intersys_base_s_allocate); rb_define_method(cDatabase, "initialize", intersys_base_initialize, 1); rb_define_method(cDatabase, "connect", intersys_base_connect, 1); rb_define_method(cDatabase, "begin_db_transaction", intersys_base_start, 0); rb_define_method(cDatabase, "start", intersys_base_start, 0); rb_define_method(cDatabase, "commit_db_transaction", intersys_base_commit, 0); rb_define_method(cDatabase, "commit", intersys_base_commit, 0); rb_define_method(cDatabase, "rollback_db_transaction", intersys_base_rollback, 0); rb_define_method(cDatabase, "rollback", intersys_base_rollback, 0); rb_define_method(cDatabase, "level", intersys_base_level, 0); rb_define_method(cDatabase, "close!", intersys_base_close, 0); #ifdef HAVE_SQL_H cQuery = rb_define_class_under(mIntersys, "Query", rb_cObject); rb_define_alloc_func(cQuery, intersys_query_s_allocate); rb_define_method(cQuery, "initialize", intersys_query_initialize, 2); rb_define_method(cQuery, "bind_params", intersys_query_bind_params, 1); rb_define_method(cQuery, "execute", intersys_query_execute, 0); rb_define_method(cQuery, "fetch", intersys_query_fetch, 0); rb_define_method(cQuery, "each", intersys_query_each, 0); rb_define_method(cQuery, "column_name", intersys_query_column_name, 1); rb_define_method(cQuery, "get_data", intersys_query_get_data, 1); rb_define_method(cQuery, "close", intersys_query_close, 0); rb_define_method(cQuery, "limit", intersys_query_get_limit, 0); rb_define_method(cQuery, "limit=", intersys_query_set_limit, 1); rb_define_method(cQuery, "offset", intersys_query_get_offset, 0); rb_define_method(cQuery, "offset=", intersys_query_set_offset, 1); #endif cObject = rb_define_class_under(mIntersys, "Object", rb_cObject); rb_define_alloc_func(cObject, intersys_object_s_allocate); rb_define_method(cObject, "initialize", intersys_object_initialize, -2); rb_define_singleton_method(cObject, "create", intersys_object_create, 0); rb_define_singleton_method(cObject, "open", intersys_object_open_by_id, 1); cDefinition = rb_define_class_under(mIntersys, "Definition", rb_cObject); rb_define_alloc_func(cDefinition, intersys_definition_s_allocate); rb_define_method(cDefinition, "initialize", intersys_definition_initialize, 3); rb_define_method(cDefinition, "cpp_type", intersys_definition_cpp_type, 0); rb_define_method(cDefinition, "cpp_name", intersys_definition_cpp_name, 0); rb_define_method(cDefinition, "cache_type", intersys_definition_cache_type, 0); rb_define_method(cDefinition, "name", intersys_definition_name, 0); rb_define_method(cDefinition, "in_name", intersys_definition_in_name, 0); cProperty = rb_define_class_under(mIntersys, "Property", cDefinition); rb_define_method(cProperty, "initialize", intersys_property_initialize, 4); rb_define_method(cProperty, "get", intersys_property_get, 0); rb_define_method(cProperty, "set", intersys_property_set, 1); cMethod = rb_define_class_under(mIntersys, "Method", cDefinition); rb_define_method(cMethod, "initialize", intersys_method_initialize, 4); rb_define_method(cMethod, "func?", intersys_method_is_func, 0); rb_define_method(cMethod, "class_method?", intersys_method_is_class_method, 0); rb_define_method(cMethod, "num_args", intersys_method_num_args, 0); rb_define_method(cMethod, "each_argument", intersys_method_each_argument, 0); rb_define_method(cMethod, "call!", intersys_method_call, 1); cArgument = rb_define_class_under(mIntersys, "Argument", cDefinition); rb_define_method(cArgument, "initialize", intersys_argument_initialize, 4); rb_define_method(cArgument, "default", intersys_argument_default_value, 0); rb_define_method(cArgument, "by_ref?", intersys_argument_is_by_ref, 0); rb_define_method(cArgument, "marshall_dlist_element", intersys_argument_marshall_dlist_elem, 1); rb_define_method(cArgument, "marshall_dlist", intersys_argument_marshall_dlist, 1); /* rb_eval_string( "class Argument \n" \ "def marshall_dlist(list)\n" \ " list.each do |elem|\n" \ " marshall_dlist_element(elem)\n" \ " end\n" \ "end\n" \ "end"); */ cGlobal = rb_define_class_under(mIntersys, "Global", rb_cObject); rb_define_alloc_func(cGlobal, intersys_global_s_allocate); rb_define_method(cGlobal, "initialize", intersys_global_initialize, 1); rb_define_method(cGlobal, "[]=", intersys_global_set, -1); rb_define_method(cGlobal, "[]", intersys_global_get, -1); rb_define_method(cGlobal, "delete", intersys_global_delete, -1); rb_define_method(cGlobal, "name", intersys_global_name, 0); }
void Init_thread_spec(void) { VALUE cls; cls = rb_define_class("CApiThreadSpecs", rb_cObject); #ifdef HAVE_RB_THREAD_ALONE rb_define_method(cls, "rb_thread_alone", thread_spec_rb_thread_alone, 0); #endif #ifdef HAVE_RB_THREAD_BLOCKING_REGION rb_define_method(cls, "rb_thread_blocking_region", thread_spec_rb_thread_blocking_region, 0); rb_define_method(cls, "rb_thread_blocking_region_with_ubf_io", thread_spec_rb_thread_blocking_region_with_ubf_io, 0); #endif #ifdef HAVE_RB_THREAD_CALL_WITHOUT_GVL rb_define_method(cls, "rb_thread_call_without_gvl", thread_spec_rb_thread_call_without_gvl, 0); rb_define_method(cls, "rb_thread_call_without_gvl_with_ubf_io", thread_spec_rb_thread_call_without_gvl_with_ubf_io, 0); #endif #ifdef HAVE_RB_THREAD_CALL_WITHOUT_GVL2 rb_define_method(cls, "rb_thread_call_without_gvl2", thread_spec_rb_thread_call_without_gvl2, 0); rb_define_method(cls, "rb_thread_call_without_gvl2_with_ubf_io", thread_spec_rb_thread_call_without_gvl2_with_ubf_io, 0); #endif #ifdef HAVE_RB_THREAD_CURRENT rb_define_method(cls, "rb_thread_current", thread_spec_rb_thread_current, 0); #endif #ifdef HAVE_RB_THREAD_LOCAL_AREF rb_define_method(cls, "rb_thread_local_aref", thread_spec_rb_thread_local_aref, 2); #endif #ifdef HAVE_RB_THREAD_LOCAL_ASET rb_define_method(cls, "rb_thread_local_aset", thread_spec_rb_thread_local_aset, 3); #endif #ifdef HAVE_RB_THREAD_SELECT rb_define_method(cls, "rb_thread_select_fd", thread_spec_rb_thread_select_fd, 2); rb_define_method(cls, "rb_thread_select", thread_spec_rb_thread_select, 1); #endif #ifdef HAVE_RB_THREAD_WAKEUP rb_define_method(cls, "rb_thread_wakeup", thread_spec_rb_thread_wakeup, 1); #endif #ifdef HAVE_RB_THREAD_WAIT_FOR rb_define_method(cls, "rb_thread_wait_for", thread_spec_rb_thread_wait_for, 2); #endif #ifdef HAVE_RB_THREAD_CREATE rb_define_method(cls, "rb_thread_create", thread_spec_rb_thread_create, 2); #endif }
void Init_do_sqlite3() { data_objects_common_init(); mSqlite3 = rb_define_module_under(mDO, "Sqlite3"); cSqlite3Connection = rb_define_class_under(mSqlite3, "Connection", cDO_Connection); rb_define_method(cSqlite3Connection, "initialize", do_sqlite3_cConnection_initialize, 1); rb_define_method(cSqlite3Connection, "dispose", do_sqlite3_cConnection_dispose, 0); rb_define_method(cSqlite3Connection, "quote_boolean", do_sqlite3_cConnection_quote_boolean, 1); rb_define_method(cSqlite3Connection, "quote_string", do_sqlite3_cConnection_quote_string, 1); rb_define_method(cSqlite3Connection, "quote_byte_array", do_sqlite3_cConnection_quote_byte_array, 1); rb_define_method(cSqlite3Connection, "character_set", data_objects_cConnection_character_set, 0); cSqlite3Command = rb_define_class_under(mSqlite3, "Command", cDO_Command); rb_define_method(cSqlite3Command, "set_types", data_objects_cCommand_set_types, -1); rb_define_method(cSqlite3Command, "execute_non_query", do_sqlite3_cCommand_execute_non_query, -1); rb_define_method(cSqlite3Command, "execute_reader", do_sqlite3_cCommand_execute_reader, -1); cSqlite3Result = rb_define_class_under(mSqlite3, "Result", cDO_Result); cSqlite3Reader = rb_define_class_under(mSqlite3, "Reader", cDO_Reader); rb_define_method(cSqlite3Reader, "close", do_sqlite3_cReader_close, 0); rb_define_method(cSqlite3Reader, "next!", do_sqlite3_cReader_next, 0); rb_define_method(cSqlite3Reader, "values", do_sqlite3_cReader_values, 0); // TODO: DRY? rb_define_method(cSqlite3Reader, "fields", data_objects_cReader_fields, 0); rb_define_method(cSqlite3Reader, "field_count", data_objects_cReader_field_count, 0); rb_global_variable(&cSqlite3Result); rb_global_variable(&cSqlite3Reader); OPEN_FLAG_READONLY = rb_str_new2("read_only"); rb_global_variable(&OPEN_FLAG_READONLY); OPEN_FLAG_READWRITE = rb_str_new2("read_write"); rb_global_variable(&OPEN_FLAG_READWRITE); OPEN_FLAG_CREATE = rb_str_new2("create"); rb_global_variable(&OPEN_FLAG_CREATE); OPEN_FLAG_NO_MUTEX = rb_str_new2("no_mutex"); rb_global_variable(&OPEN_FLAG_NO_MUTEX); OPEN_FLAG_FULL_MUTEX = rb_str_new2("full_mutex"); rb_global_variable(&OPEN_FLAG_FULL_MUTEX); Init_do_sqlite3_extension(); data_objects_define_errors(mSqlite3, do_sqlite3_errors); }
void Init_port() { cPort = rb_define_class_under( mTrema, "Port", rb_cObject ); rb_define_method( cPort, "initialize", port_init, 1 ); rb_define_method( cPort, "number", port_number, 0 ); rb_define_method( cPort, "hw_addr", port_hw_addr, 0 ); rb_define_method( cPort, "name", port_name, 0 ); rb_define_method( cPort, "config", port_config, 0 ); rb_define_method( cPort, "state", port_state, 0 ); rb_define_method( cPort, "curr", port_curr, 0 ); rb_define_method( cPort, "advertised", port_advertised, 0 ); rb_define_method( cPort, "supported", port_supported, 0 ); rb_define_method( cPort, "peer", port_peer, 0 ); rb_define_method( cPort, "up?", port_up, 0 ); rb_define_method( cPort, "down?", port_down, 0 ); rb_define_method( cPort, "<=>", port_compare, 1 ); }
void rb_define_attr_method(VALUE klass, std::string name, VALUE Readable, VALUE(*func)(...)) { rb_define_attr(klass, name.c_str(), Readable, 1); rb_define_method(klass, (name + "=").c_str(), func, 1); }
void Init_Exception(void) { rb_eException = rb_define_class("Exception", rb_cObject); rb_define_singleton_method(rb_eException, "exception", rb_class_new_instance, -1); rb_define_method(rb_eException, "exception", exc_exception, -1); rb_define_method(rb_eException, "initialize", exc_initialize, -1); rb_define_method(rb_eException, "==", exc_equal, 1); rb_define_method(rb_eException, "to_s", exc_to_s, 0); rb_define_method(rb_eException, "message", exc_message, 0); rb_define_method(rb_eException, "inspect", exc_inspect, 0); rb_define_method(rb_eException, "backtrace", exc_backtrace, 0); rb_define_method(rb_eException, "set_backtrace", exc_set_backtrace, 1); rb_eSystemExit = rb_define_class("SystemExit", rb_eException); rb_define_method(rb_eSystemExit, "initialize", exit_initialize, -1); rb_define_method(rb_eSystemExit, "status", exit_status, 0); rb_define_method(rb_eSystemExit, "success?", exit_success_p, 0); rb_eFatal = rb_define_class("fatal", rb_eException); rb_eSignal = rb_define_class("SignalException", rb_eException); rb_eInterrupt = rb_define_class("Interrupt", rb_eSignal); rb_eStandardError = rb_define_class("StandardError", rb_eException); rb_eTypeError = rb_define_class("TypeError", rb_eStandardError); rb_eArgError = rb_define_class("ArgumentError", rb_eStandardError); rb_eIndexError = rb_define_class("IndexError", rb_eStandardError); rb_eKeyError = rb_define_class("KeyError", rb_eIndexError); rb_eRangeError = rb_define_class("RangeError", rb_eStandardError); rb_eScriptError = rb_define_class("ScriptError", rb_eException); rb_eSyntaxError = rb_define_class("SyntaxError", rb_eScriptError); rb_eLoadError = rb_define_class("LoadError", rb_eScriptError); rb_eNotImpError = rb_define_class("NotImplementedError", rb_eScriptError); rb_eNameError = rb_define_class("NameError", rb_eStandardError); rb_define_method(rb_eNameError, "initialize", name_err_initialize, -1); rb_define_method(rb_eNameError, "name", name_err_name, 0); rb_define_method(rb_eNameError, "to_s", name_err_to_s, 0); rb_cNameErrorMesg = rb_define_class_under(rb_eNameError, "message", rb_cData); rb_define_singleton_method(rb_cNameErrorMesg, "!", rb_name_err_mesg_new, NAME_ERR_MESG_COUNT); rb_define_method(rb_cNameErrorMesg, "==", name_err_mesg_equal, 1); rb_define_method(rb_cNameErrorMesg, "to_str", name_err_mesg_to_str, 0); rb_define_method(rb_cNameErrorMesg, "_dump", name_err_mesg_to_str, 1); rb_define_singleton_method(rb_cNameErrorMesg, "_load", name_err_mesg_load, 1); rb_eNoMethodError = rb_define_class("NoMethodError", rb_eNameError); rb_define_method(rb_eNoMethodError, "initialize", nometh_err_initialize, -1); rb_define_method(rb_eNoMethodError, "args", nometh_err_args, 0); rb_eRuntimeError = rb_define_class("RuntimeError", rb_eStandardError); rb_eSecurityError = rb_define_class("SecurityError", rb_eException); rb_eNoMemError = rb_define_class("NoMemoryError", rb_eException); rb_eEncodingError = rb_define_class("EncodingError", rb_eStandardError); rb_eEncCompatError = rb_define_class_under(rb_cEncoding, "CompatibilityError", rb_eEncodingError); syserr_tbl = st_init_numtable(); rb_eSystemCallError = rb_define_class("SystemCallError", rb_eStandardError); rb_define_method(rb_eSystemCallError, "initialize", syserr_initialize, -1); rb_define_method(rb_eSystemCallError, "errno", syserr_errno, 0); rb_define_singleton_method(rb_eSystemCallError, "===", syserr_eqq, 1); rb_mErrno = rb_define_module("Errno"); rb_define_global_function("warn", rb_warn_m, -1); }
void MessagePack_Unpacker_module_init(VALUE mMessagePack) { msgpack_unpacker_static_init(); msgpack_unpacker_ext_registry_static_init(); mTypeError = rb_define_module_under(mMessagePack, "TypeError"); cMessagePack_Unpacker = rb_define_class_under(mMessagePack, "Unpacker", rb_cObject); eUnpackError = rb_define_class_under(mMessagePack, "UnpackError", rb_eStandardError); eMalformedFormatError = rb_define_class_under(mMessagePack, "MalformedFormatError", eUnpackError); eStackError = rb_define_class_under(mMessagePack, "StackError", eUnpackError); eUnexpectedTypeError = rb_define_class_under(mMessagePack, "UnexpectedTypeError", eUnpackError); rb_include_module(eUnexpectedTypeError, mTypeError); eUnknownExtTypeError = rb_define_class_under(mMessagePack, "UnknownExtTypeError", eUnpackError); rb_define_alloc_func(cMessagePack_Unpacker, MessagePack_Unpacker_alloc); rb_define_method(cMessagePack_Unpacker, "initialize", MessagePack_Unpacker_initialize, -1); rb_define_method(cMessagePack_Unpacker, "symbolize_keys?", Unpacker_symbolized_keys_p, 0); rb_define_method(cMessagePack_Unpacker, "allow_unknown_ext?", Unpacker_allow_unknown_ext_p, 0); rb_define_method(cMessagePack_Unpacker, "buffer", Unpacker_buffer, 0); rb_define_method(cMessagePack_Unpacker, "read", Unpacker_read, 0); rb_define_alias(cMessagePack_Unpacker, "unpack", "read"); rb_define_method(cMessagePack_Unpacker, "skip", Unpacker_skip, 0); rb_define_method(cMessagePack_Unpacker, "skip_nil", Unpacker_skip_nil, 0); rb_define_method(cMessagePack_Unpacker, "read_array_header", Unpacker_read_array_header, 0); rb_define_method(cMessagePack_Unpacker, "read_map_header", Unpacker_read_map_header, 0); //rb_define_method(cMessagePack_Unpacker, "peek_next_type", Unpacker_peek_next_type, 0); // TODO rb_define_method(cMessagePack_Unpacker, "feed", Unpacker_feed, 1); rb_define_method(cMessagePack_Unpacker, "each", Unpacker_each, 0); rb_define_method(cMessagePack_Unpacker, "feed_each", Unpacker_feed_each, 1); rb_define_method(cMessagePack_Unpacker, "reset", Unpacker_reset, 0); rb_define_private_method(cMessagePack_Unpacker, "registered_types_internal", Unpacker_registered_types_internal, 0); rb_define_method(cMessagePack_Unpacker, "register_type", Unpacker_register_type, -1); //s_unpacker_value = MessagePack_Unpacker_alloc(cMessagePack_Unpacker); //rb_gc_register_address(&s_unpacker_value); //Data_Get_Struct(s_unpacker_value, msgpack_unpacker_t, s_unpacker); /* prefer reference than copying */ //msgpack_buffer_set_write_reference_threshold(UNPACKER_BUFFER_(s_unpacker), 0); /* MessagePack.unpack(x) */ rb_define_module_function(mMessagePack, "load", MessagePack_load_module_method, -1); rb_define_module_function(mMessagePack, "unpack", MessagePack_unpack_module_method, -1); }
void rbffi_AbstractMemory_Init(VALUE moduleFFI) { VALUE classMemory = rb_define_class_under(moduleFFI, "AbstractMemory", rb_cObject); rbffi_AbstractMemoryClass = classMemory; rb_global_variable(&rbffi_AbstractMemoryClass); rb_define_alloc_func(classMemory, memory_allocate); NullPointerErrorClass = rb_define_class_under(moduleFFI, "NullPointerError", rb_eRuntimeError); rb_global_variable(&NullPointerErrorClass); #undef INT #define INT(type) \ rb_define_method(classMemory, "put_" #type, memory_put_##type, 2); \ rb_define_method(classMemory, "get_" #type, memory_get_##type, 1); \ rb_define_method(classMemory, "put_u" #type, memory_put_u##type, 2); \ rb_define_method(classMemory, "get_u" #type, memory_get_u##type, 1); \ rb_define_method(classMemory, "put_array_of_" #type, memory_put_array_of_##type, 2); \ rb_define_method(classMemory, "get_array_of_" #type, memory_get_array_of_##type, 2); \ rb_define_method(classMemory, "put_array_of_u" #type, memory_put_array_of_u##type, 2); \ rb_define_method(classMemory, "get_array_of_u" #type, memory_get_array_of_u##type, 2); INT(int8); INT(int16); INT(int32); INT(int64); INT(long); #define ALIAS(name, old) \ rb_define_alias(classMemory, "put_" #name, "put_" #old); \ rb_define_alias(classMemory, "get_" #name, "get_" #old); \ rb_define_alias(classMemory, "put_u" #name, "put_u" #old); \ rb_define_alias(classMemory, "get_u" #name, "get_u" #old); \ rb_define_alias(classMemory, "put_array_of_" #name, "put_array_of_" #old); \ rb_define_alias(classMemory, "get_array_of_" #name, "get_array_of_" #old); \ rb_define_alias(classMemory, "put_array_of_u" #name, "put_array_of_u" #old); \ rb_define_alias(classMemory, "get_array_of_u" #name, "get_array_of_u" #old); ALIAS(char, int8); ALIAS(short, int16); ALIAS(int, int32); ALIAS(long_long, int64); rb_define_method(classMemory, "put_float32", memory_put_float32, 2); rb_define_method(classMemory, "get_float32", memory_get_float32, 1); rb_define_alias(classMemory, "put_float", "put_float32"); rb_define_alias(classMemory, "get_float", "get_float32"); rb_define_method(classMemory, "put_array_of_float32", memory_put_array_of_float32, 2); rb_define_method(classMemory, "get_array_of_float32", memory_get_array_of_float32, 2); rb_define_alias(classMemory, "put_array_of_float", "put_array_of_float32"); rb_define_alias(classMemory, "get_array_of_float", "get_array_of_float32"); rb_define_method(classMemory, "put_float64", memory_put_float64, 2); rb_define_method(classMemory, "get_float64", memory_get_float64, 1); rb_define_alias(classMemory, "put_double", "put_float64"); rb_define_alias(classMemory, "get_double", "get_float64"); rb_define_method(classMemory, "put_array_of_float64", memory_put_array_of_float64, 2); rb_define_method(classMemory, "get_array_of_float64", memory_get_array_of_float64, 2); rb_define_alias(classMemory, "put_array_of_double", "put_array_of_float64"); rb_define_alias(classMemory, "get_array_of_double", "get_array_of_float64"); rb_define_method(classMemory, "put_pointer", memory_put_pointer, 2); rb_define_method(classMemory, "get_pointer", memory_get_pointer, 1); rb_define_method(classMemory, "put_array_of_pointer", memory_put_array_of_pointer, 2); rb_define_method(classMemory, "get_array_of_pointer", memory_get_array_of_pointer, 2); rb_define_method(classMemory, "get_string", memory_get_string, -1); rb_define_method(classMemory, "put_string", memory_put_string, 2); rb_define_method(classMemory, "get_bytes", memory_get_bytes, 2); rb_define_method(classMemory, "put_bytes", memory_put_bytes, -1); rb_define_method(classMemory, "get_array_of_string", memory_get_array_of_string, -1); rb_define_method(classMemory, "clear", memory_clear, 0); rb_define_method(classMemory, "total", memory_size, 0); rb_define_alias(classMemory, "size", "total"); rb_define_method(classMemory, "type_size", memory_type_size, 0); rb_define_method(classMemory, "[]", memory_aref, 1); id_to_ptr = rb_intern("to_ptr"); id_call = rb_intern("call"); id_plus = rb_intern("+"); }
static void initProperties(VALUE klass) { rb_define_method(klass, "debug", rpmds_debug_get, 0); rb_define_method(klass, "debug=", rpmds_debug_set, 1); rb_define_method(klass, "length", rpmds_Count_get, 0); rb_define_method(klass, "ix", rpmds_Ix_get, 0); rb_define_method(klass, "ix=", rpmds_Ix_set, 1); rb_define_method(klass, "Type", rpmds_Type_get, 0); rb_define_method(klass, "buildtime", rpmds_BT_get, 0); rb_define_method(klass, "buildtime=", rpmds_BT_set, 1); rb_define_method(klass, "color", rpmds_Color_get, 0); rb_define_method(klass, "color=", rpmds_Color_set, 1); rb_define_method(klass, "nopromote", rpmds_NoPromote_get, 0); rb_define_method(klass, "nopromote=", rpmds_NoPromote_set, 1); rb_define_method(klass, "N", rpmds_N_get, 0); rb_define_method(klass, "EVR", rpmds_EVR_get, 0); rb_define_method(klass, "F", rpmds_Flags_get, 0); rb_define_method(klass, "DNEVR", rpmds_DNEVR_get, 0); }
void Init__augeas() { /* Define the ruby class */ c_augeas = rb_define_class("Augeas", rb_cObject) ; /* Constants for enum aug_flags */ #define DEF_AUG_FLAG(name) \ rb_define_const(c_augeas, #name, INT2NUM(AUG_##name)) DEF_AUG_FLAG(NONE); DEF_AUG_FLAG(SAVE_BACKUP); DEF_AUG_FLAG(SAVE_NEWFILE); DEF_AUG_FLAG(TYPE_CHECK); DEF_AUG_FLAG(NO_STDINC); DEF_AUG_FLAG(SAVE_NOOP); DEF_AUG_FLAG(NO_LOAD); DEF_AUG_FLAG(NO_MODL_AUTOLOAD); DEF_AUG_FLAG(ENABLE_SPAN); #undef DEF_AUG_FLAG /* Constants for enum aug_errcode_t */ #define DEF_AUG_ERR(name) \ rb_define_const(c_augeas, #name, INT2NUM(AUG_##name)) DEF_AUG_ERR(NOERROR); DEF_AUG_ERR(ENOMEM); DEF_AUG_ERR(EINTERNAL); DEF_AUG_ERR(EPATHX); DEF_AUG_ERR(ENOMATCH); DEF_AUG_ERR(EMMATCH); DEF_AUG_ERR(ESYNTAX); DEF_AUG_ERR(ENOLENS); DEF_AUG_ERR(EMXFM); #undef DEF_AUG_ERR /* Define the methods */ rb_define_singleton_method(c_augeas, "open3", augeas_init, 3); rb_define_method(c_augeas, "defvar", augeas_defvar, 2); rb_define_method(c_augeas, "defnode", augeas_defnode, 3); rb_define_method(c_augeas, "get", augeas_get, 1); rb_define_method(c_augeas, "exists", augeas_exists, 1); rb_define_method(c_augeas, "insert", augeas_insert, 3); rb_define_method(c_augeas, "mv", augeas_mv, 2); rb_define_method(c_augeas, "rm", augeas_rm, 1); rb_define_method(c_augeas, "match", augeas_match, 1); rb_define_method(c_augeas, "save", augeas_save, 0); rb_define_method(c_augeas, "load", augeas_load, 0); rb_define_method(c_augeas, "set_internal", augeas_set, 2); rb_define_method(c_augeas, "setm", augeas_setm, 3); rb_define_method(c_augeas, "close", augeas_close, 0); rb_define_method(c_augeas, "error", augeas_error, 0); rb_define_method(c_augeas, "span", augeas_span, 1); }
// init void init_FiledbFirstIds() { cFiledbFirstIds = rb_define_class_under(GettextpoHelper, "FiledbFirstIds", rb_cObject); rb_define_singleton_method(cFiledbFirstIds, "new", RUBY_METHOD_FUNC(cFiledbFirstIds_new), 2); rb_define_method(cFiledbFirstIds, "get_first_id", RUBY_METHOD_FUNC(cFiledbFirstIds_get_first_id), 1); }
VALUE Field::createClass() { //Define the 'Field' class VALUE klass = rb_define_class_under(g_cap_dissector_module, "Field", rb_cObject); rb_define_alloc_func(klass, Field::alloc); //Define the 'initialize' method rb_define_method(klass, "initialize", reinterpret_cast<VALUE(*)(ANYARGS)>(Field::initialize), 1); //Define some const values for various flag values ::rb_define_const(klass, "FLAG_HIDDEN", LONG2FIX(FI_HIDDEN)); ::rb_define_const(klass, "FLAG_GENERATED", LONG2FIX(FI_GENERATED)); ::rb_define_const(klass, "FI_URL", LONG2FIX(FI_URL)); ::rb_define_const(klass, "PI_CHECKSUM", LONG2FIX(PI_CHECKSUM)); ::rb_define_const(klass, "PI_RESPONSE_CODE", LONG2FIX(PI_RESPONSE_CODE)); ::rb_define_const(klass, "PI_REQUEST_CODE", LONG2FIX(PI_REQUEST_CODE)); //Define the 'packet' attribute reader rb_define_attr(klass, "packet", TRUE, FALSE); rb_define_method(klass, "to_s", reinterpret_cast<VALUE(*)(ANYARGS)>(Field::to_s), 0); rb_define_method(klass, "name", reinterpret_cast<VALUE(*)(ANYARGS)>(Field::name), 0); rb_define_method(klass, "display_name", reinterpret_cast<VALUE(*)(ANYARGS)>(Field::display_name), 0); rb_define_method(klass, "value", reinterpret_cast<VALUE(*)(ANYARGS)>(Field::value), 0); rb_define_method(klass, "display_value", reinterpret_cast<VALUE(*)(ANYARGS)>(Field::display_value), 0); rb_define_method(klass, "length", reinterpret_cast<VALUE(*)(ANYARGS)>(Field::length), 0); rb_define_method(klass, "position", reinterpret_cast<VALUE(*)(ANYARGS)>(Field::position), 0); rb_define_method(klass, "flags", reinterpret_cast<VALUE(*)(ANYARGS)>(Field::flags), 0); rb_define_method(klass, "is_protocol_node?", reinterpret_cast<VALUE(*)(ANYARGS)>(Field::is_protocol_node), 0); rb_define_method(klass, "ordinal", reinterpret_cast<VALUE(*)(ANYARGS)>(Field::ordinal), 0); rb_define_method(klass, "parent", reinterpret_cast<VALUE(*)(ANYARGS)>(Field::parent), 0); rb_define_method(klass, "next_sibling", reinterpret_cast<VALUE(*)(ANYARGS)>(Field::next_sibling), 0); rb_define_method(klass, "each_child", reinterpret_cast<VALUE(*)(ANYARGS)>(Field::each_child), 0); rb_define_method(klass, "value_blob", reinterpret_cast<VALUE(*)(ANYARGS)>(Field::value_blob), 0); rb_define_method(klass, "value_blob_offset", reinterpret_cast<VALUE(*)(ANYARGS)>(Field::value_blob_offset), 0); rb_define_method(klass, "value_blob_length", reinterpret_cast<VALUE(*)(ANYARGS)>(Field::value_blob_length), 0); return klass; }
void Init_fiddle_function(void) { /* * Document-class: Fiddle::Function * * == Description * * A representation of a C function * * == Examples * * === 'strcpy' * * @libc = Fiddle.dlopen "/lib/libc.so.6" * #=> #<Fiddle::Handle:0x00000001d7a8d8> * f = Fiddle::Function.new( * @libc['strcpy'], * [Fiddle::TYPE_VOIDP, Fiddle::TYPE_VOIDP], * Fiddle::TYPE_VOIDP) * #=> #<Fiddle::Function:0x00000001d8ee00> * buff = "000" * #=> "000" * str = f.call(buff, "123") * #=> #<Fiddle::Pointer:0x00000001d0c380 ptr=0x000000018a21b8 size=0 free=0x00000000000000> * str.to_s * => "123" * * === ABI check * * @libc = DL.dlopen "/lib/libc.so.6" * #=> #<Fiddle::Handle:0x00000001d7a8d8> * f = Fiddle::Function.new(@libc['strcpy'], [TYPE_VOIDP, TYPE_VOIDP], TYPE_VOIDP) * #=> #<Fiddle::Function:0x00000001d8ee00> * f.abi == Fiddle::Function::DEFAULT * #=> true */ cFiddleFunction = rb_define_class_under(mFiddle, "Function", rb_cObject); /* * Document-const: DEFAULT * * Default ABI * */ rb_define_const(cFiddleFunction, "DEFAULT", INT2NUM(FFI_DEFAULT_ABI)); #ifdef HAVE_CONST_FFI_STDCALL /* * Document-const: STDCALL * * FFI implementation of WIN32 stdcall convention * */ rb_define_const(cFiddleFunction, "STDCALL", INT2NUM(FFI_STDCALL)); #endif rb_define_alloc_func(cFiddleFunction, allocate); /* * Document-method: call * * Calls the constructed Function, with +args+ * * For an example see Fiddle::Function * */ rb_define_method(cFiddleFunction, "call", function_call, -1); /* * Document-method: new * call-seq: new(ptr, args, ret_type, abi = DEFAULT) * * Constructs a Function object. * * +ptr+ is a referenced function, of a Fiddle::Handle * * +args+ is an Array of arguments, passed to the +ptr+ function * * +ret_type+ is the return type of the function * * +abi+ is the ABI of the function * */ rb_define_method(cFiddleFunction, "initialize", initialize, -1); }
void Init_multiset(VALUE module) { cMultiset = rb_define_class_under(module, "Multiset", cGSL_Object); rb_define_singleton_method(cMultiset, "alloc", rb_gsl_multiset_alloc, 2); rb_define_singleton_method(cMultiset, "calloc", rb_gsl_multiset_calloc, 2); rb_define_singleton_method(cMultiset, "memcpy", rb_gsl_multiset_memcpy, 2); rb_define_method(cMultiset, "init_first", rb_gsl_multiset_init_first, 0); rb_define_method(cMultiset, "init_last", rb_gsl_multiset_init_last, 0); rb_define_method(cMultiset, "get", rb_gsl_multiset_get, 1); rb_define_alias(cMultiset, "[]", "get"); rb_define_method(cMultiset, "n", rb_gsl_multiset_n, 0); rb_define_method(cMultiset, "k", rb_gsl_multiset_k, 0); rb_define_method(cMultiset, "data", rb_gsl_multiset_data, 0); rb_define_method(cMultiset, "data[]", rb_gsl_multiset_data2, 1); rb_define_method(cMultiset, "valid", rb_gsl_multiset_valid, 0); rb_define_method(cMultiset, "valid?", rb_gsl_multiset_valid2, 0); rb_define_method(cMultiset, "next", rb_gsl_multiset_next, 0); rb_define_method(cMultiset, "prev", rb_gsl_multiset_prev, 0); rb_define_method(cMultiset, "fwrite", rb_gsl_multiset_fwrite, 1); rb_define_method(cMultiset, "fread", rb_gsl_multiset_fread, 1); rb_define_method(cMultiset, "fprintf", rb_gsl_multiset_fprintf, 2); rb_define_method(cMultiset, "fscanf", rb_gsl_multiset_fscanf, 1); }