static mrb_value
mrb_proc_inspect(mrb_state *mrb, mrb_value self)
{
struct RProc *p = mrb_proc_ptr(self);
mrb_value str = mrb_str_new_lit(mrb, "#<Proc:");
mrb_str_concat(mrb, str, mrb_ptr_to_str(mrb, mrb_cptr(self)));
if (!MRB_PROC_CFUNC_P(p)) {
mrb_irep *irep = p->body.irep;
mrb_str_cat_lit(mrb, str, "@");
if (irep->filename) {
mrb_str_cat_cstr(mrb, str, irep->filename);
}
else {
mrb_str_cat_lit(mrb, str, "-");
}
mrb_str_cat_lit(mrb, str, ":");
if (irep->lines) {
mrb_str_append(mrb, str, mrb_fixnum_value(*irep->lines));
}
else {
mrb_str_cat_lit(mrb, str, "-");
}
}
if (MRB_PROC_STRICT_P(p)) {
mrb_str_cat_lit(mrb, str, " (lambda)");
}
mrb_str_cat_lit(mrb, str, ">");
return str;
}
static void
exc_output_backtrace(mrb_state *mrb, struct RObject *exc, output_stream_func func, void *stream)
{
output_backtrace(mrb, mrb_fixnum(mrb_obj_iv_get(mrb, exc, mrb_intern_lit(mrb, "ciidx"))),
(mrb_code*)mrb_cptr(mrb_obj_iv_get(mrb, exc, mrb_intern_lit(mrb, "lastpc"))),
func, stream);
}
void
mrb_save_backtrace(mrb_state *mrb)
{
mrb_value lastpc;
mrb_code *code;
mrb_int ciidx;
mrb->backtrace.n = 0;
mrb->backtrace.exc = 0;
if (!mrb->exc)
return;
mrb->backtrace.exc = mrb->exc;
lastpc = mrb_obj_iv_get(mrb, mrb->exc, mrb_intern_lit(mrb, "lastpc"));
if (mrb_nil_p(lastpc)) {
code = NULL;
}
else {
code = (mrb_code*)mrb_cptr(lastpc);
}
ciidx = mrb_fixnum(mrb_obj_iv_get(mrb, mrb->exc, mrb_intern_lit(mrb, "ciidx")));
each_backtrace(mrb, ciidx, code, save_backtrace_i, NULL);
}
static mrb_value
mrb_proc_inspect(mrb_state *mrb, mrb_value self)
{
struct RProc *p = mrb_proc_ptr(self);
mrb_value str = mrb_str_new_lit(mrb, "#<Proc:");
mrb_str_concat(mrb, str, mrb_ptr_to_str(mrb, mrb_cptr(self)));
if (!MRB_PROC_CFUNC_P(p)) {
mrb_irep *irep = p->body.irep;
const char *filename;
int32_t line;
mrb_str_cat_lit(mrb, str, "@");
filename = mrb_debug_get_filename(irep, 0);
mrb_str_cat_cstr(mrb, str, filename ? filename : "-");
mrb_str_cat_lit(mrb, str, ":");
line = mrb_debug_get_line(irep, 0);
if (line != -1) {
mrb_str_append(mrb, str, mrb_fixnum_value(line));
}
else {
mrb_str_cat_lit(mrb, str, "-");
}
}
if (MRB_PROC_STRICT_P(p)) {
mrb_str_cat_lit(mrb, str, " (lambda)");
}
mrb_str_cat_lit(mrb, str, ">");
return str;
}
static mrb_value
mrb_grn_expr_code_initialize(mrb_state *mrb, mrb_value self)
{
mrb_value mrb_code;
mrb_get_args(mrb, "o", &mrb_code);
DATA_TYPE(self) = &mrb_grn_expr_code_type;
DATA_PTR(self) = mrb_cptr(mrb_code);
return self;
}
static mrb_value
mrb_grn_scan_info_initialize(mrb_state *mrb, mrb_value self)
{
mrb_value mrb_ptr;
mrb_get_args(mrb, "o", &mrb_ptr);
DATA_TYPE(self) = &mrb_grn_scan_info_type;
DATA_PTR(self) = mrb_cptr(mrb_ptr);
return self;
}
static mrb_value
mrb_grn_variable_size_column_initialize(mrb_state *mrb, mrb_value self)
{
mrb_value mrb_variable_size_column_ptr;
mrb_get_args(mrb, "o", &mrb_variable_size_column_ptr);
DATA_TYPE(self) = &mrb_grn_variable_size_column_type;
DATA_PTR(self) = mrb_cptr(mrb_variable_size_column_ptr);
return self;
}
static mrb_value
mrb_future_value(mrb_state *mrb, mrb_value self)
{
mrb_future_context *context = (mrb_future_context *)mrb_cptr(mrb_iv_get(mrb, self, mrb_intern_cstr(mrb, "_context")));
if (mrb_fixnum(mrb_iv_get(mrb, self, mrb_intern_cstr(mrb, "_state"))) == FUTURE_RUNNING) {
pthread_join(context->thread, NULL);
}
return mrb_iv_get(mrb, self, mrb_intern_cstr(mrb, "value"));
}
mrb_value
mrb_any_to_s(mrb_state *mrb, mrb_value obj)
{
mrb_value str = mrb_str_buf_new(mrb, 20);
const char *cname = mrb_obj_classname(mrb, obj);
mrb_str_buf_cat(mrb, str, "#<", 2);
mrb_str_cat2(mrb, str, cname);
mrb_str_cat(mrb, str, ":", 1);
mrb_str_concat(mrb, str, mrb_ptr_to_str(mrb, mrb_cptr(obj)));
mrb_str_buf_cat(mrb, str, ">", 1);
return str;
}
static void
exc_output_backtrace(mrb_state *mrb, struct RObject *exc, output_stream_func func, void *stream)
{
mrb_value lastpc;
mrb_code *code;
lastpc = mrb_obj_iv_get(mrb, exc, mrb_intern_lit(mrb, "lastpc"));
if (mrb_nil_p(lastpc)) {
code = NULL;
} else {
code = (mrb_code*)mrb_cptr(lastpc);
}
output_backtrace(mrb, mrb_fixnum(mrb_obj_iv_get(mrb, exc, mrb_intern_lit(mrb, "ciidx"))),
code, func, stream);
}
static void *
mrb_sdl2_input_to_voidp(mrb_state *mrb, mrb_value data)
{
mrb_sdl2_input_user_data_t *udata =
(mrb_sdl2_input_user_data_t*)mrb_malloc(mrb, sizeof(mrb_sdl2_input_user_data_t));
if (NULL == udata) {
mrb_raise(mrb, E_RUNTIME_ERROR, "insufficient memory.");
}
switch (mrb_type(data)) {
case MRB_TT_FIXNUM:
udata->data.fixnum_value = mrb_fixnum(data);
break;
case MRB_TT_FLOAT:
udata->data.float_value = mrb_float(data);
break;
case MRB_TT_STRING: {
size_t const len = RSTRING_LEN(data);
char *str = (char*)mrb_malloc(mrb, sizeof(char) * (len + 1));
if (NULL == str) {
mrb_free(mrb, udata);
mrb_raise(mrb, E_RUNTIME_ERROR, "insufficient memory.");
}
str[len] = '\0';
udata->data.string_value = str;
break;
}
case MRB_TT_CPTR:
udata->data.cptr_value = mrb_cptr(data);
break;
default:
mrb_free(mrb, udata);
mrb_raise(mrb, E_TYPE_ERROR, "expected Fixnum/Float/String/Cptr");
break;
}
udata->type = mrb_type(data);
return (void*)udata;
}
static mrb_value
mrb_grn_expr_code_inspect(mrb_state *mrb, mrb_value self)
{
grn_ctx *ctx = (grn_ctx *)mrb->ud;
grn_expr_code *code;
mrb_value inspected;
code = DATA_PTR(self);
inspected = mrb_str_buf_new(mrb, 48);
mrb_str_cat_lit(mrb, inspected, "#<");
mrb_str_cat_cstr(mrb, inspected, mrb_obj_classname(mrb, self));
mrb_str_cat_lit(mrb, inspected, ":");
mrb_str_concat(mrb, inspected, mrb_ptr_to_str(mrb, mrb_cptr(self)));
{
int32_t weight;
uint32_t offset;
weight = grn_expr_code_get_weight(ctx, DATA_PTR(self), &offset);
mrb_str_cat_lit(mrb, inspected, " weight=");
mrb_str_concat(mrb, inspected,
mrb_funcall(mrb,
mrb_fixnum_value(weight),
"inspect",
0));
mrb_str_cat_lit(mrb, inspected, ", offset=");
mrb_str_concat(mrb, inspected,
mrb_funcall(mrb,
mrb_fixnum_value(offset),
"inspect",
0));
}
mrb_str_cat_lit(mrb, inspected, ", modify=");
mrb_str_concat(mrb, inspected,
mrb_funcall(mrb,
mrb_fixnum_value(code->modify),
"inspect",
0));
mrb_str_cat_lit(mrb, inspected, ", op=");
mrb_str_concat(mrb, inspected,
mrb_funcall(mrb,
grn_mrb_value_from_operator(mrb, code->op),
"inspect",
0));
mrb_str_cat_lit(mrb, inspected, ", flags=");
mrb_str_concat(mrb, inspected,
mrb_funcall(mrb,
mrb_fixnum_value(code->flags),
"inspect",
0));
mrb_str_cat_lit(mrb, inspected, ", value=");
mrb_str_concat(mrb, inspected,
mrb_funcall(mrb,
grn_mrb_value_from_grn_obj(mrb, code->value),
"inspect",
0));
mrb_str_cat_lit(mrb, inspected, ">");
return inspected;
}
static mrb_value
mrb_addrinfo_getaddrinfo(mrb_state *mrb, mrb_value klass)
{
struct addrinfo hints, *res0, *res;
mrb_value ai, ary, family, lastai, nodename, protocol, sa, service, socktype;
mrb_int flags;
int arena_idx, error;
const char *hostname = NULL, *servname = NULL;
ary = mrb_ary_new(mrb);
arena_idx = mrb_gc_arena_save(mrb); /* ary must be on arena! */
family = socktype = protocol = mrb_nil_value();
flags = 0;
mrb_get_args(mrb, "oo|oooi", &nodename, &service, &family, &socktype, &protocol, &flags);
if (mrb_string_p(nodename)) {
hostname = mrb_str_to_cstr(mrb, nodename);
} else if (mrb_nil_p(nodename)) {
hostname = NULL;
} else {
mrb_raise(mrb, E_TYPE_ERROR, "nodename must be String or nil");
}
if (mrb_string_p(service)) {
servname = mrb_str_to_cstr(mrb, service);
} else if (mrb_fixnum_p(service)) {
servname = mrb_str_to_cstr(mrb, mrb_funcall(mrb, service, "to_s", 0));
} else if (mrb_nil_p(service)) {
servname = NULL;
} else {
mrb_raise(mrb, E_TYPE_ERROR, "service must be String, Fixnum, or nil");
}
memset(&hints, 0, sizeof(hints));
hints.ai_flags = flags;
if (mrb_fixnum_p(family)) {
hints.ai_family = mrb_fixnum(family);
}
if (mrb_fixnum_p(socktype)) {
hints.ai_socktype = mrb_fixnum(socktype);
}
lastai = mrb_cv_get(mrb, klass, mrb_intern_lit(mrb, "_lastai"));
if (mrb_cptr_p(lastai)) {
freeaddrinfo(mrb_cptr(lastai));
mrb_cv_set(mrb, klass, mrb_intern_lit(mrb, "_lastai"), mrb_nil_value());
}
error = getaddrinfo(hostname, servname, &hints, &res0);
if (error) {
mrb_raisef(mrb, E_SOCKET_ERROR, "getaddrinfo: %S", mrb_str_new_cstr(mrb, gai_strerror(error)));
}
mrb_cv_set(mrb, klass, mrb_intern_lit(mrb, "_lastai"), mrb_cptr_value(mrb, res0));
for (res = res0; res != NULL; res = res->ai_next) {
sa = mrb_str_new(mrb, (void *)res->ai_addr, res->ai_addrlen);
ai = mrb_funcall(mrb, klass, "new", 4, sa, mrb_fixnum_value(res->ai_family), mrb_fixnum_value(res->ai_socktype), mrb_fixnum_value(res->ai_protocol));
mrb_ary_push(mrb, ary, ai);
mrb_gc_arena_restore(mrb, arena_idx);
}
freeaddrinfo(res0);
mrb_cv_set(mrb, klass, mrb_intern_lit(mrb, "_lastai"), mrb_nil_value());
return ary;
}
