static VALUE printf_test_call(int argc, VALUE *argv, VALUE self) { VALUE opt, type, num, result; char format[sizeof(int) * 6 + 8], *p = format, cnv; int n; const char *s; rb_scan_args(argc, argv, "2:", &type, &num, &opt); Check_Type(type, T_STRING); if (RSTRING_LEN(type) != 1) rb_raise(rb_eArgError, "wrong length(%ld)", RSTRING_LEN(type)); switch (cnv = RSTRING_PTR(type)[0]) { case 'd': case 'x': case 'o': case 'X': n = NUM2INT(num); break; case 's': s = StringValueCStr(num); break; default: rb_raise(rb_eArgError, "wrong conversion(%c)", cnv); } *p++ = '%'; if (!NIL_P(opt)) { VALUE v; Check_Type(opt, T_HASH); if (RTEST(rb_hash_aref(opt, ID2SYM(rb_intern("space"))))) { *p++ = ' '; } if (RTEST(rb_hash_aref(opt, ID2SYM(rb_intern("hash"))))) { *p++ = '#'; } if (RTEST(rb_hash_aref(opt, ID2SYM(rb_intern("plus"))))) { *p++ = '+'; } if (RTEST(rb_hash_aref(opt, ID2SYM(rb_intern("minus"))))) { *p++ = '-'; } if (RTEST(rb_hash_aref(opt, ID2SYM(rb_intern("zero"))))) { *p++ = '0'; } if (!NIL_P(v = rb_hash_aref(opt, ID2SYM(rb_intern("width"))))) { p = utoa(p, format + sizeof(format), NUM2UINT(v)); } if (!NIL_P(v = rb_hash_aref(opt, ID2SYM(rb_intern("prec"))))) { *p++ = '.'; if (FIXNUM_P(v)) p = utoa(p, format + sizeof(format), NUM2UINT(v)); } } *p++ = cnv; *p++ = '\0'; if (cnv == 's') { result = rb_enc_sprintf(rb_usascii_encoding(), format, s); } else { result = rb_enc_sprintf(rb_usascii_encoding(), format, n); } return rb_assoc_new(result, rb_usascii_str_new_cstr(format)); }
static VALUE get_rowid_attr(rowid_arg_t *arg) { oci8_base_t *base = arg->base; ub4 attrtype = arg->attrtype; char buf[MAX_ROWID_LEN]; ub2 buflen; sword rv; /* get a rowid descriptor from OCIHandle */ rv = OCIDescriptorAlloc(oci8_envhp, (dvoid*)&arg->ridp, OCI_DTYPE_ROWID, 0, NULL); if (rv != OCI_SUCCESS) oci8_env_raise(oci8_envhp, rv); rv = OCIAttrGet(base->hp.ptr, base->type, arg->ridp, 0, attrtype, oci8_errhp); if (rv != OCI_SUCCESS) { oci8_raise(oci8_errhp, rv, NULL); } /* convert the rowid descriptor to a string. */ if (have_OCIRowidToChar) { /* If OCIRowidToChar is available, use it. */ buflen = MAX_ROWID_LEN; rv = OCIRowidToChar(arg->ridp, TO_ORATEXT(buf), &buflen, oci8_errhp); if (rv != OCI_SUCCESS) { oci8_raise(oci8_errhp, rv, NULL); } } else { /* If OCIRowidToChar is not available, convert it on * Oracle Server. */ oci8_base_t *svc; oci8_exec_sql_var_t define_var; oci8_exec_sql_var_t bind_var; /* search a connection from the handle */ svc = base; while (svc->type != OCI_HTYPE_SVCCTX) { svc = svc->parent; if (svc == NULL) { rb_raise(rb_eRuntimeError, "No connection is found!!"); } } /* :strval */ define_var.valuep = buf; define_var.value_sz = sizeof(buf); define_var.dty = SQLT_CHR; define_var.indp = NULL; define_var.alenp = &buflen; /* :rowid */ bind_var.valuep = &arg->ridp; bind_var.value_sz = sizeof(void *); bind_var.dty = SQLT_RDD; bind_var.indp = NULL; bind_var.alenp = NULL; /* convert the rowid descriptor to a string value by querying Oracle server. */ oci8_exec_sql((oci8_svcctx_t*)svc, "SELECT :rid FROM dual", 1, &define_var, 1, &bind_var, 1); if (buflen == 0) { return Qnil; } } return rb_external_str_new_with_enc(buf, buflen, rb_usascii_encoding()); }
/* 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; }
/* call-seq: * client.info * * Returns a string that represents the client library version. */ static VALUE rb_mysql_client_info(RB_MYSQL_UNUSED VALUE klass) { VALUE version_info, version, header_version; version_info = rb_hash_new(); version = rb_str_new2(mysql_get_client_info()); header_version = rb_str_new2(MYSQL_LINK_VERSION); #ifdef HAVE_RUBY_ENCODING_H rb_enc_associate(version, rb_usascii_encoding()); rb_enc_associate(header_version, rb_usascii_encoding()); #endif rb_hash_aset(version_info, sym_id, LONG2NUM(mysql_get_client_version())); rb_hash_aset(version_info, sym_version, version); rb_hash_aset(version_info, sym_header_version, header_version); return version_info; }
static void check_utf8_encoding(VALUE str) { #ifdef HAVE_RUBY_ENCODING_H rb_encoding *enc = rb_enc_get(str); if (enc != rb_utf8_encoding() && enc != rb_usascii_encoding()) { rb_raise(rb_eTypeError, "Input must be UTF-8 or US-ASCII, %s given", rb_enc_name(enc)); } #endif }
static VALUE syserr_initialize(int argc, VALUE *argv, VALUE self) { #if !defined(_WIN32) char *strerror(); #endif const char *err; VALUE mesg, error; VALUE klass = rb_obj_class(self); if (klass == rb_eSystemCallError) { st_data_t data = (st_data_t)klass; rb_scan_args(argc, argv, "11", &mesg, &error); if (argc == 1 && FIXNUM_P(mesg)) { error = mesg; mesg = Qnil; } if (!NIL_P(error) && st_lookup(syserr_tbl, NUM2LONG(error), &data)) { klass = (VALUE)data; /* change class */ if (TYPE(self) != T_OBJECT) { /* insurance to avoid type crash */ rb_raise(rb_eTypeError, "invalid instance type"); } RBASIC(self)->klass = klass; } } else { rb_scan_args(argc, argv, "01", &mesg); error = rb_const_get(klass, rb_intern("Errno")); } if (!NIL_P(error)) err = strerror(NUM2INT(error)); else err = "unknown error"; if (!NIL_P(mesg)) { rb_encoding *le = rb_locale_encoding(); VALUE str = mesg; StringValue(str); mesg = rb_sprintf("%s - %.*s", err, (int)RSTRING_LEN(str), RSTRING_PTR(str)); if (le == rb_usascii_encoding()) { rb_encoding *me = rb_enc_get(mesg); if (le != me && rb_enc_asciicompat(me)) le = me; }/* else assume err is non ASCII string. */ OBJ_INFECT(mesg, str); rb_enc_associate(mesg, le); } else { mesg = rb_str_new2(err); rb_enc_associate(mesg, rb_locale_encoding()); } rb_call_super(1, &mesg); rb_iv_set(self, "errno", error); return self; }
static VALUE rd_die_name(VALUE self) { rd_die_t *die = GetDie(self); char *name; Dwarf_Error err; if (chkerr2(dwarf_diename(die->die, &name, &err), &err)) { return rb_enc_str_new_cstr(name, rb_usascii_encoding()); } else { return Qnil; } }
/** * call-seq: * Krypt::Hex.encode(data) -> String * * Encodes +data+, a String, or an object allowing conversion with to_str, * in hex encoding. */ static VALUE krypt_hex_module_encode(VALUE self, VALUE data) { VALUE ret; uint8_t *bytes; size_t len; StringValue(data); len = (size_t) RSTRING_LEN((data)); bytes = (uint8_t *) RSTRING_PTR((data)); int_hex_process(bytes, len, KRYPT_HEX_ENCODE, ret); rb_enc_associate(ret, rb_usascii_encoding()); return ret; }
static VALUE rb_raise_mysql2_error(mysql_client_wrapper *wrapper) { VALUE rb_error_msg = rb_str_new2(mysql_error(wrapper->client)); VALUE rb_sql_state = rb_tainted_str_new2(mysql_sqlstate(wrapper->client)); VALUE e; #ifdef HAVE_RUBY_ENCODING_H rb_enc_associate(rb_error_msg, rb_utf8_encoding()); rb_enc_associate(rb_sql_state, rb_usascii_encoding()); #endif e = rb_funcall(cMysql2Error, rb_intern("new"), 2, rb_error_msg, LONG2FIX(wrapper->server_version)); rb_funcall(e, intern_error_number_eql, 1, UINT2NUM(mysql_errno(wrapper->client))); rb_funcall(e, intern_sql_state_eql, 1, rb_sql_state); rb_exc_raise(e); return Qnil; }
static VALUE rb_raise_mysql2_error(mysql_client_wrapper *wrapper) { VALUE rb_error_msg = rb_str_new2(mysql_error(wrapper->client)); VALUE rb_sql_state = rb_tainted_str_new2(mysql_sqlstate(wrapper->client)); VALUE e; #ifdef HAVE_RUBY_ENCODING_H rb_enc_associate(rb_error_msg, rb_utf8_encoding()); rb_enc_associate(rb_sql_state, rb_usascii_encoding()); #endif e = rb_funcall(cMysql2Error, intern_new_with_args, 4, rb_error_msg, LONG2FIX(wrapper->server_version), UINT2NUM(mysql_errno(wrapper->client)), rb_sql_state); rb_exc_raise(e); }
static void check_utf8_encoding(VALUE str) { static rb_encoding *_cached[3] = {NULL, NULL, NULL}; rb_encoding *enc; if (_cached[0] == NULL) { _cached[0] = rb_utf8_encoding(); _cached[1] = rb_usascii_encoding(); _cached[2] = rb_ascii8bit_encoding(); } enc = rb_enc_get(str); if (enc != _cached[0] && enc != _cached[1] && enc != _cached[2]) { rb_raise(rb_eEncodingCompatibilityError, "Input must be UTF-8 or US-ASCII, %s given", rb_enc_name(enc)); } }
/* * call-seq: * enc.inspect -> string * * Returns a string which represents the encoding for programmers. * * Encoding::UTF_8.inspect #=> "#<Encoding:UTF-8>" * Encoding::ISO_2022_JP.inspect #=> "#<Encoding:ISO-2022-JP (dummy)>" */ static VALUE enc_inspect(VALUE self) { rb_encoding *enc; if (!is_data_encoding(self)) { not_encoding(self); } if (!(enc = DATA_PTR(self)) || rb_enc_from_index(rb_enc_to_index(enc)) != enc) { rb_raise(rb_eTypeError, "broken Encoding"); } return rb_enc_sprintf(rb_usascii_encoding(), "#<%"PRIsVALUE":%s%s%s>", rb_obj_class(self), rb_enc_name(enc), (ENC_DUMMY_P(enc) ? " (dummy)" : ""), enc_autoload_p(enc) ? " (autoload)" : ""); }
static VALUE file_path_convert(VALUE name) { #ifndef _WIN32 /* non Windows == Unix */ rb_encoding *fname_encoding = rb_enc_from_index(ENCODING_GET(name)); rb_encoding *fs_encoding; if (rb_default_internal_encoding() != NULL && rb_usascii_encoding() != fname_encoding && rb_ascii8bit_encoding() != fname_encoding && (fs_encoding = rb_filesystem_encoding()) != fname_encoding && !rb_enc_str_asciionly_p(name)) { /* Don't call rb_filesystem_encoding() before US-ASCII and ASCII-8BIT */ /* fs_encoding should be ascii compatible */ name = rb_str_conv_enc(name, fname_encoding, fs_encoding); } #endif return name; }
/* * call-seq: * Dir.new( string ) -> aDir * * Returns a new directory object for the named directory. */ static VALUE dir_initialize(int argc, VALUE *argv, VALUE dir) { struct dir_data *dp; static rb_encoding *fs_encoding; rb_encoding *intencoding, *extencoding; VALUE dirname, opt; static VALUE sym_intenc, sym_extenc; if (!sym_intenc) { sym_intenc = ID2SYM(rb_intern("internal_encoding")); sym_extenc = ID2SYM(rb_intern("external_encoding")); fs_encoding = rb_filesystem_encoding(); } intencoding = NULL; extencoding = fs_encoding; rb_scan_args(argc, argv, "11", &dirname, &opt); if (!NIL_P(opt)) { VALUE v, extenc=Qnil, intenc=Qnil; opt = rb_check_convert_type(opt, T_HASH, "Hash", "to_hash"); v = rb_hash_aref(opt, sym_intenc); if (!NIL_P(v)) intenc = v; v = rb_hash_aref(opt, sym_extenc); if (!NIL_P(v)) extenc = v; if (!NIL_P(extenc)) { extencoding = rb_to_encoding(extenc); if (!NIL_P(intenc)) { intencoding = rb_to_encoding(intenc); if (extencoding == intencoding) { rb_warn("Ignoring internal encoding '%s': it is identical to external encoding '%s'", RSTRING_PTR(rb_inspect(intenc)), RSTRING_PTR(rb_inspect(extenc))); intencoding = NULL; } } } else if (!NIL_P(intenc)) { rb_raise(rb_eArgError, "External encoding must be specified when internal encoding is given"); } } { rb_encoding *dirname_encoding = rb_enc_get(dirname); if (rb_usascii_encoding() != dirname_encoding && rb_ascii8bit_encoding() != dirname_encoding #if defined __APPLE__ && rb_utf8_encoding() != dirname_encoding #endif && extencoding != dirname_encoding) { if (!intencoding) intencoding = dirname_encoding; dirname = rb_str_transcode(dirname, rb_enc_from_encoding(extencoding)); } } FilePathValue(dirname); Data_Get_Struct(dir, struct dir_data, dp); if (dp->dir) closedir(dp->dir); if (dp->path) xfree(dp->path); dp->dir = NULL; dp->path = NULL; dp->intenc = intencoding; dp->extenc = extencoding; dp->dir = opendir(RSTRING_PTR(dirname)); if (dp->dir == NULL) { if (errno == EMFILE || errno == ENFILE) { rb_gc(); dp->dir = opendir(RSTRING_PTR(dirname)); } if (dp->dir == NULL) { rb_sys_fail(RSTRING_PTR(dirname)); } } dp->path = strdup(RSTRING_PTR(dirname)); return dir; }
static VALUE encoding_spec_rb_usascii_encoding(VALUE self) { return rb_str_new2(rb_usascii_encoding()->name); }
static VALUE printf_test_v(VALUE self, VALUE obj) { return rb_enc_sprintf(rb_usascii_encoding(), "{%+"PRIsVALUE"}", obj); }
static VALUE printf_test_q(VALUE self, VALUE obj) { return rb_enc_sprintf(rb_usascii_encoding(), "[% "PRIsVALUE"]", obj); }