void Init_duktape_ext()
{
int one = 1;
if (*(char*)(&one) == 1) {
utf16enc = rb_enc_find("UTF-16LE");
} else {
utf16enc = rb_enc_find("UTF-16BE");
}
id_complex_object = rb_intern("complex_object");
mDuktape = rb_define_module("Duktape");
cContext = rb_define_class_under(mDuktape, "Context", rb_cObject);
cComplexObject = rb_define_class_under(mDuktape, "ComplexObject", rb_cObject);
eInternalError = rb_define_class_under(mDuktape, "InternalError", rb_eStandardError);
eUnimplementedError = rb_define_class_under(mDuktape, "UnimplementedError", eInternalError);
eUnsupportedError = rb_define_class_under(mDuktape, "UnsupportedError", eInternalError);
eAllocError = rb_define_class_under(mDuktape, "AllocError", eInternalError);
eAssertionError = rb_define_class_under(mDuktape, "AssertionError", eInternalError);
eAPIError = rb_define_class_under(mDuktape, "APIError", eInternalError);
eUncaughtError = rb_define_class_under(mDuktape, "UncaughtError", eInternalError);
eError = rb_define_class_under(mDuktape, "Error", rb_eStandardError);
eEvalError = rb_define_class_under(mDuktape, "EvalError", eError);
eRangeError = rb_define_class_under(mDuktape, "RangeError", eError);
eReferenceError = rb_define_class_under(mDuktape, "ReferenceError", eError);
eSyntaxError = rb_define_class_under(mDuktape, "SyntaxError", eError);
eTypeError = rb_define_class_under(mDuktape, "TypeError", eError);
eURIError = rb_define_class_under(mDuktape, "URIError", eError);
rb_define_alloc_func(cContext, ctx_alloc);
rb_define_method(cContext, "initialize", ctx_initialize, -1);
rb_define_method(cContext, "complex_object", ctx_complex_object, 0);
rb_define_method(cContext, "eval_string", ctx_eval_string, -1);
rb_define_method(cContext, "exec_string", ctx_exec_string, -1);
rb_define_method(cContext, "get_prop", ctx_get_prop, 1);
rb_define_method(cContext, "call_prop", ctx_call_prop, -1);
rb_define_method(cContext, "define_function", ctx_define_function, 1);
rb_define_method(cContext, "_valid?", ctx_is_valid, 0);
oComplexObject = rb_obj_alloc(cComplexObject);
rb_define_singleton_method(cComplexObject, "instance", complex_object_instance, 0);
rb_ivar_set(cComplexObject, rb_intern("duktape.instance"), oComplexObject);
sDefaultFilename = rb_str_new2("(duktape)");
OBJ_FREEZE(sDefaultFilename);
rb_global_variable(&sDefaultFilename);
}
/*
* call-seq:
* commit.header_field(field_name) -> str
*
* Returns +commit+'s header field value.
*/
static VALUE rb_git_commit_header_field(VALUE self, VALUE rb_field)
{
git_buf header_field = { 0 };
git_commit *commit = NULL;
const char *encoding_name;
rb_encoding *encoding = rb_utf8_encoding();
VALUE rb_result;
int error;
Check_Type(rb_field, T_STRING);
Data_Get_Struct(self, git_commit, commit);
error = git_commit_header_field(&header_field, commit, StringValueCStr(rb_field));
if (error < 0) {
git_buf_free(&header_field);
if (error == GIT_ENOTFOUND)
return Qnil;
rugged_exception_check(error);
}
encoding_name = git_commit_message_encoding(commit);
if (encoding_name != NULL)
encoding = rb_enc_find(encoding_name);
rb_result = rb_enc_str_new(header_field.ptr, header_field.size, encoding);
git_buf_free(&header_field);
return rb_result;
}
static VALUE rb_smbdir_initialize(VALUE self, VALUE smb_obj, VALUE url_obj)
{
RB_SMBFILE_DATA_FROM_OBJ(self, data);
RB_SMB_DATA_FROM_OBJ(smb_obj, smb_data);
smbc_opendir_fn fn;
const char *url = StringValueCStr(url_obj);
fn = smbc_getFunctionOpendir(smb_data->smbcctx);
data->smbcfile = (*fn)(smb_data->smbcctx, url);
if (data->smbcfile == NULL) {
rb_sys_fail_str(url_obj);
}
/* FIXME: Take encoding from argument */
/* FIXME: Read unix charset (?) from smb.conf for default encoding */
data->enc = rb_enc_find("UTF-8");
data->smb_obj = smb_obj;
data->smb_data = smb_data;
data->smbcctx = smb_data->smbcctx;
data->url = ruby_strdup(url);
RB_SMB_DEBUG("smbcctx=%p smbcfile=%p\n", data->smbcctx, data->smbcfile);
if (rb_block_given_p()) {
return rb_ensure(rb_yield, self, rb_smbdir_close, self);
}
return self;
}
VALUE rugged_signature_new(const git_signature *sig, const char *encoding_name)
{
VALUE rb_sig, rb_time;
rb_encoding *encoding = rb_utf8_encoding();
if (encoding_name != NULL)
encoding = rb_enc_find(encoding_name);
rb_sig = rb_hash_new();
/* Allocate the time with a the given timezone */
rb_time = rb_funcall(
rb_time_new(sig->when.time, 0),
rb_intern("getlocal"), 1,
INT2FIX(sig->when.offset * 60)
);
rb_hash_aset(rb_sig, CSTR2SYM("name"),
rb_enc_str_new(sig->name, strlen(sig->name), encoding));
rb_hash_aset(rb_sig, CSTR2SYM("email"),
rb_enc_str_new(sig->email, strlen(sig->email), encoding));
rb_hash_aset(rb_sig, CSTR2SYM("time"), rb_time);
return rb_sig;
}
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 void
create_prolog_doc(PInfo pi, const char *target, Attr attrs) {
VALUE doc;
VALUE ah;
VALUE nodes;
if (0 != pi->h) { // top level object
rb_raise(rb_eSyntaxError, "Prolog must be the first element in an XML document.\n");
}
pi->h = pi->helpers;
doc = rb_obj_alloc(ox_document_clas);
ah = rb_hash_new();
for (; 0 != attrs->name; attrs++) {
rb_hash_aset(ah, ID2SYM(rb_intern(attrs->name)), rb_str_new2(attrs->value));
#ifdef HAVE_RUBY_ENCODING_H
if (0 == strcmp("encoding", attrs->name)) {
pi->encoding = rb_enc_find(attrs->value);
}
#endif
}
nodes = rb_ary_new();
rb_ivar_set(doc, attributes_id, ah);
rb_ivar_set(doc, nodes_id, nodes);
pi->h->obj = nodes;
pi->obj = doc;
}
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 rb_encoding* _guess_encoding(VALUE str) {
rb_encoding *enc;
const char *encname;
encname = libguess_determine_encoding(RSTRING_PTR(str), RSTRING_LEN(str),
RSTRING_PTR(guess4r_enc__guess_region(rb_cEncoding)));
return rb_enc_find(encname);
}
VALUE rb_utf8_str_new(const char *str, long len)
{
#ifdef RUBY_ENCODING_H
return rb_enc_str_new(str, len, rb_enc_find("UTF-8"));
#else
return rb_str_new(str, len);
#endif
}
static void
parse_options(VALUE ropts, Options copts) {
struct _YesNoOpt ynos[] = {
{ circular_sym, &copts->circular },
{ auto_define_sym, &copts->auto_define },
{ symbol_keys_sym, &copts->sym_key },
{ ascii_only_sym, &copts->ascii_only },
{ Qnil, 0 }
};
YesNoOpt o;
if (rb_cHash == rb_obj_class(ropts)) {
VALUE v;
if (Qnil != (v = rb_hash_lookup(ropts, indent_sym))) {
if (rb_cFixnum != rb_obj_class(v)) {
rb_raise(rb_eArgError, ":indent must be a Fixnum.\n");
}
copts->indent = NUM2INT(v);
}
#ifdef HAVE_RUBY_ENCODING_H
if (Qnil != (v = rb_hash_lookup(ropts, encoding_sym))) {
if (T_STRING == rb_type(v)) {
oj_default_options.encoding = rb_enc_find(StringValuePtr(v));
} else if (rb_cEncoding == rb_obj_class(v)) {
oj_default_options.encoding = rb_to_encoding(v);
} else {
rb_raise(rb_eArgError, ":encoding must be nil, a String, or an Encoding.\n");
}
}
#endif
if (Qnil != (v = rb_hash_lookup(ropts, mode_sym))) {
if (object_sym == v) {
copts->mode = ObjectMode;
} else if (strict_sym == v) {
copts->mode = StrictMode;
} else if (compat_sym == v) {
copts->mode = CompatMode;
} else if (null_sym == v) {
copts->mode = NullMode;
} else {
rb_raise(rb_eArgError, ":mode must be :object, :strict, :compat, or :null.\n");
}
}
for (o = ynos; 0 != o->attr; o++) {
if (Qnil != (v = rb_hash_lookup(ropts, o->sym))) {
if (Qtrue == v) {
*o->attr = Yes;
} else if (Qfalse == v) {
*o->attr = No;
} else {
rb_raise(rb_eArgError, "%s must be true or false.\n", rb_id2name(SYM2ID(o->sym)));
}
}
}
}
}
static VALUE
mr_enc_s_find(VALUE klass, SEL sel, VALUE name)
{
StringValue(name);
rb_encoding_t *enc = rb_enc_find(RSTRING_PTR(name));
if (enc == NULL) {
rb_raise(rb_eArgError, "unknown encoding name - %s",
RSTRING_PTR(name));
}
return (VALUE)enc;
}
void init_tinytds_result() {
/* Data Classes */
cBigDecimal = rb_const_get(rb_cObject, rb_intern("BigDecimal"));
cDate = rb_const_get(rb_cObject, rb_intern("Date"));
/* Define TinyTds::Result */
cTinyTdsResult = rb_define_class_under(mTinyTds, "Result", rb_cObject);
/* Define TinyTds::Result Public Methods */
rb_define_method(cTinyTdsResult, "fields", rb_tinytds_result_fields, 0);
rb_define_method(cTinyTdsResult, "each", rb_tinytds_result_each, -1);
rb_define_method(cTinyTdsResult, "cancel", rb_tinytds_result_cancel, 0);
rb_define_method(cTinyTdsResult, "do", rb_tinytds_result_do, 0);
rb_define_method(cTinyTdsResult, "affected_rows", rb_tinytds_result_affected_rows, 0);
rb_define_method(cTinyTdsResult, "return_code", rb_tinytds_result_return_code, 0);
rb_define_method(cTinyTdsResult, "insert", rb_tinytds_result_insert, 0);
/* Intern String Helpers */
intern_new = rb_intern("new");
intern_utc = rb_intern("utc");
intern_local = rb_intern("local");
intern_merge = rb_intern("merge");
intern_localtime = rb_intern("localtime");
intern_civil = rb_intern("civil");
intern_new_offset = rb_intern("new_offset");
intern_plus = rb_intern("+");
intern_divide = rb_intern("/");
/* Symbol Helpers */
sym_symbolize_keys = ID2SYM(rb_intern("symbolize_keys"));
sym_as = ID2SYM(rb_intern("as"));
sym_array = ID2SYM(rb_intern("array"));
sym_cache_rows = ID2SYM(rb_intern("cache_rows"));
sym_first = ID2SYM(rb_intern("first"));
sym_local = ID2SYM(intern_local);
sym_utc = ID2SYM(intern_utc);
sym_timezone = ID2SYM(rb_intern("timezone"));
sym_empty_sets = ID2SYM(rb_intern("empty_sets"));
/* Data Conversion Options */
opt_decimal_zero = rb_str_new2("0.0");
rb_global_variable(&opt_decimal_zero);
opt_float_zero = rb_float_new((double)0);
rb_global_variable(&opt_float_zero);
opt_one = INT2NUM(1);
opt_zero = INT2NUM(0);
opt_four = INT2NUM(4);
opt_19hdr = INT2NUM(1900);
opt_onek = INT2NUM(1000);
opt_tenk = INT2NUM(10000);
opt_onemil = INT2NUM(1000000);
opt_onebil = INT2NUM(1000000000);
/* Encoding */
#ifdef HAVE_RUBY_ENCODING_H
binaryEncoding = rb_enc_find("binary");
#endif
}
static VALUE rb_tinytds_connect(VALUE self, VALUE opts) {
/* Parsing options hash to local vars. */
VALUE user, pass, dataserver, database, app, version, ltimeout, timeout, charset;
user = rb_hash_aref(opts, sym_username);
pass = rb_hash_aref(opts, sym_password);
dataserver = rb_hash_aref(opts, sym_dataserver);
database = rb_hash_aref(opts, sym_database);
app = rb_hash_aref(opts, sym_appname);
version = rb_hash_aref(opts, sym_tds_version);
ltimeout = rb_hash_aref(opts, sym_login_timeout);
timeout = rb_hash_aref(opts, sym_timeout);
charset = rb_hash_aref(opts, sym_encoding);
/* Dealing with options. */
if (dbinit() == FAIL) {
rb_raise(cTinyTdsError, "failed dbinit() function");
return self;
}
dberrhandle(tinytds_err_handler);
dbmsghandle(tinytds_msg_handler);
GET_CLIENT_WRAPPER(self);
cwrap->login = dblogin();
if (!NIL_P(user))
dbsetluser(cwrap->login, StringValuePtr(user));
if (!NIL_P(pass))
dbsetlpwd(cwrap->login, StringValuePtr(pass));
if (!NIL_P(app))
dbsetlapp(cwrap->login, StringValuePtr(app));
if (!NIL_P(version))
dbsetlversion(cwrap->login, NUM2INT(version));
if (!NIL_P(ltimeout))
dbsetlogintime(NUM2INT(ltimeout));
if (!NIL_P(timeout))
dbsettime(NUM2INT(timeout));
if (!NIL_P(charset))
DBSETLCHARSET(cwrap->login, StringValuePtr(charset));
cwrap->client = dbopen(cwrap->login, StringValuePtr(dataserver));
if (cwrap->client) {
cwrap->closed = 0;
cwrap->charset = charset;
dbsetuserdata(cwrap->client, (BYTE*)cwrap->userdata);
cwrap->userdata->closed = 0;
if (!NIL_P(database))
dbuse(cwrap->client, StringValuePtr(database));
#ifdef HAVE_RUBY_ENCODING_H
VALUE transposed_encoding = rb_funcall(cTinyTdsClient, intern_transpose_iconv_encoding, 1, charset);
cwrap->encoding = rb_enc_find(StringValuePtr(transposed_encoding));
#endif
}
return self;
}
/*
* call-seq:
* commit.message -> msg
*
* Return the message of this commit. This includes the full body of the
* message, with the short description, detailed descritpion, and any
* optional footers or signatures after it.
*
* In Ruby 1.9+, the returned string will be encoded with the encoding
* specified in the +Encoding+ header of the commit, if available.
*
* commit.message #=> "add a lot of RDoc docs\n\nthis includes docs for commit and blob"
*/
static VALUE rb_git_commit_message_GET(VALUE self)
{
git_commit *commit;
rb_encoding *encoding = rb_utf8_encoding();
const char *encoding_name;
const char *message;
Data_Get_Struct(self, git_commit, commit);
message = git_commit_message(commit);
encoding_name = git_commit_message_encoding(commit);
if (encoding_name != NULL)
encoding = rb_enc_find(encoding_name);
return rb_enc_str_new(message, strlen(message), encoding);
}
void init_mysql2_result() {
cBigDecimal = rb_const_get(rb_cObject, rb_intern("BigDecimal"));
cDate = rb_const_get(rb_cObject, rb_intern("Date"));
cDateTime = rb_const_get(rb_cObject, rb_intern("DateTime"));
cMysql2Result = rb_define_class_under(mMysql2, "Result", rb_cObject);
rb_define_method(cMysql2Result, "each", rb_mysql_result_each, -1);
rb_define_method(cMysql2Result, "fields", rb_mysql_result_fetch_fields, 0);
rb_define_method(cMysql2Result, "count", rb_mysql_result_count, 0);
rb_define_alias(cMysql2Result, "size", "count");
intern_encoding_from_charset = rb_intern("encoding_from_charset");
intern_encoding_from_charset_code = rb_intern("encoding_from_charset_code");
intern_new = rb_intern("new");
intern_utc = rb_intern("utc");
intern_local = rb_intern("local");
intern_merge = rb_intern("merge");
intern_localtime = rb_intern("localtime");
intern_local_offset = rb_intern("local_offset");
intern_civil = rb_intern("civil");
intern_new_offset = rb_intern("new_offset");
sym_symbolize_keys = ID2SYM(rb_intern("symbolize_keys"));
sym_as = ID2SYM(rb_intern("as"));
sym_array = ID2SYM(rb_intern("array"));
sym_local = ID2SYM(rb_intern("local"));
sym_utc = ID2SYM(rb_intern("utc"));
sym_cast_booleans = ID2SYM(rb_intern("cast_booleans"));
sym_database_timezone = ID2SYM(rb_intern("database_timezone"));
sym_application_timezone = ID2SYM(rb_intern("application_timezone"));
sym_cache_rows = ID2SYM(rb_intern("cache_rows"));
sym_cast = ID2SYM(rb_intern("cast"));
sym_stream = ID2SYM(rb_intern("stream"));
opt_decimal_zero = rb_str_new2("0.0");
rb_global_variable(&opt_decimal_zero); //never GC
opt_float_zero = rb_float_new((double)0);
rb_global_variable(&opt_float_zero);
opt_time_year = INT2NUM(2000);
opt_time_month = INT2NUM(1);
opt_utc_offset = INT2NUM(0);
#ifdef HAVE_RUBY_ENCODING_H
binaryEncoding = rb_enc_find("binary");
#endif
}
rb_encoding_t *
rb_to_encoding(VALUE obj)
{
rb_encoding_t *enc;
if (CLASS_OF(obj) == rb_cEncoding) {
enc = RENC(obj);
}
else {
StringValue(obj);
enc = rb_enc_find(RSTRING_PTR(obj));
if (enc == NULL) {
rb_raise(rb_eArgError, "unknown encoding name - %s",
RSTRING_PTR(obj));
}
}
return enc;
}
/*
* Return the given PostgreSQL encoding name as an rb_encoding.
*/
rb_encoding *
pg_get_pg_encname_as_rb_encoding( const char *pg_encname )
{
size_t i;
/* Trying looking it up in the conversion table */
for ( i = 0; i < sizeof(pg_enc_pg2ruby_mapping)/sizeof(pg_enc_pg2ruby_mapping[0]); ++i ) {
if ( strcmp(pg_encname, pg_enc_pg2ruby_mapping[i][0]) == 0 )
return rb_enc_find( pg_enc_pg2ruby_mapping[i][1] );
}
/* JOHAB isn't a builtin encoding, so make up a dummy encoding if it's seen */
if ( strncmp(pg_encname, "JOHAB", 5) == 0 )
return pg_find_or_create_johab();
/* Fallthrough to ASCII-8BIT */
return rb_ascii8bit_encoding();
}
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;
}
void Init_mosquitto_ext()
{
mosquitto_lib_init();
intern_call = rb_intern("call");
binary_encoding = rb_enc_find("binary");
rb_mMosquitto = rb_define_module("Mosquitto");
/*
* Message QOS specific constants
*/
rb_define_const(rb_mMosquitto, "AT_MOST_ONCE", INT2NUM(0));
rb_define_const(rb_mMosquitto, "AT_LEAST_ONCE", INT2NUM(1));
rb_define_const(rb_mMosquitto, "EXACTLY_ONCE", INT2NUM(2));
/*
* Log specific constants *
*/
rb_define_const(rb_mMosquitto, "LOG_NONE", INT2NUM(0x00));
rb_define_const(rb_mMosquitto, "LOG_INFO", INT2NUM(0x01));
rb_define_const(rb_mMosquitto, "LOG_NOTICE", INT2NUM(0x02));
rb_define_const(rb_mMosquitto, "LOG_WARNING", INT2NUM(0x04));
rb_define_const(rb_mMosquitto, "LOG_ERR", INT2NUM(0x08));
rb_define_const(rb_mMosquitto, "LOG_DEBUG", INT2NUM(0x10));
rb_define_const(rb_mMosquitto, "LOG_SUBSCRIBE", INT2NUM(0x20));
rb_define_const(rb_mMosquitto, "LOG_UNSUBSCRIBE", INT2NUM(0x40));
rb_define_const(rb_mMosquitto, "LOG_ALL", INT2NUM(0xFFFF));
/*
* TLS specific constants
*/
rb_define_const(rb_mMosquitto, "SSL_VERIFY_NONE", INT2NUM(0));
rb_define_const(rb_mMosquitto, "SSL_VERIFY_PEER", INT2NUM(1));
rb_eMosquittoError = rb_define_class_under(rb_mMosquitto, "Error", rb_eStandardError);
rb_define_module_function(rb_mMosquitto, "version", rb_mosquitto_version, 0);
rb_define_module_function(rb_mMosquitto, "cleanup", rb_mosquitto_cleanup, 0);
_init_rb_mosquitto_client();
_init_rb_mosquitto_message();
}
void init_mysql2_result()
{
cBigDecimal = rb_const_get(rb_cObject, rb_intern("BigDecimal"));
cDate = rb_const_get(rb_cObject, rb_intern("Date"));
cDateTime = rb_const_get(rb_cObject, rb_intern("DateTime"));
cMysql2Result = rb_define_class_under(mMysql2, "Result", rb_cObject);
rb_define_method(cMysql2Result, "each", rb_mysql_result_each, -1);
rb_define_method(cMysql2Result, "fields", rb_mysql_result_fetch_fields, 0);
sym_symbolize_keys = ID2SYM(rb_intern("symbolize_keys"));
intern_new = rb_intern("new");
intern_utc = rb_intern("utc");
intern_encoding_from_charset_code = rb_intern("encoding_from_charset_code");
#ifdef HAVE_RUBY_ENCODING_H
binaryEncoding = rb_enc_find("binary");
#endif
}
static void
sax_drive_init(SaxDrive dr, VALUE handler, VALUE io, SaxOptions options) {
ox_sax_buf_init(&dr->buf, io);
dr->buf.dr = dr;
stack_init(&dr->stack);
dr->handler = handler;
dr->value_obj = rb_data_object_alloc(ox_sax_value_class, dr, 0, 0);
rb_gc_register_address(&dr->value_obj);
dr->options = *options;
dr->hints = 0;
dr->err = 0;
has_init(&dr->has, handler);
#if HAS_ENCODING_SUPPORT
if ('\0' == *ox_default_options.encoding) {
VALUE encoding;
dr->encoding = 0;
if (rb_respond_to(io, ox_external_encoding_id) && Qnil != (encoding = rb_funcall(io, ox_external_encoding_id, 0))) {
int e = rb_enc_get_index(encoding);
if (0 <= e) {
dr->encoding = rb_enc_from_index(e);
}
}
} else {
dr->encoding = rb_enc_find(ox_default_options.encoding);
}
#elif HAS_PRIVATE_ENCODING
if ('\0' == *ox_default_options.encoding) {
VALUE encoding;
if (rb_respond_to(io, ox_external_encoding_id) && Qnil != (encoding = rb_funcall(io, ox_external_encoding_id, 0))) {
dr->encoding = encoding;
} else {
dr->encoding = Qnil;
}
} else {
dr->encoding = rb_str_new2(ox_default_options.encoding);
}
#else
dr->encoding = 0;
#endif
}
/*
* In Ruby 1.9 or later, ruby String object has encoding.
* conversion buffer string of vim to ruby String object using
* VIM encoding option.
*/
static VALUE
vim_str2rb_enc_str(const char *s)
{
#ifdef RUBY19_OR_LATER
int isnum;
long lval;
char_u *sval;
rb_encoding *enc;
isnum = get_option_value((char_u *)"enc", &lval, &sval, 0);
if (isnum == 0)
{
enc = rb_enc_find((char *)sval);
vim_free(sval);
if (enc) {
return rb_enc_str_new(s, strlen(s), enc);
}
}
#endif
return rb_str_new2(s);
}
VALUE rugged_signature_new(const git_signature *sig, const char *encoding_name)
{
VALUE rb_sig, rb_time;
#ifdef HAVE_RUBY_ENCODING_H
rb_encoding *encoding = NULL;
if (encoding_name != NULL)
encoding = rb_enc_find(encoding_name);
#endif
rb_sig = rb_hash_new();
rb_time = rb_time_new(sig->when.time, 0);
rb_funcall(rb_time, rb_intern("utc"), 0);
rb_hash_aset(rb_sig, CSTR2SYM("name"), rugged_str_new2(sig->name, encoding));
rb_hash_aset(rb_sig, CSTR2SYM("email"), rugged_str_new2(sig->email, encoding));
rb_hash_aset(rb_sig, CSTR2SYM("time"), rb_time);
return rb_sig;
}
static VALUE
eval_enc_string_protect(const char *str, int *state)
{
#ifdef RUBY19_OR_LATER
int isnum;
long lval;
char_u *sval;
rb_encoding *enc;
VALUE v;
isnum = get_option_value((char_u *)"enc", &lval, &sval, 0);
if (isnum == 0)
{
enc = rb_enc_find((char *)sval);
vim_free(sval);
if (enc)
{
v = rb_sprintf("#-*- coding:%s -*-\n%s", rb_enc_name(enc), str);
return rb_eval_string_protect(StringValuePtr(v), state);
}
}
#endif
return rb_eval_string_protect(str, state);
}
int
rb_enc_find_index(const char *name)
{
return index_of_encoding(rb_enc_find(name));
}
static VALUE encoding_spec_rb_enc_associate(VALUE self, VALUE obj, VALUE enc) {
return rb_enc_associate(obj, rb_enc_find(RSTRING_PTR(enc)));
}
static VALUE encoding_spec_rb_enc_to_index(VALUE self, VALUE name) {
return INT2NUM(rb_enc_to_index(rb_enc_find(RSTRING_PTR(name))));
}
static VALUE encoding_spec_rb_enc_from_encoding(VALUE self, VALUE name) {
return rb_enc_from_encoding(rb_enc_find(RSTRING_PTR(name)));
}
static VALUE encoding_spec_rb_enc_find(VALUE self, VALUE name) {
return rb_str_new2(rb_enc_find(RSTRING_PTR(name))->name);
}
static VALUE rb_tinytds_connect(VALUE self, VALUE opts) {
/* Parsing options hash to local vars. */
VALUE user, pass, dataserver, database, app, version, ltimeout, timeout, charset, azure;
GET_CLIENT_WRAPPER(self);
user = rb_hash_aref(opts, sym_username);
pass = rb_hash_aref(opts, sym_password);
dataserver = rb_hash_aref(opts, sym_dataserver);
database = rb_hash_aref(opts, sym_database);
app = rb_hash_aref(opts, sym_appname);
version = rb_hash_aref(opts, sym_tds_version);
ltimeout = rb_hash_aref(opts, sym_login_timeout);
timeout = rb_hash_aref(opts, sym_timeout);
charset = rb_hash_aref(opts, sym_encoding);
azure = rb_hash_aref(opts, sym_azure);
/* Dealing with options. */
if (dbinit() == FAIL) {
rb_raise(cTinyTdsError, "failed dbinit() function");
return self;
}
dberrhandle(tinytds_err_handler);
dbmsghandle(tinytds_msg_handler);
cwrap->login = dblogin();
if (!NIL_P(version))
dbsetlversion(cwrap->login, NUM2INT(version));
if (!NIL_P(user))
dbsetluser(cwrap->login, StringValueCStr(user));
if (!NIL_P(pass))
dbsetlpwd(cwrap->login, StringValueCStr(pass));
if (!NIL_P(app))
dbsetlapp(cwrap->login, StringValueCStr(app));
if (!NIL_P(ltimeout))
dbsetlogintime(NUM2INT(ltimeout));
if (!NIL_P(timeout))
dbsettime(NUM2INT(timeout));
if (!NIL_P(charset))
DBSETLCHARSET(cwrap->login, StringValueCStr(charset));
if (!NIL_P(database) && (azure == Qtrue)) {
#ifdef DBSETLDBNAME
DBSETLDBNAME(cwrap->login, StringValueCStr(database));
#else
rb_warn("TinyTds: Azure connections not supported in this version of FreeTDS.\n");
#endif
}
cwrap->client = dbopen(cwrap->login, StringValueCStr(dataserver));
if (cwrap->client) {
VALUE transposed_encoding;
cwrap->closed = 0;
cwrap->charset = charset;
if (!NIL_P(version))
dbsetversion(NUM2INT(version));
dbsetuserdata(cwrap->client, (BYTE*)cwrap->userdata);
cwrap->userdata->closed = 0;
if (!NIL_P(database) && (azure != Qtrue)) {
dbuse(cwrap->client, StringValueCStr(database));
}
transposed_encoding = rb_funcall(cTinyTdsClient, intern_transpose_iconv_encoding, 1, charset);
cwrap->encoding = rb_enc_find(StringValueCStr(transposed_encoding));
if (dbtds(cwrap->client) <= 7) {
cwrap->identity_insert_sql = "SELECT CAST(@@IDENTITY AS bigint) AS Ident";
} else {
cwrap->identity_insert_sql = "SELECT CAST(SCOPE_IDENTITY() AS bigint) AS Ident";
}
}
return self;
}
