void Init_nkf() { VALUE mNKF = rb_define_module("NKF"); rb_define_module_function(mNKF, "nkf", rb_nkf_convert, 2); rb_define_module_function(mNKF, "guess", rb_nkf_guess, 1); rb_define_alias(rb_singleton_class(mNKF), "guess", "guess"); rb_define_const(mNKF, "AUTO", Qnil); rb_define_const(mNKF, "NOCONV", Qnil); rb_define_const(mNKF, "UNKNOWN", Qnil); rb_define_const(mNKF, "BINARY", rb_enc_from_encoding(rb_nkf_enc_get("BINARY"))); rb_define_const(mNKF, "ASCII", rb_enc_from_encoding(rb_nkf_enc_get("US-ASCII"))); rb_define_const(mNKF, "JIS", rb_enc_from_encoding(rb_nkf_enc_get("ISO-2022-JP"))); rb_define_const(mNKF, "EUC", rb_enc_from_encoding(rb_nkf_enc_get("EUC-JP"))); rb_define_const(mNKF, "SJIS", rb_enc_from_encoding(rb_nkf_enc_get("Shift_JIS"))); rb_define_const(mNKF, "UTF8", rb_enc_from_encoding(rb_utf8_encoding())); rb_define_const(mNKF, "UTF16", rb_enc_from_encoding(rb_nkf_enc_get("UTF-16BE"))); rb_define_const(mNKF, "UTF32", rb_enc_from_encoding(rb_nkf_enc_get("UTF-32BE"))); /* Full version string of nkf */ rb_define_const(mNKF, "VERSION", rb_str_new2(RUBY_NKF_VERSION)); /* Version of nkf */ rb_define_const(mNKF, "NKF_VERSION", rb_str_new2(NKF_VERSION)); /* Release date of nkf */ rb_define_const(mNKF, "NKF_RELEASE_DATE", rb_str_new2(NKF_RELEASE_DATE)); }
void registerEnc(wxFontEncoding enc,const char* name) { rb_encoding *rb_enc = rb_enc_find(name); if(rb_enc) encodingholder[enc]=rb_enc_from_encoding(rb_enc); }
static inline VALUE get_user_from_path(wchar_t **wpath, int offset, UINT cp, UINT path_cp, rb_encoding *path_encoding) { VALUE result, tmp; wchar_t *wuser = *wpath + offset; wchar_t *pos = wuser; char *user; size_t size; while (!IS_DIR_SEPARATOR_P(*pos) && *pos != '\0') pos++; *pos = '\0'; convert_wchar_to_mb(wuser, &user, &size, cp); /* convert to VALUE and set the path encoding */ if (path_cp == INVALID_CODE_PAGE) { tmp = rb_enc_str_new(user, size, rb_utf8_encoding()); result = rb_str_encode(tmp, rb_enc_from_encoding(path_encoding), 0, Qnil); rb_str_resize(tmp, 0); } else { result = rb_enc_str_new(user, size, path_encoding); } if (user) xfree(user); return result; }
static VALUE set_charset_name(VALUE self, VALUE value) { char *charset_name; #ifdef HAVE_RUBY_ENCODING_H const struct mysql2_mysql_enc_name_to_rb_map *mysql2rb; rb_encoding *enc; VALUE rb_enc; #endif GET_CLIENT(self); charset_name = RSTRING_PTR(value); #ifdef HAVE_RUBY_ENCODING_H mysql2rb = mysql2_mysql_enc_name_to_rb(charset_name, (unsigned int)RSTRING_LEN(value)); if (mysql2rb == NULL || mysql2rb->rb_name == NULL) { VALUE inspect = rb_inspect(value); rb_raise(cMysql2Error, "Unsupported charset: '%s'", RSTRING_PTR(inspect)); } else { enc = rb_enc_find(mysql2rb->rb_name); rb_enc = rb_enc_from_encoding(enc); wrapper->encoding = rb_enc; } #endif if (mysql_options(wrapper->client, MYSQL_SET_CHARSET_NAME, charset_name)) { /* TODO: warning - unable to set charset */ rb_warn("%s\n", mysql_error(wrapper->client)); } return value; }
static VALUE encoding_spec_rb_enc_compatible(VALUE self, VALUE a, VALUE b) { rb_encoding* enc = rb_enc_compatible(a, b); if(!enc) return INT2FIX(0); return rb_enc_from_encoding(enc); }
int eruta_ruby_init() { VALUE options = Qnil, sublet = Qnil; void Init_prelude(void); RUBY_INIT_STACK; ruby_init(); ruby_init_loadpath(); ruby_script("eruta"); #ifdef HAVE_RB_ENC_SET_DEFAULT_INTERNAL { VALUE encoding = Qnil; /* FIXME: Fix for ruby 1.9.2p429 borrowed from ruby? */ (void)rb_filesystem_encoding(); /* Set encoding */ encoding = rb_enc_from_encoding(rb_locale_encoding()); rb_enc_set_default_external(encoding); } #endif /* HAVE_RB_ENC_SET_DEFAULT_INTERNAL */ /* FIXME: Fake ruby_init_gems(Qtrue) */ rb_define_module("Gem"); Init_prelude(); /* Bypassing garbage collection. Why? */ /* shelter = rb_ary_new(); rb_gc_register_address(&shelter); */ }
static VALUE rb_tinytds_encoding(VALUE self) { GET_CLIENT_WRAPPER(self); #ifdef HAVE_RUBY_ENCODING_H return rb_enc_from_encoding(cwrap->encoding); #else return Qnil; #endif }
/* Return code page number of the encoding. Cache code page into a hash for performance since finding the code page in Encoding#names is slow. */ static UINT code_page(rb_encoding *enc) { VALUE code_page_value, name_key; VALUE encoding, names_ary = Qundef, name; char *enc_name; struct RString fake_str; ID names; long i; if (!enc) return system_code_page(); enc_name = (char *)rb_enc_name(enc); fake_str.basic.flags = T_STRING|RSTRING_NOEMBED; fake_str.basic.klass = rb_cString; fake_str.as.heap.len = strlen(enc_name); fake_str.as.heap.ptr = enc_name; fake_str.as.heap.aux.capa = fake_str.as.heap.len; name_key = (VALUE)&fake_str; ENCODING_CODERANGE_SET(name_key, rb_usascii_encindex(), ENC_CODERANGE_7BIT); code_page_value = rb_hash_lookup(rb_code_page, name_key); if (code_page_value != Qnil) return (UINT)FIX2INT(code_page_value); name_key = rb_usascii_str_new2(enc_name); encoding = rb_enc_from_encoding(enc); if (!NIL_P(encoding)) { CONST_ID(names, "names"); names_ary = rb_funcall(encoding, names, 0); } /* map US-ASCII and ASCII-8bit as code page 1252 (us-ascii) */ if (enc == rb_usascii_encoding() || enc == rb_ascii8bit_encoding()) { UINT code_page = 1252; rb_hash_aset(rb_code_page, name_key, INT2FIX(code_page)); return code_page; } if (names_ary != Qundef) { for (i = 0; i < RARRAY_LEN(names_ary); i++) { name = RARRAY_PTR(names_ary)[i]; if (strncmp("CP", RSTRING_PTR(name), 2) == 0) { int code_page = atoi(RSTRING_PTR(name) + 2); if (code_page != 0) { rb_hash_aset(rb_code_page, name_key, INT2FIX(code_page)); return (UINT)code_page; } } } } rb_hash_aset(rb_code_page, name_key, INT2FIX(INVALID_CODE_PAGE)); return INVALID_CODE_PAGE; }
static void mriBindingExecute() { /* Normally only a ruby executable would do a sysinit, * but not doing it will lead to crashes due to closed * stdio streams on some platforms (eg. Windows) */ int argc = 0; char **argv = 0; ruby_sysinit(&argc, &argv); ruby_setup(); rb_enc_set_default_external(rb_enc_from_encoding(rb_utf8_encoding())); Config &conf = shState->rtData().config; if (!conf.rubyLoadpaths.empty()) { /* Setup custom load paths */ VALUE lpaths = rb_gv_get(":"); for (size_t i = 0; i < conf.rubyLoadpaths.size(); ++i) { std::string &path = conf.rubyLoadpaths[i]; VALUE pathv = rb_str_new(path.c_str(), path.size()); rb_ary_push(lpaths, pathv); } } RbData rbData; shState->setBindingData(&rbData); BacktraceData btData; mriBindingInit(); STEAMSHIM_init(); _rb_define_module_function(rb_mKernel, "_steam_achievement_unlock", _steamAchievementUnlock); std::string &customScript = conf.customScript; if (!customScript.empty()) runCustomScript(customScript); else runRMXPScripts(btData); VALUE exc = rb_errinfo(); if (!NIL_P(exc) && !rb_obj_is_kind_of(exc, rb_eSystemExit)) showExc(exc, btData); ruby_cleanup(0); STEAMSHIM_deinit(); shState->rtData().rqTermAck.set(); }
VALUE rb_obj_encoding(VALUE obj) { rb_encoding *enc = rb_enc_get(obj); if (!enc) { rb_raise(rb_eTypeError, "unknown encoding"); } return rb_enc_from_encoding(enc); }
static VALUE dir_enc_str(VALUE str, struct dir_data *dirp) { rb_enc_associate(str, dirp->extenc); if (dirp->intenc) { str = rb_str_transcode(str, rb_enc_from_encoding(dirp->intenc)); } return str; }
/* Return code page number of the encoding. Cache code page into a hash for performance since finding the code page in Encoding#names is slow. */ static UINT fenix_code_page(rb_encoding *enc) { VALUE code_page_value, name_key; VALUE encoding, names_ary = Qundef, name; char *enc_name; struct RString fake_str; ID names; long i; if (!enc) return system_code_page(); enc_name = (char *)rb_enc_name(enc); fake_str.basic.flags = T_STRING|RSTRING_NOEMBED; fake_str.basic.klass = rb_cString; fake_str.as.heap.len = strlen(enc_name); fake_str.as.heap.ptr = enc_name; fake_str.as.heap.aux.capa = fake_str.as.heap.len; name_key = (VALUE)&fake_str; ENCODING_CODERANGE_SET(name_key, rb_usascii_encindex(), ENC_CODERANGE_7BIT); OBJ_FREEZE(name_key); code_page_value = rb_hash_lookup(rb_code_page, name_key); if (code_page_value != Qnil) { // printf("cached code page: %i\n", FIX2INT(code_page_value)); if (FIX2INT(code_page_value) == -1) { return system_code_page(); } else { return (UINT)FIX2INT(code_page_value); } } name_key = rb_usascii_str_new2(enc_name); encoding = rb_enc_from_encoding(enc); if (!NIL_P(encoding)) { CONST_ID(names, "names"); names_ary = rb_funcall(encoding, names, 0); } if (names_ary != Qundef) { for (i = 0; i < RARRAY_LEN(names_ary); i++) { name = RARRAY_PTR(names_ary)[i]; if (strncmp("CP", RSTRING_PTR(name), 2) == 0) { int code_page = atoi(RSTRING_PTR(name) + 2); rb_hash_aset(rb_code_page, name_key, INT2FIX(code_page)); return (UINT)code_page; } } } rb_hash_aset(rb_code_page, name_key, INT2FIX(-1)); return system_code_page(); }
static inline VALUE fix_string_encoding(VALUE str, rb_encoding *encoding) { VALUE result, tmp; tmp = rb_enc_str_new(RSTRING_PTR(str), RSTRING_LEN(str), encoding); result = rb_str_encode(tmp, rb_enc_from_encoding(rb_utf8_encoding()), 0, Qnil); return result; }
static int enc_cb(void * _self, int UNUSED(columns), char **data, char **UNUSED(names)) { VALUE self = (VALUE)_self; int index = rb_enc_find_index(data[0]); rb_encoding * e = rb_enc_from_index(index); rb_iv_set(self, "@encoding", rb_enc_from_encoding(e)); return 0; }
/* * call-seq: * Encoding.compatible?(str1, str2) -> enc or nil * * Checks the compatibility of two strings. * If they are compatible, means concatenatable, * returns an encoding which the concatenated string will be. * If they are not compatible, nil is returned. * * Encoding.compatible?("\xa1".force_encoding("iso-8859-1"), "b") * #=> #<Encoding:ISO-8859-1> * * Encoding.compatible?( * "\xa1".force_encoding("iso-8859-1"), * "\xa1\xa1".force_encoding("euc-jp")) * #=> nil * */ static VALUE enc_compatible_p(VALUE klass, VALUE str1, VALUE str2) { rb_encoding *enc; if (!enc_capable(str1)) return Qnil; if (!enc_capable(str2)) return Qnil; enc = rb_enc_compatible(str1, str2); if (!enc) return Qnil; return rb_enc_from_encoding(enc); }
static VALUE rxml_document_rb_encoding_get(VALUE self) { xmlDocPtr xdoc; const char *xencoding; rb_encoding* rbencoding; Data_Get_Struct(self, xmlDoc, xdoc); xencoding = (const char*)xdoc->encoding; rbencoding = rxml_xml_encoding_to_rb_encoding(mXMLEncoding, xmlParseCharEncoding(xencoding)); return rb_enc_from_encoding(rbencoding); }
static VALUE pg_tmir_copy_get( t_typemap *p_typemap, VALUE field_str, int fieldno, int format, int enc_idx ) { t_tmir *this = (t_tmir *) p_typemap; rb_encoding *p_encoding = rb_enc_from_index(enc_idx); VALUE enc = rb_enc_from_encoding(p_encoding); /* field_str is reused in-place by pg_text_dec_copy_row(), so we need to make * a copy of the string buffer for use in ruby space. */ VALUE field_str_copy = rb_str_dup(field_str); rb_str_modify(field_str_copy); return rb_funcall( this->self, s_id_typecast_copy_get, 4, field_str_copy, INT2NUM(fieldno), INT2NUM(format), enc ); }
VALUE rb_grn_context_rb_string_encode (grn_ctx *context, VALUE rb_string) { #ifdef HAVE_RUBY_ENCODING_H rb_encoding *encoding, *to_encode; encoding = rb_enc_get(rb_string); to_encode = rb_grn_encoding_to_ruby_encoding(context->encoding); if (rb_enc_to_index(encoding) != rb_enc_to_index(to_encode)) rb_string = rb_str_encode(rb_string, rb_enc_from_encoding(to_encode), 0, Qnil); #endif return rb_string; }
static void set_encoding_const(const char *name, rb_encoding *enc) { VALUE encoding = rb_enc_from_encoding(enc); char *s = (char *)name; int haslower = 0, hasupper = 0, valid = 0; if (ISDIGIT(*s)) return; if (ISUPPER(*s)) { hasupper = 1; while (*++s && (ISALNUM(*s) || *s == '_')) { if (ISLOWER(*s)) haslower = 1; } } if (!*s) { if (s - name > ENCODING_NAMELEN_MAX) return; valid = 1; rb_define_const(rb_cEncoding, name, encoding); } if (!valid || haslower) { size_t len = s - name; if (len > ENCODING_NAMELEN_MAX) return; if (!haslower || !hasupper) { do { if (ISLOWER(*s)) haslower = 1; if (ISUPPER(*s)) hasupper = 1; } while (*++s && (!haslower || !hasupper)); len = s - name; } len += strlen(s); if (len++ > ENCODING_NAMELEN_MAX) return; MEMCPY(s = ALLOCA_N(char, len), name, char, len); name = s; if (!valid) { if (ISLOWER(*s)) *s = ONIGENC_ASCII_CODE_TO_UPPER_CASE((int)*s); for (; *s; ++s) { if (!ISALNUM(*s)) *s = '_'; } if (hasupper) { rb_define_const(rb_cEncoding, name, encoding); } } if (haslower) { for (s = (char *)name; *s; ++s) { if (ISLOWER(*s)) *s = ONIGENC_ASCII_CODE_TO_UPPER_CASE((int)*s); } rb_define_const(rb_cEncoding, name, encoding); } }
/** * 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); }
static VALUE pg_tmir_copy_get( t_typemap *p_typemap, VALUE field_str, int fieldno, int format, int enc_idx ) { t_tmir *this = (t_tmir *) p_typemap; rb_encoding *p_encoding = rb_enc_from_index(enc_idx); VALUE enc = rb_enc_from_encoding(p_encoding); /* field_str is reused in-place by pg_text_dec_copy_row(), so we need to make * a copy of the string buffer before used in ruby space. * This requires rb_str_new() instead of rb_str_dup() for Rubinius. */ VALUE field_str_copy = rb_str_new(RSTRING_PTR(field_str), RSTRING_LEN(field_str)); PG_ENCODING_SET_NOCHECK(field_str_copy, ENCODING_GET(field_str)); OBJ_INFECT(field_str_copy, field_str); return rb_funcall( this->self, s_id_typecast_copy_get, 4, field_str_copy, INT2NUM(fieldno), INT2NUM(format), enc ); }
static VALUE rb_nkf_guess(VALUE obj, VALUE src) { reinit(); input_ctr = 0; StringValue(src); input = (unsigned char *)RSTRING_PTR(src); i_len = RSTRING_LEN(src); guess_f = TRUE; kanji_convert( NULL ); guess_f = FALSE; return rb_enc_from_encoding(rb_nkf_enc_get(get_guessed_code())); }
static int pg_text_enc_in_ruby(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate, int enc_idx) { int arity = rb_obj_method_arity(conv->coder_obj, s_id_encode); if( arity == 1 ){ VALUE out_str = rb_funcall( conv->coder_obj, s_id_encode, 1, value ); StringValue( out_str ); *intermediate = rb_str_export_to_enc(out_str, rb_enc_from_index(enc_idx)); }else{ VALUE enc = rb_enc_from_encoding(rb_enc_from_index(enc_idx)); VALUE out_str = rb_funcall( conv->coder_obj, s_id_encode, 2, value, enc ); StringValue( out_str ); *intermediate = out_str; } return -1; }
wxFontEncoding unwrapenum< wxFontEncoding >(const VALUE &venc) { VALUE tmp = venc; if(rb_obj_is_kind_of(tmp,rb_cString)) { rb_encoding *rb_enc = rb_enc_find(unwrap<char*>(tmp)); if(rb_enc) tmp = rb_enc_from_encoding(rb_enc); else return wxFONTENCODING_DEFAULT; } for(encodingholdertype::iterator it = encodingholder.begin();it != encodingholder.end();++it) { if(it->second == tmp) return it->first; } return wxFONTENCODING_DEFAULT; }
VALUE native_slot_encode_and_freeze_string(upb_fieldtype_t type, VALUE value) { rb_encoding* desired_encoding = (type == UPB_TYPE_STRING) ? kRubyStringUtf8Encoding : kRubyString8bitEncoding; VALUE desired_encoding_value = rb_enc_from_encoding(desired_encoding); // Note: this will not duplicate underlying string data unless necessary. value = rb_str_encode(value, desired_encoding_value, 0, Qnil); if (type == UPB_TYPE_STRING && rb_enc_str_coderange(value) == ENC_CODERANGE_BROKEN) { rb_raise(rb_eEncodingError, "String is invalid UTF-8"); } // Ensure the data remains valid. Since we called #encode a moment ago, // this does not freeze the string the user assigned. rb_obj_freeze(value); return value; }
/* call-seq: default_options() => Hash * * Returns the default load and dump options as a Hash. The options are * - indent: [Fixnum] number of spaces to indent each element in an JSON document * - encoding: [String|Encoding] character encoding for the JSON coument * - circular: [true|false|nil] support circular references while dumping * - auto_define: [true|false|nil] automatically define classes if they do not exist * - symbol_keys: [true|false|nil] use symbols instead of strings for hash keys * - mode: [:object|:strict|:compat|:null] load and dump modes to use for JSON * @return [Hash] all current option settings. */ static VALUE get_def_opts(VALUE self) { VALUE opts = rb_hash_new(); #ifdef HAVE_RUBY_ENCODING_H rb_hash_aset(opts, encoding_sym, (0 == oj_default_options.encoding) ? Qnil : rb_enc_from_encoding(oj_default_options.encoding)); #endif rb_hash_aset(opts, indent_sym, INT2FIX(oj_default_options.indent)); rb_hash_aset(opts, circular_sym, (Yes == oj_default_options.circular) ? Qtrue : ((No == oj_default_options.circular) ? Qfalse : Qnil)); rb_hash_aset(opts, auto_define_sym, (Yes == oj_default_options.auto_define) ? Qtrue : ((No == oj_default_options.auto_define) ? Qfalse : Qnil)); rb_hash_aset(opts, ascii_only_sym, (Yes == oj_default_options.ascii_only) ? Qtrue : ((No == oj_default_options.ascii_only) ? Qfalse : Qnil)); rb_hash_aset(opts, symbol_keys_sym, (Yes == oj_default_options.sym_key) ? Qtrue : ((No == oj_default_options.sym_key) ? Qfalse : Qnil)); switch (oj_default_options.mode) { case StrictMode: rb_hash_aset(opts, mode_sym, strict_sym); break; case CompatMode: rb_hash_aset(opts, mode_sym, compat_sym); break; case NullMode: rb_hash_aset(opts, mode_sym, null_sym); break; case ObjectMode: default: rb_hash_aset(opts, mode_sym, object_sym); break; } return opts; }
/* * TermInfo.wcswidth(str) * * TermInfo.wcswidth returns a the number of columns of str, * according to current locale. */ static VALUE rt_wcswidth(VALUE self, VALUE str) { char *s; size_t l, r; mbstate_t mbs; wchar_t wc; long cols; int width; #ifdef HAVE_RUBY_ENCODING_H /* The encoding of str is assumed to be the locale encoding on Ruby 1.8. */ str = rb_str_encode(str, rb_enc_from_encoding(rb_locale_encoding()), 0, Qnil); #endif memset(&mbs,0,sizeof(mbstate_t)); s = StringValueCStr(str); l = RSTRING_LEN(str); cols = 0; while (0 < l) { r = mbrtowc(&wc, s, l, &mbs); if (r == 0) rb_raise(rb_eArgError, "NUL found"); width = wcwidth(wc); if (width == -1) rb_raise(rb_eArgError, "non-printable charactor found"); cols += width; l -= r; s += r; } return LONG2NUM(cols); }
static void mriBindingExecute() { ruby_setup(); rb_enc_set_default_external(rb_enc_from_encoding(rb_utf8_encoding())); RbData rbData; shState->setBindingData(&rbData); mriBindingInit(); std::string &customScript = shState->rtData().config.customScript; if (!customScript.empty()) runCustomScript(customScript); else runRMXPScripts(); VALUE exc = rb_errinfo(); if (!NIL_P(exc) && !rb_obj_is_kind_of(exc, rb_eSystemExit)) showExc(exc); ruby_cleanup(0); shState->rtData().rqTermAck = true; }
VALUE rb_enc_default_external(void) { return rb_enc_from_encoding(rb_default_external_encoding()); }
VALUE rb_enc_default_internal(void) { /* Note: These functions cope with default_internal not being set */ return rb_enc_from_encoding(rb_default_internal_encoding()); }