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: refactor ROM method tables to array-of-structs layout

Browse Source 
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
2026-02-19 23:59:30 +09:00
parent cfd9214b3d
commit bde2202100
34 changed files with 969 additions and 2337 deletions
Download Patch File Download Diff File Expand all files Collapse all files
doc/guides/rom-method-table.md
+74 -84
View File
@@ -45,18 +45,19 @@ After String.define_method(:foo):
### Memory Layout
Each `mrb_mt_tbl` stores method entries as parallel arrays in a single
contiguous block:
Each `mrb_mt_tbl` stores method entries as an array of `mrb_mt_entry`
structs, each combining a function pointer and an encoded key:
```
ptr -> [ vals[0] vals[1] ... vals[N-1] | keys[0] keys[1] ... keys[N-1] ]
|<--- union mrb_mt_ptr array ------>|<--- mrb_sym (encoded) array -->|
ptr -> [ entry[0] | entry[1] | ... | entry[N-1] ]
|<--- mrb_mt_entry: { val, key } each ---->|
```
Values are `union mrb_mt_ptr` (function pointer or proc pointer). Keys are
`mrb_sym` with flags packed into the lower bits using `MRB_MT_KEY()`.
Values are `union mrb_mt_ptr` (function pointer or proc pointer). Keys
are `mrb_sym` with flags packed into the lower bits using
`MRB_MT_KEY()`.
Keys must be sorted by symbol ID for binary search. The
Entries must be sorted by symbol ID for binary search. The
`mrb_mt_init_rom()` function handles sorting at startup, so the
source code order does not matter.
@@ -64,33 +65,20 @@ source code order does not matter.
### Step 1: Define the Static Data
Include `<mruby/internal.h>` (which provides `mrb_mt_tbl`, `union mrb_mt_ptr`,
`MRB_MT_KEY()`, and flag constants) and define the ROM data structure:
Include `<mruby/internal.h>` (which provides `mrb_mt_entry`,
`mrb_mt_tbl`, `MRB_MT_ENTRY()`, `MRB_MT_ROM_TAB()`, and flag
constants) and define the ROM entries:
```c
#include <mruby/internal.h>
#include <mruby/presym.h>
#define MY_ROM_MT_SIZE 3
static struct {
union mrb_mt_ptr vals[MY_ROM_MT_SIZE];
mrb_sym keys[MY_ROM_MT_SIZE];
} my_rom_data = {
.vals = {
{ .func = my_method_a },
{ .func = my_method_b },
{ .func = my_method_c },
},
.keys = {
MRB_MT_KEY(MRB_SYM(method_a), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(method_b), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(eq), MRB_MT_FUNC|MRB_MT_PUBLIC),
}
};
static mrb_mt_tbl my_rom_mt = {
MY_ROM_MT_SIZE, MY_ROM_MT_SIZE,
(union mrb_mt_ptr*)&my_rom_data, NULL
static mrb_mt_entry my_rom_entries[] = {
MRB_MT_ENTRY(my_method_a, MRB_SYM(method_a), MRB_MT_FUNC),
MRB_MT_ENTRY(my_method_b, MRB_SYM(method_b), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(my_method_eq, MRB_OPSYM(eq), MRB_MT_FUNC),
};
static mrb_mt_tbl my_rom_mt = MRB_MT_ROM_TAB(my_rom_entries);
```
### Step 2: Register in the Init Function
@@ -107,7 +95,7 @@ mrb_mruby_mygem_gem_init(mrb_state *mrb)
}
```
`mrb_mt_init_rom()` sorts the keys by symbol ID, sets the readonly
`mrb_mt_init_rom()` sorts the entries by symbol ID, sets the readonly
flag, and pushes the ROM layer onto the class's method table chain.
### Step 3: Verify
@@ -127,14 +115,33 @@ union mrb_mt_ptr {
mrb_func_t func;
};
typedef struct mrb_mt_entry {
union mrb_mt_ptr val;
mrb_sym key;
} mrb_mt_entry;
typedef struct mrb_mt_tbl {
int size;
int alloc; /* bit 30: MRB_MT_READONLY_BIT */
union mrb_mt_ptr *ptr;
struct mrb_mt_tbl *next; /* next (lower-priority) layer, or NULL */
int alloc; /* bit 30: MRB_MT_READONLY_BIT */
mrb_mt_entry *ptr;
struct mrb_mt_tbl *next; /* next (lower-priority) layer, or NULL */
} mrb_mt_tbl;
```
### Macros
```c
/* ROM table entry: bundles function pointer with encoded key */
#define MRB_MT_ENTRY(fn, sym, flags) \
{ { .func = (fn) }, MRB_MT_KEY((sym), (flags)) }
/* ROM table initializer (auto-computes size from entries array) */
#define MRB_MT_ROM_TAB(entries) { \
(int)(sizeof(entries)/sizeof(entries[0])), \
(int)(sizeof(entries)/sizeof(entries[0])), \
(entries), NULL }
```
### Key Encoding
```c
@@ -150,7 +157,8 @@ typedef struct mrb_mt_tbl {
| `MRB_MT_PUBLIC` | 0 | Public visibility |
| `MRB_MT_PRIVATE` | 1 | Private visibility |
Most ROM entries use `MRB_MT_FUNC|MRB_MT_PUBLIC` or `MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC`.
Most ROM entries use `MRB_MT_FUNC` or `MRB_MT_FUNC|MRB_MT_NOARG`.
Since `MRB_MT_PUBLIC` is 0, it can be omitted.
**How to choose flags:**
@@ -158,8 +166,7 @@ Most ROM entries use `MRB_MT_FUNC|MRB_MT_PUBLIC` or `MRB_MT_FUNC|MRB_MT_NOARG|MR
RProc-based methods (rare in ROM tables).
- **`MRB_MT_NOARG`**: Set when the original `mrb_define_method_id()` used
`MRB_ARGS_NONE()`. This enables an optimized call path in the VM.
- **`MRB_MT_PUBLIC` / `MRB_MT_PRIVATE`**: Match the intended visibility. Almost
all methods are public.
- **`MRB_MT_PRIVATE`**: Set for private methods (e.g., `initialize`).
### Symbol Macros
@@ -189,26 +196,21 @@ Sorts the ROM table, sets the readonly flag, and pushes it onto the
class's method table chain. Multiple calls push additional layers,
which is how extension gems add methods to core classes.
## Vals and Keys Correspondence
## Entry Correspondence
Each `vals[i]` corresponds to `keys[i]`. The function pointer in
`vals[i]` is the C implementation of the method identified by
`keys[i]`. Their order in the source code does not matter (they are
sorted at init time), but keeping them in the same order improves
readability.
Each `MRB_MT_ENTRY()` bundles a function pointer with its method name
and flags in a single line. Their order in the source code does not
matter (they are sorted at init time), but keeping related methods
together improves readability.
**Method aliases** (two names for the same function) are expressed as
separate entries sharing the same function pointer:
```c
.vals = {
{ .func = mrb_str_size }, /* size */
{ .func = mrb_str_size }, /* length (alias) */
},
.keys = {
MRB_MT_KEY(MRB_SYM(size), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(length), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
}
static mrb_mt_entry str_rom_entries[] = {
MRB_MT_ENTRY(mrb_str_size, MRB_SYM(size), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(mrb_str_size, MRB_SYM(length), MRB_MT_FUNC|MRB_MT_NOARG),
};
```
## Conditional Methods
@@ -221,9 +223,8 @@ blocks):
```c
#ifndef MRB_NO_FLOAT
#define FLOAT_ROM_MT_SIZE 29
static struct { ... } float_rom_data = { ... };
static mrb_mt_tbl float_rom_mt = { ... };
static mrb_mt_entry float_rom_entries[] = { ... };
static mrb_mt_tbl float_rom_mt = MRB_MT_ROM_TAB(float_rom_entries);
#endif
void mrb_init_numeric(mrb_state *mrb) {
@@ -259,9 +260,8 @@ ROM layer in front of the core ROM layer:
```c
/* mrbgems/mruby-string-ext/src/string.c */
#define STRING_EXT_ROM_MT_SIZE 53
static struct { ... } string_ext_rom_data = { ... };
static mrb_mt_tbl string_ext_rom_mt = { ... };
static mrb_mt_entry string_ext_rom_entries[] = { ... };
static mrb_mt_tbl string_ext_rom_mt = MRB_MT_ROM_TAB(string_ext_rom_entries);
void mrb_mruby_string_ext_gem_init(mrb_state *mrb)
{
@@ -360,21 +360,25 @@ To convert existing `mrb_define_method_id()` calls to a ROM table:
1. **Count** the number of method definitions that can be converted.
2. **Create** the ROM data structure with `#define MY_ROM_MT_SIZE N`.
2. **Create** the ROM entries array using `MRB_MT_ENTRY()`.
3. **Move** each `mrb_define_method_id()` call into the ROM table:
- The second-to-last argument (function pointer) goes into `.vals`.
- The third argument (symbol) goes into `.keys` via `MRB_MT_KEY()`.
- Map the `MRB_ARGS_*` macro to flags:
- `MRB_ARGS_NONE()` -> `MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC`
- Anything else -> `MRB_MT_FUNC|MRB_MT_PUBLIC`
3. **Move** each `mrb_define_method_id()` call into the entries:
- `MRB_MT_ENTRY(func, sym, flags)` where:
- `func` is the function pointer
- `sym` is the symbol macro (e.g., `MRB_SYM(name)`)
- `flags` are:
- `MRB_ARGS_NONE()` -> `MRB_MT_FUNC|MRB_MT_NOARG`
- Anything else -> `MRB_MT_FUNC`
- Add `MRB_MT_PRIVATE` for private methods
4. **Replace** the calls with `mrb_mt_init_rom(c, &my_rom_mt)`.
4. **Create** the table with `MRB_MT_ROM_TAB(entries)`.
5. **Keep** any methods that cannot be converted (see above) as
5. **Replace** the calls with `mrb_mt_init_rom(c, &my_rom_mt)`.
6. **Keep** any methods that cannot be converted (see above) as
individual `mrb_define_method_id()` calls after the ROM init.
6. **Build and test**: `rake CONFIG=host-debug -j24 all test:run:serial`
7. **Build and test**: `rake CONFIG=host-debug -j24 all test:run:serial`
### Before
@@ -390,26 +394,12 @@ void mrb_mruby_foo_gem_init(mrb_state *mrb) {
### After
```c
#define FOO_ROM_MT_SIZE 3
static struct {
union mrb_mt_ptr vals[FOO_ROM_MT_SIZE];
mrb_sym keys[FOO_ROM_MT_SIZE];
} foo_rom_data = {
.vals = {
{ .func = foo_bar },
{ .func = foo_baz },
{ .func = foo_eq },
},
.keys = {
MRB_MT_KEY(MRB_SYM(bar), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(baz), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(eq), MRB_MT_FUNC|MRB_MT_PUBLIC),
}
};
static mrb_mt_tbl foo_rom_mt = {
FOO_ROM_MT_SIZE, FOO_ROM_MT_SIZE,
(union mrb_mt_ptr*)&foo_rom_data, NULL
static mrb_mt_entry foo_rom_entries[] = {
MRB_MT_ENTRY(foo_bar, MRB_SYM(bar), MRB_MT_FUNC),
MRB_MT_ENTRY(foo_baz, MRB_SYM(baz), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(foo_eq, MRB_OPSYM(eq), MRB_MT_FUNC),
};
static mrb_mt_tbl foo_rom_mt = MRB_MT_ROM_TAB(foo_rom_entries);
void mrb_mruby_foo_gem_init(mrb_state *mrb) {
struct RClass *foo = mrb_define_class_id(mrb, MRB_SYM(Foo), mrb->object_class);
include/mruby/internal.h
+18 -2
View File
@@ -34,10 +34,16 @@ union mrb_mt_ptr {
mrb_func_t func;
};
/* entry combining function pointer and key */
typedef struct mrb_mt_entry {
union mrb_mt_ptr val;
mrb_sym key;
} mrb_mt_entry;
typedef struct mrb_mt_tbl {
int size;
int alloc; /* bit 30: MRB_MT_READONLY_BIT, bit 29: MRB_MT_FROZEN_BIT */
union mrb_mt_ptr *ptr;
mrb_mt_entry *ptr;
struct mrb_mt_tbl *next;
} mrb_mt_tbl;
@@ -50,12 +56,22 @@ typedef struct mrb_mt_tbl {
#define MRB_MT_PUBLIC 0 /* MRB_METHOD_PUBLIC_FL */
#define MRB_MT_PRIVATE 1 /* MRB_METHOD_PRIVATE_FL */
/* ROM table entry: { {.func=fn}, MRB_MT_KEY(sym, flags) } */
#define MRB_MT_ENTRY(fn, sym, flags) \
{ { .func = (fn) }, MRB_MT_KEY((sym), (flags)) }
/* ROM table initializer from entries array (auto-computes size) */
#define MRB_MT_ROM_TAB(entries) { \
(int)(sizeof(entries)/sizeof(entries[0])), \
(int)(sizeof(entries)/sizeof(entries[0])), \
(entries), NULL }
/* "removed" tombstone: MRB_MT_FUNC flag set with NULL function pointer.
This combination never occurs naturally (C functions are never NULL).
Unlike undef (proc=NULL without MRB_MT_FUNC), a removed marker makes
mt_get() return 0 ("not found"), blocking ROM chain walk while
allowing superclass lookup. */
#define MRB_MT_REMOVED_P(key, val) (((key)&MRB_MT_FUNC) && (val).func==NULL)
#define MRB_MT_REMOVED_P(e) (((e).key&MRB_MT_FUNC) && (e).val.func==NULL)
void mrb_mt_init_rom(struct RClass *c, mrb_mt_tbl *rom);
#endif
mrbgems/mruby-array-ext/src/array.c
+31 -71
View File
@@ -1537,78 +1537,38 @@ ary_combination_next(mrb_state *mrb, mrb_value self)
}
/* ---------------------------*/
#define ARRAY_EXT_ROM_MT_SIZE 29
static struct {
union mrb_mt_ptr vals[ARRAY_EXT_ROM_MT_SIZE];
mrb_sym keys[ARRAY_EXT_ROM_MT_SIZE];
} array_ext_rom_data = {
.vals = {
{ .func = ary_assoc },
{ .func = ary_at },
{ .func = ary_rassoc },
{ .func = ary_values_at },
{ .func = ary_slice_bang },
{ .func = ary_compact },
{ .func = ary_compact_bang },
{ .func = ary_rotate },
{ .func = ary_rotate_bang },
{ .func = ary_sub },
{ .func = ary_difference },
{ .func = ary_union },
{ .func = ary_union_multi },
{ .func = ary_intersection },
{ .func = ary_intersection_multi },
{ .func = ary_intersect_p },
{ .func = ary_fill_parse_arg },
{ .func = ary_fill_exec },
{ .func = ary_uniq },
{ .func = ary_uniq_bang },
{ .func = ary_flatten },
{ .func = ary_flatten_bang },
{ .func = ary_normalize_index },
{ .func = ary_fetch },
{ .func = ary_insert },
{ .func = ary_deconstruct },
{ .func = ary_product_group },
{ .func = ary_combination_init },
{ .func = ary_combination_next },
},
.keys = {
MRB_MT_KEY(MRB_SYM(assoc), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(at), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(rassoc), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(values_at), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_B(slice), 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_B(compact), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(rotate), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_B(rotate), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(sub), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(difference), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(or), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(union), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(and), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(intersection), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_Q(intersect), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(__fill_parse_arg), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(__fill_exec), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(__uniq), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_B(__uniq), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(flatten), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_B(flatten), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(__normalize_index), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(__fetch), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(insert), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(deconstruct), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(__product_group), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(__combination_init), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(__combination_next), MRB_MT_FUNC|MRB_MT_PUBLIC),
}
};
static mrb_mt_tbl array_ext_rom_mt = {
ARRAY_EXT_ROM_MT_SIZE, ARRAY_EXT_ROM_MT_SIZE,
(union mrb_mt_ptr*)&array_ext_rom_data, NULL
static mrb_mt_entry array_ext_rom_entries[] = {
MRB_MT_ENTRY(ary_assoc, MRB_SYM(assoc), MRB_MT_FUNC),
MRB_MT_ENTRY(ary_at, MRB_SYM(at), MRB_MT_FUNC),
MRB_MT_ENTRY(ary_rassoc, MRB_SYM(rassoc), MRB_MT_FUNC),
MRB_MT_ENTRY(ary_values_at, MRB_SYM(values_at), MRB_MT_FUNC),
MRB_MT_ENTRY(ary_slice_bang, MRB_SYM_B(slice), MRB_MT_FUNC),
MRB_MT_ENTRY(ary_compact, MRB_SYM(compact), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(ary_compact_bang, MRB_SYM_B(compact), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(ary_rotate, MRB_SYM(rotate), MRB_MT_FUNC),
MRB_MT_ENTRY(ary_rotate_bang, MRB_SYM_B(rotate), MRB_MT_FUNC),
MRB_MT_ENTRY(ary_sub, MRB_OPSYM(sub), MRB_MT_FUNC),
MRB_MT_ENTRY(ary_difference, MRB_SYM(difference), MRB_MT_FUNC),
MRB_MT_ENTRY(ary_union, MRB_OPSYM(or), MRB_MT_FUNC),
MRB_MT_ENTRY(ary_union_multi, MRB_SYM(union), MRB_MT_FUNC),
MRB_MT_ENTRY(ary_intersection, MRB_OPSYM(and), MRB_MT_FUNC),
MRB_MT_ENTRY(ary_intersection_multi, MRB_SYM(intersection), MRB_MT_FUNC),
MRB_MT_ENTRY(ary_intersect_p, MRB_SYM_Q(intersect), MRB_MT_FUNC),
MRB_MT_ENTRY(ary_fill_parse_arg, MRB_SYM(__fill_parse_arg), MRB_MT_FUNC),
MRB_MT_ENTRY(ary_fill_exec, MRB_SYM(__fill_exec), MRB_MT_FUNC),
MRB_MT_ENTRY(ary_uniq, MRB_SYM(__uniq), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(ary_uniq_bang, MRB_SYM_B(__uniq), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(ary_flatten, MRB_SYM(flatten), MRB_MT_FUNC),
MRB_MT_ENTRY(ary_flatten_bang, MRB_SYM_B(flatten), MRB_MT_FUNC),
MRB_MT_ENTRY(ary_normalize_index, MRB_SYM(__normalize_index), MRB_MT_FUNC),
MRB_MT_ENTRY(ary_fetch, MRB_SYM(__fetch), MRB_MT_FUNC),
MRB_MT_ENTRY(ary_insert, MRB_SYM(insert), MRB_MT_FUNC),
MRB_MT_ENTRY(ary_deconstruct, MRB_SYM(deconstruct), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(ary_product_group, MRB_SYM(__product_group), MRB_MT_FUNC),
MRB_MT_ENTRY(ary_combination_init, MRB_SYM(__combination_init), MRB_MT_FUNC),
MRB_MT_ENTRY(ary_combination_next, MRB_SYM(__combination_next), MRB_MT_FUNC),
};
static mrb_mt_tbl array_ext_rom_mt = MRB_MT_ROM_TAB(array_ext_rom_entries);
void
mrb_mruby_array_ext_gem_init(mrb_state* mrb)
mrbgems/mruby-class-ext/src/class.c
+15 -48
View File
@@ -335,57 +335,24 @@ mrb_mod_cmp(mrb_state *mrb, mrb_value self)
}
/* ---------------------------*/
#define MOD_EXT_ROM_MT_SIZE 9
static struct {
union mrb_mt_ptr vals[MOD_EXT_ROM_MT_SIZE];
mrb_sym keys[MOD_EXT_ROM_MT_SIZE];
} mod_ext_rom_data = {
.vals = {
{ .func = mrb_mod_lt },
{ .func = mrb_mod_le },
{ .func = mrb_mod_cmp },
{ .func = mrb_mod_gt },
{ .func = mrb_mod_ge },
{ .func = mod_module_exec },
{ .func = mod_module_exec },
{ .func = mod_name },
{ .func = mod_singleton_class_p },
},
.keys = {
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(cmp), 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(class_exec), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(module_exec), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(name), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_Q(singleton_class), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
}
};
static mrb_mt_tbl mod_ext_rom_mt = {
MOD_EXT_ROM_MT_SIZE, MOD_EXT_ROM_MT_SIZE,
(union mrb_mt_ptr*)&mod_ext_rom_data, NULL
static mrb_mt_entry mod_ext_rom_entries[] = {
MRB_MT_ENTRY(mrb_mod_lt, MRB_OPSYM(lt), MRB_MT_FUNC),
MRB_MT_ENTRY(mrb_mod_le, MRB_OPSYM(le), MRB_MT_FUNC),
MRB_MT_ENTRY(mrb_mod_cmp, MRB_OPSYM(cmp), MRB_MT_FUNC),
MRB_MT_ENTRY(mrb_mod_gt, MRB_OPSYM(gt), MRB_MT_FUNC),
MRB_MT_ENTRY(mrb_mod_ge, MRB_OPSYM(ge), MRB_MT_FUNC),
MRB_MT_ENTRY(mod_module_exec, MRB_SYM(class_exec), MRB_MT_FUNC),
MRB_MT_ENTRY(mod_module_exec, MRB_SYM(module_exec), MRB_MT_FUNC),
MRB_MT_ENTRY(mod_name, MRB_SYM(name), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(mod_singleton_class_p, MRB_SYM_Q(singleton_class), MRB_MT_FUNC|MRB_MT_NOARG),
};
static mrb_mt_tbl mod_ext_rom_mt = MRB_MT_ROM_TAB(mod_ext_rom_entries);
#define CLS_EXT_ROM_MT_SIZE 2
static struct {
union mrb_mt_ptr vals[CLS_EXT_ROM_MT_SIZE];
mrb_sym keys[CLS_EXT_ROM_MT_SIZE];
} cls_ext_rom_data = {
.vals = {
{ .func = class_attached_object },
{ .func = class_subclasses },
},
.keys = {
MRB_MT_KEY(MRB_SYM(attached_object), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(subclasses), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
}
};
static mrb_mt_tbl cls_ext_rom_mt = {
CLS_EXT_ROM_MT_SIZE, CLS_EXT_ROM_MT_SIZE,
(union mrb_mt_ptr*)&cls_ext_rom_data, NULL
static mrb_mt_entry cls_ext_rom_entries[] = {
MRB_MT_ENTRY(class_attached_object, MRB_SYM(attached_object), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(class_subclasses, MRB_SYM(subclasses), MRB_MT_FUNC|MRB_MT_NOARG),
};
static mrb_mt_tbl cls_ext_rom_mt = MRB_MT_ROM_TAB(cls_ext_rom_entries);
/*
* Initialize the mruby-class-ext gem.
mrbgems/mruby-complex/src/complex.c
+21 -69
View File
@@ -558,80 +558,32 @@ complex_pow(mrb_state *mrb, mrb_value self)
}
/* ---------------------------*/
#define COMPLEX_ROM_MT_SIZE 13
static struct {
union mrb_mt_ptr vals[COMPLEX_ROM_MT_SIZE];
mrb_sym keys[COMPLEX_ROM_MT_SIZE];
} complex_rom_data = {
.vals = {
{ .func = complex_real },
{ .func = complex_imaginary },
{ .func = mrb_complex_to_f },
{ .func = mrb_complex_to_i },
{ .func = mrb_obj_itself },
{ .func = complex_add },
{ .func = complex_sub },
{ .func = complex_mul },
{ .func = complex_div },
{ .func = complex_div },
{ .func = complex_eq },
{ .func = complex_hash },
{ .func = complex_pow },
},
.keys = {
MRB_MT_KEY(MRB_SYM(real), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(imaginary), MRB_MT_FUNC|MRB_MT_NOARG|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(to_c), 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(div), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(quo), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(eq), 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_OPSYM(pow), MRB_MT_FUNC|MRB_MT_PUBLIC),
}
};
static mrb_mt_tbl complex_rom_mt = {
COMPLEX_ROM_MT_SIZE, COMPLEX_ROM_MT_SIZE,
(union mrb_mt_ptr*)&complex_rom_data, NULL
static mrb_mt_entry complex_rom_entries[] = {
MRB_MT_ENTRY(complex_real, MRB_SYM(real), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(complex_imaginary, MRB_SYM(imaginary), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(mrb_complex_to_f, MRB_SYM(to_f), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(mrb_complex_to_i, MRB_SYM(to_i), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(mrb_obj_itself, MRB_SYM(to_c), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(complex_add, MRB_OPSYM(add), MRB_MT_FUNC),
MRB_MT_ENTRY(complex_sub, MRB_OPSYM(sub), MRB_MT_FUNC),
MRB_MT_ENTRY(complex_mul, MRB_OPSYM(mul), MRB_MT_FUNC),
MRB_MT_ENTRY(complex_div, MRB_OPSYM(div), MRB_MT_FUNC),
MRB_MT_ENTRY(complex_div, MRB_SYM(quo), MRB_MT_FUNC),
MRB_MT_ENTRY(complex_eq, MRB_OPSYM(eq), MRB_MT_FUNC),
MRB_MT_ENTRY(complex_hash, MRB_SYM(hash), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(complex_pow, MRB_OPSYM(pow), MRB_MT_FUNC),
};
static mrb_mt_tbl complex_rom_mt = MRB_MT_ROM_TAB(complex_rom_entries);
#define NIL_TO_C_ROM_MT_SIZE 1
static struct {
union mrb_mt_ptr vals[NIL_TO_C_ROM_MT_SIZE];
mrb_sym keys[NIL_TO_C_ROM_MT_SIZE];
} nil_to_c_rom_data = {
.vals = {
{ .func = nil_to_c },
},
.keys = {
MRB_MT_KEY(MRB_SYM(to_c), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
}
};
static mrb_mt_tbl nil_to_c_rom_mt = {
NIL_TO_C_ROM_MT_SIZE, NIL_TO_C_ROM_MT_SIZE,
(union mrb_mt_ptr*)&nil_to_c_rom_data, NULL
static mrb_mt_entry nil_to_c_rom_entries[] = {
MRB_MT_ENTRY(nil_to_c, MRB_SYM(to_c), MRB_MT_FUNC|MRB_MT_NOARG),
};
static mrb_mt_tbl nil_to_c_rom_mt = MRB_MT_ROM_TAB(nil_to_c_rom_entries);
#define KERNEL_COMPLEX_ROM_MT_SIZE 1
static struct {
union mrb_mt_ptr vals[KERNEL_COMPLEX_ROM_MT_SIZE];
mrb_sym keys[KERNEL_COMPLEX_ROM_MT_SIZE];
} kernel_complex_rom_data = {
.vals = {
{ .func = complex_s_rect },
},
.keys = {
MRB_MT_KEY(MRB_SYM(Complex), MRB_MT_FUNC|MRB_MT_PRIVATE),
}
};
static mrb_mt_tbl kernel_complex_rom_mt = {
KERNEL_COMPLEX_ROM_MT_SIZE, KERNEL_COMPLEX_ROM_MT_SIZE,
(union mrb_mt_ptr*)&kernel_complex_rom_data, NULL
static mrb_mt_entry kernel_complex_rom_entries[] = {
MRB_MT_ENTRY(complex_s_rect, MRB_SYM(Complex), MRB_MT_FUNC|MRB_MT_PRIVATE),
};
static mrb_mt_tbl kernel_complex_rom_mt = MRB_MT_ROM_TAB(kernel_complex_rom_entries);
void mrb_mruby_complex_gem_init(mrb_state *mrb)
{
mrbgems/mruby-hash-ext/src/hash_ext.c
+8 -25
View File
@@ -367,32 +367,15 @@ hash_merge(mrb_state *mrb, mrb_value hash)
return hash;
}
#define HASH_EXT_ROM_MT_SIZE 6
static struct {
union mrb_mt_ptr vals[HASH_EXT_ROM_MT_SIZE];
mrb_sym keys[HASH_EXT_ROM_MT_SIZE];
} hash_ext_rom_data = {
.vals = {
{ .func = hash_values_at },
{ .func = hash_slice },
{ .func = hash_slice_bang },
{ .func = hash_except },
{ .func = hash_key },
{ .func = hash_merge },
},
.keys = {
MRB_MT_KEY(MRB_SYM(values_at), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(slice), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_B(slice), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(except), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(key), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(__merge), MRB_MT_FUNC|MRB_MT_PUBLIC),
}
};
static mrb_mt_tbl hash_ext_rom_mt = {
HASH_EXT_ROM_MT_SIZE, HASH_EXT_ROM_MT_SIZE,
(union mrb_mt_ptr*)&hash_ext_rom_data, NULL
static mrb_mt_entry hash_ext_rom_entries[] = {
MRB_MT_ENTRY(hash_values_at, MRB_SYM(values_at), MRB_MT_FUNC),
MRB_MT_ENTRY(hash_slice, MRB_SYM(slice), MRB_MT_FUNC),
MRB_MT_ENTRY(hash_slice_bang, MRB_SYM_B(slice), MRB_MT_FUNC),
MRB_MT_ENTRY(hash_except, MRB_SYM(except), MRB_MT_FUNC),
MRB_MT_ENTRY(hash_key, MRB_SYM(key), MRB_MT_FUNC),
MRB_MT_ENTRY(hash_merge, MRB_SYM(__merge), MRB_MT_FUNC),
};
static mrb_mt_tbl hash_ext_rom_mt = MRB_MT_ROM_TAB(hash_ext_rom_entries);
void
mrb_mruby_hash_ext_gem_init(mrb_state *mrb)
mrbgems/mruby-io/src/file.c
+8 -25
View File
@@ -1122,32 +1122,15 @@ mrb_file_join(mrb_state *mrb, mrb_value klass)
}
/* ---------------------------*/
#define FILE_ROM_MT_SIZE 6
static struct {
union mrb_mt_ptr vals[FILE_ROM_MT_SIZE];
mrb_sym keys[FILE_ROM_MT_SIZE];
} file_rom_data = {
.vals = {
{ .func = mrb_file_flock },
{ .func = mrb_file_atime },
{ .func = mrb_file_ctime },
{ .func = mrb_file_mtime },
{ .func = mrb_file_size },
{ .func = mrb_file_truncate },
},
.keys = {
MRB_MT_KEY(MRB_SYM(flock), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(_atime), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(_ctime), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(_mtime), 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(truncate), MRB_MT_FUNC|MRB_MT_PUBLIC),
}
};
static mrb_mt_tbl file_rom_mt = {
FILE_ROM_MT_SIZE, FILE_ROM_MT_SIZE,
(union mrb_mt_ptr*)&file_rom_data, NULL
static mrb_mt_entry file_rom_entries[] = {
MRB_MT_ENTRY(mrb_file_flock, MRB_SYM(flock), MRB_MT_FUNC),
MRB_MT_ENTRY(mrb_file_atime, MRB_SYM(_atime), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(mrb_file_ctime, MRB_SYM(_ctime), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(mrb_file_mtime, MRB_SYM(_mtime), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(mrb_file_size, MRB_SYM(size), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(mrb_file_truncate, MRB_SYM(truncate), MRB_MT_FUNC),
};
static mrb_mt_tbl file_rom_mt = MRB_MT_ROM_TAB(file_rom_entries);
void
mrb_init_file(mrb_state *mrb)
mrbgems/mruby-io/src/io.c
+38 -85
View File
@@ -2197,92 +2197,45 @@ io_flush(mrb_state *mrb, mrb_value io)
}
/* ---------------------------*/
#define IO_ROM_MT_SIZE 36
static struct {
union mrb_mt_ptr vals[IO_ROM_MT_SIZE];
mrb_sym keys[IO_ROM_MT_SIZE];
} io_rom_data = {
.vals = {
{ .func = io_init },
{ .func = io_init_copy },
{ .func = io_isatty },
{ .func = io_eof },
{ .func = io_getc },
{ .func = io_gets },
{ .func = io_read },
{ .func = io_readchar },
{ .func = io_readline },
{ .func = io_readlines },
{ .func = io_sync },
{ .func = io_set_sync },
{ .func = io_sysread },
{ .func = io_sysseek },
{ .func = io_syswrite },
{ .func = io_seek },
{ .func = io_close },
{ .func = io_close_write },
{ .func = io_set_close_on_exec },
{ .func = io_close_on_exec_p },
{ .func = io_closed },
{ .func = io_flush },
{ .func = io_ungetc },
{ .func = io_ungetbyte },
{ .func = io_pos },
{ .func = io_pid },
{ .func = io_fileno },
{ .func = io_write },
{ .func = io_puts },
{ .func = io_print },
{ .func = io_putc },
{ .func = io_lshift },
{ .func = io_pread },
{ .func = io_pwrite },
{ .func = io_getbyte },
{ .func = io_readbyte },
},
.keys = {
MRB_MT_KEY(MRB_SYM(initialize), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(initialize_copy), MRB_MT_FUNC|MRB_MT_PRIVATE),
MRB_MT_KEY(MRB_SYM(isatty), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_Q(eof), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(getc), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(gets), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(read), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(readchar), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(readline), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(readlines), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(sync), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_E(sync), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(sysread), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(sysseek), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(syswrite), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(seek), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(close), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(close_write), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_E(close_on_exec), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_Q(close_on_exec), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_Q(closed), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(flush), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(ungetc), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(ungetbyte), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(pos), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(pid), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(fileno), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(write), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(puts), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(print), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(putc), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(lshift), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(pread), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(pwrite), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(getbyte), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(readbyte), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
}
};
static mrb_mt_tbl io_rom_mt = {
IO_ROM_MT_SIZE, IO_ROM_MT_SIZE,
(union mrb_mt_ptr*)&io_rom_data, NULL
static mrb_mt_entry io_rom_entries[] = {
MRB_MT_ENTRY(io_init, MRB_SYM(initialize), MRB_MT_FUNC),
MRB_MT_ENTRY(io_init_copy, MRB_SYM(initialize_copy), MRB_MT_FUNC|MRB_MT_PRIVATE),
MRB_MT_ENTRY(io_isatty, MRB_SYM(isatty), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(io_eof, MRB_SYM_Q(eof), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(io_getc, MRB_SYM(getc), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(io_gets, MRB_SYM(gets), MRB_MT_FUNC),
MRB_MT_ENTRY(io_read, MRB_SYM(read), MRB_MT_FUNC),
MRB_MT_ENTRY(io_readchar, MRB_SYM(readchar), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(io_readline, MRB_SYM(readline), MRB_MT_FUNC),
MRB_MT_ENTRY(io_readlines, MRB_SYM(readlines), MRB_MT_FUNC),
MRB_MT_ENTRY(io_sync, MRB_SYM(sync), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(io_set_sync, MRB_SYM_E(sync), MRB_MT_FUNC),
MRB_MT_ENTRY(io_sysread, MRB_SYM(sysread), MRB_MT_FUNC),
MRB_MT_ENTRY(io_sysseek, MRB_SYM(sysseek), MRB_MT_FUNC),
MRB_MT_ENTRY(io_syswrite, MRB_SYM(syswrite), MRB_MT_FUNC),
MRB_MT_ENTRY(io_seek, MRB_SYM(seek), MRB_MT_FUNC),
MRB_MT_ENTRY(io_close, MRB_SYM(close), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(io_close_write, MRB_SYM(close_write), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(io_set_close_on_exec, MRB_SYM_E(close_on_exec), MRB_MT_FUNC),
MRB_MT_ENTRY(io_close_on_exec_p, MRB_SYM_Q(close_on_exec), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(io_closed, MRB_SYM_Q(closed), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(io_flush, MRB_SYM(flush), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(io_ungetc, MRB_SYM(ungetc), MRB_MT_FUNC),
MRB_MT_ENTRY(io_ungetbyte, MRB_SYM(ungetbyte), MRB_MT_FUNC),
MRB_MT_ENTRY(io_pos, MRB_SYM(pos), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(io_pid, MRB_SYM(pid), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(io_fileno, MRB_SYM(fileno), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(io_write, MRB_SYM(write), MRB_MT_FUNC),
MRB_MT_ENTRY(io_puts, MRB_SYM(puts), MRB_MT_FUNC),
MRB_MT_ENTRY(io_print, MRB_SYM(print), MRB_MT_FUNC),
MRB_MT_ENTRY(io_putc, MRB_SYM(putc), MRB_MT_FUNC),
MRB_MT_ENTRY(io_lshift, MRB_OPSYM(lshift), MRB_MT_FUNC),
MRB_MT_ENTRY(io_pread, MRB_SYM(pread), MRB_MT_FUNC),
MRB_MT_ENTRY(io_pwrite, MRB_SYM(pwrite), MRB_MT_FUNC),
MRB_MT_ENTRY(io_getbyte, MRB_SYM(getbyte), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(io_readbyte, MRB_SYM(readbyte), MRB_MT_FUNC|MRB_MT_NOARG),
};
static mrb_mt_tbl io_rom_mt = MRB_MT_ROM_TAB(io_rom_entries);
void
mrb_init_io(mrb_state *mrb)
mrbgems/mruby-kernel-ext/src/kernel.c
+9 -27
View File
@@ -288,34 +288,16 @@ mrb_f_hash(mrb_state *mrb, mrb_value self)
return arg;
}
#define KERNEL_EXT_ROM_MT_SIZE 7
static struct {
union mrb_mt_ptr vals[KERNEL_EXT_ROM_MT_SIZE];
mrb_sym keys[KERNEL_EXT_ROM_MT_SIZE];
} kernel_ext_rom_data = {
.vals = {
{ .func = mrb_f_raise },
{ .func = mrb_f_caller },
{ .func = mrb_f_method },
{ .func = mrb_f_callee },
{ .func = mrb_f_integer },
{ .func = mrb_f_string },
{ .func = mrb_f_array },
},
.keys = {
MRB_MT_KEY(MRB_SYM(fail), MRB_MT_FUNC|MRB_MT_PRIVATE),
MRB_MT_KEY(MRB_SYM(caller), MRB_MT_FUNC|MRB_MT_PRIVATE),
MRB_MT_KEY(MRB_SYM(__method__), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PRIVATE),
MRB_MT_KEY(MRB_SYM(__callee__), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PRIVATE),
MRB_MT_KEY(MRB_SYM(Integer), MRB_MT_FUNC|MRB_MT_PRIVATE),
MRB_MT_KEY(MRB_SYM(String), MRB_MT_FUNC|MRB_MT_PRIVATE),
MRB_MT_KEY(MRB_SYM(Array), MRB_MT_FUNC|MRB_MT_PRIVATE),
}
};
static mrb_mt_tbl kernel_ext_rom_mt = {
KERNEL_EXT_ROM_MT_SIZE, KERNEL_EXT_ROM_MT_SIZE,
(union mrb_mt_ptr*)&kernel_ext_rom_data, NULL
static mrb_mt_entry kernel_ext_rom_entries[] = {
MRB_MT_ENTRY(mrb_f_raise, MRB_SYM(fail), MRB_MT_FUNC|MRB_MT_PRIVATE),
MRB_MT_ENTRY(mrb_f_caller, MRB_SYM(caller), MRB_MT_FUNC|MRB_MT_PRIVATE),
MRB_MT_ENTRY(mrb_f_method, MRB_SYM(__method__), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PRIVATE),
MRB_MT_ENTRY(mrb_f_callee, MRB_SYM(__callee__), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PRIVATE),
MRB_MT_ENTRY(mrb_f_integer, MRB_SYM(Integer), MRB_MT_FUNC|MRB_MT_PRIVATE),
MRB_MT_ENTRY(mrb_f_string, MRB_SYM(String), MRB_MT_FUNC|MRB_MT_PRIVATE),
MRB_MT_ENTRY(mrb_f_array, MRB_SYM(Array), MRB_MT_FUNC|MRB_MT_PRIVATE),
};
static mrb_mt_tbl kernel_ext_rom_mt = MRB_MT_ROM_TAB(kernel_ext_rom_entries);
void
mrb_mruby_kernel_ext_gem_init(mrb_state *mrb)
mrbgems/mruby-metaprog/src/metaprog.c
+33 -84
View File
@@ -690,93 +690,42 @@ mrb_mod_s_nesting(mrb_state *mrb, mrb_value mod)
}
/* ---------------------------*/
#define METAPROG_KRN_ROM_MT_SIZE 15
static struct {
union mrb_mt_ptr vals[METAPROG_KRN_ROM_MT_SIZE];
mrb_sym keys[METAPROG_KRN_ROM_MT_SIZE];
} metaprog_krn_rom_data = {
.vals = {
{ .func = mrb_f_global_variables },
{ .func = mrb_local_variables },
{ .func = mrb_singleton_class },
{ .func = mrb_obj_ivar_defined },
{ .func = mrb_obj_ivar_get },
{ .func = mrb_obj_ivar_set },
{ .func = mrb_obj_instance_variables },
{ .func = mrb_obj_methods_m },
{ .func = mrb_obj_private_methods },
{ .func = mrb_obj_protected_methods },
{ .func = mrb_obj_public_methods },
{ .func = mrb_obj_singleton_methods_m },
{ .func = mod_define_singleton_method },
{ .func = mrb_f_send },
{ .func = mrb_f_public_send },
},
.keys = {
MRB_MT_KEY(MRB_SYM(global_variables), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PRIVATE),
MRB_MT_KEY(MRB_SYM(local_variables), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PRIVATE),
MRB_MT_KEY(MRB_SYM(singleton_class), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_Q(instance_variable_defined), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(instance_variable_get), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(instance_variable_set), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(instance_variables), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(methods), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(private_methods), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(protected_methods), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(public_methods), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(singleton_methods), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(define_singleton_method), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(send), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(public_send), MRB_MT_FUNC|MRB_MT_PUBLIC),
}
};
static mrb_mt_tbl metaprog_krn_rom_mt = {
METAPROG_KRN_ROM_MT_SIZE, METAPROG_KRN_ROM_MT_SIZE,
(union mrb_mt_ptr*)&metaprog_krn_rom_data, NULL
static mrb_mt_entry metaprog_krn_rom_entries[] = {
MRB_MT_ENTRY(mrb_f_global_variables, MRB_SYM(global_variables), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PRIVATE),
MRB_MT_ENTRY(mrb_local_variables, MRB_SYM(local_variables), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PRIVATE),
MRB_MT_ENTRY(mrb_singleton_class, MRB_SYM(singleton_class), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(mrb_obj_ivar_defined, MRB_SYM_Q(instance_variable_defined), MRB_MT_FUNC),
MRB_MT_ENTRY(mrb_obj_ivar_get, MRB_SYM(instance_variable_get), MRB_MT_FUNC),
MRB_MT_ENTRY(mrb_obj_ivar_set, MRB_SYM(instance_variable_set), MRB_MT_FUNC),
MRB_MT_ENTRY(mrb_obj_instance_variables, MRB_SYM(instance_variables), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(mrb_obj_methods_m, MRB_SYM(methods), MRB_MT_FUNC),
MRB_MT_ENTRY(mrb_obj_private_methods, MRB_SYM(private_methods), MRB_MT_FUNC),
MRB_MT_ENTRY(mrb_obj_protected_methods, MRB_SYM(protected_methods), MRB_MT_FUNC),
MRB_MT_ENTRY(mrb_obj_public_methods, MRB_SYM(public_methods), MRB_MT_FUNC),
MRB_MT_ENTRY(mrb_obj_singleton_methods_m, MRB_SYM(singleton_methods), MRB_MT_FUNC),
MRB_MT_ENTRY(mod_define_singleton_method, MRB_SYM(define_singleton_method), MRB_MT_FUNC),
MRB_MT_ENTRY(mrb_f_send, MRB_SYM(send), MRB_MT_FUNC),
MRB_MT_ENTRY(mrb_f_public_send, MRB_SYM(public_send), MRB_MT_FUNC),
};
static mrb_mt_tbl metaprog_krn_rom_mt = MRB_MT_ROM_TAB(metaprog_krn_rom_entries);
#define METAPROG_MOD_ROM_MT_SIZE 14
static struct {
union mrb_mt_ptr vals[METAPROG_MOD_ROM_MT_SIZE];
mrb_sym keys[METAPROG_MOD_ROM_MT_SIZE];
} metaprog_mod_rom_data = {
.vals = {
{ .func = mrb_mod_class_variables },
{ .func = mrb_mod_remove_cvar },
{ .func = mrb_mod_cvar_defined },
{ .func = mrb_mod_cvar_get },
{ .func = mrb_mod_cvar_set },
{ .func = mrb_mod_included_modules },
{ .func = mrb_mod_instance_methods },
{ .func = mrb_mod_public_instance_methods },
{ .func = mrb_mod_private_instance_methods },
{ .func = mrb_mod_protected_instance_methods },
{ .func = mrb_mod_undefined_methods },
{ .func = mrb_mod_remove_method },
{ .func = mrb_f_nil },
{ .func = mrb_mod_constants },
},
.keys = {
MRB_MT_KEY(MRB_SYM(class_variables), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(remove_class_variable), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_Q(class_variable_defined), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(class_variable_get), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(class_variable_set), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(included_modules), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(instance_methods), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(public_instance_methods), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(private_instance_methods), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(protected_instance_methods), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(undefined_instance_methods), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(remove_method), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(method_removed), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(constants), MRB_MT_FUNC|MRB_MT_PUBLIC),
}
};
static mrb_mt_tbl metaprog_mod_rom_mt = {
METAPROG_MOD_ROM_MT_SIZE, METAPROG_MOD_ROM_MT_SIZE,
(union mrb_mt_ptr*)&metaprog_mod_rom_data, NULL
static mrb_mt_entry metaprog_mod_rom_entries[] = {
MRB_MT_ENTRY(mrb_mod_class_variables, MRB_SYM(class_variables), MRB_MT_FUNC),
MRB_MT_ENTRY(mrb_mod_remove_cvar, MRB_SYM(remove_class_variable), MRB_MT_FUNC),
MRB_MT_ENTRY(mrb_mod_cvar_defined, MRB_SYM_Q(class_variable_defined), MRB_MT_FUNC),
MRB_MT_ENTRY(mrb_mod_cvar_get, MRB_SYM(class_variable_get), MRB_MT_FUNC),
MRB_MT_ENTRY(mrb_mod_cvar_set, MRB_SYM(class_variable_set), MRB_MT_FUNC),
MRB_MT_ENTRY(mrb_mod_included_modules, MRB_SYM(included_modules), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(mrb_mod_instance_methods, MRB_SYM(instance_methods), MRB_MT_FUNC),
MRB_MT_ENTRY(mrb_mod_public_instance_methods, MRB_SYM(public_instance_methods), MRB_MT_FUNC),
MRB_MT_ENTRY(mrb_mod_private_instance_methods, MRB_SYM(private_instance_methods), MRB_MT_FUNC),
MRB_MT_ENTRY(mrb_mod_protected_instance_methods, MRB_SYM(protected_instance_methods), MRB_MT_FUNC),
MRB_MT_ENTRY(mrb_mod_undefined_methods, MRB_SYM(undefined_instance_methods), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(mrb_mod_remove_method, MRB_SYM(remove_method), MRB_MT_FUNC),
MRB_MT_ENTRY(mrb_f_nil, MRB_SYM(method_removed), MRB_MT_FUNC),
MRB_MT_ENTRY(mrb_mod_constants, MRB_SYM(constants), MRB_MT_FUNC),
};
static mrb_mt_tbl metaprog_mod_rom_mt = MRB_MT_ROM_TAB(metaprog_mod_rom_entries);
void
mrb_mruby_metaprog_gem_init(mrb_state* mrb)
mrbgems/mruby-method/src/method.c
+37 -110
View File
@@ -832,123 +832,50 @@ method_name(mrb_state *mrb, mrb_value self)
}
/* ---------------------------*/
#define METHOD_UBM_ROM_MT_SIZE 12
static struct {
union mrb_mt_ptr vals[METHOD_UBM_ROM_MT_SIZE];
mrb_sym keys[METHOD_UBM_ROM_MT_SIZE];
} method_ubm_rom_data = {
.vals = {
{ .func = unbound_method_bind },
{ .func = method_super_method },
{ .func = method_eql },
{ .func = method_eql },
{ .func = method_to_s },
{ .func = method_to_s },
{ .func = method_arity },
{ .func = method_source_location },
{ .func = method_parameters },
{ .func = method_bcall },
{ .func = method_owner },
{ .func = method_name },
},
.keys = {
MRB_MT_KEY(MRB_SYM(bind), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(super_method), 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(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(arity), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(source_location), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(parameters), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(bind_call), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(owner), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(name), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
}
};
static mrb_mt_tbl method_ubm_rom_mt = {
METHOD_UBM_ROM_MT_SIZE, METHOD_UBM_ROM_MT_SIZE,
(union mrb_mt_ptr*)&method_ubm_rom_data, NULL
static mrb_mt_entry method_ubm_rom_entries[] = {
MRB_MT_ENTRY(unbound_method_bind, MRB_SYM(bind), MRB_MT_FUNC),
MRB_MT_ENTRY(method_super_method, MRB_SYM(super_method), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(method_eql, MRB_OPSYM(eq), MRB_MT_FUNC),
MRB_MT_ENTRY(method_eql, MRB_SYM_Q(eql), MRB_MT_FUNC),
MRB_MT_ENTRY(method_to_s, MRB_SYM(to_s), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(method_to_s, MRB_SYM(inspect), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(method_arity, MRB_SYM(arity), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(method_source_location, MRB_SYM(source_location), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(method_parameters, MRB_SYM(parameters), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(method_bcall, MRB_SYM(bind_call), MRB_MT_FUNC),
MRB_MT_ENTRY(method_owner, MRB_SYM(owner), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(method_name, MRB_SYM(name), MRB_MT_FUNC|MRB_MT_NOARG),
};
static mrb_mt_tbl method_ubm_rom_mt = MRB_MT_ROM_TAB(method_ubm_rom_entries);
#define METHOD_MTD_ROM_MT_SIZE 14
static struct {
union mrb_mt_ptr vals[METHOD_MTD_ROM_MT_SIZE];
mrb_sym keys[METHOD_MTD_ROM_MT_SIZE];
} method_mtd_rom_data = {
.vals = {
{ .func = method_eql },
{ .func = method_eql },
{ .func = method_to_s },
{ .func = method_to_s },
{ .func = method_call },
{ .func = method_call },
{ .func = method_unbind },
{ .func = method_super_method },
{ .func = method_arity },
{ .func = method_source_location },
{ .func = method_parameters },
{ .func = method_owner },
{ .func = method_receiver },
{ .func = method_name },
},
.keys = {
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(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(call), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(aref), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(unbind), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(super_method), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(arity), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(source_location), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(parameters), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(owner), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(receiver), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(name), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
}
};
static mrb_mt_tbl method_mtd_rom_mt = {
METHOD_MTD_ROM_MT_SIZE, METHOD_MTD_ROM_MT_SIZE,
(union mrb_mt_ptr*)&method_mtd_rom_data, NULL
static mrb_mt_entry method_mtd_rom_entries[] = {
MRB_MT_ENTRY(method_eql, MRB_OPSYM(eq), MRB_MT_FUNC),
MRB_MT_ENTRY(method_eql, MRB_SYM_Q(eql), MRB_MT_FUNC),
MRB_MT_ENTRY(method_to_s, MRB_SYM(to_s), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(method_to_s, MRB_SYM(inspect), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(method_call, MRB_SYM(call), MRB_MT_FUNC),
MRB_MT_ENTRY(method_call, MRB_OPSYM(aref), MRB_MT_FUNC),
MRB_MT_ENTRY(method_unbind, MRB_SYM(unbind), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(method_super_method, MRB_SYM(super_method), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(method_arity, MRB_SYM(arity), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(method_source_location, MRB_SYM(source_location), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(method_parameters, MRB_SYM(parameters), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(method_owner, MRB_SYM(owner), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(method_receiver, MRB_SYM(receiver), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(method_name, MRB_SYM(name), MRB_MT_FUNC|MRB_MT_NOARG),
};
static mrb_mt_tbl method_mtd_rom_mt = MRB_MT_ROM_TAB(method_mtd_rom_entries);
#define METHOD_KRN_ROM_MT_SIZE 2
static struct {
union mrb_mt_ptr vals[METHOD_KRN_ROM_MT_SIZE];
mrb_sym keys[METHOD_KRN_ROM_MT_SIZE];
} method_krn_rom_data = {
.vals = {
{ .func = mrb_kernel_method },
{ .func = mrb_kernel_singleton_method },
},
.keys = {
MRB_MT_KEY(MRB_SYM(method), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(singleton_method), MRB_MT_FUNC|MRB_MT_PUBLIC),
}
};
static mrb_mt_tbl method_krn_rom_mt = {
METHOD_KRN_ROM_MT_SIZE, METHOD_KRN_ROM_MT_SIZE,
(union mrb_mt_ptr*)&method_krn_rom_data, NULL
static mrb_mt_entry method_krn_rom_entries[] = {
MRB_MT_ENTRY(mrb_kernel_method, MRB_SYM(method), MRB_MT_FUNC),
MRB_MT_ENTRY(mrb_kernel_singleton_method, MRB_SYM(singleton_method), MRB_MT_FUNC),
};
static mrb_mt_tbl method_krn_rom_mt = MRB_MT_ROM_TAB(method_krn_rom_entries);
#define METHOD_MOD_ROM_MT_SIZE 1
static struct {
union mrb_mt_ptr vals[METHOD_MOD_ROM_MT_SIZE];
mrb_sym keys[METHOD_MOD_ROM_MT_SIZE];
} method_mod_rom_data = {
.vals = {
{ .func = mrb_module_instance_method },
},
.keys = {
MRB_MT_KEY(MRB_SYM(instance_method), MRB_MT_FUNC|MRB_MT_PUBLIC),
}
};
static mrb_mt_tbl method_mod_rom_mt = {
METHOD_MOD_ROM_MT_SIZE, METHOD_MOD_ROM_MT_SIZE,
(union mrb_mt_ptr*)&method_mod_rom_data, NULL
static mrb_mt_entry method_mod_rom_entries[] = {
MRB_MT_ENTRY(mrb_module_instance_method, MRB_SYM(instance_method), MRB_MT_FUNC),
};
static mrb_mt_tbl method_mod_rom_mt = MRB_MT_ROM_TAB(method_mod_rom_entries);
void
mrb_mruby_method_gem_init(mrb_state* mrb)
mrbgems/mruby-numeric-ext/src/numeric_ext.c
+11 -31
View File
@@ -480,38 +480,18 @@ int_sqrt(mrb_state *mrb, mrb_value self)
}
}
#define INTEGER_EXT_ROM_MT_SIZE 9
static struct {
union mrb_mt_ptr vals[INTEGER_EXT_ROM_MT_SIZE];
mrb_sym keys[INTEGER_EXT_ROM_MT_SIZE];
} integer_ext_rom_data = {
.vals = {
{ .func = int_remainder },
{ .func = int_powm },
{ .func = int_digits },
{ .func = int_size },
{ .func = int_bit_length },
{ .func = int_odd },
{ .func = int_even },
{ .func = int_gcd },
{ .func = int_lcm },
},
.keys = {
MRB_MT_KEY(MRB_SYM(remainder), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(pow), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(digits), 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(bit_length), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_Q(odd), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_Q(even), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(gcd), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(lcm), MRB_MT_FUNC|MRB_MT_PUBLIC),
}
};
static mrb_mt_tbl integer_ext_rom_mt = {
INTEGER_EXT_ROM_MT_SIZE, INTEGER_EXT_ROM_MT_SIZE,
(union mrb_mt_ptr*)&integer_ext_rom_data, NULL
static mrb_mt_entry integer_ext_rom_entries[] = {
MRB_MT_ENTRY(int_remainder, MRB_SYM(remainder), MRB_MT_FUNC),
MRB_MT_ENTRY(int_powm, MRB_SYM(pow), MRB_MT_FUNC),
MRB_MT_ENTRY(int_digits, MRB_SYM(digits), MRB_MT_FUNC),
MRB_MT_ENTRY(int_size, MRB_SYM(size), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(int_bit_length, MRB_SYM(bit_length), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(int_odd, MRB_SYM_Q(odd), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(int_even, MRB_SYM_Q(even), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(int_gcd, MRB_SYM(gcd), MRB_MT_FUNC),
MRB_MT_ENTRY(int_lcm, MRB_SYM(lcm), MRB_MT_FUNC),
};
static mrb_mt_tbl integer_ext_rom_mt = MRB_MT_ROM_TAB(integer_ext_rom_entries);
void
mrb_mruby_numeric_ext_gem_init(mrb_state* mrb)
mrbgems/mruby-object-ext/src/object.c
+11 -49
View File
@@ -97,60 +97,22 @@ obj_instance_exec(mrb_state *mrb, mrb_value self)
return mrb_object_exec(mrb, self, mrb_singleton_class_ptr(mrb, self));
}
#define NIL_EXT_ROM_MT_SIZE 3
static struct {
union mrb_mt_ptr vals[NIL_EXT_ROM_MT_SIZE];
mrb_sym keys[NIL_EXT_ROM_MT_SIZE];
} nil_ext_rom_data = {
.vals = {
{ .func = nil_to_a },
{ .func = nil_to_h },
{ .func = nil_to_i },
},
.keys = {
MRB_MT_KEY(MRB_SYM(to_a), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(to_h), 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),
}
};
static mrb_mt_tbl nil_ext_rom_mt = {
NIL_EXT_ROM_MT_SIZE, NIL_EXT_ROM_MT_SIZE,
(union mrb_mt_ptr*)&nil_ext_rom_data, NULL
static mrb_mt_entry nil_ext_rom_entries[] = {
MRB_MT_ENTRY(nil_to_a, MRB_SYM(to_a), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(nil_to_h, MRB_SYM(to_h), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(nil_to_i, MRB_SYM(to_i), MRB_MT_FUNC|MRB_MT_NOARG),
};
static mrb_mt_tbl nil_ext_rom_mt = MRB_MT_ROM_TAB(nil_ext_rom_entries);
#define KERNEL_EXT_ROM_MT_SIZE 1
static struct {
union mrb_mt_ptr vals[KERNEL_EXT_ROM_MT_SIZE];
mrb_sym keys[KERNEL_EXT_ROM_MT_SIZE];
} kernel_ext_rom_data = {
.vals = {
{ .func = mrb_obj_itself },
},
.keys = {
MRB_MT_KEY(MRB_SYM(itself), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
}
};
static mrb_mt_tbl kernel_ext_rom_mt = {
KERNEL_EXT_ROM_MT_SIZE, KERNEL_EXT_ROM_MT_SIZE,
(union mrb_mt_ptr*)&kernel_ext_rom_data, NULL
static mrb_mt_entry kernel_ext_rom_entries[] = {
MRB_MT_ENTRY(mrb_obj_itself, MRB_SYM(itself), MRB_MT_FUNC|MRB_MT_NOARG),
};
static mrb_mt_tbl kernel_ext_rom_mt = MRB_MT_ROM_TAB(kernel_ext_rom_entries);
#define BOB_EXT_ROM_MT_SIZE 1
static struct {
union mrb_mt_ptr vals[BOB_EXT_ROM_MT_SIZE];
mrb_sym keys[BOB_EXT_ROM_MT_SIZE];
} bob_ext_rom_data = {
.vals = {
{ .func = obj_instance_exec },
},
.keys = {
MRB_MT_KEY(MRB_SYM(instance_exec), MRB_MT_FUNC|MRB_MT_PUBLIC),
}
};
static mrb_mt_tbl bob_ext_rom_mt = {
BOB_EXT_ROM_MT_SIZE, BOB_EXT_ROM_MT_SIZE,
(union mrb_mt_ptr*)&bob_ext_rom_data, NULL
static mrb_mt_entry bob_ext_rom_entries[] = {
MRB_MT_ENTRY(obj_instance_exec, MRB_SYM(instance_exec), MRB_MT_FUNC),
};
static mrb_mt_tbl bob_ext_rom_mt = MRB_MT_ROM_TAB(bob_ext_rom_entries);
void
mrb_mruby_object_ext_gem_init(mrb_state* mrb)
mrbgems/mruby-proc-ext/src/proc.c
+10 -38
View File
@@ -244,47 +244,19 @@ mrb_proc_parameters(mrb_state *mrb, mrb_value self)
}
/* ---------------------------*/
#define PROC_EXT_ROM_MT_SIZE 5
static struct {
union mrb_mt_ptr vals[PROC_EXT_ROM_MT_SIZE];
mrb_sym keys[PROC_EXT_ROM_MT_SIZE];
} proc_ext_rom_data = {
.vals = {
{ .func = proc_inspect },
{ .func = proc_lambda_p },
{ .func = mrb_proc_parameters },
{ .func = proc_source_location },
{ .func = proc_inspect },
},
.keys = {
MRB_MT_KEY(MRB_SYM(inspect), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_Q(lambda), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(parameters), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(source_location), 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),
}
};
static mrb_mt_tbl proc_ext_rom_mt = {
PROC_EXT_ROM_MT_SIZE, PROC_EXT_ROM_MT_SIZE,
(union mrb_mt_ptr*)&proc_ext_rom_data, NULL
static mrb_mt_entry proc_ext_rom_entries[] = {
MRB_MT_ENTRY(proc_inspect, MRB_SYM(inspect), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(proc_lambda_p, MRB_SYM_Q(lambda), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(mrb_proc_parameters, MRB_SYM(parameters), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(proc_source_location, MRB_SYM(source_location), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(proc_inspect, MRB_SYM(to_s), MRB_MT_FUNC|MRB_MT_NOARG),
};
static mrb_mt_tbl proc_ext_rom_mt = MRB_MT_ROM_TAB(proc_ext_rom_entries);
#define KERNEL_EXT_ROM_MT_SIZE 1
static struct {
union mrb_mt_ptr vals[KERNEL_EXT_ROM_MT_SIZE];
mrb_sym keys[KERNEL_EXT_ROM_MT_SIZE];
} kernel_ext_rom_data = {
.vals = {
{ .func = kernel_proc },
},
.keys = {
MRB_MT_KEY(MRB_SYM(proc), MRB_MT_FUNC|MRB_MT_PRIVATE),
}
};
static mrb_mt_tbl kernel_ext_rom_mt = {
KERNEL_EXT_ROM_MT_SIZE, KERNEL_EXT_ROM_MT_SIZE,
(union mrb_mt_ptr*)&kernel_ext_rom_data, NULL
static mrb_mt_entry kernel_ext_rom_entries[] = {
MRB_MT_ENTRY(kernel_proc, MRB_SYM(proc), MRB_MT_FUNC|MRB_MT_PRIVATE),
};
static mrb_mt_tbl kernel_ext_rom_mt = MRB_MT_ROM_TAB(kernel_ext_rom_entries);
void
mrb_mruby_proc_ext_gem_init(mrb_state* mrb)
mrbgems/mruby-random/src/random.c
+15 -57
View File
@@ -568,68 +568,26 @@ random_f_bytes(mrb_state *mrb, mrb_value self)
}
#define KERNEL_RAND_ROM_MT_SIZE 2
static struct {
union mrb_mt_ptr vals[KERNEL_RAND_ROM_MT_SIZE];
mrb_sym keys[KERNEL_RAND_ROM_MT_SIZE];
} kernel_rand_rom_data = {
.vals = {
{ .func = random_f_rand },
{ .func = random_f_srand },
},
.keys = {
MRB_MT_KEY(MRB_SYM(rand), MRB_MT_FUNC|MRB_MT_PRIVATE),
MRB_MT_KEY(MRB_SYM(srand), MRB_MT_FUNC|MRB_MT_PRIVATE),
}
};
static mrb_mt_tbl kernel_rand_rom_mt = {
KERNEL_RAND_ROM_MT_SIZE, KERNEL_RAND_ROM_MT_SIZE,
(union mrb_mt_ptr*)&kernel_rand_rom_data, NULL
static mrb_mt_entry kernel_rand_rom_entries[] = {
MRB_MT_ENTRY(random_f_rand, MRB_SYM(rand), MRB_MT_FUNC|MRB_MT_PRIVATE),
MRB_MT_ENTRY(random_f_srand, MRB_SYM(srand), MRB_MT_FUNC|MRB_MT_PRIVATE),
};
static mrb_mt_tbl kernel_rand_rom_mt = MRB_MT_ROM_TAB(kernel_rand_rom_entries);
#define RANDOM_ROM_MT_SIZE 4
static struct {
union mrb_mt_ptr vals[RANDOM_ROM_MT_SIZE];
mrb_sym keys[RANDOM_ROM_MT_SIZE];
} random_rom_data = {
.vals = {
{ .func = random_m_init },
{ .func = random_m_rand },
{ .func = random_m_srand },
{ .func = random_m_bytes },
},
.keys = {
MRB_MT_KEY(MRB_SYM(initialize), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(rand), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(srand), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(bytes), MRB_MT_FUNC|MRB_MT_PUBLIC),
}
};
static mrb_mt_tbl random_rom_mt = {
RANDOM_ROM_MT_SIZE, RANDOM_ROM_MT_SIZE,
(union mrb_mt_ptr*)&random_rom_data, NULL
static mrb_mt_entry random_rom_entries[] = {
MRB_MT_ENTRY(random_m_init, MRB_SYM(initialize), MRB_MT_FUNC),
MRB_MT_ENTRY(random_m_rand, MRB_SYM(rand), MRB_MT_FUNC),
MRB_MT_ENTRY(random_m_srand, MRB_SYM(srand), MRB_MT_FUNC),
MRB_MT_ENTRY(random_m_bytes, MRB_SYM(bytes), MRB_MT_FUNC),
};
static mrb_mt_tbl random_rom_mt = MRB_MT_ROM_TAB(random_rom_entries);
#define ARRAY_RAND_ROM_MT_SIZE 3
static struct {
union mrb_mt_ptr vals[ARRAY_RAND_ROM_MT_SIZE];
mrb_sym keys[ARRAY_RAND_ROM_MT_SIZE];
} array_rand_rom_data = {
.vals = {
{ .func = mrb_ary_shuffle },
{ .func = mrb_ary_shuffle_bang },
{ .func = mrb_ary_sample },
},
.keys = {
MRB_MT_KEY(MRB_SYM(shuffle), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_B(shuffle), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(sample), MRB_MT_FUNC|MRB_MT_PUBLIC),
}
};
static mrb_mt_tbl array_rand_rom_mt = {
ARRAY_RAND_ROM_MT_SIZE, ARRAY_RAND_ROM_MT_SIZE,
(union mrb_mt_ptr*)&array_rand_rom_data, NULL
static mrb_mt_entry array_rand_rom_entries[] = {
MRB_MT_ENTRY(mrb_ary_shuffle, MRB_SYM(shuffle), MRB_MT_FUNC),
MRB_MT_ENTRY(mrb_ary_shuffle_bang, MRB_SYM_B(shuffle), MRB_MT_FUNC),
MRB_MT_ENTRY(mrb_ary_sample, MRB_SYM(sample), MRB_MT_FUNC),
};
static mrb_mt_tbl array_rand_rom_mt = MRB_MT_ROM_TAB(array_rand_rom_entries);
void mrb_mruby_random_gem_init(mrb_state *mrb)
{
mrbgems/mruby-range-ext/src/range.c
+5 -19
View File
@@ -216,26 +216,12 @@ range_empty_p(mrb_state *mrb, mrb_value range)
return mrb_bool_value(comp == -2 || comp > 0 || (comp == 0 && excl));
}
#define RANGE_EXT_ROM_MT_SIZE 3
static struct {
union mrb_mt_ptr vals[RANGE_EXT_ROM_MT_SIZE];
mrb_sym keys[RANGE_EXT_ROM_MT_SIZE];
} range_ext_rom_data = {
.vals = {
{ .func = range_cover },
{ .func = range_size },
{ .func = range_empty_p },
},
.keys = {
MRB_MT_KEY(MRB_SYM_Q(cover), 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_Q(__empty_range), MRB_MT_FUNC|MRB_MT_PUBLIC),
}
};
static mrb_mt_tbl range_ext_rom_mt = {
RANGE_EXT_ROM_MT_SIZE, RANGE_EXT_ROM_MT_SIZE,
(union mrb_mt_ptr*)&range_ext_rom_data, NULL
static mrb_mt_entry range_ext_rom_entries[] = {
MRB_MT_ENTRY(range_cover, MRB_SYM_Q(cover), MRB_MT_FUNC),
MRB_MT_ENTRY(range_size, MRB_SYM(size), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(range_empty_p, MRB_SYM_Q(__empty_range), MRB_MT_FUNC),
};
static mrb_mt_tbl range_ext_rom_mt = MRB_MT_ROM_TAB(range_ext_rom_entries);
void
mrb_mruby_range_ext_gem_init(mrb_state* mrb)
mrbgems/mruby-rational/src/rational.c
+25 -86
View File
@@ -1228,99 +1228,38 @@ rational_hash(mrb_state *mrb, mrb_value rat)
}
/* ---------------------------*/
#define RATIONAL_ROM_MT_SIZE 14
static struct {
union mrb_mt_ptr vals[RATIONAL_ROM_MT_SIZE];
mrb_sym keys[RATIONAL_ROM_MT_SIZE];
} rational_rom_data = {
.vals = {
{ .func = rational_numerator },
{ .func = rational_denominator },
{ .func = mrb_rational_to_i },
{ .func = mrb_obj_itself },
{ .func = rational_negative_p },
{ .func = rational_eq },
{ .func = rational_minus },
{ .func = rational_add },
{ .func = rational_sub },
{ .func = rational_mul },
{ .func = rational_div },
{ .func = rational_div },
{ .func = rational_pow },
{ .func = rational_hash },
},
.keys = {
MRB_MT_KEY(MRB_SYM(numerator), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(denominator), 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(to_r), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_Q(negative), 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(minus), 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(div), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(quo), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(pow), 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 rational_rom_mt = {
RATIONAL_ROM_MT_SIZE, RATIONAL_ROM_MT_SIZE,
(union mrb_mt_ptr*)&rational_rom_data, NULL
static mrb_mt_entry rational_rom_entries[] = {
MRB_MT_ENTRY(rational_numerator, MRB_SYM(numerator), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(rational_denominator, MRB_SYM(denominator), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(mrb_rational_to_i, MRB_SYM(to_i), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(mrb_obj_itself, MRB_SYM(to_r), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(rational_negative_p, MRB_SYM_Q(negative), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(rational_eq, MRB_OPSYM(eq), MRB_MT_FUNC),
MRB_MT_ENTRY(rational_minus, MRB_OPSYM(minus), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(rational_add, MRB_OPSYM(add), MRB_MT_FUNC),
MRB_MT_ENTRY(rational_sub, MRB_OPSYM(sub), MRB_MT_FUNC),
MRB_MT_ENTRY(rational_mul, MRB_OPSYM(mul), MRB_MT_FUNC),
MRB_MT_ENTRY(rational_div, MRB_OPSYM(div), MRB_MT_FUNC),
MRB_MT_ENTRY(rational_div, MRB_SYM(quo), MRB_MT_FUNC),
MRB_MT_ENTRY(rational_pow, MRB_OPSYM(pow), MRB_MT_FUNC),
MRB_MT_ENTRY(rational_hash, MRB_SYM(hash), MRB_MT_FUNC|MRB_MT_NOARG),
};
static mrb_mt_tbl rational_rom_mt = MRB_MT_ROM_TAB(rational_rom_entries);
#define INTEGER_TO_R_ROM_MT_SIZE 1
static struct {
union mrb_mt_ptr vals[INTEGER_TO_R_ROM_MT_SIZE];
mrb_sym keys[INTEGER_TO_R_ROM_MT_SIZE];
} integer_to_r_rom_data = {
.vals = {
{ .func = int_to_r },
},
.keys = {
MRB_MT_KEY(MRB_SYM(to_r), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
}
};
static mrb_mt_tbl integer_to_r_rom_mt = {
INTEGER_TO_R_ROM_MT_SIZE, INTEGER_TO_R_ROM_MT_SIZE,
(union mrb_mt_ptr*)&integer_to_r_rom_data, NULL
static mrb_mt_entry integer_to_r_rom_entries[] = {
MRB_MT_ENTRY(int_to_r, MRB_SYM(to_r), MRB_MT_FUNC|MRB_MT_NOARG),
};
static mrb_mt_tbl integer_to_r_rom_mt = MRB_MT_ROM_TAB(integer_to_r_rom_entries);
#define NIL_TO_R_ROM_MT_SIZE 1
static struct {
union mrb_mt_ptr vals[NIL_TO_R_ROM_MT_SIZE];
mrb_sym keys[NIL_TO_R_ROM_MT_SIZE];
} nil_to_r_rom_data = {
.vals = {
{ .func = nil_to_r },
},
.keys = {
MRB_MT_KEY(MRB_SYM(to_r), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
}
};
static mrb_mt_tbl nil_to_r_rom_mt = {
NIL_TO_R_ROM_MT_SIZE, NIL_TO_R_ROM_MT_SIZE,
(union mrb_mt_ptr*)&nil_to_r_rom_data, NULL
static mrb_mt_entry nil_to_r_rom_entries[] = {
MRB_MT_ENTRY(nil_to_r, MRB_SYM(to_r), MRB_MT_FUNC|MRB_MT_NOARG),
};
static mrb_mt_tbl nil_to_r_rom_mt = MRB_MT_ROM_TAB(nil_to_r_rom_entries);
#define KERNEL_RATIONAL_ROM_MT_SIZE 1
static struct {
union mrb_mt_ptr vals[KERNEL_RATIONAL_ROM_MT_SIZE];
mrb_sym keys[KERNEL_RATIONAL_ROM_MT_SIZE];
} kernel_rational_rom_data = {
.vals = {
{ .func = rational_m },
},
.keys = {
MRB_MT_KEY(MRB_SYM(Rational), MRB_MT_FUNC|MRB_MT_PRIVATE),
}
};
static mrb_mt_tbl kernel_rational_rom_mt = {
KERNEL_RATIONAL_ROM_MT_SIZE, KERNEL_RATIONAL_ROM_MT_SIZE,
(union mrb_mt_ptr*)&kernel_rational_rom_data, NULL
static mrb_mt_entry kernel_rational_rom_entries[] = {
MRB_MT_ENTRY(rational_m, MRB_SYM(Rational), MRB_MT_FUNC|MRB_MT_PRIVATE),
};
static mrb_mt_tbl kernel_rational_rom_mt = MRB_MT_ROM_TAB(kernel_rational_rom_entries);
void mrb_mruby_rational_gem_init(mrb_state *mrb)
{
mrbgems/mruby-set/src/set.c
+45 -99
View File
@@ -1464,106 +1464,52 @@ set_s_create(mrb_state *mrb, mrb_value klass)
return set;
}
#define SET_ROM_MT_SIZE 43
static struct {
union mrb_mt_ptr vals[SET_ROM_MT_SIZE];
mrb_sym keys[SET_ROM_MT_SIZE];
} set_rom_data = {
.vals = {
{ .func = set_size },
{ .func = set_size },
{ .func = set_empty_p },
{ .func = set_clear },
{ .func = set_to_a },
{ .func = set_include_p },
{ .func = set_include_p },
{ .func = set_include_p },
{ .func = set_add },
{ .func = set_add },
{ .func = set_add_p },
{ .func = set_delete },
{ .func = set_delete_p },
{ .func = set_init },
{ .func = set_core_merge },
{ .func = set_core_subtract },
{ .func = set_core_union },
{ .func = set_core_difference },
{ .func = set_core_intersection },
{ .func = set_core_xor },
{ .func = set_equal },
{ .func = set_hash_m },
{ .func = set_join },
{ .func = set_inspect },
{ .func = set_inspect },
{ .func = set_reset },
{ .func = set_add_all },
{ .func = set_delete_all },
{ .func = set_include_all_p },
{ .func = set_include_any_p },
{ .func = set_superset_p },
{ .func = set_superset_p },
{ .func = set_proper_superset_p },
{ .func = set_proper_superset_p },
{ .func = set_subset_p },
{ .func = set_subset_p },
{ .func = set_proper_subset_p },
{ .func = set_proper_subset_p },
{ .func = set_intersect_p },
{ .func = set_disjoint_p },
{ .func = set_cmp },
{ .func = set_flatten },
{ .func = set_flatten_bang },
},
.keys = {
MRB_MT_KEY(MRB_SYM(size), 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(empty), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(clear), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(to_a), 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_Q(member), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(eqq), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(add), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(lshift), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_Q(add), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(delete), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_Q(delete), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(__init), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(__merge), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(__subtract), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(__union), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(__difference), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(__intersection), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(__xor), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(eq), 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(join), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(inspect), 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(reset), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(add_all), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(delete_all), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_Q(include_all), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_Q(include_any), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_Q(superset), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(ge), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_Q(proper_superset), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(gt), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_Q(subset), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(le), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_Q(proper_subset), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(lt), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_Q(intersect), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_Q(disjoint), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(cmp), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(flatten), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_B(flatten), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
}
};
static mrb_mt_tbl set_rom_mt = {
SET_ROM_MT_SIZE, SET_ROM_MT_SIZE,
(union mrb_mt_ptr*)&set_rom_data, NULL
static mrb_mt_entry set_rom_entries[] = {
MRB_MT_ENTRY(set_size, MRB_SYM(size), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(set_size, MRB_SYM(length), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(set_empty_p, MRB_SYM_Q(empty), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(set_clear, MRB_SYM(clear), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(set_to_a, MRB_SYM(to_a), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(set_include_p, MRB_SYM_Q(include), MRB_MT_FUNC),
MRB_MT_ENTRY(set_include_p, MRB_SYM_Q(member), MRB_MT_FUNC),
MRB_MT_ENTRY(set_include_p, MRB_OPSYM(eqq), MRB_MT_FUNC),
MRB_MT_ENTRY(set_add, MRB_SYM(add), MRB_MT_FUNC),
MRB_MT_ENTRY(set_add, MRB_OPSYM(lshift), MRB_MT_FUNC),
MRB_MT_ENTRY(set_add_p, MRB_SYM_Q(add), MRB_MT_FUNC),
MRB_MT_ENTRY(set_delete, MRB_SYM(delete), MRB_MT_FUNC),
MRB_MT_ENTRY(set_delete_p, MRB_SYM_Q(delete), MRB_MT_FUNC),
MRB_MT_ENTRY(set_init, MRB_SYM(__init), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(set_core_merge, MRB_SYM(__merge), MRB_MT_FUNC),
MRB_MT_ENTRY(set_core_subtract, MRB_SYM(__subtract), MRB_MT_FUNC),
MRB_MT_ENTRY(set_core_union, MRB_SYM(__union), MRB_MT_FUNC),
MRB_MT_ENTRY(set_core_difference, MRB_SYM(__difference), MRB_MT_FUNC),
MRB_MT_ENTRY(set_core_intersection, MRB_SYM(__intersection), MRB_MT_FUNC),
MRB_MT_ENTRY(set_core_xor, MRB_SYM(__xor), MRB_MT_FUNC),
MRB_MT_ENTRY(set_equal, MRB_OPSYM(eq), MRB_MT_FUNC),
MRB_MT_ENTRY(set_hash_m, MRB_SYM(hash), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(set_join, MRB_SYM(join), MRB_MT_FUNC),
MRB_MT_ENTRY(set_inspect, MRB_SYM(inspect), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(set_inspect, MRB_SYM(to_s), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(set_reset, MRB_SYM(reset), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(set_add_all, MRB_SYM(add_all), MRB_MT_FUNC),
MRB_MT_ENTRY(set_delete_all, MRB_SYM(delete_all), MRB_MT_FUNC),
MRB_MT_ENTRY(set_include_all_p, MRB_SYM_Q(include_all), MRB_MT_FUNC),
MRB_MT_ENTRY(set_include_any_p, MRB_SYM_Q(include_any), MRB_MT_FUNC),
MRB_MT_ENTRY(set_superset_p, MRB_SYM_Q(superset), MRB_MT_FUNC),
MRB_MT_ENTRY(set_superset_p, MRB_OPSYM(ge), MRB_MT_FUNC),
MRB_MT_ENTRY(set_proper_superset_p, MRB_SYM_Q(proper_superset), MRB_MT_FUNC),
MRB_MT_ENTRY(set_proper_superset_p, MRB_OPSYM(gt), MRB_MT_FUNC),
MRB_MT_ENTRY(set_subset_p, MRB_SYM_Q(subset), MRB_MT_FUNC),
MRB_MT_ENTRY(set_subset_p, MRB_OPSYM(le), MRB_MT_FUNC),
MRB_MT_ENTRY(set_proper_subset_p, MRB_SYM_Q(proper_subset), MRB_MT_FUNC),
MRB_MT_ENTRY(set_proper_subset_p, MRB_OPSYM(lt), MRB_MT_FUNC),
MRB_MT_ENTRY(set_intersect_p, MRB_SYM_Q(intersect), MRB_MT_FUNC),
MRB_MT_ENTRY(set_disjoint_p, MRB_SYM_Q(disjoint), MRB_MT_FUNC),
MRB_MT_ENTRY(set_cmp, MRB_OPSYM(cmp), MRB_MT_FUNC),
MRB_MT_ENTRY(set_flatten, MRB_SYM(flatten), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(set_flatten_bang, MRB_SYM_B(flatten), MRB_MT_FUNC|MRB_MT_NOARG),
};
static mrb_mt_tbl set_rom_mt = MRB_MT_ROM_TAB(set_rom_entries);
void
mrb_mruby_set_gem_init(mrb_state *mrb)
mrbgems/mruby-socket/src/socket.c
+32 -100
View File
@@ -1271,113 +1271,45 @@ mrb_win32_basicsocket_syswrite(mrb_state *mrb, mrb_value self)
#endif
/* ---------------------------*/
#define ADDRINFO_ROM_MT_SIZE 2
static struct {
union mrb_mt_ptr vals[ADDRINFO_ROM_MT_SIZE];
mrb_sym keys[ADDRINFO_ROM_MT_SIZE];
} addrinfo_rom_data = {
.vals = {
{ .func = mrb_addrinfo_getnameinfo },
{ .func = mrb_addrinfo_unix_path },
},
.keys = {
MRB_MT_KEY(MRB_SYM(getnameinfo), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(unix_path), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
}
};
static mrb_mt_tbl addrinfo_rom_mt = {
ADDRINFO_ROM_MT_SIZE, ADDRINFO_ROM_MT_SIZE,
(union mrb_mt_ptr*)&addrinfo_rom_data, NULL
static mrb_mt_entry addrinfo_rom_entries[] = {
MRB_MT_ENTRY(mrb_addrinfo_getnameinfo, MRB_SYM(getnameinfo), MRB_MT_FUNC),
MRB_MT_ENTRY(mrb_addrinfo_unix_path, MRB_SYM(unix_path), MRB_MT_FUNC|MRB_MT_NOARG),
};
static mrb_mt_tbl addrinfo_rom_mt = MRB_MT_ROM_TAB(addrinfo_rom_entries);
#define BASICSOCKET_ROM_MT_SIZE 11
static struct {
union mrb_mt_ptr vals[BASICSOCKET_ROM_MT_SIZE];
mrb_sym keys[BASICSOCKET_ROM_MT_SIZE];
} basicsocket_rom_data = {
.vals = {
{ .func = mrb_basicsocket_recvfrom },
{ .func = mrb_basicsocket_setnonblock },
{ .func = mrb_basicsocket_getpeereid },
{ .func = mrb_basicsocket_getpeername },
{ .func = mrb_basicsocket_getsockname },
{ .func = mrb_basicsocket_getsockopt },
{ .func = mrb_basicsocket_recv },
{ .func = mrb_basicsocket_send },
{ .func = mrb_basicsocket_setsockopt },
{ .func = mrb_basicsocket_shutdown },
{ .func = mrb_basicsocket_set_is_socket },
},
.keys = {
MRB_MT_KEY(MRB_SYM(_recvfrom), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(_setnonblock), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(getpeereid), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(getpeername), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(getsockname), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(getsockopt), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(recv), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(send), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(setsockopt), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(shutdown), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_E(_is_socket), MRB_MT_FUNC|MRB_MT_PUBLIC),
}
};
static mrb_mt_tbl basicsocket_rom_mt = {
BASICSOCKET_ROM_MT_SIZE, BASICSOCKET_ROM_MT_SIZE,
(union mrb_mt_ptr*)&basicsocket_rom_data, NULL
static mrb_mt_entry basicsocket_rom_entries[] = {
MRB_MT_ENTRY(mrb_basicsocket_recvfrom, MRB_SYM(_recvfrom), MRB_MT_FUNC),
MRB_MT_ENTRY(mrb_basicsocket_setnonblock, MRB_SYM(_setnonblock), MRB_MT_FUNC),
MRB_MT_ENTRY(mrb_basicsocket_getpeereid, MRB_SYM(getpeereid), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(mrb_basicsocket_getpeername, MRB_SYM(getpeername), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(mrb_basicsocket_getsockname, MRB_SYM(getsockname), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(mrb_basicsocket_getsockopt, MRB_SYM(getsockopt), MRB_MT_FUNC),
MRB_MT_ENTRY(mrb_basicsocket_recv, MRB_SYM(recv), MRB_MT_FUNC),
MRB_MT_ENTRY(mrb_basicsocket_send, MRB_SYM(send), MRB_MT_FUNC),
MRB_MT_ENTRY(mrb_basicsocket_setsockopt, MRB_SYM(setsockopt), MRB_MT_FUNC),
MRB_MT_ENTRY(mrb_basicsocket_shutdown, MRB_SYM(shutdown), MRB_MT_FUNC),
MRB_MT_ENTRY(mrb_basicsocket_set_is_socket, MRB_SYM_E(_is_socket), MRB_MT_FUNC),
};
static mrb_mt_tbl basicsocket_rom_mt = MRB_MT_ROM_TAB(basicsocket_rom_entries);
#define IPSOCKET_ROM_MT_SIZE 1
static struct {
union mrb_mt_ptr vals[IPSOCKET_ROM_MT_SIZE];
mrb_sym keys[IPSOCKET_ROM_MT_SIZE];
} ipsocket_rom_data = {
.vals = {
{ .func = mrb_ipsocket_recvfrom },
},
.keys = {
MRB_MT_KEY(MRB_SYM(recvfrom), MRB_MT_FUNC|MRB_MT_PUBLIC),
}
};
static mrb_mt_tbl ipsocket_rom_mt = {
IPSOCKET_ROM_MT_SIZE, IPSOCKET_ROM_MT_SIZE,
(union mrb_mt_ptr*)&ipsocket_rom_data, NULL
static mrb_mt_entry ipsocket_rom_entries[] = {
MRB_MT_ENTRY(mrb_ipsocket_recvfrom, MRB_SYM(recvfrom), MRB_MT_FUNC),
};
static mrb_mt_tbl ipsocket_rom_mt = MRB_MT_ROM_TAB(ipsocket_rom_entries);
#define SOCKET_OPTION_ROM_MT_SIZE 10
static struct {
union mrb_mt_ptr vals[SOCKET_OPTION_ROM_MT_SIZE];
mrb_sym keys[SOCKET_OPTION_ROM_MT_SIZE];
} socket_option_rom_data = {
.vals = {
{ .func = socket_option_init },
{ .func = socket_option_inspect },
{ .func = socket_option_family },
{ .func = socket_option_level },
{ .func = socket_option_optname },
{ .func = socket_option_data },
{ .func = socket_option_bool },
{ .func = socket_option_int },
{ .func = socket_option_notimp },
{ .func = socket_option_notimp },
},
.keys = {
MRB_MT_KEY(MRB_SYM(initialize), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(inspect), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(family), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(level), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(optname), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(data), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(bool), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(int), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(linger), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(unpack), MRB_MT_FUNC|MRB_MT_PUBLIC),
}
};
static mrb_mt_tbl socket_option_rom_mt = {
SOCKET_OPTION_ROM_MT_SIZE, SOCKET_OPTION_ROM_MT_SIZE,
(union mrb_mt_ptr*)&socket_option_rom_data, NULL
static mrb_mt_entry socket_option_rom_entries[] = {
MRB_MT_ENTRY(socket_option_init, MRB_SYM(initialize), MRB_MT_FUNC),
MRB_MT_ENTRY(socket_option_inspect, MRB_SYM(inspect), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(socket_option_family, MRB_SYM(family), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(socket_option_level, MRB_SYM(level), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(socket_option_optname, MRB_SYM(optname), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(socket_option_data, MRB_SYM(data), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(socket_option_bool, MRB_SYM(bool), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(socket_option_int, MRB_SYM(int), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(socket_option_notimp, MRB_SYM(linger), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(socket_option_notimp, MRB_SYM(unpack), MRB_MT_FUNC),
};
static mrb_mt_tbl socket_option_rom_mt = MRB_MT_ROM_TAB(socket_option_rom_entries);
void
mrb_mruby_socket_gem_init(mrb_state* mrb)
mrbgems/mruby-string-ext/src/string.c
+58 -134
View File
@@ -2219,143 +2219,67 @@ str_prepend(mrb_state *mrb, mrb_value self)
}
/* ---------------------------*/
#define STRING_EXT_ROM_MT_SIZE 53
static struct {
union mrb_mt_ptr vals[STRING_EXT_ROM_MT_SIZE];
mrb_sym keys[STRING_EXT_ROM_MT_SIZE];
} string_ext_rom_data = {
.vals = {
{ .func = mrb_str_dump },
{ .func = str_swapcase_bang },
{ .func = mrb_str_slice_bang },
{ .func = str_swapcase },
{ .func = str_clear },
{ .func = str_concat_m },
{ .func = str_concat_m },
{ .func = str_append_as_bytes },
{ .func = str_count },
{ .func = str_tr_m },
{ .func = str_partition },
{ .func = str_rpartition },
{ .func = str_insert },
{ .func = str_prepend },
{ .func = str_tr_bang },
{ .func = str_tr_s },
{ .func = str_tr_s_bang },
{ .func = str_squeeze_m },
{ .func = str_squeeze_bang },
{ .func = str_delete_m },
{ .func = str_delete_bang },
{ .func = str_start_with },
{ .func = str_end_with },
{ .func = str_hex },
{ .func = str_oct },
{ .func = str_chr },
{ .func = str_succ },
{ .func = str_succ_bang },
{ .func = str_succ },
{ .func = str_succ_bang },
{ .func = str_ord },
{ .func = str_del_prefix_bang },
{ .func = str_del_prefix },
{ .func = str_del_suffix_bang },
{ .func = str_del_suffix },
{ .func = str_casecmp },
{ .func = str_casecmp_p },
{ .func = str_uplus },
{ .func = str_uminus },
{ .func = str_ascii_only_p },
{ .func = str_b },
{ .func = str_lines },
{ .func = str_codepoints },
{ .func = str_lstrip },
{ .func = str_rstrip },
{ .func = str_strip },
{ .func = str_lstrip_bang },
{ .func = str_rstrip_bang },
{ .func = str_strip_bang },
{ .func = str_chars_ary },
{ .func = str_ljust_core },
{ .func = str_rjust_core },
{ .func = str_center_core },
},
.keys = {
MRB_MT_KEY(MRB_SYM(dump), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_B(swapcase), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_B(slice), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(swapcase), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(clear), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(lshift), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(concat), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(append_as_bytes), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(count), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(tr), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(partition), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(rpartition), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(insert), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(prepend), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_B(tr), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(tr_s), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_B(tr_s), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(squeeze), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_B(squeeze), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(delete), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_B(delete), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_Q(start_with), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_Q(end_with), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(hex), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(oct), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(chr), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(succ), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_B(succ), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(next), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_B(next), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(ord), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_B(delete_prefix), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(delete_prefix), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_B(delete_suffix), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(delete_suffix), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(casecmp), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_Q(casecmp), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(plus), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(minus), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_Q(ascii_only), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(b), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(__lines), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(__codepoints), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(lstrip), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(rstrip), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(strip), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_B(lstrip), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_B(rstrip), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_B(strip), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(__chars), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(ljust), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(rjust), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(center), MRB_MT_FUNC|MRB_MT_PUBLIC),
}
};
static mrb_mt_tbl string_ext_rom_mt = {
STRING_EXT_ROM_MT_SIZE, STRING_EXT_ROM_MT_SIZE,
(union mrb_mt_ptr*)&string_ext_rom_data, NULL
static mrb_mt_entry string_ext_rom_entries[] = {
MRB_MT_ENTRY(mrb_str_dump, MRB_SYM(dump), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(str_swapcase_bang, MRB_SYM_B(swapcase), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(mrb_str_slice_bang, MRB_SYM_B(slice), MRB_MT_FUNC),
MRB_MT_ENTRY(str_swapcase, MRB_SYM(swapcase), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(str_clear, MRB_SYM(clear), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(str_concat_m, MRB_OPSYM(lshift), MRB_MT_FUNC),
MRB_MT_ENTRY(str_concat_m, MRB_SYM(concat), MRB_MT_FUNC),
MRB_MT_ENTRY(str_append_as_bytes, MRB_SYM(append_as_bytes), MRB_MT_FUNC),
MRB_MT_ENTRY(str_count, MRB_SYM(count), MRB_MT_FUNC),
MRB_MT_ENTRY(str_tr_m, MRB_SYM(tr), MRB_MT_FUNC),
MRB_MT_ENTRY(str_partition, MRB_SYM(partition), MRB_MT_FUNC),
MRB_MT_ENTRY(str_rpartition, MRB_SYM(rpartition), MRB_MT_FUNC),
MRB_MT_ENTRY(str_insert, MRB_SYM(insert), MRB_MT_FUNC),
MRB_MT_ENTRY(str_prepend, MRB_SYM(prepend), MRB_MT_FUNC),
MRB_MT_ENTRY(str_tr_bang, MRB_SYM_B(tr), MRB_MT_FUNC),
MRB_MT_ENTRY(str_tr_s, MRB_SYM(tr_s), MRB_MT_FUNC),
MRB_MT_ENTRY(str_tr_s_bang, MRB_SYM_B(tr_s), MRB_MT_FUNC),
MRB_MT_ENTRY(str_squeeze_m, MRB_SYM(squeeze), MRB_MT_FUNC),
MRB_MT_ENTRY(str_squeeze_bang, MRB_SYM_B(squeeze), MRB_MT_FUNC),
MRB_MT_ENTRY(str_delete_m, MRB_SYM(delete), MRB_MT_FUNC),
MRB_MT_ENTRY(str_delete_bang, MRB_SYM_B(delete), MRB_MT_FUNC),
MRB_MT_ENTRY(str_start_with, MRB_SYM_Q(start_with), MRB_MT_FUNC),
MRB_MT_ENTRY(str_end_with, MRB_SYM_Q(end_with), MRB_MT_FUNC),
MRB_MT_ENTRY(str_hex, MRB_SYM(hex), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(str_oct, MRB_SYM(oct), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(str_chr, MRB_SYM(chr), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(str_succ, MRB_SYM(succ), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(str_succ_bang, MRB_SYM_B(succ), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(str_succ, MRB_SYM(next), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(str_succ_bang, MRB_SYM_B(next), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(str_ord, MRB_SYM(ord), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(str_del_prefix_bang, MRB_SYM_B(delete_prefix), MRB_MT_FUNC),
MRB_MT_ENTRY(str_del_prefix, MRB_SYM(delete_prefix), MRB_MT_FUNC),
MRB_MT_ENTRY(str_del_suffix_bang, MRB_SYM_B(delete_suffix), MRB_MT_FUNC),
MRB_MT_ENTRY(str_del_suffix, MRB_SYM(delete_suffix), MRB_MT_FUNC),
MRB_MT_ENTRY(str_casecmp, MRB_SYM(casecmp), MRB_MT_FUNC),
MRB_MT_ENTRY(str_casecmp_p, MRB_SYM_Q(casecmp), MRB_MT_FUNC),
MRB_MT_ENTRY(str_uplus, MRB_OPSYM(plus), MRB_MT_FUNC),
MRB_MT_ENTRY(str_uminus, MRB_OPSYM(minus), MRB_MT_FUNC),
MRB_MT_ENTRY(str_ascii_only_p, MRB_SYM_Q(ascii_only), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(str_b, MRB_SYM(b), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(str_lines, MRB_SYM(__lines), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(str_codepoints, MRB_SYM(__codepoints), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(str_lstrip, MRB_SYM(lstrip), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(str_rstrip, MRB_SYM(rstrip), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(str_strip, MRB_SYM(strip), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(str_lstrip_bang, MRB_SYM_B(lstrip), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(str_rstrip_bang, MRB_SYM_B(rstrip), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(str_strip_bang, MRB_SYM_B(strip), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(str_chars_ary, MRB_SYM(__chars), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(str_ljust_core, MRB_SYM(ljust), MRB_MT_FUNC),
MRB_MT_ENTRY(str_rjust_core, MRB_SYM(rjust), MRB_MT_FUNC),
MRB_MT_ENTRY(str_center_core, MRB_SYM(center), MRB_MT_FUNC),
};
static mrb_mt_tbl string_ext_rom_mt = MRB_MT_ROM_TAB(string_ext_rom_entries);
#define INTEGER_CHR_ROM_MT_SIZE 1
static struct {
union mrb_mt_ptr vals[INTEGER_CHR_ROM_MT_SIZE];
mrb_sym keys[INTEGER_CHR_ROM_MT_SIZE];
} integer_chr_rom_data = {
.vals = {
{ .func = int_chr },
},
.keys = {
MRB_MT_KEY(MRB_SYM(chr), MRB_MT_FUNC|MRB_MT_PUBLIC),
}
};
static mrb_mt_tbl integer_chr_rom_mt = {
INTEGER_CHR_ROM_MT_SIZE, INTEGER_CHR_ROM_MT_SIZE,
(union mrb_mt_ptr*)&integer_chr_rom_data, NULL
static mrb_mt_entry integer_chr_rom_entries[] = {
MRB_MT_ENTRY(int_chr, MRB_SYM(chr), MRB_MT_FUNC),
};
static mrb_mt_tbl integer_chr_rom_mt = MRB_MT_ROM_TAB(integer_chr_rom_entries);
void
mrb_mruby_string_ext_gem_init(mrb_state* mrb)
mrbgems/mruby-struct/src/struct.c
+17 -43
View File
@@ -776,50 +776,24 @@ mrb_struct_to_s(mrb_state *mrb, mrb_value self)
* `Symbol` (such as `:name`).
*/
/* ---------------------------*/
#define STRUCT_ROM_MT_SIZE 15
static struct {
union mrb_mt_ptr vals[STRUCT_ROM_MT_SIZE];
mrb_sym keys[STRUCT_ROM_MT_SIZE];
} struct_rom_data = {
.vals = {
{ .func = mrb_struct_equal },
{ .func = mrb_struct_aref },
{ .func = mrb_struct_aset },
{ .func = mrb_struct_members },
{ .func = mrb_struct_initialize },
{ .func = mrb_struct_init_copy },
{ .func = mrb_struct_eql },
{ .func = mrb_struct_to_s },
{ .func = mrb_struct_to_s },
{ .func = mrb_struct_len },
{ .func = mrb_struct_len },
{ .func = mrb_struct_to_a },
{ .func = mrb_struct_to_a },
{ .func = mrb_struct_to_h },
{ .func = mrb_struct_values_at },
},
.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(members), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(initialize), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(initialize_copy), MRB_MT_FUNC|MRB_MT_PRIVATE),
MRB_MT_KEY(MRB_SYM_Q(eql), 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(size), 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(to_a), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(values), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(to_h), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(values_at), MRB_MT_FUNC|MRB_MT_PUBLIC),
}
};
static mrb_mt_tbl struct_rom_mt = {
STRUCT_ROM_MT_SIZE, STRUCT_ROM_MT_SIZE,
(union mrb_mt_ptr*)&struct_rom_data, NULL
static mrb_mt_entry struct_rom_entries[] = {
MRB_MT_ENTRY(mrb_struct_equal, MRB_OPSYM(eq), MRB_MT_FUNC),
MRB_MT_ENTRY(mrb_struct_aref, MRB_OPSYM(aref), MRB_MT_FUNC),
MRB_MT_ENTRY(mrb_struct_aset, MRB_OPSYM(aset), MRB_MT_FUNC),
MRB_MT_ENTRY(mrb_struct_members, MRB_SYM(members), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(mrb_struct_initialize, MRB_SYM(initialize), MRB_MT_FUNC),
MRB_MT_ENTRY(mrb_struct_init_copy, MRB_SYM(initialize_copy), MRB_MT_FUNC|MRB_MT_PRIVATE),
MRB_MT_ENTRY(mrb_struct_eql, MRB_SYM_Q(eql), MRB_MT_FUNC),
MRB_MT_ENTRY(mrb_struct_to_s, MRB_SYM(to_s), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(mrb_struct_to_s, MRB_SYM(inspect), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(mrb_struct_len, MRB_SYM(size), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(mrb_struct_len, MRB_SYM(length), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(mrb_struct_to_a, MRB_SYM(to_a), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(mrb_struct_to_a, MRB_SYM(values), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(mrb_struct_to_h, MRB_SYM(to_h), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(mrb_struct_values_at, MRB_SYM(values_at), MRB_MT_FUNC),
};
static mrb_mt_tbl struct_rom_mt = MRB_MT_ROM_TAB(struct_rom_entries);
void
mrb_mruby_struct_gem_init(mrb_state* mrb)
mrbgems/mruby-symbol-ext/src/symbol.c
+4 -17
View File
@@ -58,24 +58,11 @@ mrb_sym_length(mrb_state *mrb, mrb_value self)
return mrb_fixnum_value(len);
}
#define SYMBOL_EXT_ROM_MT_SIZE 2
static struct {
union mrb_mt_ptr vals[SYMBOL_EXT_ROM_MT_SIZE];
mrb_sym keys[SYMBOL_EXT_ROM_MT_SIZE];
} symbol_ext_rom_data = {
.vals = {
{ .func = mrb_sym_length },
{ .func = mrb_sym_length },
},
.keys = {
MRB_MT_KEY(MRB_SYM(length), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(size), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
}
};
static mrb_mt_tbl symbol_ext_rom_mt = {
SYMBOL_EXT_ROM_MT_SIZE, SYMBOL_EXT_ROM_MT_SIZE,
(union mrb_mt_ptr*)&symbol_ext_rom_data, NULL
static mrb_mt_entry symbol_ext_rom_entries[] = {
MRB_MT_ENTRY(mrb_sym_length, MRB_SYM(length), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(mrb_sym_length, MRB_SYM(size), MRB_MT_FUNC|MRB_MT_NOARG),
};
static mrb_mt_tbl symbol_ext_rom_mt = MRB_MT_ROM_TAB(symbol_ext_rom_entries);
void
mrb_mruby_symbol_ext_gem_init(mrb_state* mrb)
mrbgems/mruby-time/src/time.c
+48 -105
View File
@@ -1664,112 +1664,55 @@ time_utc_offset(mrb_state *mrb, mrb_value self)
}
/* ---------------------------*/
#define TIME_ROM_MT_SIZE 46
static struct {
union mrb_mt_ptr vals[TIME_ROM_MT_SIZE];
mrb_sym keys[TIME_ROM_MT_SIZE];
} time_rom_data = {
.vals = {
{ .func = time_hash },
{ .func = time_eq },
{ .func = time_eq },
{ .func = time_cmp },
{ .func = time_plus },
{ .func = time_minus },
{ .func = time_to_s },
{ .func = time_to_s },
{ .func = time_asctime },
{ .func = time_asctime },
{ .func = time_day },
{ .func = time_dst_p },
{ .func = time_getutc },
{ .func = time_getlocal },
{ .func = time_getutc },
{ .func = time_utc_p },
{ .func = time_utc },
{ .func = time_hour },
{ .func = time_localtime },
{ .func = time_day },
{ .func = time_min },
{ .func = time_mon },
{ .func = time_mon },
{ .func = time_sec },
{ .func = time_to_i },
{ .func = time_usec },
{ .func = time_nsec },
{ .func = time_nsec },
{ .func = time_utc },
{ .func = time_utc_p },
{ .func = time_wday },
{ .func = time_yday },
{ .func = time_year },
{ .func = time_zone },
{ .func = time_init },
{ .func = time_init_copy },
{ .func = time_sunday },
{ .func = time_monday },
{ .func = time_tuesday },
{ .func = time_wednesday },
{ .func = time_thursday },
{ .func = time_friday },
{ .func = time_saturday },
{ .func = time_utc_offset },
{ .func = time_utc_offset },
{ .func = time_utc_offset },
},
.keys = {
MRB_MT_KEY(MRB_SYM(hash), 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_OPSYM(eq), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(cmp), 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_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(asctime), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(ctime), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(day), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_Q(dst), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(getgm), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(getlocal), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(getutc), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_Q(gmt), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(gmtime), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(hour), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(localtime), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(mday), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(min), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(mon), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(month), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(sec), 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(usec), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(nsec), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(tv_nsec), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(utc), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_Q(utc), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(wday), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(yday), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(year), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(zone), MRB_MT_FUNC|MRB_MT_NOARG|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(sunday), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_Q(monday), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_Q(tuesday), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_Q(wednesday), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_Q(thursday), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_Q(friday), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_Q(saturday), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(gmt_offset), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(gmtoff), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(utc_offset), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
}
};
static mrb_mt_tbl time_rom_mt = {
TIME_ROM_MT_SIZE, TIME_ROM_MT_SIZE,
(union mrb_mt_ptr*)&time_rom_data, NULL
static mrb_mt_entry time_rom_entries[] = {
MRB_MT_ENTRY(time_hash, MRB_SYM(hash), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(time_eq, MRB_SYM_Q(eql), MRB_MT_FUNC),
MRB_MT_ENTRY(time_eq, MRB_OPSYM(eq), MRB_MT_FUNC),
MRB_MT_ENTRY(time_cmp, MRB_OPSYM(cmp), MRB_MT_FUNC),
MRB_MT_ENTRY(time_plus, MRB_OPSYM(add), MRB_MT_FUNC),
MRB_MT_ENTRY(time_minus, MRB_OPSYM(sub), MRB_MT_FUNC),
MRB_MT_ENTRY(time_to_s, MRB_SYM(to_s), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(time_to_s, MRB_SYM(inspect), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(time_asctime, MRB_SYM(asctime), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(time_asctime, MRB_SYM(ctime), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(time_day, MRB_SYM(day), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(time_dst_p, MRB_SYM_Q(dst), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(time_getutc, MRB_SYM(getgm), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(time_getlocal, MRB_SYM(getlocal), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(time_getutc, MRB_SYM(getutc), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(time_utc_p, MRB_SYM_Q(gmt), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(time_utc, MRB_SYM(gmtime), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(time_hour, MRB_SYM(hour), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(time_localtime, MRB_SYM(localtime), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(time_day, MRB_SYM(mday), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(time_min, MRB_SYM(min), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(time_mon, MRB_SYM(mon), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(time_mon, MRB_SYM(month), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(time_sec, MRB_SYM(sec), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(time_to_i, MRB_SYM(to_i), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(time_usec, MRB_SYM(usec), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(time_nsec, MRB_SYM(nsec), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(time_nsec, MRB_SYM(tv_nsec), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(time_utc, MRB_SYM(utc), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(time_utc_p, MRB_SYM_Q(utc), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(time_wday, MRB_SYM(wday), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(time_yday, MRB_SYM(yday), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(time_year, MRB_SYM(year), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(time_zone, MRB_SYM(zone), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(time_init, MRB_SYM(initialize), MRB_MT_FUNC|MRB_MT_PRIVATE),
MRB_MT_ENTRY(time_init_copy, MRB_SYM(initialize_copy), MRB_MT_FUNC|MRB_MT_PRIVATE),
MRB_MT_ENTRY(time_sunday, MRB_SYM_Q(sunday), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(time_monday, MRB_SYM_Q(monday), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(time_tuesday, MRB_SYM_Q(tuesday), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(time_wednesday, MRB_SYM_Q(wednesday), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(time_thursday, MRB_SYM_Q(thursday), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(time_friday, MRB_SYM_Q(friday), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(time_saturday, MRB_SYM_Q(saturday), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(time_utc_offset, MRB_SYM(gmt_offset), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(time_utc_offset, MRB_SYM(gmtoff), MRB_MT_FUNC|MRB_MT_NOARG),
MRB_MT_ENTRY(time_utc_offset, MRB_SYM(utc_offset), MRB_MT_FUNC|MRB_MT_NOARG),
};
static mrb_mt_tbl time_rom_mt = MRB_MT_ROM_TAB(time_rom_entries);
void
mrb_mruby_time_gem_init(mrb_state* mrb)
src/array.c
+38 -85
View File
@@ -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)
src/class.c
+111 -233
View File
@@ -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)
src/error.c
+9 -27
View File
@@ -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)
src/hash.c
+38 -85
View File
@@ -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)
src/kernel.c
+29 -67
View File
@@ -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)
src/numeric.c
+69 -165
View File
@@ -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
src/object.c
+22 -71
View File
@@ -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)
src/proc.c
+7 -23
View File
@@ -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)
src/range.c
+17 -43
View File
@@ -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)
src/string.c
+48 -105
View File
@@ -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)
src/symbol.c
+8 -25
View File
@@ -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)