admin/mruby-mruby
1
0
Fork 0
mirror of https://github.com/mruby/mruby synced 2026-06-08 16:11:16 +00:00
Code Issues Packages Projects Releases Wiki Activity

class.c: rename mt_/MT_ to mrb_mt_/MRB_MT_ for non-static identifiers

Browse Source 
Follow mruby's naming convention: non-static types, macros, and
functions use the mrb_/MRB_ prefix. Renamed:
- union mt_ptr -> union mrb_mt_ptr
- mt_tbl -> mrb_mt_tbl
- MT_KEY(), MT_FUNC, MT_NOARG, MT_PUBLIC, MT_PRIVATE -> MRB_MT_*
- MT_KEY_SHIFT, MT_READONLY_BIT, MT_REMOVED_P -> MRB_MT_*
- mt_init_rom() -> mrb_mt_init_rom()
File-local static functions and macros in class.c are unchanged.

Co-authored-by: Claude <noreply@anthropic.com>
This commit is contained in:
Yukihiro "Matz" Matsumoto
2026-02-19 15:22:55 +09:00
parent 494d55c9f7
commit 0ed26f8352
35 changed files with 1030 additions and 1030 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/array.c
+39 -39
View File
@@ -2251,7 +2251,7 @@ mrb_ary_to_a(mrb_state *mrb, mrb_value self)
/* ---------------------------*/
#define ARRAY_ROM_MT_SIZE 36
static struct {
union mt_ptr vals[ARRAY_ROM_MT_SIZE];
union mrb_mt_ptr vals[ARRAY_ROM_MT_SIZE];
mrb_sym keys[ARRAY_ROM_MT_SIZE];
} array_rom_data = {
.vals = {
@@ -2293,47 +2293,47 @@ static struct {
{ .func = mrb_ary_svalue },
},
.keys = {
MT_KEY(MRB_OPSYM(add), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(mul), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(lshift), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(aref), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(aset), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(clear), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_OPSYM(cmp), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(concat), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(delete), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(delete_at), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(empty), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_OPSYM(eq), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(eql), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(first), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(index), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(initialize), MT_FUNC|MT_PRIVATE),
MT_KEY(MRB_SYM(initialize_copy), MT_FUNC|MT_PRIVATE),
MT_KEY(MRB_SYM(join), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(last), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(length), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(pop), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(push), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(replace), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(reverse), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_B(reverse), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(rindex), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(shift), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(size), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(slice), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(unshift), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(to_a), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(entries), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(to_s), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(inspect), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_B(sort), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(__svalue), MT_FUNC|MT_NOARG|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(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 mt_tbl array_rom_mt = {
static mrb_mt_tbl array_rom_mt = {
ARRAY_ROM_MT_SIZE, ARRAY_ROM_MT_SIZE,
(union mt_ptr*)&array_rom_data, NULL
(union mrb_mt_ptr*)&array_rom_data, NULL
};
void
src/class.c
+133 -133
View File
@@ -21,41 +21,41 @@
#define METHOD_MID(m) MT_KEY_SYM((m).flags)
/* mt_tbl, union mt_ptr, MT_KEY(), MT_READONLY_BIT, etc. defined in internal.h */
#define MT_KEY_MASK ((1<<MT_KEY_SHIFT)-1)
#define MT_KEY_P(k) (((k)>>MT_KEY_SHIFT) != 0)
/* mrb_mt_tbl, union mrb_mt_ptr, MRB_MT_KEY(), etc. defined in internal.h */
#define MT_KEY_MASK ((1<<MRB_MT_KEY_SHIFT)-1)
#define MT_KEY_P(k) (((k)>>MRB_MT_KEY_SHIFT) != 0)
#define MT_PROTECTED MRB_METHOD_PROTECTED_FL
#define MT_VDEFAULT MRB_METHOD_VDEFAULT_FL
#define MT_VMASK MRB_METHOD_VISIBILITY_MASK
#define MT_EMPTY 0
#define MT_DELETED 1
#define MT_KEY_SYM(k) ((k)>>MT_KEY_SHIFT)
#define MT_KEY_SYM(k) ((k)>>MRB_MT_KEY_SHIFT)
#define MT_KEY_FLG(k) ((k)&MT_KEY_MASK)
#define MT_ALLOC(t) ((t)->alloc & ~MT_READONLY_BIT)
#define mt_readonly_p(t) ((t)->alloc & MT_READONLY_BIT)
#define MT_ALLOC(t) ((t)->alloc & ~MRB_MT_READONLY_BIT)
#define mt_readonly_p(t) ((t)->alloc & MRB_MT_READONLY_BIT)
/* Helper to get keys array from method table */
static inline mrb_sym*
mt_keys(mt_tbl *t) {
mt_keys(mrb_mt_tbl *t) {
return (mrb_sym*)&t->ptr[MT_ALLOC(t)];
}
/* Helper to get values array from method table */
static union mt_ptr*
mt_vals(mt_tbl *t) {
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 */
static void
mt_grow(mrb_state *mrb, mt_tbl *t, int new_alloc)
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 mt_ptr) + sizeof(mrb_sym));
size_t new_block = new_alloc * (sizeof(union mrb_mt_ptr) + sizeof(mrb_sym));
t->ptr = (union mt_ptr*)mrb_realloc(mrb, t->ptr, new_block);
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];
@@ -69,12 +69,12 @@ mt_grow(mrb_state *mrb, mt_tbl *t, int new_alloc)
}
/* Creates a new empty method table */
static mt_tbl*
static mrb_mt_tbl*
mt_new(mrb_state *mrb)
{
mt_tbl *t;
mrb_mt_tbl *t;
t = (mt_tbl*)mrb_malloc(mrb, sizeof(mt_tbl));
t = (mrb_mt_tbl*)mrb_malloc(mrb, sizeof(mrb_mt_tbl));
t->size = 0;
t->alloc = 0;
t->ptr = NULL;
@@ -111,9 +111,9 @@ mt_bsearch_idx(mrb_sym *keys, int size, mrb_sym target)
/* Inserts or updates an entry in the method table */
static void
mt_put(mrb_state *mrb, mt_tbl *t, mrb_sym sym, mrb_sym flags, union mt_ptr ptrval)
mt_put(mrb_state *mrb, mrb_mt_tbl *t, mrb_sym sym, mrb_sym flags, union mrb_mt_ptr ptrval)
{
mrb_sym key = MT_KEY(sym, flags);
mrb_sym key = MRB_MT_KEY(sym, flags);
/* Ensure there is capacity */
if (MT_ALLOC(t) == 0) {
@@ -124,7 +124,7 @@ mt_put(mrb_state *mrb, mt_tbl *t, mrb_sym sym, mrb_sym flags, union mt_ptr ptrva
}
mrb_sym *keys = mt_keys(t);
union mt_ptr *vals = mt_vals(t);
union mrb_mt_ptr *vals = mt_vals(t);
/*
* If table is empty, insertion index is 0.
@@ -142,7 +142,7 @@ mt_put(mrb_state *mrb, mt_tbl *t, mrb_sym sym, mrb_sym flags, union mt_ptr ptrva
/* 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 mt_ptr));
memmove(&vals[lo+1], &vals[lo], move_count * sizeof(union mrb_mt_ptr));
memmove(&keys[lo+1], &keys[lo], move_count * sizeof(mrb_sym));
}
@@ -154,15 +154,15 @@ mt_put(mrb_state *mrb, mt_tbl *t, mrb_sym sym, mrb_sym flags, union mt_ptr ptrva
/* Retrieves a value from the method table (walks chain) */
static mrb_sym
mt_get(mrb_state *mrb, mt_tbl *t, mrb_sym sym, union mt_ptr *pp)
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 mt_ptr *vals = mt_vals(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 (MT_REMOVED_P(keys[lo], vals[lo])) return 0; /* removed tombstone */
if (MRB_MT_REMOVED_P(keys[lo], vals[lo])) return 0; /* removed tombstone */
*pp = vals[lo];
return keys[lo];
}
@@ -174,13 +174,13 @@ mt_get(mrb_state *mrb, mt_tbl *t, mrb_sym sym, union mt_ptr *pp)
/* Deletes an entry from the method table */
static mrb_bool
mt_del(mrb_state *mrb, mt_tbl *t, mrb_sym sym)
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 mt_ptr *vals = mt_vals(t);
union mrb_mt_ptr *vals = mt_vals(t);
/* Find the index of `sym` in a branch-free manner */
int lo = mt_bsearch_idx(keys, t->size, sym);
@@ -189,7 +189,7 @@ mt_del(mrb_state *mrb, mt_tbl *t, mrb_sym sym)
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 mt_ptr));
memmove(&vals[lo], &vals[lo + 1], move_count * sizeof(union mrb_mt_ptr));
memmove(&keys[lo], &keys[lo + 1], move_count * sizeof(mrb_sym));
t->size--;
return TRUE;
@@ -201,7 +201,7 @@ mt_del(mrb_state *mrb, mt_tbl *t, mrb_sym sym)
/* Checks if any layer in the chain contains the given symbol */
static mrb_bool
mt_chain_has(mt_tbl *t, mrb_sym sym)
mt_chain_has(mrb_mt_tbl *t, mrb_sym sym)
{
while (t) {
if (t->size > 0) {
@@ -215,22 +215,22 @@ mt_chain_has(mt_tbl *t, mrb_sym sym)
}
/* Creates a copy of the method table */
static mt_tbl*
mt_copy(mrb_state *mrb, mt_tbl *t)
static mrb_mt_tbl*
mt_copy(mrb_state *mrb, mrb_mt_tbl *t)
{
if (!t) return NULL;
if (mt_readonly_p(t)) {
/* source is ROM — new class gets empty mutable top + shared ROM chain */
if (t->size == 0 && !t->next) return NULL;
mt_tbl *t2 = mt_new(mrb);
mrb_mt_tbl *t2 = mt_new(mrb);
t2->next = t;
return t2;
}
if (t->size == 0 && !t->next) return NULL;
mt_tbl *t2 = mt_new(mrb);
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 mt_ptr));
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));
t2->size = t->size;
}
@@ -240,10 +240,10 @@ mt_copy(mrb_state *mrb, mt_tbl *t)
/* Frees memory of the method table (skips readonly/ROM layers) */
static void
mt_free(mrb_state *mrb, mt_tbl *t)
mt_free(mrb_state *mrb, mrb_mt_tbl *t)
{
while (t && !mt_readonly_p(t)) {
mt_tbl *next = t->next;
mrb_mt_tbl *next = t->next;
mrb_free(mrb, t->ptr);
mrb_free(mrb, t);
t = next;
@@ -252,11 +252,11 @@ mt_free(mrb_state *mrb, mt_tbl *t)
/* Sorts parallel vals/keys arrays by key symbol (insertion sort) */
static void
mt_sort(union mt_ptr *vals, mrb_sym *keys, int n)
mt_sort(union mrb_mt_ptr *vals, mrb_sym *keys, int n)
{
for (int i = 1; i < n; i++) {
mrb_sym key = keys[i];
union mt_ptr val = vals[i];
union mrb_mt_ptr val = vals[i];
mrb_sym sym = MT_KEY_SYM(key);
int j = i;
while (j > 0 && MT_KEY_SYM(keys[j-1]) > sym) {
@@ -271,15 +271,15 @@ mt_sort(union mt_ptr *vals, mrb_sym *keys, int n)
/* Sorts a static ROM table, sets readonly flag, and pushes it to the class */
void
mrb_mt_init_rom(struct RClass *c, mt_tbl *rom)
mrb_mt_init_rom(struct RClass *c, mrb_mt_tbl *rom)
{
union mt_ptr *vals = rom->ptr;
union mrb_mt_ptr *vals = rom->ptr;
mrb_sym *keys = (mrb_sym*)&vals[rom->size];
mt_sort(vals, keys, rom->size);
rom->alloc = rom->size | MT_READONLY_BIT;
rom->alloc = rom->size | MRB_MT_READONLY_BIT;
/* push ROM layer */
mt_tbl *t = c->mt;
mrb_mt_tbl *t = c->mt;
if (!t || mt_readonly_p(t)) {
rom->next = t;
c->mt = rom;
@@ -292,7 +292,7 @@ mrb_mt_init_rom(struct RClass *c, mt_tbl *rom)
/* Creates a method value structure from key and pointer */
static inline mrb_method_t
create_method_value(mrb_state *mrb, mrb_sym key, union mt_ptr val)
create_method_value(mrb_state *mrb, mrb_sym key, union mrb_mt_ptr val)
{
mrb_method_t m = { key, { val.proc } };
return m;
@@ -302,15 +302,15 @@ create_method_value(mrb_state *mrb, mrb_sym key, union mt_ptr val)
MRB_API void
mrb_mt_foreach(mrb_state *mrb, struct RClass *c, mrb_mt_foreach_func *fn, void *p)
{
mt_tbl *t = c->mt;
mrb_mt_tbl *t = c->mt;
if (!t) return;
/* fast path: single layer */
if (!t->next) {
for (int i = 0; i < t->size; i++) {
union mt_ptr *vals = mt_vals(t);
union mrb_mt_ptr *vals = mt_vals(t);
mrb_sym *keys = mt_keys(t);
if (MT_REMOVED_P(keys[i], vals[i])) continue;
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)
return;
@@ -319,16 +319,16 @@ 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 (mt_tbl *layer = t; layer; layer = layer->next) {
for (mrb_mt_tbl *layer = t; layer; layer = layer->next) {
mrb_sym *keys = mt_keys(layer);
union mt_ptr *vals = mt_vals(layer);
union mrb_mt_ptr *vals = mt_vals(layer);
for (int i = 0; i < layer->size; i++) {
if (MT_REMOVED_P(keys[i], vals[i])) continue;
if (MRB_MT_REMOVED_P(keys[i], vals[i])) continue;
mrb_sym sym = MT_KEY_SYM(keys[i]);
/* check if shadowed by a higher layer */
if (layer != t) {
mrb_bool shadowed = FALSE;
for (mt_tbl *upper = t; upper != layer; upper = upper->next) {
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);
@@ -351,13 +351,13 @@ size_t
mrb_gc_mark_mt(mrb_state *mrb, struct RClass *c)
{
size_t children = 0;
for (mt_tbl *t = c->mt; t; t = t->next) {
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 mt_ptr *vals = mt_vals(t);
union mrb_mt_ptr *vals = mt_vals(t);
for (int i = 0; i < t->size; i++) {
if (MT_KEY_P(keys[i]) && (keys[i] & MT_FUNC) == 0) {
if (MT_KEY_P(keys[i]) && (keys[i] & MRB_MT_FUNC) == 0) {
mrb_gc_mark(mrb, (struct RBasic*)vals[i].proc);
}
}
@@ -371,9 +371,9 @@ size_t
mrb_class_mt_memsize(mrb_state *mrb, struct RClass *c)
{
size_t total = 0;
for (mt_tbl *h = c->mt; h && !mt_readonly_p(h); h = h->next)
total += sizeof(mt_tbl) + (size_t)MT_ALLOC(h) *
(sizeof(union mt_ptr) + sizeof(mrb_sym));
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));
return total;
}
@@ -1075,11 +1075,11 @@ find_visibility_scope(mrb_state *mrb, const struct RClass *c, int n, mrb_callinf
MRB_API void
mrb_define_method_raw(mrb_state *mrb, struct RClass *c, mrb_sym mid, mrb_method_t m)
{
union mt_ptr ptr;
union mrb_mt_ptr ptr;
MRB_CLASS_ORIGIN(c);
mt_tbl *h = c->mt;
mrb_mt_tbl *h = c->mt;
if (c->tt == MRB_TT_SCLASS && mrb_frozen_p(c)) {
mrb_value v = mrb_iv_get(mrb, mrb_obj_value(c), MRB_SYM(__attached__));
mrb_check_frozen_value(mrb, v);
@@ -1092,7 +1092,7 @@ mrb_define_method_raw(mrb_state *mrb, struct RClass *c, mrb_sym mid, mrb_method_
}
else if (mt_readonly_p(h)) {
/* COW: create mutable top layer, chain to ROM */
mt_tbl *top = mt_new(mrb);
mrb_mt_tbl *top = mt_new(mrb);
top->next = h;
h = c->mt = top;
}
@@ -1123,12 +1123,12 @@ mrb_define_method_raw(mrb_state *mrb, struct RClass *c, mrb_sym mid, mrb_method_
if (mid == MRB_SYM(initialize) ||
mid == MRB_SYM(initialize_copy) ||
mid == MRB_SYM_Q(respond_to_missing)) {
MRB_SET_VISIBILITY_FLAGS(flags, MT_PRIVATE);
MRB_SET_VISIBILITY_FLAGS(flags, MRB_MT_PRIVATE);
}
else if ((flags & MT_VMASK) == MT_VDEFAULT) {
/* singleton methods are always public */
if (c->tt == MRB_TT_SCLASS) {
MRB_SET_VISIBILITY_FLAGS(flags, MT_PUBLIC);
MRB_SET_VISIBILITY_FLAGS(flags, MRB_MT_PUBLIC);
}
else {
mrb_callinfo *ci;
@@ -1171,7 +1171,7 @@ define_method_id(mrb_state *mrb, struct RClass *c, mrb_sym mid, mrb_func_t func,
MRB_API void
mrb_define_method_id(mrb_state *mrb, struct RClass *c, mrb_sym mid, mrb_func_t func, mrb_aspec aspec)
{
define_method_id(mrb, c, mid, func, aspec, MT_PUBLIC);
define_method_id(mrb, c, mid, func, aspec, MRB_MT_PUBLIC);
}
/*
@@ -1206,7 +1206,7 @@ mrb_define_method(mrb_state *mrb, struct RClass *c, const char *name, mrb_func_t
MRB_API void
mrb_define_private_method_id(mrb_state *mrb, struct RClass *c, mrb_sym mid, mrb_func_t func, mrb_aspec aspec)
{
define_method_id(mrb, c, mid, func, aspec, MT_PRIVATE);
define_method_id(mrb, c, mid, func, aspec, MRB_MT_PRIVATE);
}
/*
@@ -2368,13 +2368,13 @@ mrb_mod_visibility(mrb_state *mrb, mrb_value mod, int vis)
}
}
else {
mt_tbl *h = c->mt;
mrb_mt_tbl *h = c->mt;
for (int i=0; i<argc; i++) {
mrb_check_type(mrb, argv[i], MRB_TT_SYMBOL);
mrb_sym mid = mrb_symbol(argv[i]);
mrb_method_t m = mrb_method_search(mrb, c, mid);
MRB_METHOD_SET_VISIBILITY(m, vis);
union mt_ptr ptr;
union mrb_mt_ptr ptr;
if (MRB_METHOD_PROC_P(m)) {
ptr.proc = MRB_METHOD_PROC(m);
}
@@ -2390,14 +2390,14 @@ mrb_mod_visibility(mrb_state *mrb, mrb_value mod, int vis)
static mrb_value
mrb_mod_public(mrb_state *mrb, mrb_value mod)
{
mrb_mod_visibility(mrb, mod, MT_PUBLIC);
mrb_mod_visibility(mrb, mod, MRB_MT_PUBLIC);
return mod;
}
static mrb_value
mrb_mod_private(mrb_state *mrb, mrb_value mod)
{
mrb_mod_visibility(mrb, mod, MT_PRIVATE);
mrb_mod_visibility(mrb, mod, MRB_MT_PRIVATE);
return mod;
}
@@ -2412,7 +2412,7 @@ static mrb_value
top_public(mrb_state *mrb, mrb_value self)
{
self = mrb_obj_value(mrb->object_class);
mrb_mod_visibility(mrb, self, MT_PUBLIC);
mrb_mod_visibility(mrb, self, MRB_MT_PUBLIC);
return self;
}
@@ -2420,7 +2420,7 @@ static mrb_value
top_private(mrb_state *mrb, mrb_value self)
{
self = mrb_obj_value(mrb->object_class);
mrb_mod_visibility(mrb, self, MT_PRIVATE);
mrb_mod_visibility(mrb, self, MRB_MT_PRIVATE);
return self;
}
@@ -2711,10 +2711,10 @@ mrb_vm_find_method(mrb_state *mrb, struct RClass *c, struct RClass **cp, mrb_sym
#endif
while (c) {
mt_tbl *h = c->mt;
mrb_mt_tbl *h = c->mt;
if (h) {
union mt_ptr ptr;
union mrb_mt_ptr ptr;
mrb_sym ret = mt_get(mrb, h, mid, &ptr);
if (ret) {
if (ptr.proc == 0) break;
@@ -3646,20 +3646,20 @@ mrb_remove_method(mrb_state *mrb, struct RClass *c0, mrb_sym mid)
mrb_bool found = FALSE;
MRB_CLASS_ORIGIN(c);
mt_tbl *h = c->mt;
mrb_mt_tbl *h = c->mt;
if (h) {
found = mt_del(mrb, h, mid);
/* insert removed tombstone to block ROM chain lookup */
if (h->next && mt_chain_has(h->next, mid)) {
union mt_ptr tombstone;
union mrb_mt_ptr tombstone;
tombstone.func = NULL;
found = TRUE;
if (mt_readonly_p(h)) {
mt_tbl *top = mt_new(mrb);
mrb_mt_tbl *top = mt_new(mrb);
top->next = h;
h = c->mt = top;
}
mt_put(mrb, h, mid, MT_FUNC, tombstone);
mt_put(mrb, h, mid, MRB_MT_FUNC, tombstone);
}
}
if (!found) {
@@ -3907,7 +3907,7 @@ define_method_m(mrb_state *mrb, struct RClass *c, int vis)
mrb_value
mrb_mod_define_method_m(mrb_state *mrb, struct RClass *c)
{
return define_method_m(mrb, c, MT_PUBLIC);
return define_method_m(mrb, c, MRB_MT_PUBLIC);
}
static mrb_value
@@ -3919,7 +3919,7 @@ mod_define_method(mrb_state *mrb, mrb_value self)
static mrb_value
top_define_method(mrb_state *mrb, mrb_value self)
{
return define_method_m(mrb, mrb->object_class, MT_PRIVATE);
return define_method_m(mrb, mrb->object_class, MRB_MT_PRIVATE);
}
static mrb_value
@@ -3965,7 +3965,7 @@ mrb_mod_module_function(mrb_state *mrb, mrb_value mod)
mrb_method_t m = mrb_method_search(mrb, rclass, mid);
prepare_singleton_class(mrb, (struct RBasic*)rclass);
MRB_METHOD_SET_VISIBILITY(m, MT_PUBLIC);
MRB_METHOD_SET_VISIBILITY(m, MRB_MT_PUBLIC);
mrb_define_method_raw(mrb, rclass->c, mid, m);
mrb_gc_arena_restore(mrb, ai);
}
@@ -4354,7 +4354,7 @@ static const struct RProc neq_proc = {
/* ---------------------------*/
#define BOB_ROM_MT_SIZE 11
static struct {
union mt_ptr vals[BOB_ROM_MT_SIZE];
union mrb_mt_ptr vals[BOB_ROM_MT_SIZE];
mrb_sym keys[BOB_ROM_MT_SIZE];
} bob_rom_data = {
.vals = {
@@ -4371,27 +4371,27 @@ static struct {
{ .func = mrb_do_nothing },
},
.keys = {
MT_KEY(MRB_OPSYM(eq), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(not), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(__id__), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(__send__), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(equal), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(initialize), MT_FUNC|MT_NOARG|MT_PRIVATE),
MT_KEY(MRB_SYM(instance_eval), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(method_missing), MT_FUNC|MT_PRIVATE),
MT_KEY(MRB_SYM(singleton_method_added), MT_FUNC|MT_PRIVATE),
MT_KEY(MRB_SYM(singleton_method_removed), MT_FUNC|MT_PRIVATE),
MT_KEY(MRB_SYM(singleton_method_undefined), MT_FUNC|MT_PRIVATE),
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 mt_tbl bob_rom_mt = {
static mrb_mt_tbl bob_rom_mt = {
BOB_ROM_MT_SIZE, BOB_ROM_MT_SIZE,
(union mt_ptr*)&bob_rom_data, NULL
(union mrb_mt_ptr*)&bob_rom_data, NULL
};
#define CLS_ROM_MT_SIZE 4
static struct {
union mt_ptr vals[CLS_ROM_MT_SIZE];
union mrb_mt_ptr vals[CLS_ROM_MT_SIZE];
mrb_sym keys[CLS_ROM_MT_SIZE];
} cls_rom_data = {
.vals = {
@@ -4401,20 +4401,20 @@ static struct {
{ .func = mrb_class_superclass },
},
.keys = {
MT_KEY(MRB_SYM(allocate), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(inherited), MT_FUNC|MT_PRIVATE),
MT_KEY(MRB_SYM(initialize), MT_FUNC|MT_PRIVATE),
MT_KEY(MRB_SYM(superclass), MT_FUNC|MT_NOARG|MT_PUBLIC),
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 mt_tbl cls_rom_mt = {
static mrb_mt_tbl cls_rom_mt = {
CLS_ROM_MT_SIZE, CLS_ROM_MT_SIZE,
(union mt_ptr*)&cls_rom_data, NULL
(union mrb_mt_ptr*)&cls_rom_data, NULL
};
#define MOD_ROM_MT_SIZE 34
static struct {
union mt_ptr vals[MOD_ROM_MT_SIZE];
union mrb_mt_ptr vals[MOD_ROM_MT_SIZE];
mrb_sym keys[MOD_ROM_MT_SIZE];
} mod_rom_data = {
.vals = {
@@ -4454,45 +4454,45 @@ static struct {
{ .func = mrb_mod_undef },
},
.keys = {
MT_KEY(MRB_OPSYM(eqq), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(alias_method), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(ancestors), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(attr_accessor), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(attr_reader), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(attr_writer), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(class_eval), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(const_added), MT_FUNC|MT_PRIVATE),
MT_KEY(MRB_SYM_Q(const_defined), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(const_get), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(const_missing), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(const_set), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(define_method), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(dup), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(extended), MT_FUNC|MT_PRIVATE),
MT_KEY(MRB_SYM(include), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(include), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(included), MT_FUNC|MT_PRIVATE),
MT_KEY(MRB_SYM(initialize), MT_FUNC|MT_NOARG|MT_PRIVATE),
MT_KEY(MRB_SYM(inspect), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(method_added), MT_FUNC|MT_PRIVATE),
MT_KEY(MRB_SYM(method_removed), MT_FUNC|MT_PRIVATE),
MT_KEY(MRB_SYM_Q(method_defined), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(method_undefined), MT_FUNC|MT_PRIVATE),
MT_KEY(MRB_SYM(module_eval), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(module_function), MT_FUNC|MT_PRIVATE),
MT_KEY(MRB_SYM(prepend), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(prepended), MT_FUNC|MT_PRIVATE),
MT_KEY(MRB_SYM(private), MT_FUNC|MT_PRIVATE),
MT_KEY(MRB_SYM(protected), MT_FUNC|MT_PRIVATE),
MT_KEY(MRB_SYM(public), MT_FUNC|MT_PRIVATE),
MT_KEY(MRB_SYM(remove_const), MT_FUNC|MT_PRIVATE),
MT_KEY(MRB_SYM(to_s), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(undef_method), MT_FUNC|MT_PUBLIC),
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 mt_tbl mod_rom_mt = {
static mrb_mt_tbl mod_rom_mt = {
MOD_ROM_MT_SIZE, MOD_ROM_MT_SIZE,
(union mt_ptr*)&mod_rom_data, NULL
(union mrb_mt_ptr*)&mod_rom_data, NULL
};
void
src/error.c
+10 -10
View File
@@ -894,7 +894,7 @@ mrb_check_error(mrb_state *mrb)
/* ---------------------------*/
#define EXCEPTION_ROM_MT_SIZE 7
static struct {
union mt_ptr vals[EXCEPTION_ROM_MT_SIZE];
union mrb_mt_ptr vals[EXCEPTION_ROM_MT_SIZE];
mrb_sym keys[EXCEPTION_ROM_MT_SIZE];
} exception_rom_data = {
.vals = {
@@ -907,18 +907,18 @@ static struct {
{ .func = exc_set_backtrace },
},
.keys = {
MT_KEY(MRB_SYM(exception), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(initialize), MT_FUNC|MT_PRIVATE),
MT_KEY(MRB_SYM(to_s), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(message), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(inspect), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(backtrace), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(set_backtrace), MT_FUNC|MT_PUBLIC),
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 mt_tbl exception_rom_mt = {
static mrb_mt_tbl exception_rom_mt = {
EXCEPTION_ROM_MT_SIZE, EXCEPTION_ROM_MT_SIZE,
(union mt_ptr*)&exception_rom_data, NULL
(union mrb_mt_ptr*)&exception_rom_data, NULL
};
void
src/hash.c
+39 -39
View File
@@ -2305,7 +2305,7 @@ mrb_hash_eql(mrb_state *mrb, mrb_value hash)
/* ---------------------------*/
#define HASH_ROM_MT_SIZE 36
static struct {
union mt_ptr vals[HASH_ROM_MT_SIZE];
union mrb_mt_ptr vals[HASH_ROM_MT_SIZE];
mrb_sym keys[HASH_ROM_MT_SIZE];
} hash_rom_data = {
.vals = {
@@ -2347,47 +2347,47 @@ static struct {
{ .func = mrb_hash_except_keys },
},
.keys = {
MT_KEY(MRB_OPSYM(eq), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(aref), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(aset), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(clear), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(default), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM_E(default), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(default_proc), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_E(default_proc), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(__delete), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(eql), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(empty), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(has_key), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(has_value), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(include), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(initialize), MT_FUNC|MT_PRIVATE),
MT_KEY(MRB_SYM(initialize_copy), MT_FUNC|MT_PRIVATE),
MT_KEY(MRB_SYM_Q(key), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(keys), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(length), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(member), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(replace), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(shift), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(size), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(store), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(value), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(values), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(to_s), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(inspect), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(rehash), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(to_hash), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(assoc), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(rassoc), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(__merge), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(__compact), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(__pat_values), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(__except), MT_FUNC|MT_PUBLIC),
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 mt_tbl hash_rom_mt = {
static mrb_mt_tbl hash_rom_mt = {
HASH_ROM_MT_SIZE, HASH_ROM_MT_SIZE,
(union mt_ptr*)&hash_rom_data, NULL
(union mrb_mt_ptr*)&hash_rom_data, NULL
};
void
src/kernel.c
+30 -30
View File
@@ -668,7 +668,7 @@ mrb_p_m(mrb_state *mrb, mrb_value self)
/* ---------------------------*/
#define KERNEL_ROM_MT_SIZE 27
static struct {
union mt_ptr vals[KERNEL_ROM_MT_SIZE];
union mrb_mt_ptr vals[KERNEL_ROM_MT_SIZE];
mrb_sym keys[KERNEL_ROM_MT_SIZE];
} kernel_rom_data = {
.vals = {
@@ -701,38 +701,38 @@ static struct {
{ .func = mrb_obj_method_recursive_p },
},
.keys = {
MT_KEY(MRB_OPSYM(eqq), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(cmp), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(block_given), MT_FUNC|MT_NOARG|MT_PRIVATE),
MT_KEY(MRB_SYM(class), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(clone), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(dup), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(eql), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(freeze), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(frozen), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(extend), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(hash), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(initialize_copy), MT_FUNC|MT_PRIVATE),
MT_KEY(MRB_SYM(inspect), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(instance_of), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(is_a), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(iterator), MT_FUNC|MT_NOARG|MT_PRIVATE),
MT_KEY(MRB_SYM_Q(kind_of), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(nil), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(object_id), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(raise), MT_FUNC|MT_PRIVATE),
MT_KEY(MRB_SYM(remove_instance_variable), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(respond_to), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(to_s), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(__case_eqq), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(__to_int), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(respond_to_missing), MT_FUNC|MT_PRIVATE),
MT_KEY(MRB_SYM_Q(__method_recursive), MT_FUNC|MT_PUBLIC),
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 mt_tbl kernel_rom_mt = {
static mrb_mt_tbl kernel_rom_mt = {
KERNEL_ROM_MT_SIZE, KERNEL_ROM_MT_SIZE,
(union mt_ptr*)&kernel_rom_data, NULL
(union mrb_mt_ptr*)&kernel_rom_data, NULL
};
void
src/numeric.c
+72 -72
View File
@@ -2301,7 +2301,7 @@ flo_hash(mrb_state *mrb, mrb_value flo)
/* ------------------------------------------------------------------------*/
#define NUMERIC_ROM_MT_SIZE 3
static struct {
union mt_ptr vals[NUMERIC_ROM_MT_SIZE];
union mrb_mt_ptr vals[NUMERIC_ROM_MT_SIZE];
mrb_sym keys[NUMERIC_ROM_MT_SIZE];
} numeric_rom_data = {
.vals = {
@@ -2310,19 +2310,19 @@ static struct {
{ .func = num_eql },
},
.keys = {
MT_KEY(MRB_SYM_Q(finite), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(infinite), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(eql), MT_FUNC|MT_PUBLIC),
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 mt_tbl numeric_rom_mt = {
static mrb_mt_tbl numeric_rom_mt = {
NUMERIC_ROM_MT_SIZE, NUMERIC_ROM_MT_SIZE,
(union mt_ptr*)&numeric_rom_data, NULL
(union mrb_mt_ptr*)&numeric_rom_data, NULL
};
#define INTEGER_ROM_MT_SIZE 31
static struct {
union mt_ptr vals[INTEGER_ROM_MT_SIZE];
union mrb_mt_ptr vals[INTEGER_ROM_MT_SIZE];
mrb_sym keys[INTEGER_ROM_MT_SIZE];
} integer_rom_data = {
.vals = {
@@ -2359,48 +2359,48 @@ static struct {
{ .func = coerce_step_counter },
},
.keys = {
MT_KEY(MRB_OPSYM(pow), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(cmp), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(lt), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(le), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(gt), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(ge), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(to_i), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(to_int), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_OPSYM(add), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(sub), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(mul), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(mod), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(div), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(quo), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(div), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(eq), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(neg), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_OPSYM(and), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(or), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(xor), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(lshift), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(rshift), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(ceil), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(floor), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(round), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(truncate), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(hash), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(to_s), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(inspect), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(divmod), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(__coerce_step_counter), MT_FUNC|MT_PUBLIC),
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 mt_tbl integer_rom_mt = {
static mrb_mt_tbl integer_rom_mt = {
INTEGER_ROM_MT_SIZE, INTEGER_ROM_MT_SIZE,
(union mt_ptr*)&integer_rom_data, NULL
(union mrb_mt_ptr*)&integer_rom_data, NULL
};
#ifndef MRB_NO_FLOAT
#define FLOAT_ROM_MT_SIZE 29
static struct {
union mt_ptr vals[FLOAT_ROM_MT_SIZE];
union mrb_mt_ptr vals[FLOAT_ROM_MT_SIZE];
mrb_sym keys[FLOAT_ROM_MT_SIZE];
} float_rom_data = {
.vals = {
@@ -2435,40 +2435,40 @@ static struct {
{ .func = flo_hash },
},
.keys = {
MT_KEY(MRB_OPSYM(pow), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(div), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(quo), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(fdiv), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(div), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(add), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(sub), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(mul), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(mod), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(cmp), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(lt), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(le), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(gt), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(ge), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(eq), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(ceil), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(finite), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(floor), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(infinite), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(round), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(to_f), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(to_i), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(truncate), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(divmod), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(to_s), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(inspect), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(nan), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(abs), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(hash), MT_FUNC|MT_NOARG|MT_PUBLIC),
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 mt_tbl float_rom_mt = {
static mrb_mt_tbl float_rom_mt = {
FLOAT_ROM_MT_SIZE, FLOAT_ROM_MT_SIZE,
(union mt_ptr*)&float_rom_data, NULL
(union mrb_mt_ptr*)&float_rom_data, NULL
};
#endif /* !MRB_NO_FLOAT */
src/object.c
+25 -25
View File
@@ -324,7 +324,7 @@ false_to_s(mrb_state *mrb, mrb_value obj)
/* ---------------------------*/
#define NIL_ROM_MT_SIZE 6
static struct {
union mt_ptr vals[NIL_ROM_MT_SIZE];
union mrb_mt_ptr vals[NIL_ROM_MT_SIZE];
mrb_sym keys[NIL_ROM_MT_SIZE];
} nil_rom_data = {
.vals = {
@@ -336,22 +336,22 @@ static struct {
{ .func = nil_inspect },
},
.keys = {
MT_KEY(MRB_OPSYM(and), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(or), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(xor), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(nil), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(to_s), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(inspect), MT_FUNC|MT_NOARG|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_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 mt_tbl nil_rom_mt = {
static mrb_mt_tbl nil_rom_mt = {
NIL_ROM_MT_SIZE, NIL_ROM_MT_SIZE,
(union mt_ptr*)&nil_rom_data, NULL
(union mrb_mt_ptr*)&nil_rom_data, NULL
};
#define TRUE_ROM_MT_SIZE 5
static struct {
union mt_ptr vals[TRUE_ROM_MT_SIZE];
union mrb_mt_ptr vals[TRUE_ROM_MT_SIZE];
mrb_sym keys[TRUE_ROM_MT_SIZE];
} true_rom_data = {
.vals = {
@@ -362,21 +362,21 @@ static struct {
{ .func = true_to_s },
},
.keys = {
MT_KEY(MRB_OPSYM(and), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(or), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(xor), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(to_s), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(inspect), MT_FUNC|MT_NOARG|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_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 mt_tbl true_rom_mt = {
static mrb_mt_tbl true_rom_mt = {
TRUE_ROM_MT_SIZE, TRUE_ROM_MT_SIZE,
(union mt_ptr*)&true_rom_data, NULL
(union mrb_mt_ptr*)&true_rom_data, NULL
};
#define FALSE_ROM_MT_SIZE 5
static struct {
union mt_ptr vals[FALSE_ROM_MT_SIZE];
union mrb_mt_ptr vals[FALSE_ROM_MT_SIZE];
mrb_sym keys[FALSE_ROM_MT_SIZE];
} false_rom_data = {
.vals = {
@@ -387,16 +387,16 @@ static struct {
{ .func = false_to_s },
},
.keys = {
MT_KEY(MRB_OPSYM(and), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(or), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(xor), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(to_s), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(inspect), MT_FUNC|MT_NOARG|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_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 mt_tbl false_rom_mt = {
static mrb_mt_tbl false_rom_mt = {
FALSE_ROM_MT_SIZE, FALSE_ROM_MT_SIZE,
(union mt_ptr*)&false_rom_data, NULL
(union mrb_mt_ptr*)&false_rom_data, NULL
};
void
src/proc.c
+8 -8
View File
@@ -547,7 +547,7 @@ 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 mt_ptr vals[PROC_ROM_MT_SIZE];
union mrb_mt_ptr vals[PROC_ROM_MT_SIZE];
mrb_sym keys[PROC_ROM_MT_SIZE];
} proc_rom_data = {
.vals = {
@@ -558,16 +558,16 @@ static struct {
{ .func = proc_hash },
},
.keys = {
MT_KEY(MRB_SYM(initialize_copy), MT_FUNC|MT_PRIVATE),
MT_KEY(MRB_SYM(arity), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_OPSYM(eq), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(eql), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(hash), MT_FUNC|MT_NOARG|MT_PUBLIC),
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 mt_tbl proc_rom_mt = {
static mrb_mt_tbl proc_rom_mt = {
PROC_ROM_MT_SIZE, PROC_ROM_MT_SIZE,
(union mt_ptr*)&proc_rom_data, NULL
(union mrb_mt_ptr*)&proc_rom_data, NULL
};
void
src/range.c
+18 -18
View File
@@ -568,7 +568,7 @@ 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 mt_ptr vals[RANGE_ROM_MT_SIZE];
union mrb_mt_ptr vals[RANGE_ROM_MT_SIZE];
mrb_sym keys[RANGE_ROM_MT_SIZE];
} range_rom_data = {
.vals = {
@@ -589,26 +589,26 @@ static struct {
{ .func = range_num_to_a },
},
.keys = {
MT_KEY(MRB_SYM(begin), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(end), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_OPSYM(eq), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(eqq), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(exclude_end), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(first), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(include), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(initialize), MT_FUNC|MT_PRIVATE),
MT_KEY(MRB_SYM(last), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(member), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(to_s), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(inspect), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(eql), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(initialize_copy), MT_FUNC|MT_PRIVATE),
MT_KEY(MRB_SYM(__num_to_a), MT_FUNC|MT_NOARG|MT_PUBLIC),
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 mt_tbl range_rom_mt = {
static mrb_mt_tbl range_rom_mt = {
RANGE_ROM_MT_SIZE, RANGE_ROM_MT_SIZE,
(union mt_ptr*)&range_rom_data, NULL
(union mrb_mt_ptr*)&range_rom_data, NULL
};
void
src/string.c
+49 -49
View File
@@ -3510,7 +3510,7 @@ mrb_encoding(mrb_state *mrb, mrb_value self)
/* ---------------------------*/
#define STRING_ROM_MT_SIZE 46
static struct {
union mt_ptr vals[STRING_ROM_MT_SIZE];
union mrb_mt_ptr vals[STRING_ROM_MT_SIZE];
mrb_sym keys[STRING_ROM_MT_SIZE];
} string_rom_data = {
.vals = {
@@ -3562,57 +3562,57 @@ static struct {
{ .func = sub_replace },
},
.keys = {
MT_KEY(MRB_SYM(bytesize), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_OPSYM(cmp), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(eq), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(add), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(mul), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(aref), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(aset), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(capitalize), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_B(capitalize), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(chomp), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM_B(chomp), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(chop), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_B(chop), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(downcase), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_B(downcase), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(empty), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(eql), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(hash), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(include), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(index), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(initialize), MT_FUNC|MT_PRIVATE),
MT_KEY(MRB_SYM(initialize_copy), MT_FUNC|MT_PRIVATE),
MT_KEY(MRB_SYM(intern), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(length), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(replace), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(reverse), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_B(reverse), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(rindex), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(size), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(slice), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(split), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(to_i), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(to_s), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(to_str), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(to_sym), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(upcase), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_B(upcase), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(inspect), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(bytes), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(getbyte), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(setbyte), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(byteindex), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(byterindex), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(byteslice), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(bytesplice), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(__sub_replace), MT_FUNC|MT_PUBLIC),
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 mt_tbl string_rom_mt = {
static mrb_mt_tbl string_rom_mt = {
STRING_ROM_MT_SIZE, STRING_ROM_MT_SIZE,
(union mt_ptr*)&string_rom_data, NULL
(union mrb_mt_ptr*)&string_rom_data, NULL
};
void
src/symbol.c
+9 -9
View File
@@ -1003,7 +1003,7 @@ sym_cmp(mrb_state *mrb, mrb_value s1)
/* ---------------------------*/
#define SYMBOL_ROM_MT_SIZE 6
static struct {
union mt_ptr vals[SYMBOL_ROM_MT_SIZE];
union mrb_mt_ptr vals[SYMBOL_ROM_MT_SIZE];
mrb_sym keys[SYMBOL_ROM_MT_SIZE];
} symbol_rom_data = {
.vals = {
@@ -1015,17 +1015,17 @@ static struct {
{ .func = mrb_obj_equal_m },
},
.keys = {
MT_KEY(MRB_SYM(to_s), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(name), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(to_sym), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(inspect), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_OPSYM(cmp), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(eq), MT_FUNC|MT_PUBLIC),
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 mt_tbl symbol_rom_mt = {
static mrb_mt_tbl symbol_rom_mt = {
SYMBOL_ROM_MT_SIZE, SYMBOL_ROM_MT_SIZE,
(union mt_ptr*)&symbol_rom_data, NULL
(union mrb_mt_ptr*)&symbol_rom_data, NULL
};
void