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; }