static void require_libraries(VALUE *req_list) { VALUE list = *req_list; VALUE self = rb_vm_top_self(); ID require; rb_thread_t *th = GET_THREAD(); rb_block_t *prev_base_block = th->base_block; rb_encoding *extenc = rb_default_external_encoding(); int prev_parse_in_eval = th->parse_in_eval; th->base_block = 0; th->parse_in_eval = 0; Init_ext(); /* should be called here for some reason :-( */ CONST_ID(require, "require"); while (list && RARRAY_LEN(list) > 0) { VALUE feature = rb_ary_shift(list); rb_enc_associate(feature, extenc); RBASIC(feature)->klass = rb_cString; OBJ_FREEZE(feature); rb_funcall2(self, require, 1, &feature); } *req_list = 0; th->parse_in_eval = prev_parse_in_eval; th->base_block = prev_base_block; }
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; }
void CRScriptCore::InitializeEnvironment() { ATLTRACE(_("Initialize Environment in Thread:%08X\n"), GetCurrentThreadId()); #ifndef __IRubyEngine_INTERFACE_DEFINED__ int stacktop; s_pStackTop = reinterpret_cast<LPBYTE>(&stacktop); #endif int dummyargc(1); char* dummyargv[] = {"dummy", NULL }; char** pargv; ruby_sysinit(&dummyargc, &pargv); RUBY_INIT_STACK; ruby_init(); ruby_options(3, asr_argv); s_pEncoding = rb_default_internal_encoding(); if (!s_pEncoding) s_pEncoding = rb_default_external_encoding(); try { rb_require("win32ole"); VALUE v = rb_eval_string("WIN32OLE"); // override original constructor rb_define_singleton_method(v, "new", reinterpret_cast<VALUE(*)(...)>(fole_s_new), -1); rb_define_singleton_method(v, "connect", reinterpret_cast<VALUE(*)(...)>(fole_s_connect), 1); rb_define_singleton_method(v, "attach", reinterpret_cast<VALUE(*)(...)>(foleex_attach), 2); rb_define_method(v, "__release", reinterpret_cast<VALUE(*)(...)>(foleex_release), 0); rb_define_method(v, "method_missing", reinterpret_cast<VALUE(*)(...)>(foleex_missing), -1); rb_define_method(v, "each", reinterpret_cast<VALUE(*)(...)>(foleex_each), 0); if (rb_const_defined_at(v, rb_intern("ARGV")) == Qfalse) { rb_define_const(v, "ARGV", rb_ary_new()); } s_valueWin32Ole = v; s_valueWIN32OLERuntimeError = rb_eval_string("WIN32OLERuntimeError"); v = rb_define_class("WIN32OLEEX", v); s_valueWin32OleEx = v; rb_define_singleton_method(v, "attach", reinterpret_cast<VALUE(*)(...)>(foleex_attach), 2); rb_define_method(v, "method_missing", reinterpret_cast<VALUE(*)(...)>(foleex_missing), -1); // s_valueActiveRubyScript = rb_define_class("ActiveScriptRuby", rb_cObject); rb_define_singleton_method(s_valueActiveRubyScript, "trace", (VALUE(*)(...))trace_hook, 6); rb_define_singleton_method(s_valueActiveRubyScript, "settrace", (VALUE(*)(...))trace_set, 1); rb_define_singleton_method(s_valueActiveRubyScript, "rubyize", (VALUE(*)(...))rubyize, 1); } catch (...) { ATLTRACE(_T("Exception for class\n")); } }
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; }
/* * call-seq: * blob.text(max_lines = -1, encoding = Encoding.default_external) -> String * * Return up to +max_lines+ of text from a blob as a +String+. * * In Ruby 1.9.x, the string is created with the given +encoding+, * defaulting to Encoding.default_external. * * In previous versions, the +encoding+ argument is dummy and has no * effect on the returned string. * * When limiting the size of the text with +max_lines+, the string is * expected to have an ASCII-compatible encoding, and is checked * for the newline +\n+ character. */ static VALUE rb_git_blob_text_GET(int argc, VALUE *argv, VALUE self) { #ifdef HAVE_RUBY_ENCODING_H rb_encoding *encoding = rb_default_external_encoding(); #endif git_blob *blob; size_t size; const char *content; VALUE rb_max_lines, rb_encoding; Data_Get_Struct(self, git_blob, blob); rb_scan_args(argc, argv, "02", &rb_max_lines, &rb_encoding); content = git_blob_rawcontent(blob); size = git_blob_rawsize(blob); if (!NIL_P(rb_max_lines)) { size_t i = 0; int lines = 0, maxlines; Check_Type(rb_max_lines, T_FIXNUM); maxlines = FIX2INT(rb_max_lines); if (maxlines >= 0) { while (i < size && lines < maxlines) { if (content[i++] == '\n') lines++; } } size = (size_t)i; } #ifdef HAVE_RUBY_ENCODING_H if (!NIL_P(rb_encoding)) { encoding = rb_to_encoding(rb_encoding); } #endif if (size == 0) return rugged_str_new("", 0, encoding); return rugged_str_new(content, size, encoding); }
VALUE rb_enc_default_external(void) { return rb_enc_from_encoding(rb_default_external_encoding()); }
VALUE ruv_buffer_write(int argc, VALUE* argv, VALUE rb_buffer) { VALUE rb_str, rb_offset, rb_length, rb_extern_enc, rb_cBuffer; size_t offset, length, max_length, char_count; ruv_buffer_t *buffer; rb_encoding *rb_extern_encoding; Data_Get_Struct(rb_buffer, ruv_buffer_t, buffer); rb_scan_args(argc, argv, "13", &rb_str, &rb_offset, &rb_length, &rb_extern_enc); StringValue(rb_str); // encoding: use specified external encoding if provided // otherwise use Encoding.default_external as default if(!NIL_P(rb_extern_enc)) { rb_extern_encoding = rb_enc_get(rb_extern_enc); } else { rb_extern_encoding = rb_default_external_encoding(); } // convert to external encoding rb_str = rb_str_export_to_enc(rb_str, rb_extern_encoding); // offset: either specified in params or 0 if(!NIL_P(rb_offset)) { Check_Type(rb_offset, T_FIXNUM); offset = NUM2SIZET(rb_offset); if(offset >= buffer->length) { rb_raise(rb_eArgError, "Overflow! offset is larger than buffer size."); } } else { offset = 0; } // max length: the smaller of the max available space or the whole ruby string max_length = MIN(buffer->length - offset, (size_t)RSTRING_LEN(rb_str)); // length: number of bytes to write. (include half chars) if(!NIL_P(rb_length)) { Check_Type(rb_length, T_FIXNUM); length = NUM2SIZET(rb_length); } else { length = max_length; } // If we are not writing the whole string into the buffer, // re-adjust length so we don't write half a character (uft8, etc) // 1). get char count from calculated byte length // 2). get byte length back from char count // This way only whole char is written to buffer if(length != (size_t)RSTRING_LEN(rb_str)) { char_count = rb_str_sublen(rb_str, length); length = rb_str_offset(rb_str, char_count); } memcpy(buffer->data + offset, RSTRING_PTR(rb_str), length); // set instance variable so we know how much characters are written rb_cBuffer = rb_obj_class(rb_buffer); rb_iv_set(rb_cBuffer, RUV_BUFFER_CHAR_WRITTEN_SYM, SIZET2NUM(char_count)); return SIZET2NUM(length); }
int Init_enc_set_filesystem_encoding(void) { return rb_enc_to_index(rb_default_external_encoding()); }
static VALUE encoding_spec_rb_default_external_encoding(VALUE self) { rb_encoding* enc = rb_default_external_encoding(); if(enc == 0) return Qnil; return rb_str_new2(enc->name); }