mirror of
https://github.com/mruby/mruby
synced 2026-06-08 16:11:16 +00:00
class.c: refactor ROM method tables to array-of-structs layout
Replace the parallel-arrays (struct-of-arrays) ROM method table layout with an array-of-structs layout where each mrb_mt_entry bundles its function pointer and symbol key together. New MRB_MT_ENTRY() and MRB_MT_ROM_TAB() macros simplify ROM table definitions from a 3-part pattern (SIZE define + anonymous struct + mrb_mt_tbl) to a 2-part pattern (entries array + mrb_mt_tbl). Internal mt_* functions in class.c are simplified: single memmove/ memcpy operations replace paired key+value operations. Co-authored-by: Claude <noreply@anthropic.com>
This commit is contained in:
Yukihiro "Matz" Matsumoto
+38
-85
@@ -2249,92 +2249,45 @@ mrb_ary_to_a(mrb_state *mrb, mrb_value self)
|
||||
}
|
||||
|
||||
/* ---------------------------*/
|
||||
#define ARRAY_ROM_MT_SIZE 36
|
||||
static struct {
|
||||
union mrb_mt_ptr vals[ARRAY_ROM_MT_SIZE];
|
||||
mrb_sym keys[ARRAY_ROM_MT_SIZE];
|
||||
} array_rom_data = {
|
||||
.vals = {
|
||||
{ .func = mrb_ary_plus },
|
||||
{ .func = mrb_ary_times },
|
||||
{ .func = mrb_ary_push_m },
|
||||
{ .func = mrb_ary_aget },
|
||||
{ .func = mrb_ary_aset },
|
||||
{ .func = mrb_ary_clear },
|
||||
{ .func = mrb_ary_cmp },
|
||||
{ .func = mrb_ary_concat_m },
|
||||
{ .func = mrb_ary_delete },
|
||||
{ .func = mrb_ary_delete_at },
|
||||
{ .func = mrb_ary_empty_p },
|
||||
{ .func = mrb_ary_eq },
|
||||
{ .func = mrb_ary_eql },
|
||||
{ .func = mrb_ary_first },
|
||||
{ .func = mrb_ary_index_m },
|
||||
{ .func = mrb_ary_init },
|
||||
{ .func = mrb_ary_replace_m },
|
||||
{ .func = mrb_ary_join_m },
|
||||
{ .func = mrb_ary_last },
|
||||
{ .func = mrb_ary_size },
|
||||
{ .func = mrb_ary_pop },
|
||||
{ .func = mrb_ary_push_m },
|
||||
{ .func = mrb_ary_replace_m },
|
||||
{ .func = mrb_ary_reverse },
|
||||
{ .func = mrb_ary_reverse_bang },
|
||||
{ .func = mrb_ary_rindex_m },
|
||||
{ .func = mrb_ary_shift_m },
|
||||
{ .func = mrb_ary_size },
|
||||
{ .func = mrb_ary_aget },
|
||||
{ .func = mrb_ary_unshift_m },
|
||||
{ .func = mrb_ary_to_a },
|
||||
{ .func = mrb_ary_to_a },
|
||||
{ .func = mrb_ary_to_s },
|
||||
{ .func = mrb_ary_to_s },
|
||||
{ .func = mrb_ary_sort_bang },
|
||||
{ .func = mrb_ary_svalue },
|
||||
},
|
||||
.keys = {
|
||||
MRB_MT_KEY(MRB_OPSYM(add), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_OPSYM(mul), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_OPSYM(lshift), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_OPSYM(aref), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_OPSYM(aset), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(clear), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_OPSYM(cmp), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(concat), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(delete), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(delete_at), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM_Q(empty), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_OPSYM(eq), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM_Q(eql), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(first), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(index), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(initialize), MRB_MT_FUNC|MRB_MT_PRIVATE),
|
||||
MRB_MT_KEY(MRB_SYM(initialize_copy), MRB_MT_FUNC|MRB_MT_PRIVATE),
|
||||
MRB_MT_KEY(MRB_SYM(join), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(last), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(length), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(pop), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(push), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(replace), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(reverse), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM_B(reverse), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(rindex), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(shift), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(size), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(slice), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(unshift), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(to_a), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(entries), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(to_s), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(inspect), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM_B(sort), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(__svalue), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
}
|
||||
};
|
||||
static mrb_mt_tbl array_rom_mt = {
|
||||
ARRAY_ROM_MT_SIZE, ARRAY_ROM_MT_SIZE,
|
||||
(union mrb_mt_ptr*)&array_rom_data, NULL
|
||||
static mrb_mt_entry array_rom_entries[] = {
|
||||
MRB_MT_ENTRY(mrb_ary_plus, MRB_OPSYM(add), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_ary_times, MRB_OPSYM(mul), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_ary_push_m, MRB_OPSYM(lshift), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_ary_aget, MRB_OPSYM(aref), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_ary_aset, MRB_OPSYM(aset), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_ary_clear, MRB_SYM(clear), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(mrb_ary_cmp, MRB_OPSYM(cmp), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_ary_concat_m, MRB_SYM(concat), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_ary_delete, MRB_SYM(delete), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_ary_delete_at, MRB_SYM(delete_at), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_ary_empty_p, MRB_SYM_Q(empty), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(mrb_ary_eq, MRB_OPSYM(eq), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_ary_eql, MRB_SYM_Q(eql), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_ary_first, MRB_SYM(first), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_ary_index_m, MRB_SYM(index), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_ary_init, MRB_SYM(initialize), MRB_MT_FUNC|MRB_MT_PRIVATE),
|
||||
MRB_MT_ENTRY(mrb_ary_replace_m, MRB_SYM(initialize_copy), MRB_MT_FUNC|MRB_MT_PRIVATE),
|
||||
MRB_MT_ENTRY(mrb_ary_join_m, MRB_SYM(join), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_ary_last, MRB_SYM(last), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_ary_size, MRB_SYM(length), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(mrb_ary_pop, MRB_SYM(pop), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(mrb_ary_push_m, MRB_SYM(push), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_ary_replace_m, MRB_SYM(replace), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_ary_reverse, MRB_SYM(reverse), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(mrb_ary_reverse_bang, MRB_SYM_B(reverse), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(mrb_ary_rindex_m, MRB_SYM(rindex), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_ary_shift_m, MRB_SYM(shift), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_ary_size, MRB_SYM(size), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(mrb_ary_aget, MRB_SYM(slice), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_ary_unshift_m, MRB_SYM(unshift), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_ary_to_a, MRB_SYM(to_a), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(mrb_ary_to_a, MRB_SYM(entries), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(mrb_ary_to_s, MRB_SYM(to_s), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(mrb_ary_to_s, MRB_SYM(inspect), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(mrb_ary_sort_bang, MRB_SYM_B(sort), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(mrb_ary_svalue, MRB_SYM(__svalue), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
};
|
||||
static mrb_mt_tbl array_rom_mt = MRB_MT_ROM_TAB(array_rom_entries);
|
||||
|
||||
void
|
||||
mrb_init_array(mrb_state *mrb)
|
||||
|
||||
+111
-233
@@ -38,35 +38,12 @@
|
||||
#define mt_readonly_p(t) ((t)->alloc & MRB_MT_READONLY_BIT)
|
||||
#define mt_frozen_p(t) ((t)->alloc & MRB_MT_FROZEN_BIT)
|
||||
|
||||
/* Helper to get keys array from method table */
|
||||
static inline mrb_sym*
|
||||
mt_keys(mrb_mt_tbl *t) {
|
||||
return (mrb_sym*)&t->ptr[MT_ALLOC(t)];
|
||||
}
|
||||
|
||||
/* Helper to get values array from method table */
|
||||
static union mrb_mt_ptr*
|
||||
mt_vals(mrb_mt_tbl *t) {
|
||||
return t->ptr;
|
||||
}
|
||||
|
||||
/* Allocates or grows the method table block to exactly new_alloc entries */
|
||||
/* Allocates or grows the method table to exactly new_alloc entries */
|
||||
static void
|
||||
mt_grow(mrb_state *mrb, mrb_mt_tbl *t, int new_alloc)
|
||||
{
|
||||
int old_alloc = MT_ALLOC(t);
|
||||
size_t new_block = new_alloc * (sizeof(union mrb_mt_ptr) + sizeof(mrb_sym));
|
||||
|
||||
t->ptr = (union mrb_mt_ptr*)mrb_realloc(mrb, t->ptr, new_block);
|
||||
if (old_alloc > 0) {
|
||||
/* keys used to live at &ptr[old_alloc] */
|
||||
mrb_sym *old_keys = (mrb_sym*)&t->ptr[old_alloc];
|
||||
/* keys must now live at &ptr[new_alloc] */
|
||||
mrb_sym *new_keys = (mrb_sym*)&t->ptr[new_alloc];
|
||||
|
||||
/* move the old key array up to its new position */
|
||||
memmove(new_keys, old_keys, old_alloc * sizeof(mrb_sym));
|
||||
}
|
||||
t->ptr = (mrb_mt_entry*)mrb_realloc(mrb, t->ptr,
|
||||
new_alloc * sizeof(mrb_mt_entry));
|
||||
t->alloc = (t->alloc & MRB_MT_FLAG_BITS) | new_alloc;
|
||||
}
|
||||
|
||||
@@ -85,19 +62,19 @@ mt_new(mrb_state *mrb)
|
||||
return t;
|
||||
}
|
||||
|
||||
/* Branch-free binary search helper for method table keys */
|
||||
/* Branch-free binary search helper for method table entries */
|
||||
static inline int
|
||||
mt_bsearch_idx(mrb_sym *keys, int size, mrb_sym target)
|
||||
mt_bsearch_idx(mrb_mt_entry *entries, int size, mrb_sym target)
|
||||
{
|
||||
if (size == 0) return 0;
|
||||
int n = size;
|
||||
mrb_sym *p = keys;
|
||||
mrb_mt_entry *p = entries;
|
||||
/* While more than one element remains, halve the range each iteration */
|
||||
while (n > 1) {
|
||||
int half = n >> 1;
|
||||
MRB_MEM_PREFETCH(p + (half >> 1));
|
||||
MRB_MEM_PREFETCH(p + half + (half >> 1));
|
||||
mrb_sym mid_sym = MT_KEY_SYM(p[half]);
|
||||
mrb_sym mid_sym = MT_KEY_SYM(p[half].key);
|
||||
/*
|
||||
* Update pointer p without a branch:
|
||||
* If mid_sym < target, move p forward by half; otherwise keep p unchanged.
|
||||
@@ -107,8 +84,8 @@ mt_bsearch_idx(mrb_sym *keys, int size, mrb_sym target)
|
||||
n -= half;
|
||||
}
|
||||
/* Final adjustment: if the remaining element is still less than target, advance by one */
|
||||
int offset = (MT_KEY_SYM(*p) < target);
|
||||
return (int)(p - keys) + offset;
|
||||
int offset = (MT_KEY_SYM(p->key) < target);
|
||||
return (int)(p - entries) + offset;
|
||||
}
|
||||
|
||||
/* Inserts or updates an entry in the method table */
|
||||
@@ -125,32 +102,30 @@ mt_put(mrb_state *mrb, mrb_mt_tbl *t, mrb_sym sym, mrb_sym flags, union mrb_mt_p
|
||||
mt_grow(mrb, t, MT_ALLOC(t) * 2);
|
||||
}
|
||||
|
||||
mrb_sym *keys = mt_keys(t);
|
||||
union mrb_mt_ptr *vals = mt_vals(t);
|
||||
mrb_mt_entry *entries = t->ptr;
|
||||
|
||||
/*
|
||||
* If table is empty, insertion index is 0.
|
||||
* Otherwise, find the insertion/update position branch-free.
|
||||
*/
|
||||
int lo = mt_bsearch_idx(keys, t->size, sym);
|
||||
int lo = mt_bsearch_idx(entries, t->size, sym);
|
||||
|
||||
/* If the key already exists, update its value and return */
|
||||
if (lo < t->size && MT_KEY_SYM(keys[lo]) == sym) {
|
||||
keys[lo] = key;
|
||||
vals[lo] = ptrval;
|
||||
if (lo < t->size && MT_KEY_SYM(entries[lo].key) == sym) {
|
||||
entries[lo].key = key;
|
||||
entries[lo].val = ptrval;
|
||||
return;
|
||||
}
|
||||
|
||||
/* Shift existing entries to make room at index lo */
|
||||
if (t->size > lo) {
|
||||
int move_count = t->size - lo;
|
||||
memmove(&vals[lo+1], &vals[lo], move_count * sizeof(union mrb_mt_ptr));
|
||||
memmove(&keys[lo+1], &keys[lo], move_count * sizeof(mrb_sym));
|
||||
memmove(&entries[lo+1], &entries[lo],
|
||||
(t->size - lo) * sizeof(mrb_mt_entry));
|
||||
}
|
||||
|
||||
/* Insert the new key and value */
|
||||
keys[lo] = key;
|
||||
vals[lo] = ptrval;
|
||||
/* Insert the new entry */
|
||||
entries[lo].key = key;
|
||||
entries[lo].val = ptrval;
|
||||
t->size++;
|
||||
}
|
||||
|
||||
@@ -160,13 +135,12 @@ mt_get(mrb_state *mrb, mrb_mt_tbl *t, mrb_sym sym, union mrb_mt_ptr *pp)
|
||||
{
|
||||
while (t) {
|
||||
if (t->size > 0) {
|
||||
mrb_sym *keys = mt_keys(t);
|
||||
union mrb_mt_ptr *vals = mt_vals(t);
|
||||
int lo = mt_bsearch_idx(keys, t->size, sym);
|
||||
if (lo < t->size && MT_KEY_SYM(keys[lo]) == sym) {
|
||||
if (MRB_MT_REMOVED_P(keys[lo], vals[lo])) return 0; /* removed tombstone */
|
||||
*pp = vals[lo];
|
||||
return keys[lo];
|
||||
mrb_mt_entry *entries = t->ptr;
|
||||
int lo = mt_bsearch_idx(entries, t->size, sym);
|
||||
if (lo < t->size && MT_KEY_SYM(entries[lo].key) == sym) {
|
||||
if (MRB_MT_REMOVED_P(entries[lo])) return 0; /* removed tombstone */
|
||||
*pp = entries[lo].val;
|
||||
return entries[lo].key;
|
||||
}
|
||||
}
|
||||
t = t->next;
|
||||
@@ -181,18 +155,15 @@ mt_del(mrb_state *mrb, mrb_mt_tbl *t, mrb_sym sym)
|
||||
/* Return FALSE if table is null or empty */
|
||||
if (!t || t->size == 0) return FALSE;
|
||||
|
||||
mrb_sym *keys = mt_keys(t);
|
||||
union mrb_mt_ptr *vals = mt_vals(t);
|
||||
mrb_mt_entry *entries = t->ptr;
|
||||
|
||||
/* Find the index of `sym` in a branch-free manner */
|
||||
int lo = mt_bsearch_idx(keys, t->size, sym);
|
||||
int lo = mt_bsearch_idx(entries, t->size, sym);
|
||||
|
||||
/* If the key exists at index lo, remove it by shifting left */
|
||||
if (lo < t->size && MT_KEY_SYM(keys[lo]) == sym) {
|
||||
int move_count = t->size - lo - 1;
|
||||
/* shift left to remove entry */
|
||||
memmove(&vals[lo], &vals[lo + 1], move_count * sizeof(union mrb_mt_ptr));
|
||||
memmove(&keys[lo], &keys[lo + 1], move_count * sizeof(mrb_sym));
|
||||
if (lo < t->size && MT_KEY_SYM(entries[lo].key) == sym) {
|
||||
memmove(&entries[lo], &entries[lo + 1],
|
||||
(t->size - lo - 1) * sizeof(mrb_mt_entry));
|
||||
t->size--;
|
||||
return TRUE;
|
||||
}
|
||||
@@ -207,9 +178,9 @@ mt_chain_has(mrb_mt_tbl *t, mrb_sym sym)
|
||||
{
|
||||
while (t) {
|
||||
if (t->size > 0) {
|
||||
mrb_sym *keys = mt_keys(t);
|
||||
int lo = mt_bsearch_idx(keys, t->size, sym);
|
||||
if (lo < t->size && MT_KEY_SYM(keys[lo]) == sym) return TRUE;
|
||||
mrb_mt_entry *entries = t->ptr;
|
||||
int lo = mt_bsearch_idx(entries, t->size, sym);
|
||||
if (lo < t->size && MT_KEY_SYM(entries[lo].key) == sym) return TRUE;
|
||||
}
|
||||
t = t->next;
|
||||
}
|
||||
@@ -232,8 +203,7 @@ mt_copy(mrb_state *mrb, mrb_mt_tbl *t)
|
||||
mrb_mt_tbl *t2 = mt_new(mrb);
|
||||
if (t->size > 0) {
|
||||
mt_grow(mrb, t2, t->size);
|
||||
memcpy(mt_vals(t2), mt_vals(t), t->size * sizeof(union mrb_mt_ptr));
|
||||
memcpy(mt_keys(t2), mt_keys(t), t->size * sizeof(mrb_sym));
|
||||
memcpy(t2->ptr, t->ptr, t->size * sizeof(mrb_mt_entry));
|
||||
t2->size = t->size;
|
||||
}
|
||||
t2->next = t->next; /* share ROM chain */
|
||||
@@ -252,22 +222,19 @@ mt_free(mrb_state *mrb, mrb_mt_tbl *t)
|
||||
}
|
||||
}
|
||||
|
||||
/* Sorts parallel vals/keys arrays by key symbol (insertion sort) */
|
||||
/* Sorts entries array by key symbol (insertion sort) */
|
||||
static void
|
||||
mt_sort(union mrb_mt_ptr *vals, mrb_sym *keys, int n)
|
||||
mt_sort(mrb_mt_entry *entries, int n)
|
||||
{
|
||||
for (int i = 1; i < n; i++) {
|
||||
mrb_sym key = keys[i];
|
||||
union mrb_mt_ptr val = vals[i];
|
||||
mrb_sym sym = MT_KEY_SYM(key);
|
||||
mrb_mt_entry e = entries[i];
|
||||
mrb_sym sym = MT_KEY_SYM(e.key);
|
||||
int j = i;
|
||||
while (j > 0 && MT_KEY_SYM(keys[j-1]) > sym) {
|
||||
keys[j] = keys[j-1];
|
||||
vals[j] = vals[j-1];
|
||||
while (j > 0 && MT_KEY_SYM(entries[j-1].key) > sym) {
|
||||
entries[j] = entries[j-1];
|
||||
j--;
|
||||
}
|
||||
keys[j] = key;
|
||||
vals[j] = val;
|
||||
entries[j] = e;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -275,9 +242,7 @@ mt_sort(union mrb_mt_ptr *vals, mrb_sym *keys, int n)
|
||||
void
|
||||
mrb_mt_init_rom(struct RClass *c, mrb_mt_tbl *rom)
|
||||
{
|
||||
union mrb_mt_ptr *vals = rom->ptr;
|
||||
mrb_sym *keys = (mrb_sym*)&vals[rom->size];
|
||||
mt_sort(vals, keys, rom->size);
|
||||
mt_sort(rom->ptr, rom->size);
|
||||
rom->alloc = rom->size | MRB_MT_READONLY_BIT;
|
||||
|
||||
/* push ROM layer */
|
||||
@@ -313,12 +278,11 @@ mrb_mt_foreach(mrb_state *mrb, struct RClass *c, mrb_mt_foreach_func *fn, void *
|
||||
|
||||
/* fast path: single layer */
|
||||
if (!t->next) {
|
||||
mrb_mt_entry *entries = t->ptr;
|
||||
for (int i = 0; i < t->size; i++) {
|
||||
union mrb_mt_ptr *vals = mt_vals(t);
|
||||
mrb_sym *keys = mt_keys(t);
|
||||
if (MRB_MT_REMOVED_P(keys[i], vals[i])) continue;
|
||||
if (fn(mrb, MT_KEY_SYM(keys[i]),
|
||||
create_method_value(mrb, keys[i], vals[i]), p) != 0)
|
||||
if (MRB_MT_REMOVED_P(entries[i])) continue;
|
||||
if (fn(mrb, MT_KEY_SYM(entries[i].key),
|
||||
create_method_value(mrb, entries[i].key, entries[i].val), p) != 0)
|
||||
return;
|
||||
}
|
||||
return;
|
||||
@@ -326,19 +290,17 @@ mrb_mt_foreach(mrb_state *mrb, struct RClass *c, mrb_mt_foreach_func *fn, void *
|
||||
|
||||
/* multi-layer: iterate each layer, skip if shadowed by a higher one */
|
||||
for (mrb_mt_tbl *layer = t; layer; layer = layer->next) {
|
||||
mrb_sym *keys = mt_keys(layer);
|
||||
union mrb_mt_ptr *vals = mt_vals(layer);
|
||||
mrb_mt_entry *entries = layer->ptr;
|
||||
for (int i = 0; i < layer->size; i++) {
|
||||
if (MRB_MT_REMOVED_P(keys[i], vals[i])) continue;
|
||||
mrb_sym sym = MT_KEY_SYM(keys[i]);
|
||||
if (MRB_MT_REMOVED_P(entries[i])) continue;
|
||||
mrb_sym sym = MT_KEY_SYM(entries[i].key);
|
||||
/* check if shadowed by a higher layer */
|
||||
if (layer != t) {
|
||||
mrb_bool shadowed = FALSE;
|
||||
for (mrb_mt_tbl *upper = t; upper != layer; upper = upper->next) {
|
||||
if (upper->size > 0) {
|
||||
mrb_sym *ukeys = mt_keys(upper);
|
||||
int lo = mt_bsearch_idx(ukeys, upper->size, sym);
|
||||
if (lo < upper->size && MT_KEY_SYM(ukeys[lo]) == sym) {
|
||||
int lo = mt_bsearch_idx(upper->ptr, upper->size, sym);
|
||||
if (lo < upper->size && MT_KEY_SYM(upper->ptr[lo].key) == sym) {
|
||||
shadowed = TRUE;
|
||||
break;
|
||||
}
|
||||
@@ -346,7 +308,7 @@ mrb_mt_foreach(mrb_state *mrb, struct RClass *c, mrb_mt_foreach_func *fn, void *
|
||||
}
|
||||
if (shadowed) continue;
|
||||
}
|
||||
if (fn(mrb, sym, create_method_value(mrb, keys[i], vals[i]), p) != 0)
|
||||
if (fn(mrb, sym, create_method_value(mrb, entries[i].key, entries[i].val), p) != 0)
|
||||
return;
|
||||
}
|
||||
}
|
||||
@@ -360,11 +322,10 @@ mrb_gc_mark_mt(mrb_state *mrb, struct RClass *c)
|
||||
for (mrb_mt_tbl *t = c->mt; t; t = t->next) {
|
||||
if (mt_readonly_p(t)) continue; /* ROM layers need no GC marking */
|
||||
if (t->size == 0) continue;
|
||||
mrb_sym *keys = mt_keys(t);
|
||||
union mrb_mt_ptr *vals = mt_vals(t);
|
||||
mrb_mt_entry *entries = t->ptr;
|
||||
for (int i = 0; i < t->size; i++) {
|
||||
if (MT_KEY_P(keys[i]) && (keys[i] & MRB_MT_FUNC) == 0) {
|
||||
mrb_gc_mark(mrb, (struct RBasic*)vals[i].proc);
|
||||
if (MT_KEY_P(entries[i].key) && (entries[i].key & MRB_MT_FUNC) == 0) {
|
||||
mrb_gc_mark(mrb, (struct RBasic*)entries[i].val.proc);
|
||||
}
|
||||
}
|
||||
children += (size_t)t->size;
|
||||
@@ -378,8 +339,7 @@ mrb_class_mt_memsize(mrb_state *mrb, struct RClass *c)
|
||||
{
|
||||
size_t total = 0;
|
||||
for (mrb_mt_tbl *h = c->mt; h && !mt_readonly_p(h); h = h->next)
|
||||
total += sizeof(mrb_mt_tbl) + (size_t)MT_ALLOC(h) *
|
||||
(sizeof(union mrb_mt_ptr) + sizeof(mrb_sym));
|
||||
total += sizeof(mrb_mt_tbl) + (size_t)MT_ALLOC(h) * sizeof(mrb_mt_entry);
|
||||
return total;
|
||||
}
|
||||
|
||||
@@ -4366,148 +4326,66 @@ static const struct RProc neq_proc = {
|
||||
};
|
||||
|
||||
/* ---------------------------*/
|
||||
#define BOB_ROM_MT_SIZE 11
|
||||
static struct {
|
||||
union mrb_mt_ptr vals[BOB_ROM_MT_SIZE];
|
||||
mrb_sym keys[BOB_ROM_MT_SIZE];
|
||||
} bob_rom_data = {
|
||||
.vals = {
|
||||
{ .func = mrb_obj_equal_m },
|
||||
{ .func = mrb_bob_not },
|
||||
{ .func = mrb_obj_id_m },
|
||||
{ .func = mrb_f_send },
|
||||
{ .func = mrb_obj_equal_m },
|
||||
{ .func = mrb_do_nothing },
|
||||
{ .func = mrb_obj_instance_eval },
|
||||
{ .func = mrb_obj_missing },
|
||||
{ .func = mrb_do_nothing },
|
||||
{ .func = mrb_do_nothing },
|
||||
{ .func = mrb_do_nothing },
|
||||
},
|
||||
.keys = {
|
||||
MRB_MT_KEY(MRB_OPSYM(eq), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_OPSYM(not), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(__id__), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(__send__), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM_Q(equal), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(initialize), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PRIVATE),
|
||||
MRB_MT_KEY(MRB_SYM(instance_eval), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(method_missing), MRB_MT_FUNC|MRB_MT_PRIVATE),
|
||||
MRB_MT_KEY(MRB_SYM(singleton_method_added), MRB_MT_FUNC|MRB_MT_PRIVATE),
|
||||
MRB_MT_KEY(MRB_SYM(singleton_method_removed), MRB_MT_FUNC|MRB_MT_PRIVATE),
|
||||
MRB_MT_KEY(MRB_SYM(singleton_method_undefined), MRB_MT_FUNC|MRB_MT_PRIVATE),
|
||||
}
|
||||
};
|
||||
static mrb_mt_tbl bob_rom_mt = {
|
||||
BOB_ROM_MT_SIZE, BOB_ROM_MT_SIZE,
|
||||
(union mrb_mt_ptr*)&bob_rom_data, NULL
|
||||
static mrb_mt_entry bob_rom_entries[] = {
|
||||
MRB_MT_ENTRY(mrb_obj_equal_m, MRB_OPSYM(eq), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_bob_not, MRB_OPSYM(not), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(mrb_obj_id_m, MRB_SYM(__id__), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(mrb_f_send, MRB_SYM(__send__), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_obj_equal_m, MRB_SYM_Q(equal), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_do_nothing, MRB_SYM(initialize), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PRIVATE),
|
||||
MRB_MT_ENTRY(mrb_obj_instance_eval, MRB_SYM(instance_eval), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_obj_missing, MRB_SYM(method_missing), MRB_MT_FUNC|MRB_MT_PRIVATE),
|
||||
MRB_MT_ENTRY(mrb_do_nothing, MRB_SYM(singleton_method_added), MRB_MT_FUNC|MRB_MT_PRIVATE),
|
||||
MRB_MT_ENTRY(mrb_do_nothing, MRB_SYM(singleton_method_removed), MRB_MT_FUNC|MRB_MT_PRIVATE),
|
||||
MRB_MT_ENTRY(mrb_do_nothing, MRB_SYM(singleton_method_undefined), MRB_MT_FUNC|MRB_MT_PRIVATE),
|
||||
};
|
||||
static mrb_mt_tbl bob_rom_mt = MRB_MT_ROM_TAB(bob_rom_entries);
|
||||
|
||||
#define CLS_ROM_MT_SIZE 4
|
||||
static struct {
|
||||
union mrb_mt_ptr vals[CLS_ROM_MT_SIZE];
|
||||
mrb_sym keys[CLS_ROM_MT_SIZE];
|
||||
} cls_rom_data = {
|
||||
.vals = {
|
||||
{ .func = mrb_instance_alloc },
|
||||
{ .func = mrb_do_nothing },
|
||||
{ .func = mrb_class_initialize },
|
||||
{ .func = mrb_class_superclass },
|
||||
},
|
||||
.keys = {
|
||||
MRB_MT_KEY(MRB_SYM(allocate), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(inherited), MRB_MT_FUNC|MRB_MT_PRIVATE),
|
||||
MRB_MT_KEY(MRB_SYM(initialize), MRB_MT_FUNC|MRB_MT_PRIVATE),
|
||||
MRB_MT_KEY(MRB_SYM(superclass), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
}
|
||||
};
|
||||
static mrb_mt_tbl cls_rom_mt = {
|
||||
CLS_ROM_MT_SIZE, CLS_ROM_MT_SIZE,
|
||||
(union mrb_mt_ptr*)&cls_rom_data, NULL
|
||||
static mrb_mt_entry cls_rom_entries[] = {
|
||||
MRB_MT_ENTRY(mrb_instance_alloc, MRB_SYM(allocate), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(mrb_do_nothing, MRB_SYM(inherited), MRB_MT_FUNC|MRB_MT_PRIVATE),
|
||||
MRB_MT_ENTRY(mrb_class_initialize, MRB_SYM(initialize), MRB_MT_FUNC|MRB_MT_PRIVATE),
|
||||
MRB_MT_ENTRY(mrb_class_superclass, MRB_SYM(superclass), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
};
|
||||
static mrb_mt_tbl cls_rom_mt = MRB_MT_ROM_TAB(cls_rom_entries);
|
||||
|
||||
#define MOD_ROM_MT_SIZE 34
|
||||
static struct {
|
||||
union mrb_mt_ptr vals[MOD_ROM_MT_SIZE];
|
||||
mrb_sym keys[MOD_ROM_MT_SIZE];
|
||||
} mod_rom_data = {
|
||||
.vals = {
|
||||
{ .func = mrb_mod_eqq },
|
||||
{ .func = mrb_mod_alias },
|
||||
{ .func = mrb_mod_ancestors },
|
||||
{ .func = mrb_mod_attr_accessor },
|
||||
{ .func = mrb_mod_attr_reader },
|
||||
{ .func = mrb_mod_attr_writer },
|
||||
{ .func = mrb_mod_module_eval },
|
||||
{ .func = mrb_do_nothing },
|
||||
{ .func = mrb_mod_const_defined },
|
||||
{ .func = mrb_mod_const_get },
|
||||
{ .func = mrb_mod_const_missing },
|
||||
{ .func = mrb_mod_const_set },
|
||||
{ .func = mod_define_method },
|
||||
{ .func = mrb_mod_dup },
|
||||
{ .func = mrb_do_nothing },
|
||||
{ .func = mrb_mod_include },
|
||||
{ .func = mrb_mod_include_p },
|
||||
{ .func = mrb_do_nothing },
|
||||
{ .func = mrb_mod_initialize },
|
||||
{ .func = mrb_mod_to_s },
|
||||
{ .func = mrb_do_nothing },
|
||||
{ .func = mrb_do_nothing },
|
||||
{ .func = mrb_mod_method_defined },
|
||||
{ .func = mrb_do_nothing },
|
||||
{ .func = mrb_mod_module_eval },
|
||||
{ .func = mrb_mod_module_function },
|
||||
{ .func = mrb_mod_prepend },
|
||||
{ .func = mrb_do_nothing },
|
||||
{ .func = mrb_mod_private },
|
||||
{ .func = mrb_mod_protected },
|
||||
{ .func = mrb_mod_public },
|
||||
{ .func = mrb_mod_remove_const },
|
||||
{ .func = mrb_mod_to_s },
|
||||
{ .func = mrb_mod_undef },
|
||||
},
|
||||
.keys = {
|
||||
MRB_MT_KEY(MRB_OPSYM(eqq), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(alias_method), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(ancestors), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(attr_accessor), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(attr_reader), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(attr_writer), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(class_eval), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(const_added), MRB_MT_FUNC|MRB_MT_PRIVATE),
|
||||
MRB_MT_KEY(MRB_SYM_Q(const_defined), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(const_get), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(const_missing), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(const_set), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(define_method), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(dup), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(extended), MRB_MT_FUNC|MRB_MT_PRIVATE),
|
||||
MRB_MT_KEY(MRB_SYM(include), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM_Q(include), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(included), MRB_MT_FUNC|MRB_MT_PRIVATE),
|
||||
MRB_MT_KEY(MRB_SYM(initialize), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PRIVATE),
|
||||
MRB_MT_KEY(MRB_SYM(inspect), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(method_added), MRB_MT_FUNC|MRB_MT_PRIVATE),
|
||||
MRB_MT_KEY(MRB_SYM(method_removed), MRB_MT_FUNC|MRB_MT_PRIVATE),
|
||||
MRB_MT_KEY(MRB_SYM_Q(method_defined), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(method_undefined), MRB_MT_FUNC|MRB_MT_PRIVATE),
|
||||
MRB_MT_KEY(MRB_SYM(module_eval), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(module_function), MRB_MT_FUNC|MRB_MT_PRIVATE),
|
||||
MRB_MT_KEY(MRB_SYM(prepend), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(prepended), MRB_MT_FUNC|MRB_MT_PRIVATE),
|
||||
MRB_MT_KEY(MRB_SYM(private), MRB_MT_FUNC|MRB_MT_PRIVATE),
|
||||
MRB_MT_KEY(MRB_SYM(protected), MRB_MT_FUNC|MRB_MT_PRIVATE),
|
||||
MRB_MT_KEY(MRB_SYM(public), MRB_MT_FUNC|MRB_MT_PRIVATE),
|
||||
MRB_MT_KEY(MRB_SYM(remove_const), MRB_MT_FUNC|MRB_MT_PRIVATE),
|
||||
MRB_MT_KEY(MRB_SYM(to_s), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(undef_method), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
}
|
||||
};
|
||||
static mrb_mt_tbl mod_rom_mt = {
|
||||
MOD_ROM_MT_SIZE, MOD_ROM_MT_SIZE,
|
||||
(union mrb_mt_ptr*)&mod_rom_data, NULL
|
||||
static mrb_mt_entry mod_rom_entries[] = {
|
||||
MRB_MT_ENTRY(mrb_mod_eqq, MRB_OPSYM(eqq), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_mod_alias, MRB_SYM(alias_method), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_mod_ancestors, MRB_SYM(ancestors), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(mrb_mod_attr_accessor, MRB_SYM(attr_accessor), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_mod_attr_reader, MRB_SYM(attr_reader), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_mod_attr_writer, MRB_SYM(attr_writer), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_mod_module_eval, MRB_SYM(class_eval), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_do_nothing, MRB_SYM(const_added), MRB_MT_FUNC|MRB_MT_PRIVATE),
|
||||
MRB_MT_ENTRY(mrb_mod_const_defined, MRB_SYM_Q(const_defined), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_mod_const_get, MRB_SYM(const_get), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_mod_const_missing, MRB_SYM(const_missing), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_mod_const_set, MRB_SYM(const_set), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mod_define_method, MRB_SYM(define_method), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_mod_dup, MRB_SYM(dup), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(mrb_do_nothing, MRB_SYM(extended), MRB_MT_FUNC|MRB_MT_PRIVATE),
|
||||
MRB_MT_ENTRY(mrb_mod_include, MRB_SYM(include), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_mod_include_p, MRB_SYM_Q(include), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_do_nothing, MRB_SYM(included), MRB_MT_FUNC|MRB_MT_PRIVATE),
|
||||
MRB_MT_ENTRY(mrb_mod_initialize, MRB_SYM(initialize), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PRIVATE),
|
||||
MRB_MT_ENTRY(mrb_mod_to_s, MRB_SYM(inspect), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(mrb_do_nothing, MRB_SYM(method_added), MRB_MT_FUNC|MRB_MT_PRIVATE),
|
||||
MRB_MT_ENTRY(mrb_do_nothing, MRB_SYM(method_removed), MRB_MT_FUNC|MRB_MT_PRIVATE),
|
||||
MRB_MT_ENTRY(mrb_mod_method_defined, MRB_SYM_Q(method_defined), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_do_nothing, MRB_SYM(method_undefined), MRB_MT_FUNC|MRB_MT_PRIVATE),
|
||||
MRB_MT_ENTRY(mrb_mod_module_eval, MRB_SYM(module_eval), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_mod_module_function, MRB_SYM(module_function), MRB_MT_FUNC|MRB_MT_PRIVATE),
|
||||
MRB_MT_ENTRY(mrb_mod_prepend, MRB_SYM(prepend), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_do_nothing, MRB_SYM(prepended), MRB_MT_FUNC|MRB_MT_PRIVATE),
|
||||
MRB_MT_ENTRY(mrb_mod_private, MRB_SYM(private), MRB_MT_FUNC|MRB_MT_PRIVATE),
|
||||
MRB_MT_ENTRY(mrb_mod_protected, MRB_SYM(protected), MRB_MT_FUNC|MRB_MT_PRIVATE),
|
||||
MRB_MT_ENTRY(mrb_mod_public, MRB_SYM(public), MRB_MT_FUNC|MRB_MT_PRIVATE),
|
||||
MRB_MT_ENTRY(mrb_mod_remove_const, MRB_SYM(remove_const), MRB_MT_FUNC|MRB_MT_PRIVATE),
|
||||
MRB_MT_ENTRY(mrb_mod_to_s, MRB_SYM(to_s), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(mrb_mod_undef, MRB_SYM(undef_method), MRB_MT_FUNC),
|
||||
};
|
||||
static mrb_mt_tbl mod_rom_mt = MRB_MT_ROM_TAB(mod_rom_entries);
|
||||
|
||||
void
|
||||
mrb_init_class(mrb_state *mrb)
|
||||
|
||||
+9
-27
@@ -892,34 +892,16 @@ mrb_check_error(mrb_state *mrb)
|
||||
}
|
||||
|
||||
/* ---------------------------*/
|
||||
#define EXCEPTION_ROM_MT_SIZE 7
|
||||
static struct {
|
||||
union mrb_mt_ptr vals[EXCEPTION_ROM_MT_SIZE];
|
||||
mrb_sym keys[EXCEPTION_ROM_MT_SIZE];
|
||||
} exception_rom_data = {
|
||||
.vals = {
|
||||
{ .func = exc_exception },
|
||||
{ .func = exc_initialize },
|
||||
{ .func = exc_to_s },
|
||||
{ .func = exc_to_s },
|
||||
{ .func = mrb_exc_inspect },
|
||||
{ .func = mrb_exc_backtrace },
|
||||
{ .func = exc_set_backtrace },
|
||||
},
|
||||
.keys = {
|
||||
MRB_MT_KEY(MRB_SYM(exception), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(initialize), MRB_MT_FUNC|MRB_MT_PRIVATE),
|
||||
MRB_MT_KEY(MRB_SYM(to_s), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(message), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(inspect), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(backtrace), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(set_backtrace), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
}
|
||||
};
|
||||
static mrb_mt_tbl exception_rom_mt = {
|
||||
EXCEPTION_ROM_MT_SIZE, EXCEPTION_ROM_MT_SIZE,
|
||||
(union mrb_mt_ptr*)&exception_rom_data, NULL
|
||||
static mrb_mt_entry exception_rom_entries[] = {
|
||||
MRB_MT_ENTRY(exc_exception, MRB_SYM(exception), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(exc_initialize, MRB_SYM(initialize), MRB_MT_FUNC|MRB_MT_PRIVATE),
|
||||
MRB_MT_ENTRY(exc_to_s, MRB_SYM(to_s), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(exc_to_s, MRB_SYM(message), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(mrb_exc_inspect, MRB_SYM(inspect), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(mrb_exc_backtrace, MRB_SYM(backtrace), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(exc_set_backtrace, MRB_SYM(set_backtrace), MRB_MT_FUNC),
|
||||
};
|
||||
static mrb_mt_tbl exception_rom_mt = MRB_MT_ROM_TAB(exception_rom_entries);
|
||||
|
||||
void
|
||||
mrb_init_exception(mrb_state *mrb)
|
||||
|
||||
+38
-85
@@ -2303,92 +2303,45 @@ mrb_hash_eql(mrb_state *mrb, mrb_value hash)
|
||||
}
|
||||
|
||||
/* ---------------------------*/
|
||||
#define HASH_ROM_MT_SIZE 36
|
||||
static struct {
|
||||
union mrb_mt_ptr vals[HASH_ROM_MT_SIZE];
|
||||
mrb_sym keys[HASH_ROM_MT_SIZE];
|
||||
} hash_rom_data = {
|
||||
.vals = {
|
||||
{ .func = mrb_hash_equal },
|
||||
{ .func = mrb_hash_aget },
|
||||
{ .func = mrb_hash_aset },
|
||||
{ .func = mrb_hash_clear },
|
||||
{ .func = mrb_hash_default },
|
||||
{ .func = mrb_hash_set_default },
|
||||
{ .func = mrb_hash_default_proc },
|
||||
{ .func = mrb_hash_set_default_proc },
|
||||
{ .func = mrb_hash_delete },
|
||||
{ .func = mrb_hash_eql },
|
||||
{ .func = mrb_hash_empty_m },
|
||||
{ .func = mrb_hash_has_key },
|
||||
{ .func = mrb_hash_has_value },
|
||||
{ .func = mrb_hash_has_key },
|
||||
{ .func = mrb_hash_init },
|
||||
{ .func = mrb_hash_init_copy },
|
||||
{ .func = mrb_hash_has_key },
|
||||
{ .func = mrb_hash_keys },
|
||||
{ .func = mrb_hash_size_m },
|
||||
{ .func = mrb_hash_has_key },
|
||||
{ .func = mrb_hash_init_copy },
|
||||
{ .func = mrb_hash_shift },
|
||||
{ .func = mrb_hash_size_m },
|
||||
{ .func = mrb_hash_aset },
|
||||
{ .func = mrb_hash_has_value },
|
||||
{ .func = mrb_hash_values },
|
||||
{ .func = mrb_hash_to_s },
|
||||
{ .func = mrb_hash_to_s },
|
||||
{ .func = mrb_hash_rehash },
|
||||
{ .func = mrb_hash_to_hash },
|
||||
{ .func = mrb_hash_assoc },
|
||||
{ .func = mrb_hash_rassoc },
|
||||
{ .func = mrb_hash_merge_m },
|
||||
{ .func = mrb_hash_compact },
|
||||
{ .func = mrb_hash_pat_values },
|
||||
{ .func = mrb_hash_except_keys },
|
||||
},
|
||||
.keys = {
|
||||
MRB_MT_KEY(MRB_OPSYM(eq), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_OPSYM(aref), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_OPSYM(aset), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(clear), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(default), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM_E(default), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(default_proc), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM_E(default_proc), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(__delete), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM_Q(eql), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM_Q(empty), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM_Q(has_key), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM_Q(has_value), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM_Q(include), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(initialize), MRB_MT_FUNC|MRB_MT_PRIVATE),
|
||||
MRB_MT_KEY(MRB_SYM(initialize_copy), MRB_MT_FUNC|MRB_MT_PRIVATE),
|
||||
MRB_MT_KEY(MRB_SYM_Q(key), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(keys), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(length), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM_Q(member), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(replace), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(shift), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(size), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(store), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM_Q(value), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(values), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(to_s), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(inspect), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(rehash), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(to_hash), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(assoc), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(rassoc), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(__merge), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(__compact), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(__pat_values), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(__except), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
}
|
||||
};
|
||||
static mrb_mt_tbl hash_rom_mt = {
|
||||
HASH_ROM_MT_SIZE, HASH_ROM_MT_SIZE,
|
||||
(union mrb_mt_ptr*)&hash_rom_data, NULL
|
||||
static mrb_mt_entry hash_rom_entries[] = {
|
||||
MRB_MT_ENTRY(mrb_hash_equal, MRB_OPSYM(eq), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_hash_aget, MRB_OPSYM(aref), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_hash_aset, MRB_OPSYM(aset), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_hash_clear, MRB_SYM(clear), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(mrb_hash_default, MRB_SYM(default), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_hash_set_default, MRB_SYM_E(default), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_hash_default_proc, MRB_SYM(default_proc), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(mrb_hash_set_default_proc, MRB_SYM_E(default_proc), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_hash_delete, MRB_SYM(__delete), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_hash_eql, MRB_SYM_Q(eql), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_hash_empty_m, MRB_SYM_Q(empty), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(mrb_hash_has_key, MRB_SYM_Q(has_key), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_hash_has_value, MRB_SYM_Q(has_value), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_hash_has_key, MRB_SYM_Q(include), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_hash_init, MRB_SYM(initialize), MRB_MT_FUNC|MRB_MT_PRIVATE),
|
||||
MRB_MT_ENTRY(mrb_hash_init_copy, MRB_SYM(initialize_copy), MRB_MT_FUNC|MRB_MT_PRIVATE),
|
||||
MRB_MT_ENTRY(mrb_hash_has_key, MRB_SYM_Q(key), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_hash_keys, MRB_SYM(keys), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(mrb_hash_size_m, MRB_SYM(length), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(mrb_hash_has_key, MRB_SYM_Q(member), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_hash_init_copy, MRB_SYM(replace), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_hash_shift, MRB_SYM(shift), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(mrb_hash_size_m, MRB_SYM(size), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(mrb_hash_aset, MRB_SYM(store), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_hash_has_value, MRB_SYM_Q(value), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_hash_values, MRB_SYM(values), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(mrb_hash_to_s, MRB_SYM(to_s), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(mrb_hash_to_s, MRB_SYM(inspect), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(mrb_hash_rehash, MRB_SYM(rehash), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(mrb_hash_to_hash, MRB_SYM(to_hash), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(mrb_hash_assoc, MRB_SYM(assoc), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_hash_rassoc, MRB_SYM(rassoc), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_hash_merge_m, MRB_SYM(__merge), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_hash_compact, MRB_SYM(__compact), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(mrb_hash_pat_values, MRB_SYM(__pat_values), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_hash_except_keys, MRB_SYM(__except), MRB_MT_FUNC),
|
||||
};
|
||||
static mrb_mt_tbl hash_rom_mt = MRB_MT_ROM_TAB(hash_rom_entries);
|
||||
|
||||
void
|
||||
mrb_init_hash(mrb_state *mrb)
|
||||
|
||||
+29
-67
@@ -666,74 +666,36 @@ mrb_p_m(mrb_state *mrb, mrb_value self)
|
||||
#endif
|
||||
|
||||
/* ---------------------------*/
|
||||
#define KERNEL_ROM_MT_SIZE 27
|
||||
static struct {
|
||||
union mrb_mt_ptr vals[KERNEL_ROM_MT_SIZE];
|
||||
mrb_sym keys[KERNEL_ROM_MT_SIZE];
|
||||
} kernel_rom_data = {
|
||||
.vals = {
|
||||
{ .func = mrb_eqq_m },
|
||||
{ .func = mrb_cmp_m },
|
||||
{ .func = mrb_f_block_given_p_m },
|
||||
{ .func = mrb_obj_class_m },
|
||||
{ .func = mrb_obj_clone },
|
||||
{ .func = mrb_obj_dup },
|
||||
{ .func = mrb_obj_equal_m },
|
||||
{ .func = mrb_obj_freeze },
|
||||
{ .func = mrb_obj_frozen },
|
||||
{ .func = mrb_obj_extend },
|
||||
{ .func = mrb_obj_hash },
|
||||
{ .func = mrb_obj_init_copy },
|
||||
{ .func = mrb_obj_inspect },
|
||||
{ .func = obj_is_instance_of },
|
||||
{ .func = mrb_obj_is_kind_of_m },
|
||||
{ .func = mrb_f_block_given_p_m },
|
||||
{ .func = mrb_obj_is_kind_of_m },
|
||||
{ .func = mrb_false },
|
||||
{ .func = mrb_obj_id_m },
|
||||
{ .func = mrb_f_raise },
|
||||
{ .func = mrb_obj_remove_instance_variable },
|
||||
{ .func = obj_respond_to },
|
||||
{ .func = mrb_any_to_s },
|
||||
{ .func = mrb_obj_ceqq },
|
||||
{ .func = mrb_ensure_int_type },
|
||||
{ .func = mrb_false },
|
||||
{ .func = mrb_obj_method_recursive_p },
|
||||
},
|
||||
.keys = {
|
||||
MRB_MT_KEY(MRB_OPSYM(eqq), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_OPSYM(cmp), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM_Q(block_given), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PRIVATE),
|
||||
MRB_MT_KEY(MRB_SYM(class), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(clone), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(dup), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM_Q(eql), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(freeze), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM_Q(frozen), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(extend), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(hash), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(initialize_copy), MRB_MT_FUNC|MRB_MT_PRIVATE),
|
||||
MRB_MT_KEY(MRB_SYM(inspect), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM_Q(instance_of), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM_Q(is_a), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM_Q(iterator), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PRIVATE),
|
||||
MRB_MT_KEY(MRB_SYM_Q(kind_of), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM_Q(nil), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(object_id), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(raise), MRB_MT_FUNC|MRB_MT_PRIVATE),
|
||||
MRB_MT_KEY(MRB_SYM(remove_instance_variable), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM_Q(respond_to), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(to_s), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(__case_eqq), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(__to_int), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM_Q(respond_to_missing), MRB_MT_FUNC|MRB_MT_PRIVATE),
|
||||
MRB_MT_KEY(MRB_SYM_Q(__method_recursive), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
}
|
||||
};
|
||||
static mrb_mt_tbl kernel_rom_mt = {
|
||||
KERNEL_ROM_MT_SIZE, KERNEL_ROM_MT_SIZE,
|
||||
(union mrb_mt_ptr*)&kernel_rom_data, NULL
|
||||
static mrb_mt_entry kernel_rom_entries[] = {
|
||||
MRB_MT_ENTRY(mrb_eqq_m, MRB_OPSYM(eqq), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_cmp_m, MRB_OPSYM(cmp), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_f_block_given_p_m, MRB_SYM_Q(block_given), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PRIVATE),
|
||||
MRB_MT_ENTRY(mrb_obj_class_m, MRB_SYM(class), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(mrb_obj_clone, MRB_SYM(clone), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(mrb_obj_dup, MRB_SYM(dup), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(mrb_obj_equal_m, MRB_SYM_Q(eql), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_obj_freeze, MRB_SYM(freeze), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(mrb_obj_frozen, MRB_SYM_Q(frozen), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(mrb_obj_extend, MRB_SYM(extend), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_obj_hash, MRB_SYM(hash), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(mrb_obj_init_copy, MRB_SYM(initialize_copy), MRB_MT_FUNC|MRB_MT_PRIVATE),
|
||||
MRB_MT_ENTRY(mrb_obj_inspect, MRB_SYM(inspect), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(obj_is_instance_of, MRB_SYM_Q(instance_of), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_obj_is_kind_of_m, MRB_SYM_Q(is_a), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_f_block_given_p_m, MRB_SYM_Q(iterator), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PRIVATE),
|
||||
MRB_MT_ENTRY(mrb_obj_is_kind_of_m, MRB_SYM_Q(kind_of), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_false, MRB_SYM_Q(nil), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(mrb_obj_id_m, MRB_SYM(object_id), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(mrb_f_raise, MRB_SYM(raise), MRB_MT_FUNC|MRB_MT_PRIVATE),
|
||||
MRB_MT_ENTRY(mrb_obj_remove_instance_variable, MRB_SYM(remove_instance_variable), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(obj_respond_to, MRB_SYM_Q(respond_to), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_any_to_s, MRB_SYM(to_s), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(mrb_obj_ceqq, MRB_SYM(__case_eqq), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_ensure_int_type, MRB_SYM(__to_int), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(mrb_false, MRB_SYM_Q(respond_to_missing), MRB_MT_FUNC|MRB_MT_PRIVATE),
|
||||
MRB_MT_ENTRY(mrb_obj_method_recursive_p, MRB_SYM_Q(__method_recursive), MRB_MT_FUNC),
|
||||
};
|
||||
static mrb_mt_tbl kernel_rom_mt = MRB_MT_ROM_TAB(kernel_rom_entries);
|
||||
|
||||
void
|
||||
mrb_init_kernel(mrb_state *mrb)
|
||||
|
||||
+69
-165
@@ -2299,177 +2299,81 @@ flo_hash(mrb_state *mrb, mrb_value flo)
|
||||
#endif
|
||||
|
||||
/* ------------------------------------------------------------------------*/
|
||||
#define NUMERIC_ROM_MT_SIZE 3
|
||||
static struct {
|
||||
union mrb_mt_ptr vals[NUMERIC_ROM_MT_SIZE];
|
||||
mrb_sym keys[NUMERIC_ROM_MT_SIZE];
|
||||
} numeric_rom_data = {
|
||||
.vals = {
|
||||
{ .func = num_finite_p },
|
||||
{ .func = num_infinite_p },
|
||||
{ .func = num_eql },
|
||||
},
|
||||
.keys = {
|
||||
MRB_MT_KEY(MRB_SYM_Q(finite), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM_Q(infinite), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM_Q(eql), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
}
|
||||
};
|
||||
static mrb_mt_tbl numeric_rom_mt = {
|
||||
NUMERIC_ROM_MT_SIZE, NUMERIC_ROM_MT_SIZE,
|
||||
(union mrb_mt_ptr*)&numeric_rom_data, NULL
|
||||
static mrb_mt_entry numeric_rom_entries[] = {
|
||||
MRB_MT_ENTRY(num_finite_p, MRB_SYM_Q(finite), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(num_infinite_p, MRB_SYM_Q(infinite), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(num_eql, MRB_SYM_Q(eql), MRB_MT_FUNC),
|
||||
};
|
||||
static mrb_mt_tbl numeric_rom_mt = MRB_MT_ROM_TAB(numeric_rom_entries);
|
||||
|
||||
#define INTEGER_ROM_MT_SIZE 31
|
||||
static struct {
|
||||
union mrb_mt_ptr vals[INTEGER_ROM_MT_SIZE];
|
||||
mrb_sym keys[INTEGER_ROM_MT_SIZE];
|
||||
} integer_rom_data = {
|
||||
.vals = {
|
||||
{ .func = int_pow },
|
||||
{ .func = num_cmp },
|
||||
{ .func = num_lt },
|
||||
{ .func = num_le },
|
||||
{ .func = num_gt },
|
||||
{ .func = num_ge },
|
||||
{ .func = mrb_obj_itself },
|
||||
{ .func = mrb_obj_itself },
|
||||
{ .func = int_add },
|
||||
{ .func = int_sub },
|
||||
{ .func = int_mul },
|
||||
{ .func = int_mod },
|
||||
{ .func = int_div },
|
||||
{ .func = int_quo },
|
||||
{ .func = int_idiv },
|
||||
{ .func = int_equal },
|
||||
{ .func = int_rev },
|
||||
{ .func = int_and },
|
||||
{ .func = int_or },
|
||||
{ .func = int_xor },
|
||||
{ .func = int_lshift },
|
||||
{ .func = int_rshift },
|
||||
{ .func = int_ceil },
|
||||
{ .func = int_floor },
|
||||
{ .func = int_round },
|
||||
{ .func = int_truncate },
|
||||
{ .func = int_hash },
|
||||
{ .func = int_to_s },
|
||||
{ .func = int_to_s },
|
||||
{ .func = int_divmod },
|
||||
{ .func = coerce_step_counter },
|
||||
},
|
||||
.keys = {
|
||||
MRB_MT_KEY(MRB_OPSYM(pow), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_OPSYM(cmp), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_OPSYM(lt), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_OPSYM(le), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_OPSYM(gt), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_OPSYM(ge), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(to_i), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(to_int), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_OPSYM(add), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_OPSYM(sub), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_OPSYM(mul), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_OPSYM(mod), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_OPSYM(div), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(quo), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(div), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_OPSYM(eq), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_OPSYM(neg), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_OPSYM(and), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_OPSYM(or), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_OPSYM(xor), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_OPSYM(lshift), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_OPSYM(rshift), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(ceil), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(floor), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(round), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(truncate), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(hash), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(to_s), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(inspect), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(divmod), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(__coerce_step_counter), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
}
|
||||
};
|
||||
static mrb_mt_tbl integer_rom_mt = {
|
||||
INTEGER_ROM_MT_SIZE, INTEGER_ROM_MT_SIZE,
|
||||
(union mrb_mt_ptr*)&integer_rom_data, NULL
|
||||
static mrb_mt_entry integer_rom_entries[] = {
|
||||
MRB_MT_ENTRY(int_pow, MRB_OPSYM(pow), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(num_cmp, MRB_OPSYM(cmp), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(num_lt, MRB_OPSYM(lt), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(num_le, MRB_OPSYM(le), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(num_gt, MRB_OPSYM(gt), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(num_ge, MRB_OPSYM(ge), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_obj_itself, MRB_SYM(to_i), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(mrb_obj_itself, MRB_SYM(to_int), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(int_add, MRB_OPSYM(add), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(int_sub, MRB_OPSYM(sub), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(int_mul, MRB_OPSYM(mul), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(int_mod, MRB_OPSYM(mod), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(int_div, MRB_OPSYM(div), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(int_quo, MRB_SYM(quo), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(int_idiv, MRB_SYM(div), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(int_equal, MRB_OPSYM(eq), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(int_rev, MRB_OPSYM(neg), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(int_and, MRB_OPSYM(and), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(int_or, MRB_OPSYM(or), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(int_xor, MRB_OPSYM(xor), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(int_lshift, MRB_OPSYM(lshift), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(int_rshift, MRB_OPSYM(rshift), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(int_ceil, MRB_SYM(ceil), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(int_floor, MRB_SYM(floor), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(int_round, MRB_SYM(round), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(int_truncate, MRB_SYM(truncate), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(int_hash, MRB_SYM(hash), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(int_to_s, MRB_SYM(to_s), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(int_to_s, MRB_SYM(inspect), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(int_divmod, MRB_SYM(divmod), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(coerce_step_counter, MRB_SYM(__coerce_step_counter), MRB_MT_FUNC),
|
||||
};
|
||||
static mrb_mt_tbl integer_rom_mt = MRB_MT_ROM_TAB(integer_rom_entries);
|
||||
|
||||
#ifndef MRB_NO_FLOAT
|
||||
#define FLOAT_ROM_MT_SIZE 29
|
||||
static struct {
|
||||
union mrb_mt_ptr vals[FLOAT_ROM_MT_SIZE];
|
||||
mrb_sym keys[FLOAT_ROM_MT_SIZE];
|
||||
} float_rom_data = {
|
||||
.vals = {
|
||||
{ .func = flo_pow },
|
||||
{ .func = flo_div },
|
||||
{ .func = flo_div },
|
||||
{ .func = flo_div },
|
||||
{ .func = flo_idiv },
|
||||
{ .func = flo_add },
|
||||
{ .func = flo_sub },
|
||||
{ .func = flo_mul },
|
||||
{ .func = flo_mod },
|
||||
{ .func = num_cmp },
|
||||
{ .func = num_lt },
|
||||
{ .func = num_le },
|
||||
{ .func = num_gt },
|
||||
{ .func = num_ge },
|
||||
{ .func = flo_eq },
|
||||
{ .func = flo_ceil },
|
||||
{ .func = flo_finite_p },
|
||||
{ .func = flo_floor },
|
||||
{ .func = flo_infinite_p },
|
||||
{ .func = flo_round },
|
||||
{ .func = mrb_obj_itself },
|
||||
{ .func = flo_to_i },
|
||||
{ .func = flo_truncate },
|
||||
{ .func = flo_divmod },
|
||||
{ .func = flo_to_s },
|
||||
{ .func = flo_to_s },
|
||||
{ .func = flo_nan_p },
|
||||
{ .func = flo_abs },
|
||||
{ .func = flo_hash },
|
||||
},
|
||||
.keys = {
|
||||
MRB_MT_KEY(MRB_OPSYM(pow), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_OPSYM(div), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(quo), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(fdiv), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(div), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_OPSYM(add), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_OPSYM(sub), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_OPSYM(mul), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_OPSYM(mod), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_OPSYM(cmp), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_OPSYM(lt), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_OPSYM(le), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_OPSYM(gt), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_OPSYM(ge), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_OPSYM(eq), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(ceil), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM_Q(finite), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(floor), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM_Q(infinite), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(round), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(to_f), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(to_i), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(truncate), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(divmod), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(to_s), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(inspect), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM_Q(nan), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(abs), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(hash), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
}
|
||||
};
|
||||
static mrb_mt_tbl float_rom_mt = {
|
||||
FLOAT_ROM_MT_SIZE, FLOAT_ROM_MT_SIZE,
|
||||
(union mrb_mt_ptr*)&float_rom_data, NULL
|
||||
static mrb_mt_entry float_rom_entries[] = {
|
||||
MRB_MT_ENTRY(flo_pow, MRB_OPSYM(pow), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(flo_div, MRB_OPSYM(div), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(flo_div, MRB_SYM(quo), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(flo_div, MRB_SYM(fdiv), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(flo_idiv, MRB_SYM(div), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(flo_add, MRB_OPSYM(add), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(flo_sub, MRB_OPSYM(sub), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(flo_mul, MRB_OPSYM(mul), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(flo_mod, MRB_OPSYM(mod), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(num_cmp, MRB_OPSYM(cmp), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(num_lt, MRB_OPSYM(lt), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(num_le, MRB_OPSYM(le), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(num_gt, MRB_OPSYM(gt), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(num_ge, MRB_OPSYM(ge), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(flo_eq, MRB_OPSYM(eq), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(flo_ceil, MRB_SYM(ceil), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(flo_finite_p, MRB_SYM_Q(finite), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(flo_floor, MRB_SYM(floor), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(flo_infinite_p, MRB_SYM_Q(infinite), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(flo_round, MRB_SYM(round), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_obj_itself, MRB_SYM(to_f), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(flo_to_i, MRB_SYM(to_i), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(flo_truncate, MRB_SYM(truncate), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(flo_divmod, MRB_SYM(divmod), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(flo_to_s, MRB_SYM(to_s), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(flo_to_s, MRB_SYM(inspect), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(flo_nan_p, MRB_SYM_Q(nan), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(flo_abs, MRB_SYM(abs), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(flo_hash, MRB_SYM(hash), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
};
|
||||
static mrb_mt_tbl float_rom_mt = MRB_MT_ROM_TAB(float_rom_entries);
|
||||
#endif /* !MRB_NO_FLOAT */
|
||||
|
||||
void
|
||||
|
||||
+22
-71
@@ -322,82 +322,33 @@ false_to_s(mrb_state *mrb, mrb_value obj)
|
||||
}
|
||||
|
||||
/* ---------------------------*/
|
||||
#define NIL_ROM_MT_SIZE 6
|
||||
static struct {
|
||||
union mrb_mt_ptr vals[NIL_ROM_MT_SIZE];
|
||||
mrb_sym keys[NIL_ROM_MT_SIZE];
|
||||
} nil_rom_data = {
|
||||
.vals = {
|
||||
{ .func = false_and },
|
||||
{ .func = false_or },
|
||||
{ .func = false_xor },
|
||||
{ .func = mrb_true },
|
||||
{ .func = nil_to_s },
|
||||
{ .func = nil_inspect },
|
||||
},
|
||||
.keys = {
|
||||
MRB_MT_KEY(MRB_OPSYM(and), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_OPSYM(or), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_OPSYM(xor), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM_Q(nil), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(to_s), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(inspect), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
}
|
||||
};
|
||||
static mrb_mt_tbl nil_rom_mt = {
|
||||
NIL_ROM_MT_SIZE, NIL_ROM_MT_SIZE,
|
||||
(union mrb_mt_ptr*)&nil_rom_data, NULL
|
||||
static mrb_mt_entry nil_rom_entries[] = {
|
||||
MRB_MT_ENTRY(false_and, MRB_OPSYM(and), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(false_or, MRB_OPSYM(or), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(false_xor, MRB_OPSYM(xor), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_true, MRB_SYM_Q(nil), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(nil_to_s, MRB_SYM(to_s), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(nil_inspect, MRB_SYM(inspect), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
};
|
||||
static mrb_mt_tbl nil_rom_mt = MRB_MT_ROM_TAB(nil_rom_entries);
|
||||
|
||||
#define TRUE_ROM_MT_SIZE 5
|
||||
static struct {
|
||||
union mrb_mt_ptr vals[TRUE_ROM_MT_SIZE];
|
||||
mrb_sym keys[TRUE_ROM_MT_SIZE];
|
||||
} true_rom_data = {
|
||||
.vals = {
|
||||
{ .func = true_and },
|
||||
{ .func = true_or },
|
||||
{ .func = true_xor },
|
||||
{ .func = true_to_s },
|
||||
{ .func = true_to_s },
|
||||
},
|
||||
.keys = {
|
||||
MRB_MT_KEY(MRB_OPSYM(and), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_OPSYM(or), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_OPSYM(xor), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(to_s), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(inspect), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
}
|
||||
};
|
||||
static mrb_mt_tbl true_rom_mt = {
|
||||
TRUE_ROM_MT_SIZE, TRUE_ROM_MT_SIZE,
|
||||
(union mrb_mt_ptr*)&true_rom_data, NULL
|
||||
static mrb_mt_entry true_rom_entries[] = {
|
||||
MRB_MT_ENTRY(true_and, MRB_OPSYM(and), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(true_or, MRB_OPSYM(or), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(true_xor, MRB_OPSYM(xor), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(true_to_s, MRB_SYM(to_s), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(true_to_s, MRB_SYM(inspect), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
};
|
||||
static mrb_mt_tbl true_rom_mt = MRB_MT_ROM_TAB(true_rom_entries);
|
||||
|
||||
#define FALSE_ROM_MT_SIZE 5
|
||||
static struct {
|
||||
union mrb_mt_ptr vals[FALSE_ROM_MT_SIZE];
|
||||
mrb_sym keys[FALSE_ROM_MT_SIZE];
|
||||
} false_rom_data = {
|
||||
.vals = {
|
||||
{ .func = false_and },
|
||||
{ .func = false_or },
|
||||
{ .func = false_xor },
|
||||
{ .func = false_to_s },
|
||||
{ .func = false_to_s },
|
||||
},
|
||||
.keys = {
|
||||
MRB_MT_KEY(MRB_OPSYM(and), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_OPSYM(or), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_OPSYM(xor), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(to_s), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(inspect), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
}
|
||||
};
|
||||
static mrb_mt_tbl false_rom_mt = {
|
||||
FALSE_ROM_MT_SIZE, FALSE_ROM_MT_SIZE,
|
||||
(union mrb_mt_ptr*)&false_rom_data, NULL
|
||||
static mrb_mt_entry false_rom_entries[] = {
|
||||
MRB_MT_ENTRY(false_and, MRB_OPSYM(and), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(false_or, MRB_OPSYM(or), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(false_xor, MRB_OPSYM(xor), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(false_to_s, MRB_SYM(to_s), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(false_to_s, MRB_SYM(inspect), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
};
|
||||
static mrb_mt_tbl false_rom_mt = MRB_MT_ROM_TAB(false_rom_entries);
|
||||
|
||||
void
|
||||
mrb_init_object(mrb_state *mrb)
|
||||
|
||||
+7
-23
@@ -545,30 +545,14 @@ mrb_proc_merge_lvar(mrb_state *mrb, mrb_irep *irep, struct REnv *env, int num, c
|
||||
}
|
||||
|
||||
/* ---------------------------*/
|
||||
#define PROC_ROM_MT_SIZE 5
|
||||
static struct {
|
||||
union mrb_mt_ptr vals[PROC_ROM_MT_SIZE];
|
||||
mrb_sym keys[PROC_ROM_MT_SIZE];
|
||||
} proc_rom_data = {
|
||||
.vals = {
|
||||
{ .func = mrb_proc_init_copy },
|
||||
{ .func = proc_arity },
|
||||
{ .func = proc_eql },
|
||||
{ .func = proc_eql },
|
||||
{ .func = proc_hash },
|
||||
},
|
||||
.keys = {
|
||||
MRB_MT_KEY(MRB_SYM(initialize_copy), MRB_MT_FUNC|MRB_MT_PRIVATE),
|
||||
MRB_MT_KEY(MRB_SYM(arity), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_OPSYM(eq), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM_Q(eql), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(hash), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
}
|
||||
};
|
||||
static mrb_mt_tbl proc_rom_mt = {
|
||||
PROC_ROM_MT_SIZE, PROC_ROM_MT_SIZE,
|
||||
(union mrb_mt_ptr*)&proc_rom_data, NULL
|
||||
static mrb_mt_entry proc_rom_entries[] = {
|
||||
MRB_MT_ENTRY(mrb_proc_init_copy, MRB_SYM(initialize_copy), MRB_MT_FUNC|MRB_MT_PRIVATE),
|
||||
MRB_MT_ENTRY(proc_arity, MRB_SYM(arity), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(proc_eql, MRB_OPSYM(eq), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(proc_eql, MRB_SYM_Q(eql), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(proc_hash, MRB_SYM(hash), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
};
|
||||
static mrb_mt_tbl proc_rom_mt = MRB_MT_ROM_TAB(proc_rom_entries);
|
||||
|
||||
void
|
||||
mrb_init_proc(mrb_state *mrb)
|
||||
|
||||
+17
-43
@@ -566,50 +566,24 @@ mrb_range_beg_len(mrb_state *mrb, mrb_value range, mrb_int *begp, mrb_int *lenp,
|
||||
}
|
||||
|
||||
/* ---------------------------*/
|
||||
#define RANGE_ROM_MT_SIZE 15
|
||||
static struct {
|
||||
union mrb_mt_ptr vals[RANGE_ROM_MT_SIZE];
|
||||
mrb_sym keys[RANGE_ROM_MT_SIZE];
|
||||
} range_rom_data = {
|
||||
.vals = {
|
||||
{ .func = range_beg },
|
||||
{ .func = range_end },
|
||||
{ .func = range_eq },
|
||||
{ .func = range_include },
|
||||
{ .func = range_excl },
|
||||
{ .func = range_beg },
|
||||
{ .func = range_include },
|
||||
{ .func = range_initialize },
|
||||
{ .func = range_end },
|
||||
{ .func = range_include },
|
||||
{ .func = range_to_s },
|
||||
{ .func = range_inspect },
|
||||
{ .func = range_eql },
|
||||
{ .func = range_initialize_copy },
|
||||
{ .func = range_num_to_a },
|
||||
},
|
||||
.keys = {
|
||||
MRB_MT_KEY(MRB_SYM(begin), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(end), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_OPSYM(eq), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_OPSYM(eqq), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM_Q(exclude_end), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(first), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM_Q(include), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(initialize), MRB_MT_FUNC|MRB_MT_PRIVATE),
|
||||
MRB_MT_KEY(MRB_SYM(last), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM_Q(member), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(to_s), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(inspect), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM_Q(eql), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(initialize_copy), MRB_MT_FUNC|MRB_MT_PRIVATE),
|
||||
MRB_MT_KEY(MRB_SYM(__num_to_a), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
}
|
||||
};
|
||||
static mrb_mt_tbl range_rom_mt = {
|
||||
RANGE_ROM_MT_SIZE, RANGE_ROM_MT_SIZE,
|
||||
(union mrb_mt_ptr*)&range_rom_data, NULL
|
||||
static mrb_mt_entry range_rom_entries[] = {
|
||||
MRB_MT_ENTRY(range_beg, MRB_SYM(begin), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(range_end, MRB_SYM(end), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(range_eq, MRB_OPSYM(eq), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(range_include, MRB_OPSYM(eqq), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(range_excl, MRB_SYM_Q(exclude_end), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(range_beg, MRB_SYM(first), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(range_include, MRB_SYM_Q(include), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(range_initialize, MRB_SYM(initialize), MRB_MT_FUNC|MRB_MT_PRIVATE),
|
||||
MRB_MT_ENTRY(range_end, MRB_SYM(last), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(range_include, MRB_SYM_Q(member), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(range_to_s, MRB_SYM(to_s), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(range_inspect, MRB_SYM(inspect), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(range_eql, MRB_SYM_Q(eql), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(range_initialize_copy, MRB_SYM(initialize_copy), MRB_MT_FUNC|MRB_MT_PRIVATE),
|
||||
MRB_MT_ENTRY(range_num_to_a, MRB_SYM(__num_to_a), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
};
|
||||
static mrb_mt_tbl range_rom_mt = MRB_MT_ROM_TAB(range_rom_entries);
|
||||
|
||||
void
|
||||
mrb_init_range(mrb_state *mrb)
|
||||
|
||||
+48
-105
@@ -3508,112 +3508,55 @@ mrb_encoding(mrb_state *mrb, mrb_value self)
|
||||
}
|
||||
|
||||
/* ---------------------------*/
|
||||
#define STRING_ROM_MT_SIZE 46
|
||||
static struct {
|
||||
union mrb_mt_ptr vals[STRING_ROM_MT_SIZE];
|
||||
mrb_sym keys[STRING_ROM_MT_SIZE];
|
||||
} string_rom_data = {
|
||||
.vals = {
|
||||
{ .func = mrb_str_bytesize },
|
||||
{ .func = mrb_str_cmp_m },
|
||||
{ .func = mrb_str_equal_m },
|
||||
{ .func = mrb_str_plus_m },
|
||||
{ .func = mrb_str_times },
|
||||
{ .func = mrb_str_aref_m },
|
||||
{ .func = mrb_str_aset_m },
|
||||
{ .func = mrb_str_capitalize },
|
||||
{ .func = mrb_str_capitalize_bang },
|
||||
{ .func = mrb_str_chomp },
|
||||
{ .func = mrb_str_chomp_bang },
|
||||
{ .func = mrb_str_chop },
|
||||
{ .func = mrb_str_chop_bang },
|
||||
{ .func = mrb_str_downcase },
|
||||
{ .func = mrb_str_downcase_bang },
|
||||
{ .func = mrb_str_empty_p },
|
||||
{ .func = mrb_str_eql },
|
||||
{ .func = mrb_str_hash_m },
|
||||
{ .func = mrb_str_include },
|
||||
{ .func = mrb_str_index_m },
|
||||
{ .func = mrb_str_init },
|
||||
{ .func = mrb_str_replace },
|
||||
{ .func = mrb_str_intern },
|
||||
{ .func = mrb_str_size },
|
||||
{ .func = mrb_str_replace },
|
||||
{ .func = mrb_str_reverse },
|
||||
{ .func = mrb_str_reverse_bang },
|
||||
{ .func = mrb_str_rindex_m },
|
||||
{ .func = mrb_str_size },
|
||||
{ .func = mrb_str_aref_m },
|
||||
{ .func = mrb_str_split_m },
|
||||
{ .func = mrb_str_to_i },
|
||||
{ .func = mrb_str_to_s },
|
||||
{ .func = mrb_str_to_s },
|
||||
{ .func = mrb_str_intern },
|
||||
{ .func = mrb_str_upcase },
|
||||
{ .func = mrb_str_upcase_bang },
|
||||
{ .func = mrb_str_inspect },
|
||||
{ .func = mrb_str_bytes },
|
||||
{ .func = mrb_str_getbyte },
|
||||
{ .func = mrb_str_setbyte },
|
||||
{ .func = mrb_str_byteindex_m },
|
||||
{ .func = mrb_str_byterindex_m },
|
||||
{ .func = mrb_str_byteslice },
|
||||
{ .func = mrb_str_bytesplice },
|
||||
{ .func = sub_replace },
|
||||
},
|
||||
.keys = {
|
||||
MRB_MT_KEY(MRB_SYM(bytesize), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_OPSYM(cmp), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_OPSYM(eq), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_OPSYM(add), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_OPSYM(mul), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_OPSYM(aref), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_OPSYM(aset), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(capitalize), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM_B(capitalize), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(chomp), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM_B(chomp), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(chop), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM_B(chop), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(downcase), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM_B(downcase), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM_Q(empty), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM_Q(eql), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(hash), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM_Q(include), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(index), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(initialize), MRB_MT_FUNC|MRB_MT_PRIVATE),
|
||||
MRB_MT_KEY(MRB_SYM(initialize_copy), MRB_MT_FUNC|MRB_MT_PRIVATE),
|
||||
MRB_MT_KEY(MRB_SYM(intern), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(length), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(replace), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(reverse), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM_B(reverse), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(rindex), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(size), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(slice), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(split), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(to_i), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(to_s), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(to_str), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(to_sym), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(upcase), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM_B(upcase), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(inspect), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(bytes), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(getbyte), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(setbyte), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(byteindex), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(byterindex), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(byteslice), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(bytesplice), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(__sub_replace), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
}
|
||||
};
|
||||
static mrb_mt_tbl string_rom_mt = {
|
||||
STRING_ROM_MT_SIZE, STRING_ROM_MT_SIZE,
|
||||
(union mrb_mt_ptr*)&string_rom_data, NULL
|
||||
static mrb_mt_entry string_rom_entries[] = {
|
||||
MRB_MT_ENTRY(mrb_str_bytesize, MRB_SYM(bytesize), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(mrb_str_cmp_m, MRB_OPSYM(cmp), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_str_equal_m, MRB_OPSYM(eq), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_str_plus_m, MRB_OPSYM(add), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_str_times, MRB_OPSYM(mul), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_str_aref_m, MRB_OPSYM(aref), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_str_aset_m, MRB_OPSYM(aset), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_str_capitalize, MRB_SYM(capitalize), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(mrb_str_capitalize_bang, MRB_SYM_B(capitalize), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(mrb_str_chomp, MRB_SYM(chomp), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_str_chomp_bang, MRB_SYM_B(chomp), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_str_chop, MRB_SYM(chop), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(mrb_str_chop_bang, MRB_SYM_B(chop), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(mrb_str_downcase, MRB_SYM(downcase), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(mrb_str_downcase_bang, MRB_SYM_B(downcase), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(mrb_str_empty_p, MRB_SYM_Q(empty), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(mrb_str_eql, MRB_SYM_Q(eql), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_str_hash_m, MRB_SYM(hash), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(mrb_str_include, MRB_SYM_Q(include), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_str_index_m, MRB_SYM(index), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_str_init, MRB_SYM(initialize), MRB_MT_FUNC|MRB_MT_PRIVATE),
|
||||
MRB_MT_ENTRY(mrb_str_replace, MRB_SYM(initialize_copy), MRB_MT_FUNC|MRB_MT_PRIVATE),
|
||||
MRB_MT_ENTRY(mrb_str_intern, MRB_SYM(intern), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(mrb_str_size, MRB_SYM(length), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(mrb_str_replace, MRB_SYM(replace), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_str_reverse, MRB_SYM(reverse), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(mrb_str_reverse_bang, MRB_SYM_B(reverse), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(mrb_str_rindex_m, MRB_SYM(rindex), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_str_size, MRB_SYM(size), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(mrb_str_aref_m, MRB_SYM(slice), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_str_split_m, MRB_SYM(split), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_str_to_i, MRB_SYM(to_i), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_str_to_s, MRB_SYM(to_s), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(mrb_str_to_s, MRB_SYM(to_str), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(mrb_str_intern, MRB_SYM(to_sym), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(mrb_str_upcase, MRB_SYM(upcase), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(mrb_str_upcase_bang, MRB_SYM_B(upcase), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(mrb_str_inspect, MRB_SYM(inspect), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(mrb_str_bytes, MRB_SYM(bytes), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(mrb_str_getbyte, MRB_SYM(getbyte), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_str_setbyte, MRB_SYM(setbyte), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_str_byteindex_m, MRB_SYM(byteindex), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_str_byterindex_m, MRB_SYM(byterindex), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_str_byteslice, MRB_SYM(byteslice), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_str_bytesplice, MRB_SYM(bytesplice), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(sub_replace, MRB_SYM(__sub_replace), MRB_MT_FUNC),
|
||||
};
|
||||
static mrb_mt_tbl string_rom_mt = MRB_MT_ROM_TAB(string_rom_entries);
|
||||
|
||||
void
|
||||
mrb_init_string(mrb_state *mrb)
|
||||
|
||||
+8
-25
@@ -1001,32 +1001,15 @@ sym_cmp(mrb_state *mrb, mrb_value s1)
|
||||
#undef lesser
|
||||
|
||||
/* ---------------------------*/
|
||||
#define SYMBOL_ROM_MT_SIZE 6
|
||||
static struct {
|
||||
union mrb_mt_ptr vals[SYMBOL_ROM_MT_SIZE];
|
||||
mrb_sym keys[SYMBOL_ROM_MT_SIZE];
|
||||
} symbol_rom_data = {
|
||||
.vals = {
|
||||
{ .func = sym_to_s },
|
||||
{ .func = sym_name },
|
||||
{ .func = mrb_obj_itself },
|
||||
{ .func = sym_inspect },
|
||||
{ .func = sym_cmp },
|
||||
{ .func = mrb_obj_equal_m },
|
||||
},
|
||||
.keys = {
|
||||
MRB_MT_KEY(MRB_SYM(to_s), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(name), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(to_sym), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_SYM(inspect), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_OPSYM(cmp), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
MRB_MT_KEY(MRB_OPSYM(eq), MRB_MT_FUNC|MRB_MT_PUBLIC),
|
||||
}
|
||||
};
|
||||
static mrb_mt_tbl symbol_rom_mt = {
|
||||
SYMBOL_ROM_MT_SIZE, SYMBOL_ROM_MT_SIZE,
|
||||
(union mrb_mt_ptr*)&symbol_rom_data, NULL
|
||||
static mrb_mt_entry symbol_rom_entries[] = {
|
||||
MRB_MT_ENTRY(sym_to_s, MRB_SYM(to_s), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(sym_name, MRB_SYM(name), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(mrb_obj_itself, MRB_SYM(to_sym), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(sym_inspect, MRB_SYM(inspect), MRB_MT_FUNC|MRB_MT_NOARG),
|
||||
MRB_MT_ENTRY(sym_cmp, MRB_OPSYM(cmp), MRB_MT_FUNC),
|
||||
MRB_MT_ENTRY(mrb_obj_equal_m, MRB_OPSYM(eq), MRB_MT_FUNC),
|
||||
};
|
||||
static mrb_mt_tbl symbol_rom_mt = MRB_MT_ROM_TAB(symbol_rom_entries);
|
||||
|
||||
void
|
||||
mrb_init_symbol(mrb_state *mrb)
|
||||
|
||||
Reference in New Issue
Block a user