示例#1
0
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);
    }
}
示例#2
0
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;
}
示例#3
0
文件: struct.c 项目: nyanp/mruby
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;
}
示例#4
0
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;
}	
示例#5
0
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;
}
示例#6
0
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;
}
示例#7
0
文件: hash-ext.c 项目: nobu/mruby
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;
}
示例#8
0
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;
}
示例#9
0
文件: hash.c 项目: galois17/mruby
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;
}
示例#10
0
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;
}
示例#11
0
文件: mrb4R.c 项目: rcqls/mrb4R
//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;
}
示例#13
0
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;
}
示例#14
0
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;
}
示例#15
0
文件: array.c 项目: galois17/mruby
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;
}
示例#16
0
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;
}
示例#17
0
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;
}
示例#18
0
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;
}
示例#19
0
文件: marshal.cpp 项目: cjv123/RPG
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;
}
示例#21
0
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;
}
示例#22
0
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;
}
示例#23
0
文件: struct.c 项目: akuroda/mruby
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;
}
示例#25
0
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;
}
示例#26
0
文件: array.c 项目: galois17/mruby
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;
}
示例#27
0
文件: hash.c 项目: kmasa/mruby
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;
}
示例#28
0
文件: error.c 项目: deweerdt/h2o
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));
  }
}
示例#29
0
文件: proc.c 项目: mitchblank/mruby
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;
}
示例#30
0
文件: mrb4R.c 项目: rcqls/mrb4R
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;
}