C++ rb_obj_freeze函数代码示例

static void
rb_grn_init_version (VALUE mGrn)
{
    VALUE build_version, bindings_version;

    rb_grn_init_runtime_version(mGrn);

    build_version = rb_ary_new3(3,
                                INT2NUM(GRN_MAJOR_VERSION),
                                INT2NUM(GRN_MINOR_VERSION),
                                INT2NUM(GRN_MICRO_VERSION));
    rb_obj_freeze(build_version);
    /*
     * ビルドしたgroongaのバージョン。 @[メジャーバージョン,
     * マイナーバージョン, マイクロバージョン]@ の配列。
     */
    rb_define_const(mGrn, "BUILD_VERSION", build_version);

    bindings_version = rb_ary_new3(3,
                                   INT2NUM(RB_GRN_MAJOR_VERSION),
                                   INT2NUM(RB_GRN_MINOR_VERSION),
                                   INT2NUM(RB_GRN_MICRO_VERSION));
    rb_obj_freeze(bindings_version);
    /*
     * rroongaのバージョン。 @[メジャーバージョン, マ
     * イナーバージョン, マイクロバージョン]@ の配列。
     */
    rb_define_const(mGrn, "BINDINGS_VERSION", bindings_version);
}

void
pg_define_coder( const char *name, void *func, VALUE klass, VALUE nsp )
{
  VALUE type_obj = Data_Wrap_Struct( klass, NULL, NULL, func );
	VALUE objname = rb_str_dup(rb_mod_name(nsp));
	rb_str_cat2( objname, "::");
	rb_str_cat2( objname, name);

  rb_iv_set( type_obj, "@name", rb_obj_freeze(objname) );
  rb_define_const( nsp, name, rb_obj_freeze(type_obj) );

  RB_GC_GUARD(type_obj);
}

static int lookup_sig(VALUE sig)
{
	static VALUE list;
	const char *ptr;
	long len;

	sig = rb_obj_as_string(sig);
	len = RSTRING_LEN(sig);
	ptr = RSTRING_PTR(sig);

	if (len > 3 && !memcmp("SIG", ptr, 3))
		sig = rb_str_new(ptr + 3, len - 3);

	if (!list) {
		VALUE mSignal = rb_const_get(rb_cObject, rb_intern("Signal"));

		list = rb_funcall(mSignal, rb_intern("list"), 0);
		rb_obj_freeze(list);
		rb_global_variable(&list);
	}

	sig = rb_hash_aref(list, sig);
	if (NIL_P(sig))
		rb_raise(rb_eArgError, "invalid signal: %s\n", ptr);

	return NUM2INT(sig);
}

static VALUE
env_str_new(const char *ptr, long len)
{
    VALUE str = rb_tainted_str_new(ptr, len);
    rb_obj_freeze(str);
    return str;
}

DLL_LOCAL VALUE _class_get(int argc,VALUE *argv,VALUE self)
{

	VALUE size,family,style,weight,underlined;
	rb_scan_args(argc, argv, "41",&size,&family,&style,&weight,&underlined);
	//TODO add refcounting
	wxFont *font = wxTheFontList->FindOrCreateFont(
		RB_NUM2INT(size),
		unwrapenum<wxFontFamily>(family),
		unwrapenum<wxFontStyle>(style),
		unwrapenum<wxFontWeight>(weight),
		RTEST(underlined)
	);

	if(!font || !font->IsOk())
		return Qnil;

	//look in the FontList holder is font was already wrapped
	fontlisttype::iterator it = fontlistholder.find(font);
	if(it != fontlistholder.end()) {
		return it->second;
	} else {
		//wrap wxFont pointer to ruby object
		VALUE result = wrap(font);

		//FontList objects should not be changed
		rb_obj_freeze(result);
		//Prevent FontList objects from been deleted
		rwx_refobject(result);
		//add wrapped font to the FontList holder to find it again
		fontlistholder[font] = result;
		return result;
	}
}

VALUE layout_get_default(const upb_fielddef *field) {
  switch (upb_fielddef_type(field)) {
    case UPB_TYPE_FLOAT:   return DBL2NUM(upb_fielddef_defaultfloat(field));
    case UPB_TYPE_DOUBLE:  return DBL2NUM(upb_fielddef_defaultdouble(field));
    case UPB_TYPE_BOOL:
      return upb_fielddef_defaultbool(field) ? Qtrue : Qfalse;
    case UPB_TYPE_MESSAGE: return Qnil;
    case UPB_TYPE_ENUM: {
      const upb_enumdef *enumdef = upb_fielddef_enumsubdef(field);
      int32_t num = upb_fielddef_defaultint32(field);
      const char *label = upb_enumdef_iton(enumdef, num);
      if (label) {
        return ID2SYM(rb_intern(label));
      } else {
        return INT2NUM(num);
      }
    }
    case UPB_TYPE_INT32:   return INT2NUM(upb_fielddef_defaultint32(field));
    case UPB_TYPE_INT64:   return LL2NUM(upb_fielddef_defaultint64(field));;
    case UPB_TYPE_UINT32:  return UINT2NUM(upb_fielddef_defaultuint32(field));
    case UPB_TYPE_UINT64:  return ULL2NUM(upb_fielddef_defaultuint64(field));
    case UPB_TYPE_STRING:
    case UPB_TYPE_BYTES: {
      size_t size;
      const char *str = upb_fielddef_defaultstr(field, &size);
      VALUE str_rb = rb_str_new(str, size);

      rb_enc_associate(str_rb, (upb_fielddef_type(field) == UPB_TYPE_BYTES) ?
                 kRubyString8bitEncoding : kRubyStringUtf8Encoding);
      rb_obj_freeze(str_rb);
      return str_rb;
    }
    default: return Qnil;
  }
}

// View#getInverseTransform()
// View#get_inverse_transform()
// View#inverse_transform()
VALUE rbView::GetInverseTransform( VALUE aSelf )
{
	const sf::Transform& transform = rbMacros::ToSFML< sf::View >( aSelf, rbView::Class )->getInverseTransform();
	VALUE obj = rbMacros::ToRuby( const_cast< sf::Transform* >( &transform ), rbTransform::Class );
	rb_iv_set( obj, "@__ref__owner", aSelf );
	rb_obj_freeze( obj );
	return obj;
}

void
Init_version()
{
    VALUE v = rb_obj_freeze(rb_str_new2(ruby_version));
    VALUE d = rb_obj_freeze(rb_str_new2(ruby_release_date));
    VALUE p = rb_obj_freeze(rb_str_new2(ruby_platform));

    rb_define_global_const("RUBY_VERSION", v);
    rb_define_global_const("RUBY_RELEASE_DATE", d);
    rb_define_global_const("RUBY_PLATFORM", p);
    rb_define_global_const("RUBY_PATCHLEVEL", INT2FIX(RUBY_PATCHLEVEL));

    /* obsolete constants */
    rb_define_global_const("VERSION", v);
    rb_define_global_const("RELEASE_DATE", d);
    rb_define_global_const("PLATFORM", p);
}

// RenderTexture#texture
// RenderTexture#get_texture
// RenderTexture#getTexture
VALUE rbRenderTexture::GetTexture( VALUE aSelf )
{
    const sf::Texture& texture = rbMacros::ToSFML< sf::RenderTexture >( aSelf, rbRenderTexture::Class )->getTexture();
    VALUE object = rbMacros::ToRubyNoGC( const_cast< sf::Texture* >( &texture ), rbTexture::Class );
    rb_iv_set( object, "@__ref__owner", aSelf );
    rb_obj_freeze( object );
    return object;
}

/*
 *  call-seq:
 *     buf.to_s          =>  String
 *
 *  Returns a String (binary) representation of the buffer.
 *
 * === Examples
 *     buf = ArrayBuffer.new("buffer")  =>  ArrayBuffer
 *     buf.byte_length                  =>  6
 *     buf.to_s                         =>  "buffer"
 *
*/
VALUE rb_array_buffer_to_s(VALUE obj)
{
    VALUE str;
    GetArrayBuffer(obj);
    str = rb_str_new((const char*)buf->buf, buf->length);
    ArrayBufferEncode(str);
    return rb_obj_freeze(str);
}

static void
set_rack_input(VALUE env, struct evbuffer* evbuffer)
{
    VALUE str = rb_str_new((const char*)EVBUFFER_DATA(evbuffer),
                           EVBUFFER_LENGTH(evbuffer));
    rb_obj_freeze(str);
    volatile VALUE ret = rb_funcall(rb_cStringIO, rb_intern("new"), 1, str);
    rb_hash_aset(env, global_envs[GE_RACK_INPUT], ret);
}

VALUE Init_oci8(void)
{
#if 0
    oci8_cOCIHandle = rb_define_class("OCIHandle", rb_cObject);
    cOCI8 = rb_define_class("OCI8", oci8_cOCIHandle);
#endif
    cOCI8 = oci8_define_class("OCI8", &oci8_svcctx_class);
    cSession = oci8_define_class_under(cOCI8, "Session", &oci8_svcctx_associate_class);
    cServer = oci8_define_class_under(cOCI8, "Server", &oci8_svcctx_associate_class);
    id_at_session_handle = rb_intern("@session_handle");
    id_at_server_handle = rb_intern("@server_handle");

    oracle_client_vernum = INT2FIX(oracle_client_version);
    if (have_OCIClientVersion) {
        sword major, minor, update, patch, port_update;
        OCIClientVersion(&major, &minor, &update, &patch, &port_update);
        oracle_client_vernum = INT2FIX(ORAVERNUM(major, minor, update, patch, port_update));
    }

    sym_SYSDBA = ID2SYM(rb_intern("SYSDBA"));
    sym_SYSOPER = ID2SYM(rb_intern("SYSOPER"));
    id_at_prefetch_rows = rb_intern("@prefetch_rows");
    id_set_prefetch_rows = rb_intern("prefetch_rows=");

    rb_define_const(cOCI8, "VERSION", rb_obj_freeze(rb_usascii_str_new_cstr(OCI8LIB_VERSION)));
    rb_define_singleton_method_nodoc(cOCI8, "oracle_client_vernum", oci8_s_oracle_client_vernum, 0);
    rb_define_singleton_method_nodoc(cOCI8, "__set_property", oci8_s_set_property, 2);
    if (have_OCIMessageOpen && have_OCIMessageGet) {
        rb_define_singleton_method(cOCI8, "error_message", oci8_s_error_message, 1);
    }
    rb_define_private_method(cOCI8, "parse_connect_string", oci8_parse_connect_string, 1);
    rb_define_private_method(cOCI8, "logon", oci8_logon, 3);
    rb_define_private_method(cOCI8, "allocate_handles", oci8_allocate_handles, 0);
    rb_define_private_method(cOCI8, "session_handle", oci8_get_session_handle, 0);
    rb_define_private_method(cOCI8, "server_handle", oci8_get_server_handle, 0);
    rb_define_private_method(cOCI8, "server_attach", oci8_server_attach, 2);
    rb_define_private_method(cOCI8, "session_begin", oci8_session_begin, 2);
    rb_define_method(cOCI8, "logoff", oci8_svcctx_logoff, 0);
    rb_define_method(cOCI8, "parse", oci8_svcctx_parse, 1);
    rb_define_method(cOCI8, "commit", oci8_commit, 0);
    rb_define_method(cOCI8, "rollback", oci8_rollback, 0);
    rb_define_method(cOCI8, "non_blocking?", oci8_non_blocking_p, 0);
    rb_define_method(cOCI8, "non_blocking=", oci8_set_non_blocking, 1);
    rb_define_method(cOCI8, "autocommit?", oci8_autocommit_p, 0);
    rb_define_method(cOCI8, "autocommit=", oci8_set_autocommit, 1);
    rb_define_method(cOCI8, "long_read_len", oci8_long_read_len, 0);
    rb_define_method(cOCI8, "long_read_len=", oci8_set_long_read_len, 1);
    rb_define_method(cOCI8, "break", oci8_break, 0);
    rb_define_method(cOCI8, "prefetch_rows=", oci8_set_prefetch_rows, 1);
    rb_define_private_method(cOCI8, "oracle_server_vernum", oci8_oracle_server_vernum, 0);
    rb_define_method(cOCI8, "ping", oci8_ping, 0);
    rb_define_method(cOCI8, "client_identifier=", oci8_set_client_identifier, 1);
    rb_define_method(cOCI8, "module=", oci8_set_module, 1);
    rb_define_method(cOCI8, "action=", oci8_set_action, 1);
    rb_define_method(cOCI8, "client_info=", oci8_set_client_info, 1);
    return cOCI8;
}

void Init_wkhtml_native() {
  //Global initialization of library and when Ruby shuts down
  wkhtmltopdf_init(USE_GRAPHICS_INT);
  wkhtmltoimage_init(USE_GRAPHICS_INT);
  rb_set_end_proc(Deinit_wkhtml_native, Qnil);

  idReady = rb_intern("ready");

  mWkHtml = rb_define_module("WkHtml");
  rb_define_const(mWkHtml, "LIBRARY_VERSION", rb_obj_freeze(rb_str_new_cstr(wkhtmltopdf_version())));
  rb_define_const(mWkHtml, "USE_GRAPHICS", INT2BOOL(USE_GRAPHICS_INT));

  mWkHtmlToPdf = rb_define_module_under(mWkHtml, "ToPdf");

  cWkHtmlToPdfGlobalSettings = rb_define_class_under(mWkHtmlToPdf, "GlobalSettings", rb_cObject);
  rb_define_alloc_func(cWkHtmlToPdfGlobalSettings, wkhtml_topdf_globalsettings_alloc);
  rb_define_method(cWkHtmlToPdfGlobalSettings, "[]=", wkhtml_topdf_globalsettings_aset, 2);
  rb_define_method(cWkHtmlToPdfGlobalSettings, "[]", wkhtml_topdf_globalsettings_aref, 1);

  cWkHtmlToPdfObjectSettings = rb_define_class_under(mWkHtmlToPdf, "ObjectSettings", rb_cObject);
  rb_define_alloc_func(cWkHtmlToPdfObjectSettings, wkhtml_topdf_objectsettings_alloc);
  rb_define_method(cWkHtmlToPdfObjectSettings, "[]=", wkhtml_topdf_objectsettings_aset, 2);
  rb_define_method(cWkHtmlToPdfObjectSettings, "[]", wkhtml_topdf_objectsettings_aref, 1);

  cWkHtmlToPdfConverter = rb_define_class_under(mWkHtmlToPdf, "Converter", rb_cObject);
  /*
  TODO
  rb_define_singleton_method(klass, "new", constructor, 1); //Uses Data_Wrap_Struct -> rb_obj_call_init(t_data, 1, argv);
  rb_define_method(klass, "initialize", initialize, 1);
  */
  rb_define_singleton_method(cWkHtmlToPdfConverter, "create", wkhtml_topdf_converter_create, 1);
  rb_define_method(cWkHtmlToPdfConverter, "add_object", wkhtml_topdf_converter_add_object, 2);
  rb_define_method(cWkHtmlToPdfConverter, "convert", wkhtml_topdf_converter_convert, 0);
  rb_define_method(cWkHtmlToPdfConverter, "http_error_code", wkhtml_topdf_converter_http_error_code, 0);
  rb_define_method(cWkHtmlToPdfConverter, "get_output", wkhtml_topdf_converter_get_output, 0);
  //Force use of factory method
  rb_undef_alloc_func(cWkHtmlToPdfConverter);
  rb_undef_method(rb_singleton_class(cWkHtmlToPdfConverter), "new");

  mWkHtmlToImage = rb_define_module_under(mWkHtml, "ToImage");

  cWkHtmlToImageGlobalSettings = rb_define_class_under(mWkHtmlToImage, "GlobalSettings", rb_cObject);
  rb_define_alloc_func(cWkHtmlToImageGlobalSettings, wkhtml_toimage_globalsettings_alloc);
  rb_define_method(cWkHtmlToImageGlobalSettings, "[]=", wkhtml_toimage_globalsettings_aset, 2);
  rb_define_method(cWkHtmlToImageGlobalSettings, "[]", wkhtml_toimage_globalsettings_aref, 1);

  cWkHtmlToImageConverter = rb_define_class_under(mWkHtmlToImage, "Converter", rb_cObject);
  rb_define_singleton_method(cWkHtmlToImageConverter, "create", wkhtml_toimage_converter_create, 2);
  rb_define_method(cWkHtmlToImageConverter, "convert", wkhtml_toimage_converter_convert, 0);
  rb_define_method(cWkHtmlToImageConverter, "http_error_code", wkhtml_toimage_converter_http_error_code, 0);
  rb_define_method(cWkHtmlToImageConverter, "get_output", wkhtml_toimage_converter_get_output, 0);
  //Force use of factory method
  rb_undef_alloc_func(cWkHtmlToImageConverter);
  rb_undef_method(rb_singleton_class(cWkHtmlToImageConverter), "new");
}

static void
add_modules(struct cmdline_options *opt, const char *mod)
{
    VALUE list = opt->req_list;

    if (!list) {
	opt->req_list = list = rb_ary_new();
	RBASIC(list)->klass = 0;
    }
    rb_ary_push(list, rb_obj_freeze(rb_str_new2(mod)));
}

// Transform#matrix
// Transform#get_matrix
// Transform#getMatrix
VALUE rbTransform::GetMatrix( VALUE aSelf )
{
	const float* values = rbMacros::ToSFML< sf::Transform >( aSelf, rbTransform::Class )->getMatrix();
	VALUE array = rb_ary_new2( 16 );
	for( unsigned int index = 0; index < 16; index++ )
	{
		rb_ary_store( array, index, rb_float_new( values[ index ] ) );
	}
	rb_obj_freeze( array );
	return array;
}