static mrb_value
mrb_struct_set(mrb_state *mrb, mrb_value obj, mrb_value val)
{
const char *name;
int i;
size_t len;
mrb_sym mid;
mrb_value members, slot, *ptr, *ptr_members;
/* get base id */
name = mrb_sym2name_len(mrb, mrb->ci->mid, &len);
mid = mrb_intern2(mrb, name, len-1); /* omit last "=" */
members = mrb_struct_members(mrb, obj);
ptr_members = RARRAY_PTR(members);
len = RARRAY_LEN(members);
ptr = RSTRUCT_PTR(obj);
for (i=0; i<len; i++) {
slot = ptr_members[i];
if (mrb_symbol(slot) == mid) {
return ptr[i] = val;
}
}
mrb_raisef(mrb, E_NAME_ERROR, "`%s' is not a struct member",
mrb_sym2name(mrb, mid));
return mrb_nil_value(); /* not reached */
}
static size_t
get_filename_table_size(mrb_state *mrb, mrb_irep *irep, mrb_sym **fp, uint16_t *lp)
{
mrb_sym *filenames = *fp;
size_t i, size = 0;
mrb_irep_debug_info *di = irep->debug_info;
mrb_assert(lp);
for (i = 0; i < di->flen; ++i) {
mrb_irep_debug_info_file *file;
mrb_int filename_len;
file = di->files[i];
if (find_filename_index(filenames, *lp, file->filename_sym) == -1) {
/* register filename */
*lp += 1;
*fp = filenames = (mrb_sym *)mrb_realloc(mrb, filenames, sizeof(mrb_sym) * (*lp));
filenames[*lp - 1] = file->filename_sym;
/* filename */
mrb_sym2name_len(mrb, file->filename_sym, &filename_len);
size += sizeof(uint16_t) + (size_t)filename_len;
}
}
for (i=0; i<irep->rlen; i++) {
size += get_filename_table_size(mrb, irep->reps[i], fp, lp);
}
return size;
}
char const* mrb_parser_state::mrb_parser_get_filename(uint16_t idx) {
if (idx >= filename_table_length) { return NULL; }
else {
size_t len;
return mrb_sym2name_len(m_mrb, filename_table[idx], len);
}
}
static uint32_t
get_syms_block_size(mrb_state *mrb, mrb_irep *irep, int type)
{
uint32_t size = 0;
int sym_no;
size += MRB_DUMP_SIZE_OF_LONG; /* slen */
size += MRB_DUMP_SIZE_OF_SHORT; /* crc */
size = DUMP_SIZE(size, type);
for (sym_no = 0; sym_no < irep->slen; sym_no++) {
const char * name;
uint16_t nlen =0;
size += DUMP_SIZE(MRB_DUMP_SIZE_OF_SHORT, type); /* snl(n) */
if (irep->syms[sym_no] != 0) {
int len;
name = mrb_sym2name_len(mrb, irep->syms[sym_no], &len);
nlen = str_dump_len((char*)name, len, type);
size += nlen; /* sn(n) */
}
}
return size;
}
static ptrdiff_t
write_syms_block(mrb_state *mrb, mrb_irep *irep, uint8_t *buf)
{
uint32_t sym_no;
uint8_t *cur = buf;
const char *name;
cur += uint32_to_bin(irep->slen, cur); /* number of symbol */
for (sym_no = 0; sym_no < irep->slen; sym_no++) {
if (irep->syms[sym_no] != 0) {
mrb_int len;
name = mrb_sym2name_len(mrb, irep->syms[sym_no], &len);
mrb_assert_int_fit(mrb_int, len, uint16_t, UINT16_MAX);
cur += uint16_to_bin((uint16_t)len, cur); /* length of symbol name */
memcpy(cur, name, len); /* symbol name */
cur += (uint16_t)len;
*cur++ = '\0';
}
else {
cur += uint16_to_bin(MRB_DUMP_NULL_SYM_LEN, cur); /* length of symbol name */
}
}
return cur - buf;
}
static mrb_sym
migrate_sym(mrb_state *mrb, mrb_sym sym, mrb_state *mrb2)
{
mrb_int len;
const char *p = mrb_sym2name_len(mrb, sym, &len);
return mrb_intern_static(mrb2, p, len);
}
mrb_value
mrb_class_find_path(mrb_state *mrb, struct RClass *c)
{
struct RClass *outer;
mrb_value path;
mrb_sym name;
const char *str;
mrb_int len;
if (detect_outer_loop(mrb, c)) return mrb_nil_value();
outer = outer_class(mrb, c);
if (outer == NULL) return mrb_nil_value();
name = find_class_sym(mrb, outer, c);
if (name == 0) return mrb_nil_value();
str = mrb_class_name(mrb, outer);
path = mrb_str_new_capa(mrb, 40);
mrb_str_cat_cstr(mrb, path, str);
mrb_str_cat_cstr(mrb, path, "::");
str = mrb_sym2name_len(mrb, name, &len);
mrb_str_cat(mrb, path, str, len);
if (RSTRING_PTR(path)[0] != '#') {
iv_del(mrb, c->iv, mrb_intern_lit(mrb, "__outer__"), NULL);
iv_put(mrb, c->iv, mrb_intern_lit(mrb, "__classname__"), path);
mrb_field_write_barrier_value(mrb, (struct RBasic*)c, path);
}
return path;
}
static int
write_syms_block(mrb_state *mrb, mrb_irep *irep, uint8_t *buf)
{
size_t sym_no;
uint8_t *cur = buf;
const char *name;
cur += uint32_to_bin(irep->slen, cur); /* number of symbol */
for (sym_no = 0; sym_no < irep->slen; sym_no++) {
if (irep->syms[sym_no] != 0) {
size_t len;
name = mrb_sym2name_len(mrb, irep->syms[sym_no], &len);
if (len > UINT16_MAX) {
return MRB_DUMP_GENERAL_FAILURE;
}
cur += uint16_to_bin((uint16_t)len, cur); /* length of symbol name */
memcpy(cur, name, len); /* symbol name */
cur += (uint16_t)len;
*cur++ = '\0';
}
else {
cur += uint16_to_bin(MRB_DUMP_NULL_SYM_LEN, cur); /* length of symbol name */
}
}
return (int)(cur - buf);
}
/*
* call-seq:
* sym.length -> integer
*
* Same as <code>sym.to_s.length</code>.
*/
static mrb_value
mrb_sym_length(mrb_state *mrb, mrb_value self)
{
mrb_int len;
mrb_sym2name_len(mrb, mrb_symbol(self), &len);
return mrb_fixnum_value(len);
}
static int
inspect_i(mrb_state *mrb, mrb_sym sym, mrb_value v, void *p)
{
mrb_value str = *(mrb_value*)p;
const char *s;
mrb_int len;
mrb_value ins;
char *sp = RSTRING_PTR(str);
/* need not to show internal data */
if (sp[0] == '-') { /* first element */
sp[0] = '#';
mrb_str_cat_lit(mrb, str, " ");
}
else {
mrb_str_cat_lit(mrb, str, ", ");
}
s = mrb_sym2name_len(mrb, sym, &len);
mrb_str_cat(mrb, str, s, len);
mrb_str_cat_lit(mrb, str, "=");
if (mrb_type(v) == MRB_TT_OBJECT) {
ins = mrb_any_to_s(mrb, v);
}
else {
ins = mrb_inspect(mrb, v);
}
mrb_str_cat_str(mrb, str, ins);
return 0;
}
static mrb_value
make_struct(mrb_state *mrb, mrb_value name, mrb_value members, struct RClass * klass)
{
mrb_value nstr;
mrb_sym id;
struct RClass *c;
if (mrb_nil_p(name)) {
c = mrb_class_new(mrb, klass);
}
else {
/* old style: should we warn? */
name = mrb_str_to_str(mrb, name);
id = mrb_obj_to_sym(mrb, name);
if (!is_const_id(mrb, mrb_sym2name_len(mrb, id, NULL))) {
mrb_name_error(mrb, id, "identifier %S needs to be constant", name);
}
if (mrb_const_defined_at(mrb, klass, id)) {
mrb_warn(mrb, "redefining constant Struct::%S", name);
/* ?rb_mod_remove_const(klass, mrb_sym2name(mrb, id)); */
}
c = mrb_define_class_under(mrb, klass, RSTRING_PTR(name), klass);
}
MRB_SET_INSTANCE_TT(c, MRB_TT_ARRAY);
nstr = mrb_obj_value(c);
mrb_iv_set(mrb, nstr, mrb_intern_lit(mrb, "__members__"), members);
mrb_define_class_method(mrb, c, "new", mrb_instance_new, MRB_ARGS_ANY());
mrb_define_class_method(mrb, c, "[]", mrb_instance_new, MRB_ARGS_ANY());
mrb_define_class_method(mrb, c, "members", mrb_struct_s_members_m, MRB_ARGS_NONE());
/* RSTRUCT(nstr)->basic.c->super = c->c; */
make_struct_define_accessors(mrb, members, c);
return nstr;
}
static void
check_iv_name(mrb_state *mrb, mrb_sym iv_name_id)
{
const char *s;
size_t len;
s = mrb_sym2name_len(mrb, iv_name_id, &len);
valid_iv_name(mrb, iv_name_id, s, len);
}
struct task_arg* mrb_value_to_task_arg(mrb_state *mrb, mrb_value v)
{
struct task_arg *arg = mrb_malloc(mrb, sizeof(struct task_arg));
arg->tt = mrb_type(v);
switch (mrb_type(v)) {
case MRB_TT_FALSE:
case MRB_TT_TRUE:
case MRB_TT_FIXNUM:
arg->value.i = v.value.i;
break;
case MRB_TT_FLOAT:
arg->value.f = v.value.f;
break;
case MRB_TT_SYMBOL:
{
size_t len;
const char* name = mrb_sym2name_len(mrb, v.value.sym, &len);
arg->value.string.len = len;
arg->value.string.ptr = mrb_malloc(mrb, len + 1);
memcpy(arg->value.string.ptr, name, len + 1);
}
break;
case MRB_TT_STRING:
{
struct RString *str = mrb_str_ptr(v);
arg->value.string.len = str->len;
arg->value.string.ptr = mrb_malloc(mrb, arg->value.string.len+1);
memcpy(arg->value.string.ptr, str->ptr, arg->value.string.len+1);
}
break;
case MRB_TT_ARRAY:
{
struct RArray *ary = mrb_ary_ptr(v);
arg->value.array.len = ary->len;
arg->value.array.ptr = mrb_malloc(mrb, ary->len * sizeof(struct task_arg));
int i;
for(i=0; i<ary->len; i++) {
arg->value.array.ptr[i] = mrb_value_to_task_arg(mrb, ary->ptr[i]);
}
}
break;
default:
mrb_free(mrb, arg);
mrb_raise(mrb, E_TYPE_ERROR, "cannot pass to other RubyVM");
break;
}
return arg;
}
MRB_API mrb_value
mrb_sym2str(mrb_state *mrb, mrb_sym sym)
{
mrb_int len;
const char *name = mrb_sym2name_len(mrb, sym, &len);
if (!name) return mrb_undef_value(); /* can't happen */
return mrb_str_new_static(mrb, name, len);
}
/*
* call-seq:
* sym.id2name -> string
* sym.to_s -> string
*
* Returns the name or string corresponding to <i>sym</i>.
*
* :fred.id2name #=> "fred"
*/
static mrb_value
mrb_sym_to_s(mrb_state *mrb, mrb_value sym)
{
mrb_sym id = mrb_symbol(sym);
const char *p;
mrb_int len;
p = mrb_sym2name_len(mrb, id, &len);
return mrb_str_new_static(mrb, p, len);
}
static void
check_const_name(mrb_state *mrb, mrb_sym id)
{
const char *s;
int len;
s = mrb_sym2name_len(mrb, id, &len);
if (len < 1 || !ISUPPER(*s)) {
mrb_name_error(mrb, id, "wrong constant name %s", s);
}
}
static void
check_const_name_sym(mrb_state *mrb, mrb_sym id)
{
const char *s;
size_t len;
s = mrb_sym2name_len(mrb, id, &len);
if (len < 1 || !ISUPPER(*s)) {
mrb_name_error(mrb, id, "wrong constant name %S", mrb_sym2str(mrb, id));
}
}
static void
check_cv_name_sym(mrb_state *mrb, mrb_sym id)
{
const char *s;
size_t len;
s = mrb_sym2name_len(mrb, id, &len);
if (len < 3 || !(s[0] == '@' && s[1] == '@')) {
mrb_name_error(mrb, id, "`%S' is not allowed as a class variable name", mrb_sym2str(mrb, id));
}
}
static void
check_iv_name(mrb_state *mrb, mrb_sym id)
{
const char *s;
int len;
s = mrb_sym2name_len(mrb, id, &len);
if (len < 2 && s[0] != '@') {
mrb_name_error(mrb, id, "`%s' is not allowed as an instance variable name", s);
}
}
static mrb_value mrb_js_obj_method_missing(mrb_state *mrb, mrb_value self)
{
NPP npp = MRB_UD_NPP(mrb);
mrb_value name_sym, *args;
int len;
mrb_get_args(mrb, "o*", &name_sym, &args, &len);
if (mrb_type(name_sym) != MRB_TT_SYMBOL){
return mrb_nil_value();
}
bool success = true;
NPVariant empty;
NULL_TO_NPVARIANT(empty);
std::vector< NPVariant > var_args(len, empty);
for (int i=0; i<len; i++){
if (!convert_mrb_to_js(mrb, args[i], npp, &var_args[i])){
success = false;
break;
}
}
mrb_value ret = mrb_nil_value();
if (success){
int name_len;
const char *name_char = mrb_sym2name_len(mrb, SYM2ID(name_sym), &name_len);
std::string name(name_char, name_len);
NPIdentifier name_id = NPN_GetStringIdentifier(name.c_str());
NPObject *obj = (NPObject *)DATA_PTR(self);
if (NPN_HasMethod(npp, obj, name_id)){
NPVariant result;
NPN_Invoke(npp, obj, name_id, &var_args[0], len, &result);
convert_js_to_mrb(npp, result, mrb, &ret);
}else if (NPN_HasProperty(npp, obj, name_id)){
NPVariant result;
NPN_GetProperty(npp, obj, name_id, &result);
convert_js_to_mrb(npp, result, mrb, &ret);
}else if (name.size() > 1 && name[name.size() - 1] == '=' && var_args.size() == 1){
name.resize(name.size() - 1);
name_id = NPN_GetStringIdentifier(name.c_str());
if (NPN_HasProperty(npp, obj, name_id)){
NPN_SetProperty(npp, obj, name_id, &var_args[0]);
}
}
}
for (int i=0; i<len; i++){
NPN_ReleaseVariantValue(&var_args[i]);
}
return ret;
}
MRB_API mrb_bool
mrb_iv_name_sym_p(mrb_state *mrb, mrb_sym iv_name)
{
const char *s;
mrb_int len;
s = mrb_sym2name_len(mrb, iv_name, &len);
if (len < 2) return FALSE;
if (s[0] != '@') return FALSE;
if (ISDIGIT(s[1])) return FALSE;
return mrb_ident_p(s+1, len-1);
}
static int
write_syms_block(mrb_state *mrb, mrb_irep *irep, uint8_t *buf)
{
int result;
size_t sym_no;
size_t buf_size;
uint8_t *cur = buf;
uint16_t nlen;
char *char_buf = NULL;
const char *name;
buf_size = MRB_DUMP_DEFAULT_STR_LEN;
char_buf = (char *)mrb_malloc(mrb, buf_size);
if (char_buf == NULL) {
result = MRB_DUMP_GENERAL_FAILURE;
goto error_exit;
}
cur += uint32_to_bin(irep->slen, cur); /* number of symbol */
for (sym_no = 0; sym_no < irep->slen; sym_no++) {
if (irep->syms[sym_no] != 0) {
size_t len;
name = mrb_sym2name_len(mrb, irep->syms[sym_no], &len);
if (len > UINT16_MAX) goto error_exit;
nlen = (uint16_t)len;
if (nlen > buf_size - 1) {
buf_size = nlen + 1;
char_buf = (char *)mrb_realloc(mrb, char_buf, buf_size);
if (char_buf == NULL) {
result = MRB_DUMP_GENERAL_FAILURE;
goto error_exit;
}
}
memset(char_buf, 0, buf_size);
memcpy(char_buf, name, len);
cur += uint16_to_bin(nlen, cur); /* length of symbol name */
memcpy(cur, char_buf, nlen); /* symbol name */
cur += nlen;
}
else {
cur += uint16_to_bin(MRB_DUMP_NULL_SYM_LEN, cur); /* length of symbol name */
}
}
result = (int)(cur - buf);
error_exit:
mrb_free(mrb, char_buf);
return result;
}
static mrb_value
mrb_thread_init(mrb_state* mrb, mrb_value self) {
mrb_value proc = mrb_nil_value();
mrb_int argc;
mrb_value* argv;
mrb_get_args(mrb, "&*", &proc, &argv, &argc);
if (!mrb_nil_p(proc) && MRB_PROC_CFUNC_P(mrb_proc_ptr(proc))) {
mrb_raise(mrb, E_RUNTIME_ERROR, "forking C defined block");
}
if (!mrb_nil_p(proc)) {
int i, l;
mrb_thread_context* context = (mrb_thread_context*) malloc(sizeof(mrb_thread_context));
context->mrb_caller = mrb;
context->mrb = mrb_open_allocf(mrb->allocf, mrb->allocf_ud);
migrate_all_symbols(mrb, context->mrb);
context->proc = mrb_proc_new(mrb, mrb_proc_ptr(proc)->body.irep);
context->proc->target_class = context->mrb->object_class;
context->argc = argc;
context->argv = calloc(sizeof (mrb_value), context->argc);
context->result = mrb_nil_value();
context->alive = TRUE;
for (i = 0; i < context->argc; i++) {
context->argv[i] = migrate_simple_value(mrb, argv[i], context->mrb);
}
{
mrb_value gv = mrb_funcall(mrb, self, "global_variables", 0, NULL);
l = RARRAY_LEN(gv);
for (i = 0; i < l; i++) {
mrb_int len;
int ai = mrb_gc_arena_save(mrb);
mrb_value k = mrb_ary_entry(gv, i);
mrb_value o = mrb_gv_get(mrb, mrb_symbol(k));
if (is_safe_migratable_simple_value(mrb, o, context->mrb)) {
const char *p = mrb_sym2name_len(mrb, mrb_symbol(k), &len);
mrb_gv_set(context->mrb,
mrb_intern_static(context->mrb, p, len),
migrate_simple_value(mrb, o, context->mrb));
}
mrb_gc_arena_restore(mrb, ai);
}
}
mrb_iv_set(mrb, self, mrb_intern_lit(mrb, "context"), mrb_obj_value(
Data_Wrap_Struct(mrb, mrb->object_class,
&mrb_thread_context_type, (void*) context)));
pthread_create(&context->thread, NULL, &mrb_thread_func, (void*) context);
}
return self;
}
mrb_value
mrb_sym2str(mrb_state *mrb, mrb_sym sym)
{
size_t len;
const char *name = mrb_sym2name_len(mrb, sym, &len);
if (!name) return mrb_undef_value(); /* can't happen */
if (symname_p(name) && strlen(name) == len) {
return mrb_str_new(mrb, name, len);
}
else {
return mrb_str_dump(mrb, mrb_str_new(mrb, name, len));
}
}
static int
cv_i(mrb_state *mrb, mrb_sym sym, mrb_value v, void *p)
{
mrb_value ary;
const char* s;
size_t len;
ary = *(mrb_value*)p;
s = mrb_sym2name_len(mrb, sym, &len);
if (len > 2 && s[0] == '@' && s[1] == '@') {
mrb_ary_push(mrb, ary, mrb_symbol_value(sym));
}
return 0;
}
static int
const_i(mrb_state *mrb, mrb_sym sym, mrb_value v, void *p)
{
mrb_value ary;
const char* s;
size_t len;
ary = *(mrb_value*)p;
s = mrb_sym2name_len(mrb, sym, &len);
if (len > 1 && ISUPPER(s[0])) {
mrb_ary_push(mrb, ary, mrb_symbol_value(sym));
}
return 0;
}
grn_obj *
grn_mrb_value_to_bulk(mrb_state *mrb, mrb_value mrb_value_, grn_obj *bulk)
{
grn_ctx *ctx = (grn_ctx *)mrb->ud;
switch (mrb_type(mrb_value_)) {
case MRB_TT_FALSE :
if (mrb_nil_p(mrb_value_)) {
grn_obj_reinit(ctx, bulk, GRN_DB_VOID, 0);
} else {
grn_obj_reinit(ctx, bulk, GRN_DB_BOOL, 0);
GRN_BOOL_SET(ctx, bulk, GRN_FALSE);
}
break;
case MRB_TT_TRUE :
grn_obj_reinit(ctx, bulk, GRN_DB_BOOL, 0);
GRN_BOOL_SET(ctx, bulk, GRN_TRUE);
break;
case MRB_TT_FIXNUM :
grn_obj_reinit(ctx, bulk, GRN_DB_INT64, 0);
GRN_INT64_SET(ctx, bulk, mrb_fixnum(mrb_value_));
break;
case MRB_TT_SYMBOL :
{
const char *name;
mrb_int name_length;
grn_obj_reinit(ctx, bulk, GRN_DB_TEXT, 0);
name = mrb_sym2name_len(mrb, mrb_symbol(mrb_value_), &name_length);
GRN_TEXT_SET(ctx, bulk, name, name_length);
}
break;
case MRB_TT_FLOAT :
grn_obj_reinit(ctx, bulk, GRN_DB_FLOAT, 0);
GRN_FLOAT_SET(ctx, bulk, mrb_float(mrb_value_));
break;
case MRB_TT_STRING :
grn_obj_reinit(ctx, bulk, GRN_DB_TEXT, 0);
GRN_TEXT_SET(ctx, bulk, RSTRING_PTR(mrb_value_), RSTRING_LEN(mrb_value_));
break;
default :
mrb_raisef(mrb, E_ARGUMENT_ERROR,
"unsupported object to convert to bulk: %S",
mrb_value_);
break;
}
return bulk;
}
const char*
mrb_sym2name(mrb_state *mrb, mrb_sym sym)
{
size_t len;
const char *name = mrb_sym2name_len(mrb, sym, &len);
if (!name) return NULL;
if (symname_p(name) && strlen(name) == len) {
return name;
}
else {
mrb_value str = mrb_str_dump(mrb, mrb_str_new(mrb, name, len));
return RSTRING(str)->ptr;
}
}
MRB_API const char*
mrb_sym2name(mrb_state *mrb, mrb_sym sym)
{
mrb_int len;
const char *name = mrb_sym2name_len(mrb, sym, &len);
if (!name) return NULL;
if (symname_p(name) && strlen(name) == (size_t)len) {
return name;
}
else {
mrb_value str = mrb_str_dump(mrb, mrb_str_new_static(mrb, name, len));
return RSTRING_PTR(str);
}
}
MRB_API mrb_bool
mrb_iv_p(mrb_state *mrb, mrb_sym iv_name)
{
const char *s;
mrb_int i, len;
s = mrb_sym2name_len(mrb, iv_name, &len);
if (len < 2) return FALSE;
if (s[0] != '@') return FALSE;
if (s[1] == '@') return FALSE;
for (i=1; i<len; i++) {
if (!identchar(s[i])) return FALSE;
}
return TRUE;
}
