/*
* call-seq:
* Encoding.locale_charmap -> string
*
* Returns the locale charmap name.
* It returns nil if no appropriate information.
*
* Debian GNU/Linux
* LANG=C
* Encoding.locale_charmap #=> "ANSI_X3.4-1968"
* LANG=ja_JP.EUC-JP
* Encoding.locale_charmap #=> "EUC-JP"
*
* SunOS 5
* LANG=C
* Encoding.locale_charmap #=> "646"
* LANG=ja
* Encoding.locale_charmap #=> "eucJP"
*
* The result is highly platform dependent.
* So Encoding.find(Encoding.locale_charmap) may cause an error.
* If you need some encoding object even for unknown locale,
* Encoding.find("locale") can be used.
*
*/
VALUE
rb_locale_charmap(VALUE klass)
{
#if defined NO_LOCALE_CHARMAP
return rb_usascii_str_new2("ASCII-8BIT");
#elif defined _WIN32 || defined __CYGWIN__
const char *codeset = 0;
char cp[sizeof(int) * 3 + 4];
# ifdef __CYGWIN__
const char *nl_langinfo_codeset(void);
codeset = nl_langinfo_codeset();
# endif
if (!codeset) {
UINT codepage = GetConsoleCP();
if (!codepage) codepage = GetACP();
snprintf(cp, sizeof(cp), "CP%d", codepage);
codeset = cp;
}
return rb_usascii_str_new2(codeset);
#elif defined HAVE_LANGINFO_H
char *codeset;
codeset = nl_langinfo(CODESET);
return rb_usascii_str_new2(codeset);
#else
return Qnil;
#endif
}
static void
make_patterns(void)
{
static const char comp_pat0_source[] = PATTERN0;
static const char comp_pat1_source[] = PATTERN1;
static const char comp_pat2_source[] = PATTERN2;
static const char underscores_pat_source[] = "_+";
if (comp_pat0) return;
comp_pat0 = rb_reg_new(comp_pat0_source, sizeof comp_pat0_source - 1, 0);
rb_gc_register_mark_object(comp_pat0);
comp_pat1 = rb_reg_new(comp_pat1_source, sizeof comp_pat1_source - 1, 0);
rb_gc_register_mark_object(comp_pat1);
comp_pat2 = rb_reg_new(comp_pat2_source, sizeof comp_pat2_source - 1, 0);
rb_gc_register_mark_object(comp_pat2);
a_slash = rb_usascii_str_new2("/");
rb_gc_register_mark_object(a_slash);
a_dot_and_an_e = rb_usascii_str_new2(".eE");
rb_gc_register_mark_object(a_dot_and_an_e);
null_string = rb_usascii_str_new2("");
rb_gc_register_mark_object(null_string);
underscores_pat = rb_reg_new(underscores_pat_source,
sizeof underscores_pat_source - 1, 0);
rb_gc_register_mark_object(underscores_pat);
an_underscore = rb_usascii_str_new2("_");
rb_gc_register_mark_object(an_underscore);
}
static VALUE
mr_enc_names(VALUE self, SEL sel)
{
rb_encoding_t *encoding = RENC(self);
VALUE ary = rb_ary_new2(encoding->aliases_count + 1);
rb_ary_push(ary, rb_usascii_str_new2(encoding->public_name));
for (unsigned int i = 0; i < encoding->aliases_count; ++i) {
rb_ary_push(ary, rb_usascii_str_new2(encoding->aliases[i]));
}
return ary;
}
static VALUE
mr_enc_s_aliases(VALUE klass, SEL sel)
{
VALUE hash = rb_hash_new();
for (unsigned int i = 0; i < ENCODINGS_COUNT; ++i) {
rb_encoding_t *encoding = RENC(rb_encodings[i]);
for (unsigned int j = 0; j < encoding->aliases_count; ++j) {
rb_hash_aset(hash, rb_usascii_str_new2(encoding->aliases[j]),
rb_usascii_str_new2(encoding->public_name));
}
}
return hash;
}
static VALUE
mr_enc_s_name_list(VALUE klass, SEL sel)
{
VALUE ary = rb_ary_new();
for (unsigned int i = 0; i < ENCODINGS_COUNT; ++i) {
rb_encoding_t *encoding = RENC(rb_encodings[i]);
// TODO: use US-ASCII strings
rb_ary_push(ary, rb_usascii_str_new2(encoding->public_name));
for (unsigned int j = 0; j < encoding->aliases_count; ++j) {
rb_ary_push(ary, rb_usascii_str_new2(encoding->aliases[j]));
}
}
return ary;
}
static VALUE make_exception(yaml_parser_t * parser, VALUE path)
{
size_t line, column;
line = parser->context_mark.line + 1;
column = parser->context_mark.column + 1;
return rb_funcall(ePsychSyntaxError, rb_intern("new"), 6,
path,
INT2NUM(line),
INT2NUM(column),
INT2NUM(parser->problem_offset),
parser->problem ? rb_usascii_str_new2(parser->problem) : Qnil,
parser->context ? rb_usascii_str_new2(parser->context) : Qnil);
}
static VALUE setup_plruby_oracle(plruby_context_t *ctx)
{
ub2 id;
char name[OCI_NLS_MAXBUFSZ];
VALUE mPLRubyOracle;
VALUE enc;
chk(OCIAttrGet(ctx->envhp, OCI_HTYPE_ENV, &id, NULL, OCI_ATTR_ENV_CHARSET_ID, ctx->errhp));
OCINlsCharSetIdToName(ctx->envhp, (text*)name, sizeof(name), id);
trace(ctx, 1, "before requre 'plruby_oracle'");
rb_require("plruby_oracle");
trace(ctx, 1, "before eval('PLRubyOracle')");
mPLRubyOracle = rb_eval_string("PLRubyOracle");
trace(ctx, 2, "rb_eval_string(\"PLRubyOracle\") => %p", mPLRubyOracle);
trace(ctx, 1, "before PLRubyOracle.init('%s')", name);
rb_funcall(mPLRubyOracle, rb_intern("init"), 1, rb_usascii_str_new2(name));
enc = rb_cv_get(mPLRubyOracle, "@@encoding");
trace(ctx, 2, "rb_cv_get(mPLRubyOracle, \"@@encoding\") => %s", StringValueCStr(enc));
oracle_encoding = rb_to_encoding(enc);
trace(ctx, 2, "rb_enc_get(enc) => %s", rb_enc_name(oracle_encoding));
return Qnil;
}
static VALUE
printf_test_i(VALUE self, VALUE obj)
{
char buf[256];
snprintf(buf, sizeof(buf), "<%"PRIsVALUE">", obj);
return rb_usascii_str_new2(buf);
}
static void
make_patterns(void)
{
static const char rat_pat_source[] = PATTERN;
static const char an_e_pat_source[] = "[eE]";
static const char a_dot_pat_source[] = "\\.";
static const char underscores_pat_source[] = "_+";
if (rat_pat) return;
rat_pat = rb_reg_new(rat_pat_source, sizeof rat_pat_source - 1, 0);
rb_global_variable(&rat_pat);
// rb_gc_register_mark_object(rat_pat);
an_e_pat = rb_reg_new(an_e_pat_source, sizeof an_e_pat_source - 1, 0);
rb_global_variable(&an_e_pat);
// rb_gc_register_mark_object(an_e_pat);
a_dot_pat = rb_reg_new(a_dot_pat_source, sizeof a_dot_pat_source - 1, 0);
rb_global_variable(&a_dot_pat);
// rb_gc_register_mark_object(a_dot_pat);
underscores_pat = rb_reg_new(underscores_pat_source,
sizeof underscores_pat_source - 1, 0);
rb_global_variable(&underscores_pat);
// rb_gc_register_mark_object(underscores_pat);
an_underscore = rb_usascii_str_new2("_");
rb_global_variable(&an_underscore);
// rb_gc_register_mark_object(an_underscore);
}
static VALUE
rhash_inspect(VALUE hash, SEL sel)
{
if (RHASH_EMPTY_P(hash)) {
return rb_usascii_str_new2("{}");
}
return rb_exec_recursive(inspect_hash, hash, 0);
}
/*
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;
}
/*
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();
}
/*
* call-seq:
* rat.inspect -> string
*
* Returns the value as a string for inspection.
*
* For example:
*
* Rational(2).inspect #=> "(2/1)"
* Rational(-8, 6).inspect #=> "(-4/3)"
* Rational('0.5').inspect #=> "(1/2)"
*/
static VALUE
nurat_inspect(VALUE self, SEL sel)
{
VALUE s;
s = rb_usascii_str_new2("(");
rb_str_concat(s, f_format(self, f_inspect));
rb_str_cat2(s, ")");
return s;
}
/*
* call-seq:
* cmp.inspect -> string
*
* Returns the value as a string for inspection.
*
* Complex(2).inspect #=> "(2+0i)"
* Complex('-8/6').inspect #=> "((-4/3)+0i)"
* Complex('1/2i').inspect #=> "(0+(1/2)*i)"
* Complex(0, Float::INFINITY).inspect #=> "(0+Infinity*i)"
* Complex(Float::NAN, Float::NAN).inspect #=> "(NaN+NaN*i)"
*/
static VALUE
nucomp_inspect(VALUE self)
{
VALUE s;
s = rb_usascii_str_new2("(");
rb_str_concat(s, f_format(self, rb_inspect));
rb_str_cat2(s, ")");
return s;
}
static int
enc_names_i(st_data_t name, st_data_t idx, st_data_t args)
{
VALUE *arg = (VALUE *)args;
if ((int)idx == (int)arg[0]) {
VALUE str = rb_usascii_str_new2((char *)name);
OBJ_FREEZE(str);
rb_ary_push(arg[1], str);
}
return ST_CONTINUE;
}
static VALUE
inspect_hash(VALUE hash, VALUE dummy, int recur)
{
if (recur) {
return rb_usascii_str_new2("{...}");
}
VALUE str = rb_str_buf_new2("{");
rhash_foreach(hash, inspect_i, str);
rb_str_buf_cat2(str, "}");
OBJ_INFECT(str, hash);
return str;
}
static void
keyword_error(const char *error, VALUE keys)
{
const char *msg = "";
if (RARRAY_LEN(keys) == 1) {
keys = RARRAY_AREF(keys, 0);
}
else {
keys = rb_ary_join(keys, rb_usascii_str_new2(", "));
msg = "s";
}
rb_raise(rb_eArgError, "%s keyword%s: %"PRIsVALUE, error, msg, keys);
}
static VALUE
string_to_c_internal(VALUE self)
{
VALUE s;
s = self;
if (RSTRING_LEN(s) == 0)
return rb_assoc_new(Qnil, self);
{
VALUE m, sr, si, re, r, i;
int po;
m = f_match(comp_pat0, s);
if (!NIL_P(m)) {
sr = f_aref(m, INT2FIX(1));
si = f_aref(m, INT2FIX(2));
re = f_post_match(m);
po = 1;
}
if (NIL_P(m)) {
m = f_match(comp_pat1, s);
if (!NIL_P(m)) {
sr = Qnil;
si = f_aref(m, INT2FIX(1));
if (NIL_P(si))
si = rb_usascii_str_new2("");
{
VALUE t;
t = f_aref(m, INT2FIX(2));
if (NIL_P(t))
t = rb_usascii_str_new2("1");
rb_str_concat(si, t);
}
re = f_post_match(m);
po = 0;
}
}
if (NIL_P(m)) {
m = f_match(comp_pat2, s);
if (NIL_P(m))
return rb_assoc_new(Qnil, self);
sr = f_aref(m, INT2FIX(1));
if (NIL_P(f_aref(m, INT2FIX(2))))
si = Qnil;
else {
VALUE t;
si = f_aref(m, INT2FIX(3));
t = f_aref(m, INT2FIX(4));
if (NIL_P(t))
t = rb_usascii_str_new2("1");
rb_str_concat(si, t);
}
re = f_post_match(m);
po = 0;
}
r = INT2FIX(0);
i = INT2FIX(0);
if (!NIL_P(sr)) {
if (f_include_p(sr, a_slash))
r = f_to_r(sr);
else if (f_gt_p(f_count(sr, a_dot_and_an_e), INT2FIX(0)))
r = f_to_f(sr);
else
r = f_to_i(sr);
}
if (!NIL_P(si)) {
if (f_include_p(si, a_slash))
i = f_to_r(si);
else if (f_gt_p(f_count(si, a_dot_and_an_e), INT2FIX(0)))
i = f_to_f(si);
else
i = f_to_i(si);
}
if (po)
return rb_assoc_new(rb_complex_polar(r, i), re);
else
return rb_assoc_new(rb_complex_new2(r, i), re);
}
}
VALUE
rb_enc_name2(rb_encoding_t *enc)
{
return rb_usascii_str_new2(rb_enc_name(enc));
}
static VALUE
string_to_r_internal(VALUE self)
{
VALUE s, m;
s = self;
if (RSTRING_LEN(s) == 0)
return rb_assoc_new(Qnil, self);
m = f_match(rat_pat, s);
if (!NIL_P(m)) {
VALUE v, ifp, exp, ip, fp;
VALUE si = f_aref(m, INT2FIX(1));
VALUE nu = f_aref(m, INT2FIX(2));
VALUE de = f_aref(m, INT2FIX(3));
VALUE re = f_post_match(m);
{
VALUE a;
a = f_split(nu, an_e_pat);
ifp = RARRAY_PTR(a)[0];
if (RARRAY_LEN(a) != 2)
exp = Qnil;
else
exp = RARRAY_PTR(a)[1];
a = f_split(ifp, a_dot_pat);
ip = RARRAY_PTR(a)[0];
if (RARRAY_LEN(a) != 2)
fp = Qnil;
else
fp = RARRAY_PTR(a)[1];
}
v = rb_rational_new1(f_to_i(ip));
if (!NIL_P(fp)) {
char *p = StringValuePtr(fp);
long count = 0;
VALUE l;
while (*p) {
if (rb_isdigit(*p))
count++;
p++;
}
l = f_expt(INT2FIX(10), LONG2NUM(count));
v = f_mul(v, l);
v = f_add(v, f_to_i(fp));
v = f_div(v, l);
}
if (!NIL_P(si) && *StringValuePtr(si) == '-')
v = f_negate(v);
if (!NIL_P(exp))
v = f_mul(v, f_expt(INT2FIX(10), f_to_i(exp)));
#if 0
if (!NIL_P(de) && (!NIL_P(fp) || !NIL_P(exp)))
return rb_assoc_new(v, rb_usascii_str_new2("dummy"));
#endif
if (!NIL_P(de))
v = f_div(v, f_to_i(de));
return rb_assoc_new(v, re);
}
return rb_assoc_new(Qnil, self);
}
static VALUE
mr_enc_name(VALUE self, SEL sel)
{
return rb_usascii_str_new2(RENC(self)->public_name);
}
void
rb_provide(const char *feature)
{
rb_provide_feature(rb_usascii_str_new2(feature));
}
/*
* call-seq:
* enc.name -> string
*
* Returns the name of the encoding.
*
* Encoding::UTF_8.name #=> "UTF-8"
*/
static VALUE
enc_name(VALUE self)
{
return rb_usascii_str_new2(rb_enc_name((rb_encoding*)DATA_PTR(self)));
}
static VALUE
string_to_c_internal(VALUE self)
{
VALUE s;
s = self;
if (RSTRING_LEN(s) == 0)
return rb_assoc_new(Qnil, self);
{
VALUE m, sr, si, re, r, i;
int po;
m = f_match(comp_pat0, s);
if (!NIL_P(m)) {
sr = rb_reg_nth_match(1, m);
si = rb_reg_nth_match(2, m);
re = rb_reg_match_post(m);
po = 1;
}
if (NIL_P(m)) {
m = f_match(comp_pat1, s);
if (!NIL_P(m)) {
sr = Qnil;
si = rb_reg_nth_match(1, m);
if (NIL_P(si))
si = rb_usascii_str_new2("");
{
VALUE t;
t = rb_reg_nth_match(2, m);
if (NIL_P(t))
t = rb_usascii_str_new2("1");
rb_str_concat(si, t);
}
re = rb_reg_match_post(m);
po = 0;
}
}
if (NIL_P(m)) {
m = f_match(comp_pat2, s);
if (NIL_P(m))
return rb_assoc_new(Qnil, self);
sr = rb_reg_nth_match(1, m);
if (NIL_P(rb_reg_nth_match(2, m)))
si = Qnil;
else {
VALUE t;
si = rb_reg_nth_match(3, m);
t = rb_reg_nth_match(4, m);
if (NIL_P(t))
t = rb_usascii_str_new2("1");
rb_str_concat(si, t);
}
re = rb_reg_match_post(m);
po = 0;
}
r = INT2FIX(0);
i = INT2FIX(0);
if (!NIL_P(sr)) {
if (strchr(RSTRING_PTR(sr), '/'))
r = f_to_r(sr);
else if (strpbrk(RSTRING_PTR(sr), ".eE"))
r = f_to_f(sr);
else
r = f_to_i(sr);
}
if (!NIL_P(si)) {
if (strchr(RSTRING_PTR(si), '/'))
i = f_to_r(si);
else if (strpbrk(RSTRING_PTR(si), ".eE"))
i = f_to_f(si);
else
i = f_to_i(si);
}
if (po)
return rb_assoc_new(rb_complex_polar(r, i), re);
else
return rb_assoc_new(rb_complex_new2(r, i), re);
}
}
static VALUE
env_to_s(VALUE rcv, SEL sel)
{
return rb_usascii_str_new2("ENV");
}
/* localeinit.c */
VALUE
rb_locale_charmap(VALUE klass)
{
return rb_usascii_str_new2("ASCII-8BIT");
}