static VALUE transcode_string(VALUE src, int * parser_encoding)
{
int utf8 = rb_utf8_encindex();
int utf16le = rb_enc_find_index("UTF16_LE");
int utf16be = rb_enc_find_index("UTF16_BE");
int source_encoding = rb_enc_get_index(src);
if (source_encoding == utf8) {
*parser_encoding = YAML_UTF8_ENCODING;
return src;
}
if (source_encoding == utf16le) {
*parser_encoding = YAML_UTF16LE_ENCODING;
return src;
}
if (source_encoding == utf16be) {
*parser_encoding = YAML_UTF16BE_ENCODING;
return src;
}
src = rb_str_export_to_enc(src, rb_utf8_encoding());
RB_GC_GUARD(src);
*parser_encoding = YAML_UTF8_ENCODING;
return src;
}
rb_encoding* rb_nkf_enc_get(const char *name)
{
#if 0
int idx = rb_enc_find_index(name);
if (idx < 0) {
nkf_encoding *nkf_enc = nkf_enc_find(name);
idx = rb_enc_find_index(nkf_enc_name(nkf_enc_to_base_encoding(nkf_enc)));
if (idx < 0) {
idx = rb_define_dummy_encoding(name);
} else {
rb_encoding *rb_enc = rb_enc_from_index(idx);
idx = rb_enc_replicate(name, rb_enc);
}
}
return rb_enc_from_index(idx);
#else
struct nkf_osx_name_enc_table {
const char* name;
CFStringEncoding enc;
};
static struct nkf_osx_name_enc_table table[] = {
{ "BINARY", kCFStringEncodingNonLossyASCII },
{ "US-ASCII", kCFStringEncodingASCII },
{ "ISO-2022-JP", kCFStringEncodingISO_2022_JP },
{ "ISO-2022-JP-1", kCFStringEncodingISO_2022_JP_1 },
{ "ISO-2022-JP-2", kCFStringEncodingISO_2022_JP_2 },
{ "ISO-2022-JP-3", kCFStringEncodingISO_2022_JP_3 },
{ "EUC-JP", kCFStringEncodingEUC_JP },
{ "Shift_JIS", kCFStringEncodingShiftJIS },
{ "UTF-8", kCFStringEncodingUTF8 },
{ "UTF-16", kCFStringEncodingUTF16 },
{ "UTF-16BE", kCFStringEncodingUTF16BE },
{ "UTF-16LE", kCFStringEncodingUTF16LE },
{ "UTF-32", kCFStringEncodingUTF32 },
{ "UTF-32BE", kCFStringEncodingUTF32BE },
{ "UTF-32LE", kCFStringEncodingUTF32LE },
{ NULL, kCFStringEncodingNonLossyASCII }
};
struct nkf_osx_name_enc_table* ptr = table;
while (ptr->name) {
if (strcmp(name, ptr->name) == 0)
return &(ptr->enc);
ptr++;
}
return &(ptr->enc);
#endif
}
rb_encoding* rb_nkf_enc_get(const char *name)
{
int idx = rb_enc_find_index(name);
if (idx < 0) {
nkf_encoding *nkf_enc = nkf_enc_find(name);
idx = rb_enc_find_index(nkf_enc_name(nkf_enc_to_base_encoding(nkf_enc)));
if (idx < 0) {
idx = rb_define_dummy_encoding(name);
} else {
rb_encoding *rb_enc = rb_enc_from_index(idx);
idx = rb_enc_replicate(name, rb_enc);
}
}
return rb_enc_from_index(idx);
}
VALUE do_sqlite3_cConnection_initialize(VALUE self, VALUE uri) {
VALUE path = rb_funcall(uri, rb_intern("path"), 0);
sqlite3 *db = NULL;
int ret;
#ifdef HAVE_SQLITE3_OPEN_V2
ret = sqlite3_open_v2(StringValuePtr(path), &db, do_sqlite3_flags_from_uri(uri), 0);
#else
ret = sqlite3_open(StringValuePtr(path), &db);
#endif
if (ret != SQLITE_OK) {
do_sqlite3_raise_error(self, db, Qnil);
}
rb_iv_set(self, "@uri", uri);
rb_iv_set(self, "@connection", Data_Wrap_Struct(rb_cObject, 0, 0, db));
// Sqlite3 only supports UTF-8, so this is the standard encoding
rb_iv_set(self, "@encoding", rb_str_new2("UTF-8"));
#ifdef HAVE_RUBY_ENCODING_H
rb_iv_set(self, "@encoding_id", INT2FIX(rb_enc_find_index("UTF-8")));
#endif
return Qtrue;
}
rb_encoding *
rb_enc_find(const char *name)
{
int idx = rb_enc_find_index(name);
if (idx < 0) idx = 0;
return rb_enc_from_index(idx);
}
static VALUE mysql2_set_field_string_encoding(VALUE val, MYSQL_FIELD field, rb_encoding *default_internal_enc, rb_encoding *conn_enc) {
/* if binary flag is set, respect its wishes */
if (field.flags & BINARY_FLAG && field.charsetnr == 63) {
rb_enc_associate(val, binaryEncoding);
} else if (!field.charsetnr) {
/* MySQL 4.x may not provide an encoding, binary will get the bytes through */
rb_enc_associate(val, binaryEncoding);
} else {
/* lookup the encoding configured on this field */
const char *enc_name;
int enc_index;
enc_name = mysql2_mysql_enc_to_rb[field.charsetnr-1];
if (enc_name != NULL) {
/* use the field encoding we were able to match */
enc_index = rb_enc_find_index(enc_name);
rb_enc_set_index(val, enc_index);
} else {
/* otherwise fall-back to the connection's encoding */
rb_enc_associate(val, conn_enc);
}
if (default_internal_enc) {
val = rb_str_export_to_enc(val, default_internal_enc);
}
}
return val;
}
static VALUE transcode_io(VALUE src, int * parser_encoding)
{
VALUE io_external_encoding;
int io_external_enc_index;
io_external_encoding = rb_funcall(src, rb_intern("external_encoding"), 0);
/* if no encoding is returned, assume ascii8bit. */
if (NIL_P(io_external_encoding)) {
io_external_enc_index = rb_ascii8bit_encindex();
} else {
io_external_enc_index = rb_to_encoding_index(io_external_encoding);
}
/* Treat US-ASCII as utf_8 */
if (io_external_enc_index == rb_usascii_encindex()) {
*parser_encoding = YAML_UTF8_ENCODING;
return src;
}
if (io_external_enc_index == rb_utf8_encindex()) {
*parser_encoding = YAML_UTF8_ENCODING;
return src;
}
if (io_external_enc_index == rb_enc_find_index("UTF-16LE")) {
*parser_encoding = YAML_UTF16LE_ENCODING;
return src;
}
if (io_external_enc_index == rb_enc_find_index("UTF-16BE")) {
*parser_encoding = YAML_UTF16BE_ENCODING;
return src;
}
/* Just guess on ASCII-8BIT */
if (io_external_enc_index == rb_ascii8bit_encindex()) {
*parser_encoding = YAML_ANY_ENCODING;
return src;
}
/* If the external encoding is something we don't know how to handle,
* fall back to YAML_ANY_ENCODING. */
*parser_encoding = YAML_ANY_ENCODING;
return src;
}
static VALUE transcode_io(VALUE src, int * parser_encoding)
{
VALUE io_external_encoding;
int io_external_enc_index;
io_external_encoding = rb_funcall(src, rb_intern("external_encoding"), 0);
/* if no encoding is returned, assume ascii8bit. */
if (NIL_P(io_external_encoding)) {
io_external_enc_index = rb_ascii8bit_encindex();
} else {
io_external_enc_index = rb_to_encoding_index(io_external_encoding);
}
/* Treat US-ASCII as utf_8 */
if (io_external_enc_index == rb_usascii_encindex()) {
*parser_encoding = YAML_UTF8_ENCODING;
return src;
}
if (io_external_enc_index == rb_utf8_encindex()) {
*parser_encoding = YAML_UTF8_ENCODING;
return src;
}
if (io_external_enc_index == rb_enc_find_index("UTF-16LE")) {
*parser_encoding = YAML_UTF16LE_ENCODING;
return src;
}
if (io_external_enc_index == rb_enc_find_index("UTF-16BE")) {
*parser_encoding = YAML_UTF16BE_ENCODING;
return src;
}
/* Just guess on ASCII-8BIT */
if (io_external_enc_index == rb_ascii8bit_encindex()) {
*parser_encoding = YAML_ANY_ENCODING;
return src;
}
rb_raise(rb_eArgError, "YAML file must be UTF-8, UTF-16LE, or UTF-16BE, not %s",
rb_enc_name(rb_enc_from_index(io_external_enc_index)));
return Qnil;
}
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;
}
int
rb_enc_find_index2(const char *name, long len)
{
char buf[ENCODING_NAMELEN_MAX+1];
if (len > ENCODING_NAMELEN_MAX) return -1;
memcpy(buf, name, len);
buf[len] = '\0';
return rb_enc_find_index(buf);
}
/*
Set string encoding to UTF8
See http://tenderlovemaking.com/2009/06/26/string-encoding-in-ruby-1-9-c-extensions.html
*/
static VALUE str_new(const char *str) {
VALUE string = rb_str_new2(str);
#ifdef HAVE_RUBY_ENCODING_H
int enc = rb_enc_find_index("UTF-8");
if(enc != -1) rb_enc_associate_index(string, enc);
#endif
return string;
}
static VALUE summarize(const VALUE self, volatile VALUE rb_str, volatile VALUE rb_dict_file, const VALUE rb_ratio, const VALUE rb_topics, const VALUE rb_sections) {
#ifdef HAVE_RUBY_ENCODING_H
int enc = rb_enc_find_index("UTF-8");
#endif
long int length = RSTRING_LEN(rb_str);
char *text = StringValuePtr(rb_str);
char *dictionary_file = StringValuePtr(rb_dict_file);
int ratio = NUM2INT(rb_ratio);
size_t result_len;
OtsArticle *doc = ots_new_article();
VALUE summary;
VALUE topics;
VALUE result;
VALUE sections;
if (!ots_load_xml_dictionary(doc, dictionary_file)) {
ots_free_article(doc);
rb_raise(rb_eRuntimeError, "Cannot load dictionary file");
return Qnil;
}
ots_parse_stream(text, length, doc);
ots_grade_doc(doc);
ots_highlight_doc(doc, ratio);
summary = rb_str_new2(ots_get_doc_text(doc, &result_len));
topics = rb_str_new2((const char *)doc->title);
sections = rb_ary_new();
GList *li;
for (li = (GList *) ots_get_doc_sections(doc); li != NULL; li = li->next) {
VALUE section = rb_str_new2(li->data);
rb_ary_push(sections, section);
}
#ifdef HAVE_RUBY_ENCODING_H
rb_enc_associate_index(summary, enc);
rb_enc_associate_index(summary, enc);
#endif
ots_free_article(doc);
if (rb_topics == Qtrue) {
result = rb_ary_new();
rb_ary_push(result, summary);
rb_ary_push(result, topics);
return result;
} else if (rb_sections == Qtrue) {
return sections;
} else {
return summary;
}
}
int enc_cb(void * _self, int columns, char **data, char **names)
{
VALUE self = (VALUE)_self;
int index = rb_enc_find_index("UTF-8");
VALUE enc = rb_str_new2(data[0]);
rb_enc_associate_index(enc, index);
rb_iv_set(self, "@encoding", enc);
return 0;
}
/* Returns encoding index or UNSPECIFIED_ENCODING */
static int
str_find_encindex(VALUE enc)
{
int idx;
StringValue(enc);
if (!rb_enc_asciicompat(rb_enc_get(enc))) {
rb_raise(rb_eArgError, "invalid name encoding (non ASCII)");
}
idx = rb_enc_find_index(StringValueCStr(enc));
return idx;
}
static int
opt_enc_index(VALUE enc_name)
{
const char *s = RSTRING_PTR(enc_name);
int i = rb_enc_find_index(s);
if (i < 0) {
rb_raise(rb_eRuntimeError, "unknown encoding name - %s", s);
}
else if (rb_enc_dummy_p(rb_enc_from_index(i))) {
rb_raise(rb_eRuntimeError, "dummy encoding is not acceptable - %s ", s);
}
return i;
}
int
rb_enc_alias(const char *alias, const char *orig)
{
int idx;
enc_check_duplication(alias);
if (!enc_table.list) {
rb_enc_init();
}
if ((idx = rb_enc_find_index(orig)) < 0) {
return -1;
}
return enc_alias(alias, idx);
}
static rb_encoding *
to_encoding(VALUE enc)
{
int idx;
StringValue(enc);
if (!rb_enc_asciicompat(rb_enc_get(enc))) {
rb_raise(rb_eArgError, "invalid name encoding (non ASCII)");
}
idx = rb_enc_find_index(StringValueCStr(enc));
if (idx < 0) {
rb_raise(rb_eArgError, "unknown encoding name - %s", RSTRING_PTR(enc));
}
return rb_enc_from_index(idx);
}
int
rb_locale_encindex(void)
{
VALUE charmap = rb_locale_charmap(rb_cEncoding);
int idx;
if (NIL_P(charmap))
idx = rb_usascii_encindex();
else if ((idx = rb_enc_find_index(StringValueCStr(charmap))) < 0)
idx = rb_ascii8bit_encindex();
if (rb_enc_registered("locale") < 0) enc_alias_internal("locale", idx);
return idx;
}
int
Init_enc_set_filesystem_encoding(void)
{
int idx;
#if defined NO_LOCALE_CHARMAP
# error NO_LOCALE_CHARMAP defined
#elif defined _WIN32 || defined __CYGWIN__
char cp[SIZEOF_CP_NAME];
CP_FORMAT(cp, AreFileApisANSI() ? GetACP() : GetOEMCP());
idx = rb_enc_find_index(cp);
if (idx < 0) idx = ENCINDEX_ASCII;
#else
idx = rb_enc_to_index(rb_default_external_encoding());
#endif
return idx;
}
int
rb_to_encoding_index(VALUE enc)
{
int idx;
idx = enc_check_encoding(enc);
if (idx >= 0) {
return idx;
}
else if (NIL_P(enc = rb_check_string_type(enc))) {
return -1;
}
if (!rb_enc_asciicompat(rb_enc_get(enc))) {
return -1;
}
return rb_enc_find_index(StringValueCStr(enc));
}
static int
enc_set_filesystem_encoding(void)
{
int idx;
#if defined NO_LOCALE_CHARMAP
idx = rb_enc_to_index(rb_default_external_encoding());
#elif defined _WIN32 || defined __CYGWIN__
char cp[sizeof(int) * 8 / 3 + 4];
snprintf(cp, sizeof cp, "CP%d", AreFileApisANSI() ? GetACP() : GetOEMCP());
idx = rb_enc_find_index(cp);
if (idx < 0) idx = rb_ascii8bit_encindex();
#else
idx = rb_enc_to_index(rb_default_external_encoding());
#endif
enc_alias_internal("filesystem", idx);
return idx;
}
/*
* Look up the JOHAB encoding, creating it as a dummy encoding if it's not
* already defined.
*/
static rb_encoding *
pg_find_or_create_johab(void)
{
static const char * const aliases[] = { "JOHAB", "Windows-1361", "CP1361" };
int enc_index;
size_t i;
for (i = 0; i < sizeof(aliases)/sizeof(aliases[0]); ++i) {
enc_index = rb_enc_find_index(aliases[i]);
if (enc_index > 0) return rb_enc_from_index(enc_index);
}
enc_index = rb_define_dummy_encoding(aliases[0]);
for (i = 1; i < sizeof(aliases)/sizeof(aliases[0]); ++i) {
ENC_ALIAS(aliases[i], aliases[0]);
}
return rb_enc_from_index(enc_index);
}
VALUE unserialize(VALUE self, VALUE string)
{
Check_Type(string, T_STRING);
QByteArray byte_array(RSTRING_PTR(string), RSTRING_LEN(string));
QDataStream data_stream(byte_array);
QVariant variant;
data_stream >> variant;
// FIXME return a Ruby object for the variant instead of its qDebug
QString output;
QDebug debug(&output);
debug << variant;
VALUE result = rb_str_new2(output.toUtf8().data());
rb_enc_associate_index(string, rb_enc_find_index("UTF-8"));
return result;
}
/* Ruby Extension initializer */
void Init_yajl_ext() {
mYajl = rb_define_module("Yajl");
cParseError = rb_define_class_under(mYajl, "ParseError", rb_eStandardError);
cEncodeError = rb_define_class_under(mYajl, "EncodeError", rb_eStandardError);
cParser = rb_define_class_under(mYajl, "Parser", rb_cObject);
rb_define_singleton_method(cParser, "new", rb_yajl_parser_new, -1);
rb_define_method(cParser, "initialize", rb_yajl_parser_init, -1);
rb_define_method(cParser, "parse", rb_yajl_parser_parse, -1);
rb_define_method(cParser, "parse_chunk", rb_yajl_parser_parse_chunk, -1);
rb_define_method(cParser, "<<", rb_yajl_parser_parse_chunk, 1);
rb_define_method(cParser, "on_parse_complete=", rb_yajl_parser_set_complete_cb, 1);
cEncoder = rb_define_class_under(mYajl, "Encoder", rb_cObject);
rb_define_singleton_method(cEncoder, "new", rb_yajl_encoder_new, -1);
rb_define_method(cEncoder, "initialize", rb_yajl_encoder_init, -1);
rb_define_method(cEncoder, "encode", rb_yajl_encoder_encode, -1);
rb_define_method(cEncoder, "on_progress=", rb_yajl_encoder_set_progress_cb, 1);
rb_define_singleton_method(cEncoder, "enable_json_gem_compatability", rb_yajl_encoder_enable_json_gem_ext, 0);
intern_io_read = rb_intern("read");
intern_call = rb_intern("call");
intern_keys = rb_intern("keys");
intern_to_s = rb_intern("to_s");
intern_to_json = rb_intern("to_json");
intern_to_sym = rb_intern("to_sym");
intern_has_key = rb_intern("has_key?");
intern_as_json = rb_intern("as_json");
sym_allow_comments = ID2SYM(rb_intern("allow_comments"));
sym_check_utf8 = ID2SYM(rb_intern("check_utf8"));
sym_pretty = ID2SYM(rb_intern("pretty"));
sym_indent = ID2SYM(rb_intern("indent"));
sym_terminator = ID2SYM(rb_intern("terminator"));
sym_symbolize_keys = ID2SYM(rb_intern("symbolize_keys"));
#ifdef HAVE_RUBY_ENCODING_H
utf8Encoding = rb_enc_find_index("UTF-8");
#endif
}
/** Open a connection to MySQL */
static VALUE rdo_mysql_driver_open(VALUE self) {
RDOMySQLDriver * driver;
Data_Get_Struct(self, RDOMySQLDriver, driver);
if (driver->is_open) {
return Qtrue;
}
if (!(driver->conn = mysql_init(NULL))) {
RDO_ERROR("Failed to connect to MySQL. Could not allocate memory.");
}
VALUE host = rb_funcall(self, rb_intern("host"), 0);
VALUE port = rb_funcall(self, rb_intern("port"), 0);
VALUE user = rb_funcall(self, rb_intern("user"), 0);
VALUE pass = rb_funcall(self, rb_intern("password"), 0);
VALUE db = rb_funcall(self, rb_intern("database"), 0);
Check_Type(host, T_STRING);
Check_Type(port, T_FIXNUM);
Check_Type(user, T_STRING);
Check_Type(pass, T_STRING);
Check_Type(db, T_STRING);
if (!mysql_real_connect(driver->conn,
RSTRING_PTR(host),
RSTRING_PTR(user),
RSTRING_PTR(pass),
RSTRING_PTR(db),
NUM2INT(port),
NULL, // UNIX socket
0)) {
RDO_ERROR("MySQL connection failed: %s", mysql_error(driver->conn));
} else {
driver->is_open = 1;
driver->encoding = rb_enc_find_index(
RSTRING_PTR(rb_funcall(self, rb_intern("encoding"), 0)));
rb_funcall(self, rb_intern("after_open"), 0);
}
return Qtrue;
}
int
rb_to_encoding_index(VALUE enc)
{
if (CLASS_OF(enc) != rb_cEncoding && TYPE(enc) != T_STRING) {
return -1;
}
else {
int idx = index_of_encoding((rb_encoding_t *)enc);
if (idx >= 0) {
return idx;
}
else if (NIL_P(enc = rb_check_string_type(enc))) {
return -1;
}
if (!rb_enc_asciicompat(rb_enc_get(enc))) {
return -1;
}
return rb_enc_find_index(StringValueCStr(enc));
}
}
int
rb_locale_encindex(void)
{
VALUE charmap = rb_locale_charmap(rb_cEncoding);
int idx;
if (NIL_P(charmap))
idx = ENCINDEX_US_ASCII;
else if ((idx = rb_enc_find_index(StringValueCStr(charmap))) < 0)
idx = ENCINDEX_ASCII;
if (rb_enc_registered("locale") < 0) {
# if defined _WIN32
void Init_w32_codepage(void);
Init_w32_codepage();
# endif
enc_alias_internal("locale", idx);
}
return idx;
}
void startup(const char* script_name)
{
if(running)
{
return;
}
int fake_argc = 0;
char *fake_args[fake_argc];
char **fake_argv = fake_args;
ruby_sysinit(&fake_argc, &fake_argv);
// Initialize Ruby itself
RUBY_INIT_STACK;
ruby_init();
ruby_init_loadpath();
//Init_prelude();
//ruby_init_gems();
// To load prelude.rb
static char* args[] = { "ruby", "/dev/null" };
ruby_process_options(2, args);
// Load Ruby encodings, otherwise we'll get all kinds of "Unitialized
// constanct Encoding::UTF-7", etc. everywhere.
rb_enc_find_index("encdb");
VALUE gem;
gem = rb_define_module("Gem");
rb_const_set(gem, rb_intern("Enable"), Qtrue);
rb_require("rubygems");
ruby_script((char*)script_name);
running = true;
}
/* load the interpreter and the script */
void startup_myruby(void)
{
int rc;
RUBY_INIT_STACK;
ruby_init();
ruby_init_loadpath();
/* dumps the version info to stdout */
ruby_show_version();
/* set working dir for includes */
rb_eval_string_protect("$: << '.'", &rc); /* NOTRANSLATE */
#if USE_RUBYVERSION < 19
#else
rb_enc_find_index("encdb"); /* NOTRANSLATE */
#endif
myruby_loaded = 0;
//define that callback below
rb_define_global_function("iroffer_input", cie_inputline, 0); /* NOTRANSLATE */
rb_define_global_function("iroffer_privmsg", cie_privmsg, 2); /* NOTRANSLATE */
Init_IrofferEvent();
load_script(gdata.ruby_script);
}
static VALUE encoding_spec_rb_enc_associate_index(VALUE self, VALUE obj, VALUE enc) {
return rb_enc_associate_index(obj, rb_enc_find_index(RSTRING_PTR(enc)));
}
