VALUE string_spec_rb_str_new_cstr(VALUE self, VALUE str) { if(NIL_P(str)) { return rb_str_new_cstr(NULL); } else { return rb_str_new_cstr(RSTRING_PTR(str)); } }
static VALUE symbol_new(bfd * abfd, asymbol *s, char is_dynamic) { symbol_info info; VALUE class, instance; VALUE argv[1] = { Qnil }; class = rb_class_new(clsSymbol); instance = Data_Wrap_Struct(class, NULL, NULL, s); rb_obj_call_init(instance, 0, argv); bfd_symbol_info(s, &info); /* set instance variables */ rb_iv_set(instance, IVAR(SYM_ATTR_NAME), rb_str_new_cstr(info.name) ); rb_iv_set(instance, IVAR(SYM_ATTR_TYPE), INT2NUM((int) info.type) ); rb_iv_set(instance, IVAR(SYM_ATTR_VALUE), SIZET2NUM(info.value) ); rb_iv_set(instance, IVAR(SYM_ATTR_FLAGS), INT2NUM(s->flags) ); rb_iv_set(instance, IVAR(SYM_ATTR_BIND), rb_str_new_cstr( (is_dynamic ? SYM_BIND_DYNAMIC : SYM_BIND_STATIC) ) ); if ( s->section ) { rb_iv_set(instance, IVAR(SYM_ATTR_SECTION), rb_str_new_cstr(s->section->name)); } return instance; }
static VALUE arg_string_literal_serialize(void* data) { rb_tracelog_arg_string_literal_t *arg = (rb_tracelog_arg_string_literal_t*)data; VALUE key = rb_str_new_cstr(arg->key); VALUE val = rb_str_new_cstr(arg->val); VALUE args = rb_hash_new(); rb_hash_aset(args, key, val); return args; }
static void showExc(VALUE exc) { VALUE bt = rb_funcall2(exc, rb_intern("backtrace"), 0, NULL); VALUE bt0 = rb_ary_entry(bt, 0); VALUE name = rb_class_path(rb_obj_class(exc)); VALUE ds = rb_sprintf("%" PRIsVALUE ": %" PRIsVALUE " (%" PRIsVALUE ")", bt0, exc, name); /* omit "useless" last entry (from ruby:1:in `eval') */ for (long i = 1, btlen = RARRAY_LEN(bt) - 1; i < btlen; ++i) rb_str_catf(ds, "\n\tfrom %" PRIsVALUE, rb_ary_entry(bt, i)); Debug() << StringValueCStr(ds); ID id_index = rb_intern("index"); /* an "offset" argument is not needed for the first time */ VALUE argv[2] = { rb_str_new_cstr(":") }; long filelen = NUM2LONG(rb_funcall2(bt0, id_index, 1, argv)); argv[1] = LONG2NUM(filelen + 1); VALUE tmp = rb_funcall2(bt0, id_index, ARRAY_SIZE(argv), argv); long linelen = NUM2LONG(tmp) - filelen - 1; VALUE file = rb_str_subseq(bt0, 0, filelen); VALUE line = rb_str_subseq(bt0, filelen + 1, linelen); VALUE ms = rb_sprintf("Script '%" PRIsVALUE "' line %" PRIsVALUE ": %" PRIsVALUE " occured.\n\n%" PRIsVALUE, file, line, name, exc); showMsg(StringValueCStr(ms)); }
static void grpc_rb_call_credentials_callback_with_gil(void* param) { callback_params* const params = (callback_params*)param; VALUE auth_uri = rb_str_new_cstr(params->context.service_url); /* Pass the arguments to the proc in a hash, which currently only has they key 'auth_uri' */ VALUE callback_args = rb_ary_new(); VALUE args = rb_hash_new(); VALUE result; grpc_metadata_array md_ary; grpc_status_code status; VALUE details; char* error_details; grpc_metadata_array_init(&md_ary); rb_hash_aset(args, ID2SYM(rb_intern("jwt_aud_uri")), auth_uri); rb_ary_push(callback_args, params->get_metadata); rb_ary_push(callback_args, args); result = rb_rescue(grpc_rb_call_credentials_callback, callback_args, grpc_rb_call_credentials_callback_rescue, Qnil); // Both callbacks return a hash, so result should be a hash grpc_rb_md_ary_convert(rb_hash_aref(result, rb_str_new2("metadata")), &md_ary); status = NUM2INT(rb_hash_aref(result, rb_str_new2("status"))); details = rb_hash_aref(result, rb_str_new2("details")); error_details = StringValueCStr(details); params->callback(params->user_data, md_ary.metadata, md_ary.count, status, error_details); grpc_rb_metadata_array_destroy_including_entries(&md_ary); gpr_free(params); }
VALUE zval_to_hash(zval *zv) { HashTable *ht; HashPosition pos; zval **data; VALUE ret; convert_to_array(zv); ht = Z_ARRVAL_P(zv); ret = rb_hash_new(); zend_hash_internal_pointer_reset_ex(ht, &pos); while (zend_hash_get_current_data_ex(ht, (void **)&data, &pos) == SUCCESS) { char* key_str; uint key_len; ulong num_index; VALUE key = Qnil; VALUE val = new_php_embed_value(*data); switch(zend_hash_get_current_key_ex(ht, &key_str, &key_len, &num_index, 0, &pos)) { case HASH_KEY_IS_STRING: //key = rb_str_new(key_str, key_len); key = rb_str_new_cstr(key_str); break; case HASH_KEY_IS_LONG: key = LONG2NUM(num_index); break; } rb_hash_aset(ret, key, val); zend_hash_move_forward_ex(ht, &pos); } return ret; }
static VALUE test_num2ull(VALUE obj, VALUE num) { char buf[128]; sprintf(buf, "%"PRI_LL_PREFIX"u", NUM2ULL(num)); return rb_str_new_cstr(buf); }
static VALUE test_num2int(VALUE obj, VALUE num) { char buf[128]; sprintf(buf, "%d", NUM2INT(num)); return rb_str_new_cstr(buf); }
static VALUE test_num2ulong(VALUE obj, VALUE num) { char buf[128]; sprintf(buf, "%lu", NUM2ULONG(num)); return rb_str_new_cstr(buf); }
/* * Errors */ static VALUE ossl_make_error(VALUE exc, const char *fmt, va_list args) { VALUE str = Qnil; unsigned long e; if (fmt) { str = rb_vsprintf(fmt, args); } e = ERR_peek_last_error(); if (e) { const char *msg = ERR_reason_error_string(e); if (NIL_P(str)) { if (msg) str = rb_str_new_cstr(msg); } else { if (RSTRING_LEN(str)) rb_str_cat2(str, ": "); rb_str_cat2(str, msg ? msg : "(null)"); } ossl_clear_error(); } if (NIL_P(str)) str = rb_str_new(0, 0); return rb_exc_new3(exc, str); }
VALUE xopenssl_md5(VALUE self, VALUE str) { // We need to copy to a native string as we can't pass Ruby strings into native at the moment size_t str_len = RSTRING_LEN(str); char *str_ptr = RSTRING_PTR(str); unsigned char *native_str = alloca(str_len + 1); for (int n = 0; n < str_len; n++) { native_str[n] = str_ptr[n]; } native_str[str_len] = '\0'; unsigned char digest[MD5_DIGEST_LENGTH]; MD5(native_str, str_len, digest); char *hex = alloca(MD5_DIGEST_LENGTH * 2 + 1); char *hex_ptr = hex; for (int n = 0; n < MD5_DIGEST_LENGTH; n++){ hex_ptr += sprintf(hex_ptr, "%02x", digest[n]); } *hex_ptr = '\0'; return rb_str_new_cstr(hex); }
int proxenet_ruby_load_file(plugin_t* plugin) { char* filename; char* pathname; int res = 0; if(plugin->state != INACTIVE){ #ifdef DEBUG if(cfg->verbose > 2) xlog(LOG_DEBUG, "Plugin '%s' is already loaded. Skipping...\n", plugin->name); #endif return 0; } filename = plugin->filename; pathname = plugin->fullpath; rb_load_protect(rb_str_new_cstr(pathname), 0, &res); if (res != 0) { xlog(LOG_ERROR, "[Ruby] Error %d when load file '%s'\n", res, pathname); return -1; } #ifdef DEBUG xlog(LOG_DEBUG, "%s\n", pathname); #endif return 0; }
static VALUE test_fix2short(VALUE obj, VALUE num) { char buf[128]; sprintf(buf, "%d", FIX2SHORT(num)); return rb_str_new_cstr(buf); }
static VALUE test_fix2uint(VALUE obj, VALUE num) { char buf[128]; sprintf(buf, "%u", FIX2UINT(num)); return rb_str_new_cstr(buf); }
static VALUE rd_die_source_files(VALUE self) { rd_die_t *die = GetDie(self); Dwarf_Signed cnt = 0; char **srcfiles = 0; Dwarf_Error err; VALUE files = Qnil; if (die->srcfiles != Qfalse) { return die->srcfiles; } if (chkerr2(dwarf_srcfiles(die->die, &srcfiles, &cnt, &err), &err)) { int i; files = rb_ary_new_capa(cnt); for (i = 0; i < cnt; i++) { VALUE file = rb_str_new_cstr(srcfiles[i]); OBJ_FREEZE(file); rb_ary_store(files, i, file); dwarf_dealloc(die->shared_data->dbg, srcfiles[i], DW_DLA_STRING); } dwarf_dealloc(die->shared_data->dbg, srcfiles, DW_DLA_LIST); } die->srcfiles = files; return files; }
static VALUE test_fix2long(VALUE obj, VALUE num) { char buf[128]; sprintf(buf, "%ld", FIX2LONG(num)); return rb_str_new_cstr(buf); }
static VALUE test_num2ushort(VALUE obj, VALUE num) { char buf[128]; sprintf(buf, "%u", NUM2USHORT(num)); return rb_str_new_cstr(buf); }
void KeyboardEvent::run_procs(VALUE *observer, int type, int *keycode) { for (int i = 0; i < RARRAY_LEN(*observer); i++) { if (keycode_names) key = rb_str_new_cstr(al_keycode_to_name(*keycode)); else if (unichar) key = rb_str_new_cstr((char*)keycode); else key = INT2FIX(*keycode); rb_proc_call_with_block(rb_ary_entry(*observer, i), 1, &key, rb_ary_entry(*observer, i)); } }
static void rb_grn_query_logger_log (grn_ctx *ctx, unsigned int flag, const char *timestamp, const char *info, const char *message, void *user_data) { VALUE handler = (VALUE)user_data; if (NIL_P(handler)) return; /* TODO: use rb_protect(). */ rb_funcall(handler, id_log, 4, GRNQUERYLOGFLAGS2RVAL(flag), rb_str_new_cstr(timestamp), rb_str_new_cstr(info), rb_str_new_cstr(message)); }
/* * Convert date to a String * * @return [String] */ static VALUE rb_ct_date_to_string(VALUE self) { ct_date *date; char *format; CTDBRET rc; VRLEN size = 0; TEXT str; GetCTDate(self, date); switch ( date->type ) { case CTDATE_MDCY : format = (char *)"%m/%d/%Y"; break; case CTDATE_DMCY : format = (char *)"%m/%d/%y"; break; case CTDATE_CYMD : format = (char *)"%d/%m/%Y"; break; case CTDATE_MDY : format = (char *)"%d/%m/%y"; break; case CTDATE_DMY : format = (char *)"%Y%m%d"; break; case CTDATE_YMD : format = (char *)"%y%m%d"; break; default : rb_raise(cCTError, "Unexpected default date format"); break; } if ( date->value > 0 ) { size = (VRLEN)(strlen(format) + 3); if ( (rc = ctdbDateToString(date->value, date->type, &str, size) ) != CTDBRET_OK ) rb_raise(cCTError, "[%d] ctdbDateToString failed.", rc); return rb_str_new_cstr(&str); } else return rb_str_new_cstr(""); }
/* Return a list of trace hook line numbers for the string in Ruby source src*/ static VALUE lnums_for_str(VALUE self, VALUE src) { VALUE result = rb_ary_new(); /* The returned array of line numbers. */ int len; char *token; char *disasm; rb_thread_t *th; VALUE iseqval; VALUE disasm_val; StringValue(src); /* Check that src is a string. */ th = GET_THREAD(); /* First compile to bytecode, using the method in eval_string_with_cref() in vm_eval.c */ th->parse_in_eval++; th->mild_compile_error++; iseqval = rb_iseq_compile(src, rb_str_new_cstr("(numbers_for_str)"), INT2FIX(1)); th->mild_compile_error--; th->parse_in_eval--; /* Disassemble the bytecode into text and parse into lines */ disasm_val = rb_iseq_disasm(iseqval); if (disasm_val == Qnil) return(result); disasm = (char*)malloc(strlen(RSTRING_PTR(disasm_val))+1); strcpy(disasm, RSTRING_PTR(disasm_val)); for (token = strtok(disasm, "\n"); token != NULL; token = strtok(NULL, "\n")) { /* look only for lines tracing RUBY_EVENT_LINE (1) */ if (strstr(token, "trace 1 ") == NULL) continue; len = strlen(token) - 1; if (token[len] != ')') continue; len--; if ((token[len] == '(') || (token[len] == ' ')) continue; for (; len > 0; len--) { if (token[len] == ' ') continue; if ((token[len] >= '0') && (token[len] <= '9')) continue; if (token[len] == '(') rb_ary_push(result, INT2NUM(atoi(token + len + 1))); /* trace found */ break; } } free(disasm); return result; }
static void rb_grn_logger_log (grn_ctx *ctx, grn_log_level level, const char *timestamp, const char *title, const char *message, const char *location, void *user_data) { VALUE handler = (VALUE)user_data; if (NIL_P(handler)) return; /* TODO: use rb_protect(). */ rb_funcall(handler, id_log, 5, GRNLOGLEVEL2RVAL(level), rb_str_new_cstr(timestamp), rb_str_new_cstr(title), rb_str_new_cstr(message), rb_str_new_cstr(location)); }
static void init_symbol_class( VALUE modBfd ) { /* NOTE: Symbol does not support instantiation via .new() */ clsSymbol = rb_define_class_under(modBfd, SYMBOL_CLASS_NAME, rb_cObject); /* attributes (read-only) */ rb_define_attr(clsSymbol, SYM_ATTR_NAME, 1, 0); rb_define_attr(clsSymbol, SYM_ATTR_VALUE, 1, 0); rb_define_attr(clsSymbol, SYM_ATTR_FLAGS, 1, 0); rb_define_attr(clsSymbol, SYM_ATTR_SECTION, 1, 0); rb_define_attr(clsSymbol, SYM_ATTR_BIND, 1, 0); /* constants */ rb_define_const(clsSymbol, SYM_BIND_DYN_NAME, rb_str_new_cstr(SYM_BIND_DYNAMIC)); rb_define_const(clsSymbol, SYM_BIND_STAT_NAME, rb_str_new_cstr(SYM_BIND_STATIC)); }
static VALUE wcs2rb(const wchar_t *s) { size_t n = wcslen(s); size_t size = n * 6; // Max size of a UTF-8 character char bytes[size]; if (wcstombs(bytes, s, size) != n) { encoding_failure(); } return rb_str_new_cstr(bytes); }
void Init_wkhtml_native() { //Global initialization of library and when Ruby shuts down wkhtmltopdf_init(USE_GRAPHICS_INT); wkhtmltoimage_init(USE_GRAPHICS_INT); rb_set_end_proc(Deinit_wkhtml_native, Qnil); idReady = rb_intern("ready"); mWkHtml = rb_define_module("WkHtml"); rb_define_const(mWkHtml, "LIBRARY_VERSION", rb_obj_freeze(rb_str_new_cstr(wkhtmltopdf_version()))); rb_define_const(mWkHtml, "USE_GRAPHICS", INT2BOOL(USE_GRAPHICS_INT)); mWkHtmlToPdf = rb_define_module_under(mWkHtml, "ToPdf"); cWkHtmlToPdfGlobalSettings = rb_define_class_under(mWkHtmlToPdf, "GlobalSettings", rb_cObject); rb_define_alloc_func(cWkHtmlToPdfGlobalSettings, wkhtml_topdf_globalsettings_alloc); rb_define_method(cWkHtmlToPdfGlobalSettings, "[]=", wkhtml_topdf_globalsettings_aset, 2); rb_define_method(cWkHtmlToPdfGlobalSettings, "[]", wkhtml_topdf_globalsettings_aref, 1); cWkHtmlToPdfObjectSettings = rb_define_class_under(mWkHtmlToPdf, "ObjectSettings", rb_cObject); rb_define_alloc_func(cWkHtmlToPdfObjectSettings, wkhtml_topdf_objectsettings_alloc); rb_define_method(cWkHtmlToPdfObjectSettings, "[]=", wkhtml_topdf_objectsettings_aset, 2); rb_define_method(cWkHtmlToPdfObjectSettings, "[]", wkhtml_topdf_objectsettings_aref, 1); cWkHtmlToPdfConverter = rb_define_class_under(mWkHtmlToPdf, "Converter", rb_cObject); /* TODO rb_define_singleton_method(klass, "new", constructor, 1); //Uses Data_Wrap_Struct -> rb_obj_call_init(t_data, 1, argv); rb_define_method(klass, "initialize", initialize, 1); */ rb_define_singleton_method(cWkHtmlToPdfConverter, "create", wkhtml_topdf_converter_create, 1); rb_define_method(cWkHtmlToPdfConverter, "add_object", wkhtml_topdf_converter_add_object, 2); rb_define_method(cWkHtmlToPdfConverter, "convert", wkhtml_topdf_converter_convert, 0); rb_define_method(cWkHtmlToPdfConverter, "http_error_code", wkhtml_topdf_converter_http_error_code, 0); rb_define_method(cWkHtmlToPdfConverter, "get_output", wkhtml_topdf_converter_get_output, 0); //Force use of factory method rb_undef_alloc_func(cWkHtmlToPdfConverter); rb_undef_method(rb_singleton_class(cWkHtmlToPdfConverter), "new"); mWkHtmlToImage = rb_define_module_under(mWkHtml, "ToImage"); cWkHtmlToImageGlobalSettings = rb_define_class_under(mWkHtmlToImage, "GlobalSettings", rb_cObject); rb_define_alloc_func(cWkHtmlToImageGlobalSettings, wkhtml_toimage_globalsettings_alloc); rb_define_method(cWkHtmlToImageGlobalSettings, "[]=", wkhtml_toimage_globalsettings_aset, 2); rb_define_method(cWkHtmlToImageGlobalSettings, "[]", wkhtml_toimage_globalsettings_aref, 1); cWkHtmlToImageConverter = rb_define_class_under(mWkHtmlToImage, "Converter", rb_cObject); rb_define_singleton_method(cWkHtmlToImageConverter, "create", wkhtml_toimage_converter_create, 2); rb_define_method(cWkHtmlToImageConverter, "convert", wkhtml_toimage_converter_convert, 0); rb_define_method(cWkHtmlToImageConverter, "http_error_code", wkhtml_toimage_converter_http_error_code, 0); rb_define_method(cWkHtmlToImageConverter, "get_output", wkhtml_toimage_converter_get_output, 0); //Force use of factory method rb_undef_alloc_func(cWkHtmlToImageConverter); rb_undef_method(rb_singleton_class(cWkHtmlToImageConverter), "new"); }
static VALUE rb_hello_message(VALUE self) { Hello *hello; const char *message; TypedData_Get_Struct(self, Hello, &rb_hello_type, hello); message = hello_message(hello); return rb_str_new_cstr(message); }
/* * Gets the current query log path that is used the default query logger. * * @overload path * @return [String or nil] The current query log path * * @since 3.0.1 */ static VALUE rb_grn_query_logger_s_get_path (VALUE klass) { const char *path; VALUE rb_path = Qnil; path = grn_default_query_logger_get_path(); if (path) { rb_path = rb_str_new_cstr(path); } return rb_path; }
static void reader_emit(const clj_Reader *reader, const clj_Node *node) { clj_rb_ReadData *data = (clj_rb_ReadData*)reader->data; ID id; VALUE s, value; VALUE one = rb_str_new_cstr("1"); // TODO: Delete me if (clj_is_atomic(node->type)) { s = wcs2rb(node->value); //TODO: begin shit code switch (node->type) { case CLJ_NUMBER: value = rb_funcall(data->target, sym_number, 5, s, one, one, Qfalse, Qfalse); break; case CLJ_STRING: value = rb_funcall(data->target, sym_string, 1, s); break; case CLJ_CHARACTER: value = rb_funcall(data->target, sym_character, 1, s); break; case CLJ_KEYWORD: value = rb_funcall(data->target, sym_keyword, 3, s, one, one); break; case CLJ_SYMBOL: value = rb_funcall(data->target, sym_symbol, 3, s, one, one); break; //TODO: DEFAULT CASE! } //TODO: END shit code rb_funcall(data->target, sym_atomic, 1, value); } else if (clj_is_end(node->type)) { rb_funcall(data->target, sym_end_composite, 0); } else { switch (node->type) { case CLJ_LIST: id = sym_list_builder; break; case CLJ_VECTOR: id = sym_vector_builder; break; case CLJ_MAP: id = sym_map_builder; break; case CLJ_SET: id = sym_set_builder; break; default: assert(0); //TODO: Real error //TODO: DEFAULT CASE! } value = rb_funcall(data->target, id, 0); rb_funcall(data->target, sym_begin_composite, 1, value); } }
void libssh_ruby_raise(ssh_session session) { VALUE exc, code, message; VALUE argv[1]; code = INT2FIX(ssh_get_error_code(session)); message = rb_str_new_cstr(ssh_get_error(session)); argv[0] = message; exc = rb_class_new_instance(1, argv, rb_eLibSSHError); rb_ivar_set(exc, id_code, code); rb_exc_raise(exc); }
VALUE cbasic_to_str(VALUE self) { basic_struct *this; char *str_ptr; VALUE result; Data_Get_Struct(self, basic_struct, this); str_ptr = basic_str(this); result = rb_str_new_cstr(str_ptr); basic_str_free(str_ptr); return result; }