Esempio n. 1
0
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);
}
Esempio n. 2
0
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);
}
Esempio n. 3
0
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);
}
Esempio n. 4
0
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);
}
Esempio n. 5
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);
}
Esempio n. 6
0
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);
}
Esempio n. 7
0
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);
}
Esempio n. 8
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);

}
Esempio n. 9
0
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);
}
Esempio n. 11
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);
}
Esempio n. 13
0
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));
}
Esempio n. 14
0
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);
}
Esempio n. 15
0
File: otama.c Progetto: kyama/otama
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);
}
Esempio n. 16
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);
}
Esempio n. 17
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);
}
Esempio n. 18
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
}
Esempio n. 19
0
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);
}
Esempio n. 20
0
File: port.c Progetto: mi07/trema
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 );
}
Esempio n. 21
0
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);
}
Esempio n. 22
0
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);
}
Esempio n. 23
0
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);
}
Esempio n. 24
0
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("+");
}
Esempio n. 25
0
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);
}
Esempio n. 26
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);
}
Esempio n. 27
0
// 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);
}
Esempio n. 28
0
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;
}
Esempio n. 29
0
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);
}
Esempio n. 30
0
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);
}