Beispiel #1
0
void Init_spidermonkey()
{
  JS_SetCStringsAreUTF8();

  VALUE johnson = rb_const_get(rb_mKernel, rb_intern("Johnson"));
  VALUE spidermonkey = rb_define_module_under(johnson, "SpiderMonkey");
  
  init_Johnson_SpiderMonkey_Context(spidermonkey);
  init_Johnson_SpiderMonkey_Proxy(spidermonkey);
  init_Johnson_SpiderMonkey_Debugger(spidermonkey);
  init_Johnson_SpiderMonkey_Immutable_Node(spidermonkey);
  init_Johnson_SpiderMonkey_Runtime(spidermonkey);
  
  rb_define_const(spidermonkey, "VERSION",
    rb_obj_freeze(rb_str_new2(JS_GetImplementationVersion())));
}
Beispiel #2
0
static VALUE
cov_generate_coverage_info(VALUE self)
{
  VALUE cover;

  if(rb_const_defined_at(mRCOV__, id_cover)) {
	  rb_mod_remove_const(mRCOV__, ID2SYM(id_cover));
  }

  cover = rb_hash_new();
  if(coverinfo)
	  st_foreach(coverinfo, populate_cover, cover);
  rb_define_const(mRCOV__, "COVER", cover);

  return cover;
}
Beispiel #3
0
void Init_session_ext() {
  curl_global_init(CURL_GLOBAL_ALL);
  rb_require("patron/error");

  mPatron = rb_define_module("Patron");

  ePatronError = rb_const_get(mPatron, rb_intern("Error"));

  eUnsupportedProtocol = rb_const_get(mPatron, rb_intern("UnsupportedProtocol"));
  eURLFormatError = rb_const_get(mPatron, rb_intern("URLFormatError"));
  eHostResolutionError = rb_const_get(mPatron, rb_intern("HostResolutionError"));
  eConnectionFailed = rb_const_get(mPatron, rb_intern("ConnectionFailed"));
  ePartialFileError = rb_const_get(mPatron, rb_intern("PartialFileError"));
  eTimeoutError = rb_const_get(mPatron, rb_intern("TimeoutError"));
  eTooManyRedirects = rb_const_get(mPatron, rb_intern("TooManyRedirects"));

  rb_define_module_function(mPatron, "libcurl_version", libcurl_version, 0);

  cSession = rb_define_class_under(mPatron, "Session", rb_cObject);
  cRequest = rb_define_class_under(mPatron, "Request", rb_cObject);
  rb_define_alloc_func(cSession, session_alloc);

  rb_define_method(cSession, "ext_initialize", session_ext_initialize, 0);
  rb_define_method(cSession, "escape",         session_escape,         1);
  rb_define_method(cSession, "unescape",       session_unescape,       1);
  rb_define_method(cSession, "handle_request", session_handle_request, 1);
  rb_define_method(cSession, "enable_cookie_session", enable_cookie_session, 1);

  rb_define_const(cRequest, "AuthBasic",  INT2FIX(CURLAUTH_BASIC));
  rb_define_const(cRequest, "AuthDigest", INT2FIX(CURLAUTH_DIGEST));
  rb_define_const(cRequest, "AuthAny",    INT2FIX(CURLAUTH_ANY));

  mProxyType = rb_define_module_under(mPatron, "ProxyType");
  rb_define_const(mProxyType, "HTTP", INT2FIX(CURLPROXY_HTTP));
  rb_define_const(mProxyType, "HTTP_1_0", INT2FIX(CURLPROXY_HTTP_1_0));
  rb_define_const(mProxyType, "SOCKS4", INT2FIX(CURLPROXY_SOCKS4));
  rb_define_const(mProxyType, "SOCKS5", INT2FIX(CURLPROXY_SOCKS5));
  rb_define_const(mProxyType, "SOCKS4A", INT2FIX(CURLPROXY_SOCKS4A));
  rb_define_const(mProxyType, "SOCKS5_HOSTNAME", INT2FIX(CURLPROXY_SOCKS5_HOSTNAME));
}
Beispiel #4
0
static void
interp_register_builtin()
{
	VALUE hVIPSInterpolators = rb_hash_new();

    /* Hash of available interpolators. Keys are the symbols, and values are
     * interpolator objects.
     */
    rb_define_const(cVIPSInterpolator, "INTERPOLATORS", hVIPSInterpolators);

	vips_class_map_concrete_all(
        g_type_from_name( "VipsInterpolate" ),
        (void *) interp_register,
        (void *) hVIPSInterpolators
    );
}
Beispiel #5
0
/**
 * Document-module: MessagePack
 *
 * MessagePack is a binary-based efficient object serialization library.
 * It enables to exchange structured objects between many languages like JSON.
 * But unlike JSON, it is very fast and small.
 *
 * You can install MessagePack with rubygems.
 *
 *   gem install msgpack
 *
 * Simple usage is as follows:
 *
 *   require 'msgpack'
 *   msg = [1,2,3].to_msgpack  #=> "\x93\x01\x02\x03"
 *   MessagePack.unpack(msg)   #=> [1,2,3]
 *
 * Use Unpacker class for streaming deserialization.
 *
 */
void Init_msgpack(void)
{
	mMessagePack = rb_define_module("MessagePack");

	rb_define_const(mMessagePack, "VERSION", rb_str_new2(MESSAGEPACK_VERSION));

#ifdef COMPAT_HAVE_ENCODING
	s_enc_ascii8bit = rb_ascii8bit_encindex();
	s_enc_utf8 = rb_utf8_encindex();
	s_enc_usascii = rb_usascii_encindex();
	s_enc_utf8_value = rb_enc_from_encoding(rb_utf8_encoding());
#endif

	Init_msgpack_unpack(mMessagePack);
	Init_msgpack_pack(mMessagePack);
}
void
Init_gtk_textview()
{
    VALUE cTextView = G_DEF_CLASS(GTK_TYPE_TEXT_VIEW, "TextView", mGtk);

    id_buffer = rb_intern("buffer");

    rb_define_method(cTextView, "initialize", textview_initialize, -1);
    G_REPLACE_SET_PROPERTY(cTextView, "buffer", textview_set_buffer, 1);
    G_REPLACE_GET_PROPERTY(cTextView, "buffer", textview_get_buffer, 0);
    rb_define_method(cTextView, "scroll_to_mark", textview_scroll_to_mark, 5);
    rb_define_method(cTextView, "scroll_to_iter", textview_scroll_to_iter, 5);
    rb_define_method(cTextView, "scroll_mark_onscreen", textview_scroll_mark_onscreen, 1);
    rb_define_method(cTextView, "move_mark_onscreen", textview_move_mark_onscreen, 1);
    rb_define_method(cTextView, "place_cursor_onscreen", textview_place_cursor_onscreen, 0);
    rb_define_method(cTextView, "visible_rect", textview_get_visible_rect, 0);
    rb_define_method(cTextView, "get_iter_location", textview_get_iter_location, 1);
    rb_define_method(cTextView, "get_line_at_y", textview_get_line_at_y, 1);
    rb_define_method(cTextView, "get_line_yrange", textview_get_line_yrange, 1);
    rb_define_method(cTextView, "get_iter_at_location", textview_get_iter_at_location, 2);
#if GTK_CHECK_VERSION(2,6,0)
    rb_define_method(cTextView, "get_iter_at_position", textview_get_iter_at_position, 2);
#endif
    rb_define_method(cTextView, "buffer_to_window_coords", textview_buffer_to_window_coords, 3);
    rb_define_method(cTextView, "window_to_buffer_coords", textview_window_to_buffer_coords, 3);
    rb_define_method(cTextView, "get_window", textview_get_window, 1);
    rb_define_method(cTextView, "get_window_type", textview_get_window_type, 1);
    rb_define_method(cTextView, "set_border_window_size", textview_set_border_window_size, 2);
    G_DEF_SETTER(cTextView, "border_window_size");
    rb_define_method(cTextView, "get_border_window_size", textview_get_border_window_size, 1);
    rb_define_method(cTextView, "forward_display_line", textview_forward_display_line, 1);
    rb_define_method(cTextView, "backward_display_line", textview_backward_display_line, 1);
    rb_define_method(cTextView, "forward_display_line_end", textview_forward_display_line_end, 1);
    rb_define_method(cTextView, "backward_display_line_start", textview_backward_display_line_start, 1);
    rb_define_method(cTextView, "starts_display_line", textview_starts_display_line, 1);
    rb_define_method(cTextView, "move_visually", textview_move_visually, 2);
    rb_define_method(cTextView, "add_child_at_anchor", textview_add_child_at_anchor, 2);
    rb_define_method(cTextView, "add_child_in_window", textview_add_child_in_window, 4);
    rb_define_method(cTextView, "move_child", textview_move_child, 3);
    rb_define_method(cTextView, "default_attributes", textview_get_default_attributes, 0);

    /* GtkTextWindowType */
    G_DEF_CLASS(GTK_TYPE_TEXT_WINDOW_TYPE, "WindowType", cTextView);
    G_DEF_CONSTANTS(cTextView, GTK_TYPE_TEXT_WINDOW_TYPE, "GTK_TEXT_");
 
    rb_define_const(cTextView, "PRIORITY_VALIDATE", INT2FIX(GTK_TEXT_VIEW_PRIORITY_VALIDATE));
}
Beispiel #7
0
static void
rb_grn_init_runtime_version (VALUE mGrn)
{
    const char *component_start, *component_end;
    int component_length;
    VALUE runtime_version;
    VALUE major, minor, micro, tag;

    runtime_version = rb_ary_new();

    component_start = grn_get_version();
    component_end = strstr(component_start, ".");
    component_length = component_end - component_start;
    major = rb_str_new(component_start, component_length);
    rb_ary_push(runtime_version, rb_Integer(major));

    component_start = component_end + 1;
    component_end = strstr(component_start, ".");
    component_length = component_end - component_start;
    minor = rb_str_new(component_start, component_length);
    rb_ary_push(runtime_version, rb_Integer(minor));

    component_start = component_end + 1;
    component_end = strstr(component_start, "-");
    if (component_end) {
        component_length = component_end - component_start;
    } else {
        component_length = strlen(component_start);
    }
    micro = rb_str_new(component_start, component_length);
    rb_ary_push(runtime_version, rb_Integer(micro));

    if (component_end) {
        tag = rb_str_new2(component_end + 1);
    } else {
        tag = Qnil;
    }
    rb_ary_push(runtime_version, tag);

    rb_obj_freeze(runtime_version);
    /*
     * 利用しているgroongaのバージョン。 @[メジャーバージョ
     * ン, マイナーバージョン, マイクロバージョン, タグ]@ の
     * 配列。
     */
    rb_define_const(mGrn, "VERSION", runtime_version);
}
void Init_hashpipe()
{
  VALUE mHashpipe;
  VALUE cStatus;

  mHashpipe = rb_define_module("Hashpipe");
  cStatus = rb_define_class_under(mHashpipe, "Status", rb_cObject);

  // RECORD_SIZE constant
  rb_define_const(cStatus, "RECORD_SIZE",
      INT2FIX(HASHPIPE_STATUS_RECORD_SIZE));

  rb_define_alloc_func(cStatus, rb_hps_alloc);
  rb_define_singleton_method(cStatus, "exists?", rb_hps_exists, 1);
  rb_define_method(cStatus, "initialize", rb_hps_init, -1);
  rb_define_method(cStatus, "attach", rb_hps_attach, -1);
  rb_define_method(cStatus, "detach", rb_hps_detach, 0);
  rb_define_method(cStatus, "attached?", rb_hps_attached_p, 0);
  rb_define_method(cStatus, "instance_id", rb_hps_instance_id, 0);
  rb_define_method(cStatus, "unlock", rb_hps_unlock, 0);
  rb_define_method(cStatus, "lock", rb_hps_lock, 0);
  rb_define_method(cStatus, "clear!", rb_hps_clear_bang, 0);
  rb_define_method(cStatus, "delete", rb_hps_delete, 1);
  rb_define_method(cStatus, "buf", rb_hps_buf, 0);
  rb_define_method(cStatus, "length", rb_hps_length, 0);

  // hget methods
  HGET_METHOD(cStatus, i2);
  HGET_METHOD(cStatus, i4);
  HGET_METHOD(cStatus, i8);
  HGET_METHOD(cStatus, u4);
  HGET_METHOD(cStatus, u8);
  HGET_METHOD(cStatus, r4);
  HGET_METHOD(cStatus, r8);
  HGET_METHOD(cStatus, s);

  // hput methods
  HPUT_METHOD(cStatus, i2);
  HPUT_METHOD(cStatus, i4);
  HPUT_METHOD(cStatus, i8);
  HPUT_METHOD(cStatus, u4);
  HPUT_METHOD(cStatus, u8);
  HPUT_METHOD(cStatus, r4);
  HPUT_METHOD(cStatus, r8);
  HPUT_METHOD(cStatus, s);
}
Beispiel #9
0
void
Init_gtk_paper_size()
{
#if GTK_CHECK_VERSION(2,10,0)
    VALUE gPaperSize = G_DEF_CLASS(GTK_TYPE_PAPER_SIZE, "PaperSize", mGtk);

    rb_define_singleton_method(gPaperSize, "default", ps_s_get_default, 0);

    rb_define_const(gPaperSize, "A3", rb_str_new2(GTK_PAPER_NAME_A3));
    rb_define_const(gPaperSize, "A4", rb_str_new2(GTK_PAPER_NAME_A4));
    rb_define_const(gPaperSize, "A5", rb_str_new2(GTK_PAPER_NAME_A5));
    rb_define_const(gPaperSize, "B5", rb_str_new2(GTK_PAPER_NAME_B5));
    rb_define_const(gPaperSize, "LETTER", rb_str_new2(GTK_PAPER_NAME_LETTER));
    rb_define_const(gPaperSize, "EXECUTIVE",
                    rb_str_new2(GTK_PAPER_NAME_EXECUTIVE));
    rb_define_const(gPaperSize, "LEGAL", rb_str_new2(GTK_PAPER_NAME_LEGAL));

    rb_define_method(gPaperSize, "initialize", ps_initialize, -1);
    rb_define_method(gPaperSize, "==", ps_is_equal, 1);

    rb_define_method(gPaperSize, "name", ps_get_name, 0);
    rb_define_method(gPaperSize, "display_name", ps_get_display_name, 0);
    rb_define_method(gPaperSize, "ppd_name", ps_get_ppd_name, 0);

    rb_define_method(gPaperSize, "get_width", ps_get_width, 1);
    rb_define_method(gPaperSize, "get_height", ps_get_height, 1);

    rb_define_method(gPaperSize, "custom?", ps_is_custom, 0);

    rb_define_method(gPaperSize, "set_size", ps_set_size, 3);

    rb_define_method(gPaperSize, "get_default_top_margin",
                     ps_get_default_top_margin, 1);
    rb_define_method(gPaperSize, "get_default_bottom_margin",
                     ps_get_default_bottom_margin, 1);
    rb_define_method(gPaperSize, "get_default_left_margin",
                     ps_get_default_left_margin, 1);
    rb_define_method(gPaperSize, "get_default_right_margin",
                     ps_get_default_right_margin, 1);

    G_DEF_SETTERS(gPaperSize);

    /* GtkUnit */
    G_DEF_CLASS(GTK_TYPE_UNIT, "Unit", gPaperSize);
    G_DEF_CONSTANTS(gPaperSize, GTK_TYPE_UNIT, "GTK_");

#endif
}
Beispiel #10
0
void
rbffi_NullPointer_Init(VALUE moduleFFI)
{
    rbffi_NullPointerClass = rb_define_class_under(moduleFFI, "NullPointer", rbffi_PointerClass);
    rb_global_variable(&rbffi_NullPointerClass);
    
    NullPointerErrorClass = rb_define_class_under(moduleFFI, "NullPointerError", rb_eRuntimeError);
    rb_global_variable(&NullPointerErrorClass);

    rb_define_alloc_func(rbffi_NullPointerClass, nullptr_allocate);
    rb_define_method(rbffi_NullPointerClass, "inspect", nullptr_inspect, 0);
    rb_define_method(rbffi_NullPointerClass, "+", nullptr_op, -1);
    rb_define_method(rbffi_NullPointerClass, "null?", nullptr_null_p, 0);
    rb_define_method(rbffi_NullPointerClass, "address", nullptr_address, 0);
    rb_define_method(rbffi_NullPointerClass, "==", nullptr_equals, 1);

#define NOP(name) \
    rb_define_method(rbffi_NullPointerClass, "get_" #name, nullptr_op, -1); \
    rb_define_method(rbffi_NullPointerClass, "put_" #name, nullptr_op, -1); \
    rb_define_method(rbffi_NullPointerClass, "get_array_of_" #name, nullptr_op, -1); \
    rb_define_method(rbffi_NullPointerClass, "put_array_of_" #name, nullptr_op, -1); \


    NOP(int8); NOP(uint8); NOP(int16); NOP(uint16);
    NOP(int32); NOP(uint32); NOP(int64); NOP(uint64); NOP(long); NOP(ulong);
    NOP(float32); NOP(float64);
    NOP(char); NOP(uchar); NOP(short); NOP(ushort);
    NOP(int); NOP(uint); NOP(long_long); NOP(ulong_long);
    NOP(float); NOP(double);

#undef NOP
#define NOP(name) \
    rb_define_method(rbffi_NullPointerClass, "get_" #name, nullptr_op,  -1); \
    rb_define_method(rbffi_NullPointerClass, "put_" #name, nullptr_op, -1);

    NOP(string); NOP(bytes); NOP(pointer); NOP(callback);

    rb_define_method(rbffi_NullPointerClass, "clear", nullptr_op, -1); \
    rb_define_method(rbffi_NullPointerClass, "total", nullptr_op, -1);

    // Create a singleton instance of NullPointer that can be shared
    rbffi_NullPointerSingleton = nullptr_allocate(rbffi_NullPointerClass);
    rb_global_variable(&rbffi_NullPointerSingleton);
    rb_define_const(rbffi_PointerClass, "NULL", rbffi_NullPointerSingleton);
}
Beispiel #11
0
void
init_ruby_class()
{
#if 0
  // For documentation using YARD
  VALUE opencv = rb_define_module("OpenCV");
  VALUE cvseq = rb_define_class_under(opencv, "CvSeq");
  VALUE curve = rb_define_module_under(opencv, "Curve");
  VALUE pointset = rb_define_module_under(opencv, "PointSet");
#endif

  if (rb_klass)
    return;

  VALUE opencv = rb_module_opencv();
  VALUE cvseq = cCvSeq::rb_class();
  VALUE curve = mCurve::rb_module();
  VALUE pointset = mPointSet::rb_module();

  rb_klass = rb_define_class_under(opencv, "CvContour", cvseq);
  rb_include_module(rb_klass, curve);
  rb_include_module(rb_klass, pointset);

  rb_define_alloc_func(rb_klass, rb_allocate);

  VALUE approx_option = rb_hash_new();
  rb_define_const(rb_klass, "APPROX_OPTION", approx_option);
  rb_hash_aset(approx_option, ID2SYM(rb_intern("method")), INT2FIX(CV_POLY_APPROX_DP));
  rb_hash_aset(approx_option, ID2SYM(rb_intern("accuracy")), rb_float_new(1.0));
  rb_hash_aset(approx_option, ID2SYM(rb_intern("recursive")), Qfalse);
  
  rb_define_method(rb_klass, "initialize", RUBY_METHOD_FUNC(rb_initialize), -1);
  rb_define_method(rb_klass, "rect", RUBY_METHOD_FUNC(rb_rect), 0);
  rb_define_method(rb_klass, "color", RUBY_METHOD_FUNC(rb_color), 0);
  rb_define_method(rb_klass, "color=", RUBY_METHOD_FUNC(rb_set_color), 1);
  rb_define_method(rb_klass, "reserved", RUBY_METHOD_FUNC(rb_reserved), 0);
  rb_define_method(rb_klass, "approx_poly", RUBY_METHOD_FUNC(rb_approx_poly), -1);
  rb_define_alias(rb_klass, "approx", "approx_poly");
  rb_define_method(rb_klass, "bounding_rect", RUBY_METHOD_FUNC(rb_bounding_rect), 0);
  rb_define_method(rb_klass, "create_tree", RUBY_METHOD_FUNC(rb_create_tree), -1);
  rb_define_method(rb_klass, "in?", RUBY_METHOD_FUNC(rb_in_q), 1);
  rb_define_method(rb_klass, "measure_distance", RUBY_METHOD_FUNC(rb_measure_distance), 1);
  rb_define_method(rb_klass, "point_polygon_test", RUBY_METHOD_FUNC(rb_point_polygon_test), 2);
  rb_define_method(rb_klass, "match_shapes", RUBY_METHOD_FUNC(rb_match_shapes), -1);
}
Beispiel #12
0
static void
add_obj_name_const(VALUE klass, struct objlist *nobj, const char *name)
{
  const char *obj_name;
  char str[64];
  VALUE val;

  if (nobj == NULL) {
    val = Qnil;
  } else {
    obj_name = ngraph_get_object_name(nobj);
    strncpy(str, obj_name, sizeof(str) - 1);
    str[sizeof(str) - 1] = '\0';
    str[0] = toupper(str[0]);
    val = ID2SYM(rb_intern(str));
  }
  rb_define_const(klass, name, val);
}
Beispiel #13
0
void
Init_pango_main()
{
    rb_define_module_function(mPango, "reorder_items", rpango_reorder_items, 1);

#if PANGO_CHECK_VERSION(1,4,0)
    rb_define_module_function(mPango, "unichar_direction", rpango_unichar_direction, 1);
    rb_define_module_function(mPango, "find_base_dir", rpango_find_base_dir, 1);
#endif
    rb_define_module_function(mPango, "break", rpango_break, 2);
    rb_define_module_function(mPango, "get_log_attrs", rpango_get_log_attrs, 3);
    rb_define_module_function(mPango, "find_paragraph_boundary", rpango_find_paragraph_boundary, 1);
    rb_define_module_function(mPango, "shape", rpango_shape, 2);
    rb_define_module_function(mPango, "parse_markup", rpango_parse_markup, -1);
    rb_define_module_function(mPango, "pixels", rpango_pixels, 1);

    rb_define_const(mPango, "SCALE", INT2FIX(PANGO_SCALE));
}
void
Init_ca_obj_unbound_repeat ()
{
  /* rb_cCAUnboudRepeat, CA_OBJ_UNBOUND_REPEAT are defined in rb_carray.c */

  rb_define_const(rb_cObject, "CA_OBJ_UNBOUND_REPEAT", INT2NUM(CA_OBJ_UNBOUND_REPEAT));

  rb_define_method(rb_cCArray, "unbound_repeat", rb_ca_unbound_repeat, -1);

  rb_define_alloc_func(rb_cCAUnboundRepeat, rb_ca_ubrep_s_allocate);
  rb_define_method(rb_cCAUnboundRepeat, "initialize_copy",
                                      rb_ca_ubrep_initialize_copy, 1);

  rb_define_method(rb_cCAUnboundRepeat, "bind", rb_ca_ubrep_bind, -1);
  rb_define_method(rb_cCAUnboundRepeat, "bind_with", ca_ubrep_bind_with, 1);
  rb_define_method(rb_cCAUnboundRepeat, "spec", rb_ca_ubrep_spec, 0);

}
Beispiel #15
0
void
Init_gdk_atom(VALUE mGdk)
{
    VALUE none;
    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GDK_TYPE_ATOM, "Atom", mGdk);

    RG_DEF_SMETHOD(intern, -1);

    RG_DEF_METHOD(initialize, 1);
    RG_DEF_METHOD(name, 0);
    RG_DEF_METHOD(to_i, 0);
    RG_DEF_METHOD_OPERATOR("==", equal, 1);

    /* This is a trick to define GDK_NONE as a BOXED object */
    none = GDKATOM2RVAL((gpointer)1);
    rb_define_const(RG_TARGET_NAMESPACE, "NONE", none);
    _SELF(none) = GDK_NONE;
}           
Beispiel #16
0
/*
 * Verse::MaterialNode class
 */
void
rbverse_init_verse_materialnode( void ) {
	rbverse_log( "debug", "Initializing Verse::MaterialNode" );

	/* Class methods */
	rbverse_cVerseMaterialNode = rb_define_class_under( rbverse_mVerse, "MaterialNode", rbverse_cVerseNode );

    /* Constants */
	rb_define_const( rbverse_cVerseMaterialNode, "TYPE_NUMBER", rb_uint2inum(V_NT_MATERIAL) );

	/* Initializer */
	rb_define_method( rbverse_cVerseMaterialNode, "initialize", rbverse_verse_materialnode_initialize, 0 );

	/* Tell Verse::Node about this subclass */
	rbverse_nodetype_to_nodeclass[ V_NT_MATERIAL ] = rbverse_cVerseMaterialNode;
	node_mark_funcs[ V_NT_MATERIAL ] = &rbverse_materialnode_gc_mark;
	node_free_funcs[ V_NT_MATERIAL ] = &rbverse_materialnode_gc_free;
}
Beispiel #17
0
static void Init_grpc_op_codes() {
  /* Constants representing operation type codes in grpc.h */
  VALUE grpc_rb_mCallOps = rb_define_module_under(grpc_rb_mGrpcCore, "CallOps");
  rb_define_const(grpc_rb_mCallOps, "SEND_INITIAL_METADATA",
                  UINT2NUM(GRPC_OP_SEND_INITIAL_METADATA));
  rb_define_const(grpc_rb_mCallOps, "SEND_MESSAGE",
                  UINT2NUM(GRPC_OP_SEND_MESSAGE));
  rb_define_const(grpc_rb_mCallOps, "SEND_CLOSE_FROM_CLIENT",
                  UINT2NUM(GRPC_OP_SEND_CLOSE_FROM_CLIENT));
  rb_define_const(grpc_rb_mCallOps, "SEND_STATUS_FROM_SERVER",
                  UINT2NUM(GRPC_OP_SEND_STATUS_FROM_SERVER));
  rb_define_const(grpc_rb_mCallOps, "RECV_INITIAL_METADATA",
                  UINT2NUM(GRPC_OP_RECV_INITIAL_METADATA));
  rb_define_const(grpc_rb_mCallOps, "RECV_MESSAGE",
                  UINT2NUM(GRPC_OP_RECV_MESSAGE));
  rb_define_const(grpc_rb_mCallOps, "RECV_STATUS_ON_CLIENT",
                  UINT2NUM(GRPC_OP_RECV_STATUS_ON_CLIENT));
  rb_define_const(grpc_rb_mCallOps, "RECV_CLOSE_ON_SERVER",
                  UINT2NUM(GRPC_OP_RECV_CLOSE_ON_SERVER));
}
Beispiel #18
0
void Init_grpc_call() {
  /* CallError inherits from Exception to signal that it is non-recoverable */
  rb_eCallError =
      rb_define_class_under(rb_mGrpcCore, "CallError", rb_eException);
  rb_cCall = rb_define_class_under(rb_mGrpcCore, "Call", rb_cObject);

  /* Prevent allocation or inialization of the Call class */
  rb_define_alloc_func(rb_cCall, grpc_rb_cannot_alloc);
  rb_define_method(rb_cCall, "initialize", grpc_rb_cannot_init, 0);
  rb_define_method(rb_cCall, "initialize_copy", grpc_rb_cannot_init_copy, 1);

  /* Add ruby analogues of the Call methods. */
  rb_define_method(rb_cCall, "server_accept", grpc_rb_call_server_accept, 2);
  rb_define_method(rb_cCall, "server_end_initial_metadata",
                   grpc_rb_call_server_end_initial_metadata, -1);
  rb_define_method(rb_cCall, "add_metadata", grpc_rb_call_add_metadata, -1);
  rb_define_method(rb_cCall, "cancel", grpc_rb_call_cancel, 0);
  rb_define_method(rb_cCall, "invoke", grpc_rb_call_invoke, -1);
  rb_define_method(rb_cCall, "start_read", grpc_rb_call_start_read, 1);
  rb_define_method(rb_cCall, "start_write", grpc_rb_call_start_write, -1);
  rb_define_method(rb_cCall, "start_write_status",
                   grpc_rb_call_start_write_status, 3);
  rb_define_method(rb_cCall, "writes_done", grpc_rb_call_writes_done, 1);
  rb_define_method(rb_cCall, "status", grpc_rb_call_get_status, 0);
  rb_define_method(rb_cCall, "status=", grpc_rb_call_set_status, 1);
  rb_define_method(rb_cCall, "metadata", grpc_rb_call_get_metadata, 0);
  rb_define_method(rb_cCall, "metadata=", grpc_rb_call_set_metadata, 1);

  /* Ids used to support call attributes */
  id_metadata = rb_intern("metadata");
  id_status = rb_intern("status");

  /* Ids used by the c wrapping internals. */
  id_cq = rb_intern("__cq");
  id_flags = rb_intern("__flags");
  id_input_md = rb_intern("__input_md");

  /* The hash for reference counting calls, to ensure they can't be destroyed
   * more than once */
  hash_all_calls = rb_hash_new();
  rb_define_const(rb_cCall, "INTERNAL_ALL_CALLs", hash_all_calls);

  Init_grpc_error_codes();
}
Beispiel #19
0
static void define_const(VALUE klass1, VALUE klass2)
{
  rb_define_const(klass1,
                  "CONJUGATE_FR", INT2FIX(GSL_FDFMINIMIZER_CONJUGATE_FR));
  rb_define_const(klass1,
                  "CONJUGATE_PR", INT2FIX(GSL_FDFMINIMIZER_CONJUGATE_PR));
  rb_define_const(klass1,
                  "VECTOR_BFGS", INT2FIX(GSL_FDFMINIMIZER_VECTOR_BFGS));
  rb_define_const(klass1,
                  "STEEPEST_DESCENT", INT2FIX(GSL_FDFMINIMIZER_STEEPEST_DESCENT));
  rb_define_const(klass2,
                  "NMSIMPLEX", INT2FIX(GSL_FMINIMIZER_NMSIMPLEX));
  rb_define_const(klass1,
                  "VECTOR_BFGS2", INT2FIX(GSL_FDFMINIMIZER_VECTOR_BFGS2));
  rb_define_const(klass2,
                  "NMSIMPLEX2RAND", INT2FIX(GSL_FMINIMIZER_NMSIMPLEX2RAND));
}
Beispiel #20
0
/* Document-class: LDAP::Entry
 *
 * These methods can be used to probe the entries returned by LDAP searches.
 */
void
Init_ldap_entry ()
{
  rb_cLDAP_Entry = rb_define_class_under (rb_mLDAP, "Entry", rb_cObject);
  rb_define_const (rb_mLDAP, "Message", rb_cLDAP_Entry);	/* for compatibility */
  rb_undef_method (CLASS_OF (rb_cLDAP_Entry), "new");
  rb_undef_alloc_func (rb_cLDAP_Entry);
  rb_ldap_entry_define_method ("get_dn", rb_ldap_entry_get_dn, 0);
  rb_ldap_entry_define_method ("get_values", rb_ldap_entry_get_values, 1);
  rb_ldap_entry_define_method ("get_attributes",
			       rb_ldap_entry_get_attributes, 0);
  rb_alias (rb_cLDAP_Entry, rb_intern ("dn"), rb_intern ("get_dn"));
  rb_alias (rb_cLDAP_Entry, rb_intern ("vals"), rb_intern ("get_values"));
  rb_alias (rb_cLDAP_Entry, rb_intern ("[]"), rb_intern ("get_values"));
  rb_alias (rb_cLDAP_Entry, rb_intern ("attrs"),
	    rb_intern ("get_attributes"));
  rb_ldap_entry_define_method ("to_hash", rb_ldap_entry_to_hash, 0);
  rb_ldap_entry_define_method ("inspect", rb_ldap_entry_inspect, 0);
}
Beispiel #21
0
void
rbffi_Pointer_Init(VALUE moduleFFI)
{
    VALUE rbNullAddress = ULL2NUM(0);

    /* 
     * Document-class: FFI::Pointer < FFI::AbstractMemory
     * Pointer class is used to manage C pointers with ease. A {Pointer} object is defined by his
     * {#address} (as a C pointer). It permits additions with an integer for pointer arithmetic.
     *
     * ==Autorelease
     * A pointer object may autorelease his contents when freed (by default). This behaviour may be
     * changed with {#autorelease=} method.
     */
    rbffi_PointerClass = rb_define_class_under(moduleFFI, "Pointer", rbffi_AbstractMemoryClass);
    /*
     * Document-variable: Pointer
     */
    rb_global_variable(&rbffi_PointerClass);

    rb_define_alloc_func(rbffi_PointerClass, ptr_allocate);
    rb_define_method(rbffi_PointerClass, "initialize", ptr_initialize, -1);
    rb_define_method(rbffi_PointerClass, "initialize_copy", ptr_initialize_copy, 1);
    rb_define_method(rbffi_PointerClass, "inspect", ptr_inspect, 0);
    rb_define_method(rbffi_PointerClass, "to_s", ptr_inspect, 0);
    rb_define_method(rbffi_PointerClass, "+", ptr_plus, 1);
    rb_define_method(rbffi_PointerClass, "slice", ptr_slice, 2);
    rb_define_method(rbffi_PointerClass, "null?", ptr_null_p, 0);
    rb_define_method(rbffi_PointerClass, "address", ptr_address, 0);
    rb_define_alias(rbffi_PointerClass, "to_i", "address");
    rb_define_method(rbffi_PointerClass, "==", ptr_equals, 1);
    rb_define_method(rbffi_PointerClass, "order", ptr_order, -1);
    rb_define_method(rbffi_PointerClass, "autorelease=", ptr_autorelease, 1);
    rb_define_method(rbffi_PointerClass, "autorelease?", ptr_autorelease_p, 0);
    rb_define_method(rbffi_PointerClass, "free", ptr_free, 0);

    rbffi_NullPointerSingleton = rb_class_new_instance(1, &rbNullAddress, rbffi_PointerClass);
    /*
     * NULL pointer
     */
    rb_define_const(rbffi_PointerClass, "NULL", rbffi_NullPointerSingleton);
}
Beispiel #22
0
void
Init_gtk_paper_size(VALUE mGtk)
{
#if GTK_CHECK_VERSION(2,10,0)
    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GTK_TYPE_PAPER_SIZE, "PaperSize", mGtk);

    RG_DEF_SMETHOD(default, 0);

    rb_define_const(RG_TARGET_NAMESPACE, "A3", CSTR2RVAL(GTK_PAPER_NAME_A3));
    rb_define_const(RG_TARGET_NAMESPACE, "A4", CSTR2RVAL(GTK_PAPER_NAME_A4));
    rb_define_const(RG_TARGET_NAMESPACE, "A5", CSTR2RVAL(GTK_PAPER_NAME_A5));
    rb_define_const(RG_TARGET_NAMESPACE, "B5", CSTR2RVAL(GTK_PAPER_NAME_B5));
    rb_define_const(RG_TARGET_NAMESPACE, "LETTER", CSTR2RVAL(GTK_PAPER_NAME_LETTER));
    rb_define_const(RG_TARGET_NAMESPACE, "EXECUTIVE",
                    CSTR2RVAL(GTK_PAPER_NAME_EXECUTIVE));
    rb_define_const(RG_TARGET_NAMESPACE, "LEGAL", CSTR2RVAL(GTK_PAPER_NAME_LEGAL));

    RG_DEF_METHOD(initialize, -1);
    RG_DEF_METHOD_OPERATOR("==", equal, 1);

    RG_DEF_METHOD(name, 0);
    RG_DEF_METHOD(display_name, 0);
    RG_DEF_METHOD(ppd_name, 0);

    RG_DEF_METHOD(get_width, 1);
    RG_DEF_METHOD(get_height, 1);

    RG_DEF_METHOD_P(custom, 0);

    RG_DEF_METHOD(set_size, 3);

    RG_DEF_METHOD(get_default_top_margin, 1);
    RG_DEF_METHOD(get_default_bottom_margin, 1);
    RG_DEF_METHOD(get_default_left_margin, 1);
    RG_DEF_METHOD(get_default_right_margin, 1);

    G_DEF_SETTERS(RG_TARGET_NAMESPACE);

    /* GtkUnit */
    G_DEF_CLASS(GTK_TYPE_UNIT, "Unit", RG_TARGET_NAMESPACE);
    G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, GTK_TYPE_UNIT, "GTK_");

#endif
}
Beispiel #23
0
void
init_pg_errors()
{
	rb_hErrors = rb_hash_new();
	rb_define_const( rb_mPG, "ERROR_CLASSES", rb_hErrors );

	rb_ePGerror = rb_define_class_under( rb_mPG, "Error", rb_eStandardError );

	/*************************
	 *  PG::Error
	 *************************/
	rb_define_alias( rb_ePGerror, "error", "message" );
	rb_define_attr( rb_ePGerror, "connection", 1, 0 );
	rb_define_attr( rb_ePGerror, "result", 1, 0 );

	rb_eServerError = rb_define_class_under( rb_mPG, "ServerError", rb_ePGerror );
	rb_eUnableToSend = rb_define_class_under( rb_mPG, "UnableToSend", rb_ePGerror );
	rb_eConnectionBad = rb_define_class_under( rb_mPG, "ConnectionBad", rb_ePGerror );

	#include "errorcodes.def"
}
Beispiel #24
0
void Init_libdislocker()
{
	VALUE rb_mDislocker = rb_define_module("Dislocker");
	dis_rb_classes[DIS_RB_CLASS_DISLOCKER] = rb_mDislocker;

	Init_metadata(rb_mDislocker);
	Init_accesses(rb_mDislocker);

	rb_define_method(rb_mDislocker, "initialize", rb_init_dislocker, 1);
	rb_define_method(rb_mDislocker, "dislock", rb_dislock, 3);
	rb_define_method(rb_mDislocker, "enlock", rb_enlock, 3);
	rb_define_method(rb_mDislocker, "destroy", rb_destroy_dislocker, 0);

	VALUE rb_mDisSignatures = rb_define_module_under(rb_mDislocker, "Signatures");
	VALUE signatures = rb_ary_new3(
		2,
		rb_str_new(BITLOCKER_SIGNATURE, BITLOCKER_SIGNATURE_SIZE),
		rb_str_new(BITLOCKER_TO_GO_SIGNATURE, BITLOCKER_TO_GO_SIGNATURE_SIZE)
	);
	rb_define_const(rb_mDisSignatures, "BitLocker", signatures);
}
Beispiel #25
0
void
Init_despotify(void) {
	if (!despotify_init()) {
		printf("despotify_init() failed\n");
		return;
	}

	VALUE mDespotify = rb_define_module("Despotify");

	rb_define_singleton_method(mDespotify, "id2uri", rb_despotify_id2uri, 1);
	rb_define_singleton_method(mDespotify, "uri2id", rb_despotify_uri2id, 1);
	rb_define_const(mDespotify, "MAX_SEARCH_RESULTS", INT2NUM(MAX_SEARCH_RESULTS));

	cSession = Init_despotify_session(mDespotify);
	cPlaylist = Init_despotify_playlist(mDespotify);
	cTrack = Init_despotify_track(mDespotify);
	cArtist = Init_despotify_artist(mDespotify);
	cAlbum = Init_despotify_album(mDespotify);

	eDespotifyError = rb_define_class_under(mDespotify, "DespotifyError", rb_eException);
}
void rxml_init_schema_type(void)
{
  /* Add in infinity support for ruby 1.8.7 */
  #if !defined(RUBY_VM) && defined(INFINITY)
  ID infinityId = rb_intern("INFINITY");
  if (rb_const_defined(rb_cFloat, infinityId) == Qfalse)
    rb_define_const(rb_cFloat, "INFINITY", rb_float_new(INFINITY));
  #endif

  cXMLSchemaType = rb_define_class_under(cXMLSchema, "Type", rb_cObject);

  rb_define_method(cXMLSchemaType, "namespace", rxml_schema_type_namespace, 0);
  rb_define_method(cXMLSchemaType, "name", rxml_schema_type_name, 0);
  rb_define_method(cXMLSchemaType, "elements", rxml_schema_type_elements, 0);
  rb_define_method(cXMLSchemaType, "attributes", rxml_schema_type_attributes, 0);
  rb_define_method(cXMLSchemaType, "base", rxml_schema_type_base, 0);
  rb_define_method(cXMLSchemaType, "kind", rxml_schema_type_kind, 0);
  rb_define_method(cXMLSchemaType, "node", rxml_schema_type_node, 0);
  rb_define_method(cXMLSchemaType, "facets", rxml_schema_type_facets, 0);
  rb_define_method(cXMLSchemaType, "annotation", rxml_schema_type_annot, 0);
}
Beispiel #27
0
void
Init_vte3(void)
{
    VALUE RG_TARGET_NAMESPACE;

    RG_TARGET_NAMESPACE = rb_define_module("Vte");

    rb_define_const(RG_TARGET_NAMESPACE, "BUILD_VERSION",
                    rb_ary_new3(3,
                                INT2FIX(VTE_MAJOR_VERSION),
                                INT2FIX(VTE_MINOR_VERSION),
                                INT2FIX(VTE_MICRO_VERSION)));

    G_DEF_CLASS(VTE_TYPE_TERMINAL_ANTI_ALIAS, "TerminalAntiAlias", RG_TARGET_NAMESPACE);

    Init_vte_access(RG_TARGET_NAMESPACE);
    Init_vte_reaper(RG_TARGET_NAMESPACE);
    Init_vte_terminal(RG_TARGET_NAMESPACE);
    Init_vte_charattributes(RG_TARGET_NAMESPACE);
    Init_vte_pty(RG_TARGET_NAMESPACE);
}
Beispiel #28
0
void Init_sfcc()
{
  const char *conn;
  VALUE cEnvironment; /* class */
  VALUE value; /* wrapped value */
  int rc;
  char *msg;

  /**
   * SBLIM sfcc ruby API
   */
  mSfcc = rb_define_module("Sfcc");
  /**
   * SBLIM sfcc CIMC API
   */
  mSfccCim= rb_define_module_under(mSfcc, "Cim");

  /**
   * alloc CimcEnvironment once, store as const
   */
  cEnvironment = rb_define_class_under(mSfccCim, "CimcEnvironment", rb_cObject);
  conn = getenv("RUBY_SFCC_CONNECTION"); /* "SfcbLocal" or "XML" */
  if (!conn) conn = "XML";
  cimcEnv = NewCIMCEnv(conn,0,&rc,&msg);
  if (!cimcEnv) {
    rb_raise(rb_eLoadError, "Cannot local %s cim client library. %d:%s", conn, rc, msg ? msg : "");
  }
  value = Data_Wrap_Struct(cEnvironment, NULL, Exit_sfcc, cimcEnv);
  rb_define_const(mSfccCim, "CIMC_ENV", value);

  /**
   * Init other sub-classes
   */
  init_cim_string();
  init_cim_object_path();
  init_cim_enumeration();
  init_cim_class();
  init_cim_instance();
  init_cim_client();
}
Beispiel #29
0
void Init_drizzle()
{
    VALUE mNet = rb_define_module("Net");
    VALUE cDrizzle = rb_define_class_under(mNet, "Drizzle", rb_cObject);
    rb_define_alloc_func(cDrizzle, rb_drizzle_alloc);
    rb_define_method(cDrizzle, "con_create", rb_drizzle_con_create, 0);
    rb_define_method(cDrizzle, "query_run_all", rb_drizzle_query_run_all, 0);

    VALUE cConnection = rb_define_class_under(cDrizzle, "Connection", rb_cObject);
    rb_define_alloc_func(cConnection, rb_drizzle_con_alloc);
    rb_define_method(cConnection, "initialize", rb_drizzle_con_initialize, 1);
    rb_define_method(cConnection, "add_options", rb_drizzle_con_add_options, 1);
    rb_define_method(cConnection, "set_db", rb_drizzle_con_set_db, 1);
    rb_define_method(cConnection, "host", rb_drizzle_con_host, 0);
    rb_define_method(cConnection, "port", rb_drizzle_con_port, 0);
    rb_define_method(cConnection, "set_tcp", rb_drizzle_con_set_tcp, 2);
    rb_define_method(cConnection, "query_add", rb_drizzle_con_query_add, 1);
    rb_define_method(cConnection, "clone", rb_drizzle_con_clone, 0);

    VALUE mOptions = rb_define_module_under(cConnection, "Options");
    rb_define_const(mOptions, "NONE", INT2FIX(DRIZZLE_CON_NONE));
    rb_define_const(mOptions, "ALLOCATED", INT2FIX(DRIZZLE_CON_ALLOCATED));
    rb_define_const(mOptions, "MYSQL", INT2FIX((DRIZZLE_CON_MYSQL)));
    rb_define_const(mOptions, "RAW_PACKET", INT2FIX(DRIZZLE_CON_RAW_PACKET));
    rb_define_const(mOptions, "RAW_SCRAMBLE", INT2FIX(DRIZZLE_CON_RAW_SCRAMBLE));
    rb_define_const(mOptions, "READY", INT2FIX(DRIZZLE_CON_READY));
    rb_define_const(mOptions, "NO_RESULT_READ", INT2FIX(DRIZZLE_CON_NO_RESULT_READ));
    rb_define_const(mOptions, "IO_READY", INT2FIX(DRIZZLE_CON_IO_READY));

    VALUE cQuery = rb_define_class_under(cDrizzle, "Query", rb_cObject);
    rb_define_alloc_func(cQuery, rb_drizzle_query_alloc);
    rb_define_method(cQuery, "initialize", rb_drizzle_query_initialize, 1);
    rb_define_method(cQuery, "set_con", rb_drizzle_query_set_con, 1);
    rb_define_method(cQuery, "error_code", rb_drizzle_query_error_code, 0);
    rb_define_method(cQuery, "row_next", rb_drizzle_query_row_next, 0);

}
Beispiel #30
0
void
Init_native_support() {
	struct sockaddr_un addr;
	
	/* */
	mPassenger = rb_define_module("PhusionPassenger"); // Do not remove the above comment. We want the Passenger module's rdoc to be empty.
	
	/*
	 * Utility functions for accessing system functionality.
	 */
	mNativeSupport = rb_define_module_under(mPassenger, "NativeSupport");
	
	rb_define_singleton_method(mNativeSupport, "send_fd", send_fd, 2);
	rb_define_singleton_method(mNativeSupport, "recv_fd", recv_fd, 1);
	rb_define_singleton_method(mNativeSupport, "create_unix_socket", create_unix_socket, 2);
	rb_define_singleton_method(mNativeSupport, "accept", f_accept, 1);
	rb_define_singleton_method(mNativeSupport, "close_all_file_descriptors", close_all_file_descriptors, 1);
	rb_define_singleton_method(mNativeSupport, "disable_stdio_buffering", disable_stdio_buffering, 0);
	
	/* The maximum length of a Unix socket path, including terminating null. */
	rb_define_const(mNativeSupport, "UNIX_PATH_MAX", INT2NUM(sizeof(addr.sun_path)));
}