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