static void post_response(struct st_h2o_mruby_http_request_context_t *ctx, int status, const struct phr_header *headers_sorted, size_t num_headers) { mrb_state *mrb = ctx->generator->ctx->mrb; int gc_arena = mrb_gc_arena_save(mrb); size_t i; mrb_value resp = mrb_ary_new_capa(mrb, 3); /* set status */ mrb_ary_set(mrb, resp, 0, mrb_fixnum_value(status)); /* set headers */ mrb_value headers_hash = mrb_hash_new_capa(mrb, (int)num_headers); for (i = 0; i < num_headers; ++i) { /* skip the headers, we determine the eos! */ if (h2o_memis(headers_sorted[i].name, headers_sorted[i].name_len, H2O_STRLIT("content-length")) || h2o_memis(headers_sorted[i].name, headers_sorted[i].name_len, H2O_STRLIT("transfer-encoding"))) continue; /* build and set the hash entry */ mrb_value k = mrb_str_new(mrb, headers_sorted[i].name, headers_sorted[i].name_len); mrb_value v = mrb_str_new(mrb, headers_sorted[i].value, headers_sorted[i].value_len); while (i + 1 < num_headers && h2o_memis(headers_sorted[i].name, headers_sorted[i].name_len, headers_sorted[i + 1].name, headers_sorted[i + 1].name_len)) { ++i; v = mrb_str_cat_lit(mrb, v, "\n"); v = mrb_str_cat(mrb, v, headers_sorted[i].value, headers_sorted[i].value_len); } mrb_hash_set(mrb, headers_hash, k, v); } mrb_ary_set(mrb, resp, 1, headers_hash); /* set input stream */ assert(mrb_nil_p(ctx->refs.input_stream)); ctx->refs.input_stream = h2o_mruby_create_data_instance( mrb, mrb_ary_entry(ctx->generator->ctx->constants, H2O_MRUBY_HTTP_INPUT_STREAM_CLASS), ctx, &input_stream_type); mrb_ary_set(mrb, resp, 2, ctx->refs.input_stream); if (mrb_nil_p(ctx->receiver)) { /* is async */ mrb_funcall(mrb, ctx->refs.request, "_set_response", 1, resp); if (mrb->exc != NULL) { fprintf(stderr, "_set_response failed\n"); abort(); } } else { /* send response to the waiting receiver */ h2o_mruby_run_fiber(ctx->generator, detach_receiver(ctx), resp, gc_arena, NULL); } }
static mrb_value blender_getter(mrb_state *mrb, mrb_value self) { int op; int src; int dst; mrb_value a; al_get_blender(&op, &src, &dst); a = mrb_ary_new_capa(mrb, 3); mrb_ary_push(mrb, a, mrb_fixnum_value(op)); mrb_ary_push(mrb, a, mrb_fixnum_value(src)); mrb_ary_push(mrb, a, mrb_fixnum_value(dst)); return a; }
static mrb_value mrb_struct_s_members_m(mrb_state *mrb, mrb_value klass) { mrb_value members, ary; mrb_value *p, *pend; members = mrb_struct_s_members(mrb, klass); ary = mrb_ary_new_capa(mrb, RARRAY_LEN(members)); p = RARRAY_PTR(members); pend = p + RARRAY_LEN(members); while (p < pend) { mrb_ary_push(mrb, ary, *p); p++; } return ary; }
static mrb_value mrb_sdl2_mixer_query_spec(mrb_state *mrb, mrb_value self) { mrb_value array; int frequency, channels; Uint16 format; array = mrb_ary_new_capa(mrb, 3); Mix_QuerySpec(&frequency, &format, &channels); mrb_ary_push(mrb, array, mrb_fixnum_value(frequency)); mrb_ary_push(mrb, array, mrb_fixnum_value(format)); mrb_ary_push(mrb, array, mrb_fixnum_value(channels)); return array; }
static mrb_value color_unmap_rgb_f(mrb_state *mrb, mrb_value self) { ALLEGRO_COLOR *c; float r; float g; float b; mrb_value ary; c = mrb_data_get_ptr(mrb, self, &mrbal_color_data_type); al_unmap_rgb_f(*c, &r, &g, &b); ary = mrb_ary_new_capa(mrb, 3); mrb_ary_push(mrb, ary, mrb_float_value(mrb, r)); mrb_ary_push(mrb, ary, mrb_float_value(mrb, g)); mrb_ary_push(mrb, ary, mrb_float_value(mrb, b)); return ary; }
static mrb_value mrb_grn_expression_codes(mrb_state *mrb, mrb_value self) { grn_expr *expr; mrb_value mrb_codes; int i; expr = DATA_PTR(self); mrb_codes = mrb_ary_new_capa(mrb, expr->codes_curr); for (i = 0; i < expr->codes_curr; i++) { grn_expr_code *code = expr->codes + i; mrb_ary_push(mrb, mrb_codes, mrb_grn_expr_code_new(mrb, code)); } return mrb_codes; }
static mrb_value hash_values_at(mrb_state *mrb, mrb_value hash) { mrb_value *argv, result; mrb_int argc, i; int ai; mrb_get_args(mrb, "*!", &argv, &argc); result = mrb_ary_new_capa(mrb, argc); ai = mrb_gc_arena_save(mrb); for (i = 0; i < argc; i++) { mrb_ary_push(mrb, result, mrb_hash_get(mrb, hash, argv[i])); mrb_gc_arena_restore(mrb, ai); } return result; }
static mrb_value mrb_cp_contact_points_value(mrb_state *mrb, cpContactPointSet *contact_point_set) { mrb_value points; mrb_value point; int i; points = mrb_ary_new_capa(mrb, contact_point_set->count); for (i = 0; i < contact_point_set->count; ++i) { point = mrb_obj_new(mrb, mrb_cp_contact_point_class, 0, NULL); mrb_iv_set(mrb, point, mrb_intern_lit(mrb, "@point_a"), mrb_cp_vect_value(mrb, contact_point_set->points[i].pointA)); mrb_iv_set(mrb, point, mrb_intern_lit(mrb, "@point_b"), mrb_cp_vect_value(mrb, contact_point_set->points[i].pointB)); mrb_iv_set(mrb, point, mrb_intern_lit(mrb, "@distance"), mrb_float_value(mrb, contact_point_set->points[i].distance)); mrb_ary_set(mrb, points, i, point); } return points; }
static mrb_value mrb_hash_values(mrb_state *mrb, mrb_value hash) { khash_t(ht) *h = RHASH_TBL(hash); khiter_t k; mrb_value ary = mrb_ary_new_capa(mrb, kh_size(h)); if (!h) return ary; for (k = kh_begin(h); k != kh_end(h); k++) { if (kh_exist(h, k)){ mrb_value v = kh_value(h,k); mrb_ary_push(mrb, ary, v); } } return ary; }
static mrb_value color_unmap_rgb(mrb_state *mrb, mrb_value self) { ALLEGRO_COLOR *c; unsigned char r; unsigned char g; unsigned char b; mrb_value ary; c = mrb_data_get_ptr(mrb, self, &mrbal_color_data_type); al_unmap_rgb(*c, &r, &g, &b); ary = mrb_ary_new_capa(mrb, 3); mrb_ary_push(mrb, ary, mrb_fixnum_value(r)); mrb_ary_push(mrb, ary, mrb_fixnum_value(g)); mrb_ary_push(mrb, ary, mrb_fixnum_value(b)); return ary; }
//convert rbObj in RVector (assumed to be possible!!!) SEXP mrbArray2RVector(mrb_value rbobj) { SEXP ans; mrb_value arr,elt,tmp; //char *name; int n,i; if(!mrb_obj_is_kind_of(mrb,rbobj,mrb->array_class)) { if(!(mrb_obj_is_kind_of(mrb,rbobj,mrb->fixnum_class) || mrb_obj_is_kind_of(mrb,rbobj,mrb->float_class) || mrb_obj_is_kind_of(mrb,rbobj,mrb->string_class) || mrb_obj_is_kind_of(mrb,rbobj,mrb->true_class) || mrb_obj_is_kind_of(mrb,rbobj,mrb->false_class))) return R_NilValue; n=1; arr = mrb_ary_new_capa(mrb,1); mrb_ary_push(mrb,arr,rbobj); } else { arr=rbobj; n=RARRAY_LEN(rbobj); } //Rprintf("n=%d\n",n); elt=mrb_ary_entry(arr,0); if(mrb_type(elt)==MRB_TT_FLOAT) { PROTECT(ans=allocVector(REALSXP,n)); for(i=0;i<n;i++) { REAL(ans)[i]=mrb_float(mrb_ary_entry(arr,i)); } } else if(mrb_type(elt)==MRB_TT_FIXNUM) { PROTECT(ans=allocVector(INTSXP,n)); for(i=0;i<n;i++) { INTEGER(ans)[i]=mrb_int(mrb,mrb_ary_entry(arr,i)); } } else if(mrb_type(elt)==MRB_TT_TRUE || mrb_type(elt)==MRB_TT_FALSE) { PROTECT(ans=allocVector(LGLSXP,n)); for(i=0;i<n;i++) { LOGICAL(ans)[i]=(mrb_type(mrb_ary_entry(arr,i))==MRB_TT_FALSE ? FALSE : TRUE); } } else if(mrb_type(elt)==MRB_TT_STRING) { PROTECT(ans=allocVector(STRSXP,n)); for(i=0;i<n;i++) { tmp=mrb_ary_entry(arr,i); SET_STRING_ELT(ans,i,mkChar(mrb_string_value_ptr(mrb,tmp))); } } else ans=R_NilValue; UNPROTECT(1); return ans; }
ngx_int_t ngx_http_mruby_run_body_filter(ngx_http_request_t *r, ngx_http_mruby_state_t *state, ngx_http_mruby_code_t *code, ngx_flag_t cached) { ngx_http_mruby_ctx_t *ctx; mrb_value ARGV, mrb_result; size_t body_length; ctx = ngx_http_get_module_ctx(r, ngx_http_mruby_module); ngx_http_mruby_push_request(r); state->ai = mrb_gc_arena_save(state->mrb); ARGV = mrb_ary_new_capa(state->mrb, 1); mrb_ary_push(state->mrb, ARGV, mrb_str_new(state->mrb, (char *)ctx->filter_ctx.body, ctx->filter_ctx.body_length)); mrb_define_global_const(state->mrb, "ARGV", ARGV); mrb_result = mrb_run(state->mrb, code->proc, mrb_top_self(state->mrb)); if (state->mrb->exc) { ngx_http_mruby_raise_error(state, code, r); mrb_gc_arena_restore(state->mrb, state->ai); //mrb_gc_protect(state->mrb, ctx->table); if (!cached) { ngx_http_mruby_irep_clean(state, code); } return NGX_ERROR; } mrb_result = mrb_obj_as_string(state->mrb, mrb_result); body_length = RSTRING_LEN(mrb_result); if (body_length != 0) { ctx->filter_ctx.body = (u_char *)RSTRING_PTR(mrb_result); ctx->filter_ctx.body_length = body_length; } mrb_gc_arena_restore(state->mrb, state->ai); //mrb_gc_protect(state->mrb, ctx->table); if (!cached) { ngx_http_mruby_irep_clean(state, code); } return NGX_OK; }
static mrb_value mrb_sdl2_ttf_font_get_size_UNICODE(mrb_state *mrb, mrb_value self) { mrb_value text; int w, h; mrb_value result; mrb_get_args(mrb, "S", &text); if (TTF_SizeUNICODE(mrb_sdl2_font_get_ptr(mrb, self), (Uint16 *) RSTRING_PTR(text), &w, &h) == -1) { mruby_sdl2_raise_error(mrb); return mrb_false_value(); } result = mrb_ary_new_capa(mrb, 2); mrb_ary_push(mrb, result, mrb_fixnum_value(w)); mrb_ary_push(mrb, result, mrb_fixnum_value(h)); return result; }
static mrb_value indexable_indexes(mrb_state *mrb, mrb_value self) { grn_ctx *ctx = (grn_ctx *)mrb->ud; grn_obj *object; grn_index_datum index_datum; grn_index_datum *index_data; int i, n_index_data; mrb_value mrb_indexes; object = DATA_PTR(self); n_index_data = grn_column_get_all_index_data(ctx, object, &index_datum, 1); if (n_index_data == 0) { return mrb_ary_new(mrb); } if (n_index_data == 1) { index_data = &index_datum; } else { index_data = GRN_MALLOCN(grn_index_datum, n_index_data); n_index_data = grn_column_get_all_index_data(ctx, object, index_data, n_index_data); } mrb_indexes = mrb_ary_new_capa(mrb, n_index_data); for (i = 0; i < n_index_data; i++) { grn_mrb_data *data; struct RClass *klass; mrb_value args[2]; data = &(ctx->impl->mrb); klass = mrb_class_get_under(mrb, data->module, "IndexInfo"); args[0] = grn_mrb_value_from_grn_obj(mrb, index_data[i].index); args[1] = mrb_fixnum_value(index_data[i].section); mrb_ary_push(mrb, mrb_indexes, mrb_obj_new(mrb, klass, 2, args)); } if (index_data != &index_datum) { GRN_FREE(index_data); } return mrb_indexes; }
mrb_value mrb_ary_plus(mrb_state *mrb, mrb_value self) { struct RArray *a1 = mrb_ary_ptr(self); struct RArray *a2; mrb_value ary; mrb_value *ptr; int blen; mrb_get_args(mrb, "a", &ptr, &blen); ary = mrb_ary_new_capa(mrb, a1->len + blen); a2 = mrb_ary_ptr(ary); memcpy(a2->ptr, a1->ptr, sizeof(mrb_value)*a1->len); memcpy(a2->ptr + a1->len, ptr, sizeof(mrb_value)*blen); a2->len = a1->len + blen; return ary; }
MRB_API mrb_value mrb_hash_values(mrb_state *mrb, mrb_value hash) { khash_t(ht) *h = RHASH_TBL(hash); khiter_t k; mrb_value ary; if (!h) return mrb_ary_new(mrb); ary = mrb_ary_new_capa(mrb, kh_size(h)); for (k = kh_begin(h); k != kh_end(h); k++) { if (kh_exist(h, k)) { mrb_hash_value hv = kh_value(h, k); mrb_ary_set(mrb, ary, hv.n, hv.v); } } return ary; }
mrb_value task_arg_to_mrb_value(mrb_state *mrb, struct task_arg* arg) { mrb_value v; mrb_type(v) = arg->tt; switch (arg->tt) { case MRB_TT_FALSE: case MRB_TT_TRUE: case MRB_TT_FIXNUM: v.value.i = arg->value.i; break; case MRB_TT_FLOAT: v.value.f = arg->value.f; break; case MRB_TT_SYMBOL: v.value.sym = mrb_intern(mrb, arg->value.string.ptr); break; case MRB_TT_STRING: v = mrb_str_new(mrb, arg->value.string.ptr, arg->value.string.len); break; case MRB_TT_ARRAY: { v = mrb_ary_new_capa(mrb, arg->value.array.len); struct RArray *ary = mrb_ary_ptr(v); ary->len = arg->value.array.len; int i; for(i=0; i<arg->value.array.len; i++) { ary->ptr[i] = task_arg_to_mrb_value(mrb, arg->value.array.ptr[i]); } } break; default: mrb_raise(mrb, E_TYPE_ERROR, "cannot pass to other RubyVM"); break; } return v; }
static mrb_value mrb_sdl2_joystick_joystick_get_ball(mrb_state *mrb, mrb_value self) { mrb_value array; int dx; int dy; int result; mrb_int ball; SDL_Joystick * joystick_p = mrb_sdl2_joystick_joystick_get_ptr(mrb, self); mrb_get_args(mrb, "i", &ball); result = SDL_JoystickGetBall(joystick_p, ball, &dx, &dy); if (0 > result) { mruby_sdl2_raise_error(mrb); } array = mrb_ary_new_capa(mrb, 2); mrb_ary_push(mrb, array, mrb_fixnum_value(dx)); mrb_ary_push(mrb, array, mrb_fixnum_value(dy)); return array; }
static mrb_value read_array(MarshalContext *ctx) { mrb_state *mrb = ctx->mrb; int len = read_fixnum(ctx); int i; mrb_value array = mrb_ary_new_capa(mrb, len); ctx->objects.add(array); for (i = 0; i < len; ++i) { mrb_value val = read_value(ctx); mrb_ary_set(mrb, array, i, val); } return array; }
ngx_int_t ngx_http_mruby_run_args(ngx_http_request_t *r, ngx_http_mruby_state_t *state, ngx_http_mruby_code_t *code, ngx_flag_t cached, ngx_http_variable_value_t *args, size_t nargs, ngx_str_t *result) { ngx_uint_t i; mrb_value ARGV, mrb_result; state->ai = mrb_gc_arena_save(state->mrb); ARGV = mrb_ary_new_capa(state->mrb, nargs); for (i = 0; i < nargs; i++) { mrb_ary_push(state->mrb, ARGV, mrb_str_new(state->mrb, (char *)args[i].data, args[i].len)); } mrb_define_global_const(state->mrb, "ARGV", ARGV); ngx_http_mruby_push_request(r); mrb_result = mrb_run(state->mrb, code->proc, mrb_top_self(state->mrb)); if (state->mrb->exc) { ngx_http_mruby_raise_error(state, code, r); mrb_gc_arena_restore(state->mrb, state->ai); //mrb_gc_protect(state->mrb, ctx->table); if (!cached) { ngx_http_mruby_irep_clean(state, code); } return NGX_ERROR; } mrb_result = mrb_obj_as_string(state->mrb, mrb_result); result->data = (u_char *)RSTRING_PTR(mrb_result); result->len = RSTRING_LEN(mrb_result); mrb_gc_arena_restore(state->mrb, state->ai); //mrb_gc_protect(state->mrb, ctx->table); if (!cached) { ngx_http_mruby_irep_clean(state, code); } return NGX_OK; }
static mrb_value indexable_index_ids(mrb_state *mrb, mrb_value self) { grn_ctx *ctx = (grn_ctx *)mrb->ud; grn_obj *object; grn_hook_entry entry; int i; int n_indexes; mrb_value mrb_index_ids; grn_obj hook_data; object = DATA_PTR(self); if (grn_obj_is_key_accessor(ctx, object)) { object = grn_ctx_at(ctx, object->header.domain); } if (grn_obj_is_table(ctx, object)) { entry = GRN_HOOK_INSERT; } else if (grn_obj_is_column(ctx, object)) { entry = GRN_HOOK_SET; } else { return mrb_ary_new(mrb); } n_indexes = grn_obj_get_nhooks(ctx, object, entry); mrb_index_ids = mrb_ary_new_capa(mrb, n_indexes); GRN_TEXT_INIT(&hook_data, 0); for (i = 0; i < n_indexes; i++) { GRN_BULK_REWIND(&hook_data); grn_obj_get_hook(ctx, object, entry, i, &hook_data); if (GRN_BULK_VSIZE(&hook_data) == sizeof(grn_obj_default_set_value_hook_data)) { grn_obj_default_set_value_hook_data *data; data = (grn_obj_default_set_value_hook_data *)GRN_TEXT_VALUE(&hook_data); mrb_ary_push(mrb, mrb_index_ids, mrb_fixnum_value(data->target)); } } return mrb_index_ids; }
static mrb_value separate_blender_getter(mrb_state *mrb, mrb_value self) { int op; int src; int dst; int alpha_op; int alpha_src; int alpha_dst; mrb_value a; al_get_separate_blender(&op, &src, &dst, &alpha_op, &alpha_src, &alpha_dst); a = mrb_ary_new_capa(mrb, 6); mrb_ary_push(mrb, a, mrb_fixnum_value(op)); mrb_ary_push(mrb, a, mrb_fixnum_value(src)); mrb_ary_push(mrb, a, mrb_fixnum_value(dst)); mrb_ary_push(mrb, a, mrb_fixnum_value(alpha_op)); mrb_ary_push(mrb, a, mrb_fixnum_value(alpha_src)); mrb_ary_push(mrb, a, mrb_fixnum_value(alpha_dst)); return a; }
mrb_value mrb_struct_new(mrb_state *mrb, struct RClass *klass, ...) { mrb_value tmpargs[N_REF_FUNC], *mem = tmpargs; int size, i; va_list args; size = mrb_long2int(num_members(mrb, klass)); if (size > numberof(tmpargs)) { tmpargs[0] = mrb_ary_new_capa(mrb, size); mem = RARRAY_PTR(tmpargs[0]); } va_start(args, klass); for (i=0; i<size; i++) { mem[i] = va_arg(args, mrb_value); } va_end(args); return mrb_class_new_instance(mrb, size, mem, klass); }
static mrb_value bs_locate_handle_buffer(mrb_state *mrb, mrb_value self) { mrb_value guid; mrb_value ret; UINTN size; EFI_HANDLE *phandles; mrb_get_args(mrb, "o", &guid); if (mrb_nil_p(guid)){ /* AllHandles */ EFI_STATUS status; status = gBS->LocateHandleBuffer(AllHandles, NULL, NULL, &size, &phandles); if (EFI_ERROR(status)){ return mrb_nil_value(); } }else{ /* ByProtocol */ EFI_STATUS status; EFI_GUID efi_guid; mrb_uefi_guid_get_guid(mrb, guid, &efi_guid); status = gBS->LocateHandleBuffer(ByProtocol, &efi_guid, NULL, &size, &phandles); if (EFI_ERROR(status)){ return mrb_nil_value(); } } ret = mrb_ary_new_capa(mrb, (int)size); { UINTN i; for (i=0; i<size; i++){ int arena = mrb_gc_arena_save(mrb); mrb_ary_push(mrb, ret, mrb_uefi_handle_make(mrb, phandles[i])); mrb_gc_arena_restore(mrb, arena); } } gBS->FreePool(phandles); return ret; }
int main(int argc, char *argv[]) { mrb_state *mrb = mrb_open(); mrb_value ARGV = mrb_ary_new_capa(mrb, argc); int i; int return_value; #ifdef HACONIWA_SECURE_RUN if(check_match_owner(argc, argv) < 0) { mrb_raise(mrb, E_RUNTIME_ERROR, "haconiwa runner and hacofile's owner would not be matched: This run prohibited on secure-run build"); exit(2); } #endif if(setuid(geteuid()) < 0) { mrb_sys_fail(mrb, "setuid"); exit(2); } if(setgid(getegid()) < 0) { mrb_sys_fail(mrb, "setgid"); exit(2); } for (i = 0; i < argc; i++) { mrb_ary_push(mrb, ARGV, mrb_str_new_cstr(mrb, argv[i])); } mrb_define_global_const(mrb, "ARGV", ARGV); // call __main__(ARGV) mrb_funcall(mrb, mrb_top_self(mrb), "__main__", 1, ARGV); return_value = EXIT_SUCCESS; if (mrb->exc) { mrb_print_error(mrb); return_value = EXIT_FAILURE; } mrb_close(mrb); return return_value; }
mrb_value mrb_ary_reverse(mrb_state *mrb, mrb_value self) { struct RArray *a = mrb_ary_ptr(self), *b; mrb_value ary; ary = mrb_ary_new_capa(mrb, a->len); b = mrb_ary_ptr(ary); if (a->len > 0) { mrb_value *p1, *p2, *e; p1 = a->ptr; e = p1 + a->len; p2 = b->ptr + a->len - 1; while(p1 < e) { *p2-- = *p1++; } b->len = a->len; } return ary; }
mrb_value mrb_hash_keys(mrb_state *mrb, mrb_value hash) { khash_t(ht) *h = RHASH_TBL(hash); khiter_t k; mrb_value ary, *p; if (!h || kh_size(h) == 0) return mrb_ary_new(mrb); ary = mrb_ary_new_capa(mrb, kh_size(h)); mrb_ary_set(mrb, ary, kh_size(h)-1, mrb_nil_value()); p = RARRAY_PTR(ary); for (k = kh_begin(h); k != kh_end(h); k++) { if (kh_exist(h, k)) { mrb_value kv = kh_key(h,k); mrb_hash_value hv = kh_value(h,k); p[hv.n] = kv; } } return ary; }
MRB_API mrb_value mrb_vformat(mrb_state *mrb, const char *format, va_list ap) { const char *p = format; const char *b = p; ptrdiff_t size; mrb_value ary = mrb_ary_new_capa(mrb, 4); while (*p) { const char c = *p++; if (c == '%') { if (*p == 'S') { size = p - b - 1; mrb_ary_push(mrb, ary, mrb_str_new(mrb, b, size)); mrb_ary_push(mrb, ary, va_arg(ap, mrb_value)); b = p + 1; } } else if (c == '\\') { if (*p) { size = p - b - 1; mrb_ary_push(mrb, ary, mrb_str_new(mrb, b, size)); mrb_ary_push(mrb, ary, mrb_str_new(mrb, p, 1)); b = ++p; } else { break; } } } if (b == format) { return mrb_str_new_cstr(mrb, format); } else { size = p - b; mrb_ary_push(mrb, ary, mrb_str_new(mrb, b, size)); return mrb_ary_join(mrb, ary, mrb_str_new(mrb, NULL, 0)); } }
static mrb_value mrb_local_variables(mrb_state *mrb, mrb_value self) { mrb_value ret; struct RProc *proc; struct mrb_irep *irep; size_t i; proc = mrb->c->ci[-1].proc; if (MRB_PROC_CFUNC_P(proc)) { return mrb_ary_new(mrb); } irep = proc->body.irep; if (!irep->lv) { return mrb_ary_new(mrb); } ret = mrb_ary_new_capa(mrb, irep->nlocals - 1); for (i = 0; i + 1 < irep->nlocals; ++i) { mrb_ary_push(mrb, ret, mrb_symbol_value(irep->lv[i].name)); } if (proc->env) { struct REnv *e = proc->env; while (e) { if (!MRB_PROC_CFUNC_P(mrb->c->cibase[e->cioff].proc)) { irep = mrb->c->cibase[e->cioff].proc->body.irep; if (irep->lv) { for (i = 0; i + 1 < irep->nlocals; ++i) { mrb_ary_push(mrb, ret, mrb_symbol_value(irep->lv[i].name)); } } } e = (struct REnv*)e->c; } } return ret; }
int rbIsRVector(mrb_value rbobj) { mrb_value rbobj2; int i,n; if(!mrb_obj_is_kind_of(mrb,rbobj,mrb->array_class)) { if(!(mrb_obj_is_kind_of(mrb,rbobj,mrb->fixnum_class) || mrb_obj_is_kind_of(mrb,rbobj,mrb->float_class) || mrb_obj_is_kind_of(mrb,rbobj,mrb->string_class) || mrb_obj_is_kind_of(mrb,rbobj,mrb->true_class) || mrb_obj_is_kind_of(mrb,rbobj,mrb->false_class))) return 0; rbobj2=mrb_ary_new_capa(mrb,1); mrb_ary_push(mrb,rbobj2,rbobj); rbobj=rbobj2; //Seems that the 3 previous lines could be replaced by: // return 1; } n=RARRAY_LEN(rbobj); for(i=0;i<n;i++) { rbobj2=mrb_ary_entry(rbobj,i); if(!(mrb_obj_is_kind_of(mrb,rbobj2,mrb->fixnum_class) || mrb_obj_is_kind_of(mrb,rbobj2,mrb->float_class) || mrb_obj_is_kind_of(mrb,rbobj2,mrb->string_class) || mrb_obj_is_kind_of(mrb,rbobj2,mrb->true_class) || mrb_obj_is_kind_of(mrb,rbobj2,mrb->false_class))) { return 0; } } return 1; }