Esempio n. 1
0
static mrb_value
mrb_skkdic_dict_data(mrb_state *mrb, mrb_value self)
{
     mrb_value path, block, argv[4], table;
     char line[2048], *cstr, *p;
     int okuri_pos = 0;
     FILE *f;
     int i = 0;

     mrb_get_args(mrb, "&S", &block, &path);
     f = fopen(RSTRING_PTR(path), "r");
     if (f == NULL) {
	  puts("file open error\n");
     } else {
	  while(fgets(line, sizeof(line), f) != NULL) {
	       int ai = mrb_gc_arena_save(mrb);
	       if (strcmp(line, ";; okuri-ari entries.\n") == 0) {
		    okuri_pos++;
		    continue;
	       }
	       if (strcmp(line, ";; okuri-nasi entries.\n") == 0) {
		    okuri_pos++;
		    continue;
	       }
	       if (line[0] == ';') {
		    continue;
	       }
	       cstr = strtok(line, " ");
	       argv[1] = mrb_str_new_cstr(mrb, cstr);
	       cstr = strtok(NULL, " ");
	       p = strtok(cstr, "/");

	       table = mrb_ary_new(mrb);
	       while (p != NULL) {
		    int ai2 = mrb_gc_arena_save(mrb);
		    mrb_ary_push(mrb, table, mrb_str_new_cstr(mrb, p));
		    p = strtok(NULL, "/");
		    mrb_gc_arena_restore(mrb, ai2);
	       }
	       mrb_ary_pop(mrb, table);
	       argv[2] = table;
	       if (okuri_pos == 1) {
		    // okuri_ari
		    argv[0] = mrb_fixnum_value(0);
		    mrb_yield_argv(mrb, block, 3,
				   argv);
	       } else if(okuri_pos == 2) {
		    // okuri_nasi
		    argv[0] = mrb_fixnum_value(1);
		    mrb_yield_argv(mrb, block, 3,
				   argv);

	       }
	       mrb_gc_arena_restore(mrb, ai);
	  }
     }
     return self;
}
Esempio n. 2
0
static void*
mrb_thread_func(void* data) {
  mrb_thread_context* context = (mrb_thread_context*) data;
  mrb_state* mrb = context->mrb;
  context->result = mrb_yield_argv(mrb, mrb_obj_value(context->proc), context->argc, context->argv);
  return NULL;
}
Esempio n. 3
0
static ssize_t
mrb_wslay_event_recv_callback(wslay_event_context_ptr ctx,
  uint8_t *buf, size_t len, int flags, void *user_data)
{
  mrb_wslay_user_data *data = (mrb_wslay_user_data *) user_data;
  mrb_state*mrb = data->mrb;
  int ai = mrb_gc_arena_save(mrb);

  struct mrb_jmpbuf *prev_jmp = mrb->jmp;
  struct mrb_jmpbuf c_jmp;

  mrb_int ret = -1;
  MRB_TRY(&c_jmp) {
    mrb->jmp = &c_jmp;

    mrb_value argv[2];
    argv[0] = mrb_cptr_value(mrb, buf);
    argv[1] = mrb_fixnum_value(len);

    errno = 0;
    mrb_assert(mrb_type(data->recv_callback) == MRB_TT_PROC);
    mrb_value buf_obj = mrb_yield_argv(mrb, data->recv_callback, NELEMS(argv), argv);

    if (mrb_fixnum_p(buf_obj)) {
      ret = mrb_fixnum(buf_obj);
    } else {
      buf_obj = mrb_str_to_str(mrb, buf_obj);
      ret = RSTRING_LEN(buf_obj);
      if (ret < 0||ret > len) {
        mrb_raise(mrb, E_RANGE_ERROR, "returned buf doesn't fit");
      }
      if (ret > 0) {
        memmove(buf, (uint8_t *) RSTRING_PTR(buf_obj), ret);
      }
    }

    mrb->jmp = prev_jmp;
  } MRB_CATCH(&c_jmp) {
    mrb->jmp = prev_jmp;
    if (mrb_obj_is_kind_of(mrb,
        mrb_obj_value(mrb->exc),
            mrb_class_get_under(mrb,
                mrb_module_get(mrb, "Errno"), "EAGAIN"))||
    mrb_obj_is_kind_of(mrb,
        mrb_obj_value(mrb->exc),
            mrb_class_get_under(mrb,
                mrb_module_get(mrb, "Errno"), "EWOULDBLOCK"))) {
      mrb->exc = NULL;
      wslay_event_set_error(ctx, WSLAY_ERR_WOULDBLOCK);
    } else {
      wslay_event_set_error(ctx, WSLAY_ERR_CALLBACK_FAILURE);
    }
  } MRB_END_EXC(&c_jmp);

  mrb_gc_arena_restore(mrb, ai);

  return ret;
}
Esempio n. 4
0
static mrb_value
mrb_mutex_synchronize(mrb_state* mrb, mrb_value self) {
  mrb_value proc = mrb_nil_value();
  mrb_get_args(mrb, "&", &proc);
  if (!mrb_nil_p(proc)) {
    mrb_mutex_lock(mrb, self);
    mrb_yield_argv(mrb, proc, 0, NULL);
    mrb_mutex_unlock(mrb, self);
  }
  return mrb_nil_value();
}
Esempio n. 5
0
static void
_uv_thread_proc(void *arg)
{
  mrb_uv_thread* context = (mrb_uv_thread*) arg;
  mrb_state* mrb = context->mrb;
  mrb_value proc, thread_arg;
  if (!mrb) return;
  proc = mrb_iv_get(mrb, context->instance, mrb_intern_lit(mrb, "thread_proc"));
  thread_arg = mrb_iv_get(mrb, context->instance, mrb_intern_lit(mrb, "thread_arg"));
  if (!mrb_nil_p(proc)) {
    mrb_value args[1];
    args[0] = thread_arg;
    mrb_yield_argv(mrb, proc, 1, args);
  }
}
Esempio n. 6
0
// FLTK::Group#begin
static mrb_value
mrb_fltk_group_begin_method( mrb_state *mrb, mrb_value self ) {
  CONTEXT_SETUP( widget );

  mrb_value block = mrb_nil_value();

  mrb_get_args( mrb, "&", &block );

  if( !mrb_nil_p( block ) ) {
    mrb_value args[1];

    args[0] = self;

    ( (Fl_Group *)context->fl_instance )->begin();
    mrb_yield_argv( mrb, block, 1, args );
    ( (Fl_Group *)context->fl_instance )->end();
  } else {
    ( (Fl_Group *)context->fl_instance )->begin();
  }

  return mrb_nil_value();
}
Esempio n. 7
0
/*
 *  call-seq:
 *     string.lines    ->  array of string
 *
 *  Returns strings per line;
 *
 *     a = "abc\ndef"
 *     a.lines    #=> ["abc\n", "def"]
 */
static mrb_value
mrb_str_lines(mrb_state *mrb, mrb_value self)
{
  mrb_value result;
  mrb_value blk;
  int ai;
  mrb_int len;
  mrb_value arg;
  char *p = RSTRING_PTR(self), *t;
  char *e = p + RSTRING_LEN(self);

  mrb_get_args(mrb, "&", &blk);

  result = mrb_ary_new(mrb);

  if (!mrb_nil_p(blk)) {
    while (p < e) {
      t = p;
      while (p < e && *p != '\n') p++;
      if (*p == '\n') p++;
      len = (mrb_int) (p - t);
      arg = mrb_str_new(mrb, t, len);
      mrb_yield_argv(mrb, blk, 1, &arg);
    }
    return self;
  }
  while (p < e) {
    ai = mrb_gc_arena_save(mrb);
    t = p;
    while (p < e && *p != '\n') p++;
    if (*p == '\n') p++;
    len = (mrb_int) (p - t);
    mrb_ary_push(mrb, result, mrb_str_new(mrb, t, len));
    mrb_gc_arena_restore(mrb, ai);
  }
  return result;
}
Esempio n. 8
0
static int
parser_settings_on_message_complete(http_parser* parser)
{
  mrb_value c;
  mrb_http_parser_context *context = (mrb_http_parser_context*) parser->data;
  mrb_http_parser_context *new_context;
  mrb_state* mrb = context->mrb;
  mrb_value args[1];

  c = mrb_class_new_instance(mrb, 0, NULL, _class_http_request);
  new_context = (mrb_http_parser_context*) malloc(sizeof(mrb_http_parser_context));
  memcpy(new_context, context, sizeof(mrb_http_parser_context));
  mrb_iv_set(mrb, c, mrb_intern(mrb, "context"), mrb_obj_value(
    Data_Wrap_Struct(mrb, mrb->object_class,
    &http_parser_context_type, (void*) new_context)));
  args[0] = c;
  mrb_yield_argv(context->mrb, context->proc, 1, args);
  PARSER_SET(context, "headers", mrb_nil_value());
  PARSER_SET(context, "last_header_field", mrb_nil_value());
  PARSER_SET(context, "last_header_value", mrb_nil_value());
  PARSER_SET(context, "buf", mrb_nil_value());

  return 0;
}
Esempio n. 9
0
static size_t
memfwrite_callback(char* ptr, size_t size, size_t nmemb, void* stream) {
  MEMFILE* mf = (MEMFILE*) stream;
  int block = size * nmemb;

  mrb_value args[2];
  mrb_state* mrb = mf->mrb;

  int ai = mrb_gc_arena_save(mrb); \
  if (mf->data && mrb_nil_p(mf->header))  {
    mrb_value str = mrb_str_new(mrb, mf->data, mf->size);
    struct RClass* _class_http = mrb_class_get(mrb, "HTTP");
    struct RClass* _class_http_parser = mrb_class_ptr(mrb_const_get(mrb, mrb_obj_value(_class_http), mrb_intern_cstr(mrb, "Parser")));
    mrb_value parser = mrb_obj_new(mrb, _class_http_parser, 0, NULL);
    args[0] = str;
    mf->header = mrb_funcall_argv(mrb, parser, mrb_intern_cstr(mrb, "parse_response"), 1, args);
  }

  args[0] = mf->header;
  args[1] = mrb_str_new(mrb, ptr, block);
  mrb_gc_arena_restore(mrb, ai);
  mrb_yield_argv(mrb, mf->proc, 2, args);
  return block;
}
Esempio n. 10
0
static void
_uv_once_cb() {
  mrb_assert(!mrb_nil_p(once_info.block));
  mrb_yield_argv(once_info.mrb, once_info.block, 0, NULL);
}
Esempio n. 11
0
static mrb_value
_http_parser_parse(mrb_state *mrb, mrb_value self, int type)
{
  mrb_value arg_data = mrb_nil_value();
  mrb_value value_context;
  mrb_http_parser_context* context;
  mrb_value b = mrb_nil_value();
  struct RClass* _class_http;
  struct RClass* clazz;
  char* data;
  size_t len;
  char* eol;
  size_t done;

  value_context = mrb_iv_get(mrb, self, mrb_intern(mrb, "context"));
  Data_Get_Struct(mrb, value_context, &http_parser_context_type, context);
  if (!context) {
    mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid argument");
  }

  mrb_get_args(mrb, "|&o", &b, &arg_data);
  if (mrb_nil_p(arg_data)) {
    mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid argument");
  }
  context->parser.data = context;

  _class_http = mrb_class_get(mrb, "HTTP");
  if (type == HTTP_REQUEST) {
    clazz = mrb_class_ptr(mrb_const_get(mrb, mrb_obj_value(_class_http), mrb_intern(mrb, "Request")));
    context->instance = mrb_class_new_instance(mrb, 0, NULL, clazz);
  } else {
    clazz = mrb_class_ptr(mrb_const_get(mrb, mrb_obj_value(_class_http), mrb_intern(mrb, "Response")));
    context->instance = mrb_class_new_instance(mrb, 0, NULL, clazz);
  }
  context->was_header_value = TRUE;

  http_parser_init(&context->parser, type);

  context->type = type;
  context->settings.on_url = parser_settings_on_url;
  context->settings.on_header_field = parser_settings_on_header_field;
  context->settings.on_header_value = parser_settings_on_header_value;
  context->settings.on_headers_complete = parser_settings_on_headers_complete;
  context->settings.on_body = parser_settings_on_body;
  context->settings.on_message_complete = parser_settings_on_message_complete;

  data = RSTRING_PTR(arg_data);
  len = RSTRING_LEN(arg_data);

  eol = strpbrk(data, "\r\n");
  if (eol) {
  }

RETRY:
  if (len > 10 && (!strncmp(data+9, "200 Connection established\r\n", 28) ||
      !strncmp(data+9, "100 Continue\r\n", 14) || *(data+9) == '3')) {
    char* next = strstr(data, "\r\n\r\n");
    if (next) {
      len -= (next + 4 - data);
      data = next + 4;
      goto RETRY;
    }
  }

  done = http_parser_execute(&context->parser, &context->settings, data, len);
  if (done < len) {
    OBJECT_SET(mrb, context->instance, "body", mrb_str_new(mrb, data + done, len - done));
  }

  if (!mrb_nil_p(b)) {
    mrb_value args[1];
    args[0] = context->instance;
    mrb_yield_argv(mrb, b, 1, args);
    return mrb_nil_value();
  }
  return context->instance;
}
Esempio n. 12
0
static mrb_value
mrb_sqlite3_database_execute(mrb_state *mrb, mrb_value self) {
  int argc = 0;
  mrb_value* argv = NULL;
  mrb_value b = mrb_nil_value();
  mrb_value value_context;
  mrb_sqlite3_database* db = NULL;
  mrb_value fields;
  int i, r, count;
  sqlite3_stmt* stmt = NULL;
  mrb_value args[2];
  mrb_value query;

  mrb_get_args(mrb, "&S*", &b, &query, &argv, &argc);

  value_context = mrb_iv_get(mrb, self, mrb_intern(mrb, "context"));
  db = NULL;
  Data_Get_Struct(mrb, value_context, &mrb_sqlite3_database_type, db);
  if (!db) {
    mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid argument");
  }

  r = sqlite3_prepare_v2(db->db, RSTRING_PTR(query), RSTRING_LEN(query),
    &stmt, NULL);
  if (r != SQLITE_OK) {
    if (stmt) {
      sqlite3_finalize(stmt);
      sqlite3_reset(stmt);
    }
    mrb_raise(mrb, E_RUNTIME_ERROR, sqlite3_errmsg(db->db));
  }
  if (!stmt) {
    return mrb_nil_value();
  }

  if (argc > 0) {
    const char* error = bind_values(mrb, db->db, stmt, argc, argv);
    if (error) {
      mrb_raise(mrb, E_ARGUMENT_ERROR, error);
    }
  }

  fields = mrb_ary_new(mrb);
  count = sqlite3_column_count(stmt);
  for (i = 0; i < count; i++) {
    const char* name = sqlite3_column_name(stmt, i);
    mrb_ary_push(mrb, fields, mrb_str_new_cstr(mrb, name));
  }

  if (mrb_nil_p(b)) {
    struct RClass* _class_sqlite3;
    struct RClass* _class_sqlite3_resultset;
    mrb_value c;
    mrb_sqlite3_resultset* rs = (mrb_sqlite3_resultset*)
      malloc(sizeof(mrb_sqlite3_resultset));
    if (!rs) {
      mrb_raise(mrb, E_RUNTIME_ERROR, "can't memory alloc");
    }
    memset(rs, 0, sizeof(mrb_sqlite3_resultset));
    rs->mrb = mrb;
    rs->stmt = stmt;
    _class_sqlite3 = mrb_class_get(mrb, "SQLite3");
    _class_sqlite3_resultset = mrb_class_ptr(mrb_const_get(mrb, mrb_obj_value(_class_sqlite3), mrb_intern(mrb, "ResultSet")));
    c = mrb_class_new_instance(mrb, 0, NULL, _class_sqlite3_resultset);
    mrb_iv_set(mrb, c, mrb_intern(mrb, "context"), mrb_obj_value(
      Data_Wrap_Struct(mrb, mrb->object_class,
      &mrb_sqlite3_resultset_type, (void*) rs)));
    mrb_iv_set(mrb, c, mrb_intern(mrb, "fields"), fields);
    mrb_iv_set(mrb, c, mrb_intern(mrb, "db"), self);
    mrb_iv_set(mrb, c, mrb_intern(mrb, "eof"), mrb_false_value());
    return c;
  }
  while ((r = sqlite3_step(stmt)) == SQLITE_ROW) {
    int ai = mrb_gc_arena_save(mrb);
    args[0] = row_to_value(mrb, stmt);
    args[1] = fields;
    mrb_yield_argv(mrb, b, 2, args);
    mrb_gc_arena_restore(mrb, ai);
  }
  sqlite3_finalize(stmt);
  if (r != SQLITE_OK && r != SQLITE_DONE) {
    mrb_raise(mrb, E_RUNTIME_ERROR, sqlite3_errmsg(db->db));
  }
  return mrb_nil_value();
}
Esempio n. 13
0
static mrb_value
protect_cb(mrb_state *mrb, mrb_value b)
{
  return mrb_yield_argv(mrb, b, 0, NULL);
}