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

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

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

Co-authored-by: Claude <noreply@anthropic.com>
This commit is contained in:
Yukihiro "Matz" Matsumoto
2026-02-19 15:22:55 +09:00
parent 494d55c9f7
commit 0ed26f8352
35 changed files with 1030 additions and 1030 deletions
Download Patch File Download Diff File Expand all files Collapse all files
doc/guides/rom-method-table.md
+46 -46
View File
@@ -22,7 +22,7 @@ reopening a class to add methods) trigger heap allocation.
### Chained Layers
Each class has a method table (`mt`) pointer to a linked list of
`mt_tbl` layers:
`mrb_mt_tbl` layers:
```
String.mt -> [mutable layer] -> [string_ext ROM] -> [string_core ROM] -> NULL
@@ -45,16 +45,16 @@ After String.define_method(:foo):
### Memory Layout
Each `mt_tbl` stores method entries as parallel arrays in a single
Each `mrb_mt_tbl` stores method entries as parallel arrays in a single
contiguous block:
```
ptr -> [ vals[0] vals[1] ... vals[N-1] | keys[0] keys[1] ... keys[N-1] ]
|<--- union mt_ptr array ------>|<--- mrb_sym (encoded) array -->|
|<--- union mrb_mt_ptr array ------>|<--- mrb_sym (encoded) array -->|
```
Values are `union mt_ptr` (function pointer or proc pointer). Keys are
`mrb_sym` with flags packed into the lower bits using `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
`mrb_mt_init_rom()` function handles sorting at startup, so the
@@ -64,8 +64,8 @@ source code order does not matter.
### Step 1: Define the Static Data
Include `<mruby/internal.h>` (which provides `mt_tbl`, `union mt_ptr`,
`MT_KEY()`, and flag constants) and define the ROM data structure:
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:
```c
#include <mruby/internal.h>
@@ -73,7 +73,7 @@ Include `<mruby/internal.h>` (which provides `mt_tbl`, `union mt_ptr`,
#define MY_ROM_MT_SIZE 3
static struct {
union mt_ptr vals[MY_ROM_MT_SIZE];
union mrb_mt_ptr vals[MY_ROM_MT_SIZE];
mrb_sym keys[MY_ROM_MT_SIZE];
} my_rom_data = {
.vals = {
@@ -82,14 +82,14 @@ static struct {
{ .func = my_method_c },
},
.keys = {
MT_KEY(MRB_SYM(method_a), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(method_b), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_OPSYM(eq), MT_FUNC|MT_PUBLIC),
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 mt_tbl my_rom_mt = {
static mrb_mt_tbl my_rom_mt = {
MY_ROM_MT_SIZE, MY_ROM_MT_SIZE,
(union mt_ptr*)&my_rom_data, NULL
(union mrb_mt_ptr*)&my_rom_data, NULL
};
```
@@ -122,43 +122,43 @@ to Ruby code.
Defined in `include/mruby/internal.h`:
```c
union mt_ptr {
union mrb_mt_ptr {
const struct RProc *proc;
mrb_func_t func;
};
typedef struct mt_tbl {
typedef struct mrb_mt_tbl {
int size;
int alloc; /* bit 30: MT_READONLY_BIT */
union mt_ptr *ptr;
struct mt_tbl *next; /* next (lower-priority) layer, or NULL */
} mt_tbl;
int alloc; /* bit 30: MRB_MT_READONLY_BIT */
union mrb_mt_ptr *ptr;
struct mrb_mt_tbl *next; /* next (lower-priority) layer, or NULL */
} mrb_mt_tbl;
```
### Key Encoding
```c
#define MT_KEY(sym, flags) ((sym) << MT_KEY_SHIFT | (flags))
#define MRB_MT_KEY(sym, flags) ((sym) << MRB_MT_KEY_SHIFT | (flags))
```
### Flags
| Flag | Value | Description |
| ------------ | ----- | ---------------------------------------------- |
| `MT_FUNC` | 8 | Entry is a C function pointer (not an RProc) |
| `MT_NOARG` | 4 | Method takes no arguments (optimization hint) |
| `MT_PUBLIC` | 0 | Public visibility |
| `MT_PRIVATE` | 1 | Private visibility |
| Flag | Value | Description |
| ---------------- | ----- | --------------------------------------------- |
| `MRB_MT_FUNC` | 8 | Entry is a C function pointer (not an RProc) |
| `MRB_MT_NOARG` | 4 | Method takes no arguments (optimization hint) |
| `MRB_MT_PUBLIC` | 0 | Public visibility |
| `MRB_MT_PRIVATE` | 1 | Private visibility |
Most ROM entries use `MT_FUNC|MT_PUBLIC` or `MT_FUNC|MT_NOARG|MT_PUBLIC`.
Most ROM entries use `MRB_MT_FUNC|MRB_MT_PUBLIC` or `MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC`.
**How to choose flags:**
- **`MT_FUNC`**: Always set for C function methods. Omit only for
- **`MRB_MT_FUNC`**: Always set for C function methods. Omit only for
RProc-based methods (rare in ROM tables).
- **`MT_NOARG`**: Set when the original `mrb_define_method_id()` used
- **`MRB_MT_NOARG`**: Set when the original `mrb_define_method_id()` used
`MRB_ARGS_NONE()`. This enables an optimized call path in the VM.
- **`MT_PUBLIC` / `MT_PRIVATE`**: Match the intended visibility. Almost
- **`MRB_MT_PUBLIC` / `MRB_MT_PRIVATE`**: Match the intended visibility. Almost
all methods are public.
### Symbol Macros
@@ -182,7 +182,7 @@ MRB_IVSYM(name) /* @name */
### API
```c
void mrb_mt_init_rom(struct RClass *c, mt_tbl *rom);
void mrb_mt_init_rom(struct RClass *c, mrb_mt_tbl *rom);
```
Sorts the ROM table, sets the readonly flag, and pushes it onto the
@@ -206,8 +206,8 @@ separate entries sharing the same function pointer:
{ .func = mrb_str_size }, /* length (alias) */
},
.keys = {
MT_KEY(MRB_SYM(size), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(length), MT_FUNC|MT_NOARG|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),
}
```
@@ -223,7 +223,7 @@ blocks):
#ifndef MRB_NO_FLOAT
#define FLOAT_ROM_MT_SIZE 29
static struct { ... } float_rom_data = { ... };
static mt_tbl float_rom_mt = { ... };
static mrb_mt_tbl float_rom_mt = { ... };
#endif
void mrb_init_numeric(mrb_state *mrb) {
@@ -261,7 +261,7 @@ ROM layer in front of the core ROM layer:
#define STRING_EXT_ROM_MT_SIZE 53
static struct { ... } string_ext_rom_data = { ... };
static mt_tbl string_ext_rom_mt = { ... };
static mrb_mt_tbl string_ext_rom_mt = { ... };
void mrb_mruby_string_ext_gem_init(mrb_state *mrb)
{
@@ -326,7 +326,7 @@ end
### Method Removal
`remove_method` works on ROM methods using a tombstone marker. When a
method in a ROM layer is removed, a special entry (`MT_FUNC` flag with
method in a ROM layer is removed, a special entry (`MRB_MT_FUNC` flag with
`func=NULL`) is inserted into the mutable layer. The `mt_get()` lookup
treats this marker as "not found" and stops searching the chain,
effectively hiding the ROM entry. Unlike `undef_method` (which blocks
@@ -334,7 +334,7 @@ superclass lookup), `remove_method`'s tombstone allows the superclass
method to be found.
`undef_method` uses a different tombstone (`proc=NULL` without
`MT_FUNC`), which is returned by `mt_get()` so the caller raises
`MRB_MT_FUNC`), which is returned by `mt_get()` so the caller raises
NoMethodError without searching the superclass.
### Class Duplication
@@ -364,10 +364,10 @@ To convert existing `mrb_define_method_id()` calls to a ROM table:
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 `MT_KEY()`.
- The third argument (symbol) goes into `.keys` via `MRB_MT_KEY()`.
- Map the `MRB_ARGS_*` macro to flags:
- `MRB_ARGS_NONE()` -> `MT_FUNC|MT_NOARG|MT_PUBLIC`
- Anything else -> `MT_FUNC|MT_PUBLIC`
- `MRB_ARGS_NONE()` -> `MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC`
- Anything else -> `MRB_MT_FUNC|MRB_MT_PUBLIC`
4. **Replace** the calls with `mrb_mt_init_rom(c, &my_rom_mt)`.
@@ -392,7 +392,7 @@ void mrb_mruby_foo_gem_init(mrb_state *mrb) {
```c
#define FOO_ROM_MT_SIZE 3
static struct {
union mt_ptr vals[FOO_ROM_MT_SIZE];
union mrb_mt_ptr vals[FOO_ROM_MT_SIZE];
mrb_sym keys[FOO_ROM_MT_SIZE];
} foo_rom_data = {
.vals = {
@@ -401,14 +401,14 @@ static struct {
{ .func = foo_eq },
},
.keys = {
MT_KEY(MRB_SYM(bar), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(baz), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_OPSYM(eq), MT_FUNC|MT_PUBLIC),
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 mt_tbl foo_rom_mt = {
static mrb_mt_tbl foo_rom_mt = {
FOO_ROM_MT_SIZE, FOO_ROM_MT_SIZE,
(union mt_ptr*)&foo_rom_data, NULL
(union mrb_mt_ptr*)&foo_rom_data, NULL
};
void mrb_mruby_foo_gem_init(mrb_state *mrb) {
include/mruby/class.h
+1 -1
View File
@@ -17,7 +17,7 @@ MRB_BEGIN_DECL
struct RClass {
MRB_OBJECT_HEADER;
struct iv_tbl *iv;
struct mt_tbl *mt;
struct mrb_mt_tbl *mt;
struct RClass *super;
};
include/mruby/internal.h
+18 -18
View File
@@ -29,34 +29,34 @@ size_t mrb_class_mt_memsize(mrb_state*, struct RClass*);
mrb_value mrb_obj_extend(mrb_state*, mrb_value obj);
/* ROM method table types for static method registration */
union mt_ptr {
union mrb_mt_ptr {
const struct RProc *proc;
mrb_func_t func;
};
typedef struct mt_tbl {
int size;
int alloc; /* bit 30: MT_READONLY_BIT */
union mt_ptr *ptr;
struct mt_tbl *next;
} mt_tbl;
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;
} mrb_mt_tbl;
#define MT_READONLY_BIT (1 << 30)
#define MT_KEY_SHIFT 4
#define MT_KEY(sym, flags) ((sym)<<MT_KEY_SHIFT|(flags))
#define MT_FUNC 8 /* MRB_METHOD_FUNC_FL */
#define MT_NOARG 4 /* MRB_METHOD_NOARG_FL */
#define MT_PUBLIC 0 /* MRB_METHOD_PUBLIC_FL */
#define MT_PRIVATE 1 /* MRB_METHOD_PRIVATE_FL */
#define MRB_MT_READONLY_BIT (1 << 30)
#define MRB_MT_KEY_SHIFT 4
#define MRB_MT_KEY(sym, flags) ((sym)<<MRB_MT_KEY_SHIFT|(flags))
#define MRB_MT_FUNC 8 /* MRB_METHOD_FUNC_FL */
#define MRB_MT_NOARG 4 /* MRB_METHOD_NOARG_FL */
#define MRB_MT_PUBLIC 0 /* MRB_METHOD_PUBLIC_FL */
#define MRB_MT_PRIVATE 1 /* MRB_METHOD_PRIVATE_FL */
/* "removed" tombstone: MT_FUNC flag set with NULL function pointer.
/* "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 MT_FUNC), a removed marker makes
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 MT_REMOVED_P(key, val) (((key)&MT_FUNC) && (val).func==NULL)
#define MRB_MT_REMOVED_P(key, val) (((key)&MRB_MT_FUNC) && (val).func==NULL)
void mrb_mt_init_rom(struct RClass *c, mt_tbl *rom);
void mrb_mt_init_rom(struct RClass *c, mrb_mt_tbl *rom);
#endif
mrb_value mrb_obj_equal_m(mrb_state *mrb, mrb_value);
mrbgems/mruby-array-ext/src/array.c
+32 -32
View File
@@ -1539,7 +1539,7 @@ ary_combination_next(mrb_state *mrb, mrb_value self)
/* ---------------------------*/
#define ARRAY_EXT_ROM_MT_SIZE 29
static struct {
union mt_ptr vals[ARRAY_EXT_ROM_MT_SIZE];
union mrb_mt_ptr vals[ARRAY_EXT_ROM_MT_SIZE];
mrb_sym keys[ARRAY_EXT_ROM_MT_SIZE];
} array_ext_rom_data = {
.vals = {
@@ -1574,40 +1574,40 @@ static struct {
{ .func = ary_combination_next },
},
.keys = {
MT_KEY(MRB_SYM(assoc), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(at), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(rassoc), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(values_at), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM_B(slice), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(compact), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_B(compact), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(rotate), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM_B(rotate), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(sub), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(difference), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(or), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(union), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(and), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(intersection), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(intersect), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(__fill_parse_arg), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(__fill_exec), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(__uniq), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_B(__uniq), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(flatten), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM_B(flatten), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(__normalize_index), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(__fetch), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(insert), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(deconstruct), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(__product_group), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(__combination_init), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(__combination_next), MT_FUNC|MT_PUBLIC),
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 mt_tbl array_ext_rom_mt = {
static mrb_mt_tbl array_ext_rom_mt = {
ARRAY_EXT_ROM_MT_SIZE, ARRAY_EXT_ROM_MT_SIZE,
(union mt_ptr*)&array_ext_rom_data, NULL
(union mrb_mt_ptr*)&array_ext_rom_data, NULL
};
void
mrbgems/mruby-class-ext/src/class.c
+17 -17
View File
@@ -337,7 +337,7 @@ mrb_mod_cmp(mrb_state *mrb, mrb_value self)
/* ---------------------------*/
#define MOD_EXT_ROM_MT_SIZE 9
static struct {
union mt_ptr vals[MOD_EXT_ROM_MT_SIZE];
union mrb_mt_ptr vals[MOD_EXT_ROM_MT_SIZE];
mrb_sym keys[MOD_EXT_ROM_MT_SIZE];
} mod_ext_rom_data = {
.vals = {
@@ -352,25 +352,25 @@ static struct {
{ .func = mod_singleton_class_p },
},
.keys = {
MT_KEY(MRB_OPSYM(lt), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(le), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(cmp), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(gt), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(ge), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(class_exec), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(module_exec), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(name), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(singleton_class), MT_FUNC|MT_NOARG|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(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 mt_tbl mod_ext_rom_mt = {
static mrb_mt_tbl mod_ext_rom_mt = {
MOD_EXT_ROM_MT_SIZE, MOD_EXT_ROM_MT_SIZE,
(union mt_ptr*)&mod_ext_rom_data, NULL
(union mrb_mt_ptr*)&mod_ext_rom_data, NULL
};
#define CLS_EXT_ROM_MT_SIZE 2
static struct {
union mt_ptr vals[CLS_EXT_ROM_MT_SIZE];
union mrb_mt_ptr vals[CLS_EXT_ROM_MT_SIZE];
mrb_sym keys[CLS_EXT_ROM_MT_SIZE];
} cls_ext_rom_data = {
.vals = {
@@ -378,13 +378,13 @@ static struct {
{ .func = class_subclasses },
},
.keys = {
MT_KEY(MRB_SYM(attached_object), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(subclasses), MT_FUNC|MT_NOARG|MT_PUBLIC),
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 mt_tbl cls_ext_rom_mt = {
static mrb_mt_tbl cls_ext_rom_mt = {
CLS_EXT_ROM_MT_SIZE, CLS_EXT_ROM_MT_SIZE,
(union mt_ptr*)&cls_ext_rom_data, NULL
(union mrb_mt_ptr*)&cls_ext_rom_data, NULL
};
/*
mrbgems/mruby-complex/src/complex.c
+24 -24
View File
@@ -560,7 +560,7 @@ complex_pow(mrb_state *mrb, mrb_value self)
/* ---------------------------*/
#define COMPLEX_ROM_MT_SIZE 13
static struct {
union mt_ptr vals[COMPLEX_ROM_MT_SIZE];
union mrb_mt_ptr vals[COMPLEX_ROM_MT_SIZE];
mrb_sym keys[COMPLEX_ROM_MT_SIZE];
} complex_rom_data = {
.vals = {
@@ -579,58 +579,58 @@ static struct {
{ .func = complex_pow },
},
.keys = {
MT_KEY(MRB_SYM(real), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(imaginary), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(to_f), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(to_i), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(to_c), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_OPSYM(add), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(sub), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(mul), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(div), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(quo), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(eq), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(hash), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_OPSYM(pow), MT_FUNC|MT_PUBLIC),
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 mt_tbl complex_rom_mt = {
static mrb_mt_tbl complex_rom_mt = {
COMPLEX_ROM_MT_SIZE, COMPLEX_ROM_MT_SIZE,
(union mt_ptr*)&complex_rom_data, NULL
(union mrb_mt_ptr*)&complex_rom_data, NULL
};
#define NIL_TO_C_ROM_MT_SIZE 1
static struct {
union mt_ptr vals[NIL_TO_C_ROM_MT_SIZE];
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 = {
MT_KEY(MRB_SYM(to_c), MT_FUNC|MT_NOARG|MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(to_c), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
}
};
static mt_tbl nil_to_c_rom_mt = {
static mrb_mt_tbl nil_to_c_rom_mt = {
NIL_TO_C_ROM_MT_SIZE, NIL_TO_C_ROM_MT_SIZE,
(union mt_ptr*)&nil_to_c_rom_data, NULL
(union mrb_mt_ptr*)&nil_to_c_rom_data, NULL
};
#define KERNEL_COMPLEX_ROM_MT_SIZE 1
static struct {
union mt_ptr vals[KERNEL_COMPLEX_ROM_MT_SIZE];
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 = {
MT_KEY(MRB_SYM(Complex), MT_FUNC|MT_PRIVATE),
MRB_MT_KEY(MRB_SYM(Complex), MRB_MT_FUNC|MRB_MT_PRIVATE),
}
};
static mt_tbl kernel_complex_rom_mt = {
static mrb_mt_tbl kernel_complex_rom_mt = {
KERNEL_COMPLEX_ROM_MT_SIZE, KERNEL_COMPLEX_ROM_MT_SIZE,
(union mt_ptr*)&kernel_complex_rom_data, NULL
(union mrb_mt_ptr*)&kernel_complex_rom_data, NULL
};
void mrb_mruby_complex_gem_init(mrb_state *mrb)
mrbgems/mruby-hash-ext/src/hash_ext.c
+9 -9
View File
@@ -369,7 +369,7 @@ hash_merge(mrb_state *mrb, mrb_value hash)
#define HASH_EXT_ROM_MT_SIZE 6
static struct {
union mt_ptr vals[HASH_EXT_ROM_MT_SIZE];
union mrb_mt_ptr vals[HASH_EXT_ROM_MT_SIZE];
mrb_sym keys[HASH_EXT_ROM_MT_SIZE];
} hash_ext_rom_data = {
.vals = {
@@ -381,17 +381,17 @@ static struct {
{ .func = hash_merge },
},
.keys = {
MT_KEY(MRB_SYM(values_at), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(slice), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM_B(slice), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(except), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(key), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(__merge), MT_FUNC|MT_PUBLIC),
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 mt_tbl hash_ext_rom_mt = {
static mrb_mt_tbl hash_ext_rom_mt = {
HASH_EXT_ROM_MT_SIZE, HASH_EXT_ROM_MT_SIZE,
(union mt_ptr*)&hash_ext_rom_data, NULL
(union mrb_mt_ptr*)&hash_ext_rom_data, NULL
};
void
mrbgems/mruby-io/src/file.c
+9 -9
View File
@@ -1124,7 +1124,7 @@ mrb_file_join(mrb_state *mrb, mrb_value klass)
/* ---------------------------*/
#define FILE_ROM_MT_SIZE 6
static struct {
union mt_ptr vals[FILE_ROM_MT_SIZE];
union mrb_mt_ptr vals[FILE_ROM_MT_SIZE];
mrb_sym keys[FILE_ROM_MT_SIZE];
} file_rom_data = {
.vals = {
@@ -1136,17 +1136,17 @@ static struct {
{ .func = mrb_file_truncate },
},
.keys = {
MT_KEY(MRB_SYM(flock), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(_atime), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(_ctime), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(_mtime), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(size), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(truncate), MT_FUNC|MT_PUBLIC),
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 mt_tbl file_rom_mt = {
static mrb_mt_tbl file_rom_mt = {
FILE_ROM_MT_SIZE, FILE_ROM_MT_SIZE,
(union mt_ptr*)&file_rom_data, NULL
(union mrb_mt_ptr*)&file_rom_data, NULL
};
void
mrbgems/mruby-io/src/io.c
+39 -39
View File
@@ -2199,7 +2199,7 @@ io_flush(mrb_state *mrb, mrb_value io)
/* ---------------------------*/
#define IO_ROM_MT_SIZE 36
static struct {
union mt_ptr vals[IO_ROM_MT_SIZE];
union mrb_mt_ptr vals[IO_ROM_MT_SIZE];
mrb_sym keys[IO_ROM_MT_SIZE];
} io_rom_data = {
.vals = {
@@ -2241,47 +2241,47 @@ static struct {
{ .func = io_readbyte },
},
.keys = {
MT_KEY(MRB_SYM(initialize), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(initialize_copy), MT_FUNC|MT_PRIVATE),
MT_KEY(MRB_SYM(isatty), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(eof), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(getc), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(gets), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(read), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(readchar), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(readline), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(readlines), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(sync), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_E(sync), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(sysread), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(sysseek), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(syswrite), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(seek), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(close), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(close_write), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_E(close_on_exec), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(close_on_exec), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(closed), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(flush), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(ungetc), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(ungetbyte), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(pos), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(pid), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(fileno), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(write), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(puts), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(print), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(putc), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(lshift), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(pread), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(pwrite), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(getbyte), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(readbyte), MT_FUNC|MT_NOARG|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(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 mt_tbl io_rom_mt = {
static mrb_mt_tbl io_rom_mt = {
IO_ROM_MT_SIZE, IO_ROM_MT_SIZE,
(union mt_ptr*)&io_rom_data, NULL
(union mrb_mt_ptr*)&io_rom_data, NULL
};
void
mrbgems/mruby-kernel-ext/src/kernel.c
+10 -10
View File
@@ -290,7 +290,7 @@ mrb_f_hash(mrb_state *mrb, mrb_value self)
#define KERNEL_EXT_ROM_MT_SIZE 7
static struct {
union mt_ptr vals[KERNEL_EXT_ROM_MT_SIZE];
union mrb_mt_ptr vals[KERNEL_EXT_ROM_MT_SIZE];
mrb_sym keys[KERNEL_EXT_ROM_MT_SIZE];
} kernel_ext_rom_data = {
.vals = {
@@ -303,18 +303,18 @@ static struct {
{ .func = mrb_f_array },
},
.keys = {
MT_KEY(MRB_SYM(fail), MT_FUNC|MT_PRIVATE),
MT_KEY(MRB_SYM(caller), MT_FUNC|MT_PRIVATE),
MT_KEY(MRB_SYM(__method__), MT_FUNC|MT_NOARG|MT_PRIVATE),
MT_KEY(MRB_SYM(__callee__), MT_FUNC|MT_NOARG|MT_PRIVATE),
MT_KEY(MRB_SYM(Integer), MT_FUNC|MT_PRIVATE),
MT_KEY(MRB_SYM(String), MT_FUNC|MT_PRIVATE),
MT_KEY(MRB_SYM(Array), MT_FUNC|MT_PRIVATE),
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 mt_tbl kernel_ext_rom_mt = {
static mrb_mt_tbl kernel_ext_rom_mt = {
KERNEL_EXT_ROM_MT_SIZE, KERNEL_EXT_ROM_MT_SIZE,
(union mt_ptr*)&kernel_ext_rom_data, NULL
(union mrb_mt_ptr*)&kernel_ext_rom_data, NULL
};
void
mrbgems/mruby-metaprog/src/metaprog.c
+47 -47
View File
@@ -9,12 +9,12 @@
#include <mruby/khash.h>
#include <mruby/presym.h>
#undef MT_PUBLIC
#undef MT_PRIVATE
#define MT_PUBLIC MRB_METHOD_PUBLIC_FL
#define MT_PRIVATE MRB_METHOD_PRIVATE_FL
#undef MRB_MT_PUBLIC
#undef MRB_MT_PRIVATE
#define MRB_MT_PUBLIC MRB_METHOD_PUBLIC_FL
#define MRB_MT_PRIVATE MRB_METHOD_PRIVATE_FL
#define MT_PROTECTED MRB_METHOD_PROTECTED_FL
#define MT_NOPRIV (MT_PRIVATE|MT_PROTECTED)
#define MT_NOPRIV (MRB_MT_PRIVATE|MT_PROTECTED)
static mrb_value
mrb_f_nil(mrb_state *mrb, mrb_value cv)
@@ -139,7 +139,7 @@ struct mt_set {
khash_t(st) *set;
};
#define vicheck(flags, visi) (((visi)==MT_NOPRIV) ? (((flags)&0x3)!=MT_PRIVATE) : (((flags)&0x3)==(visi)))
#define vicheck(flags, visi) (((visi)==MT_NOPRIV) ? (((flags)&0x3)!=MRB_MT_PRIVATE) : (((flags)&0x3)==(visi)))
static int
method_entry_i(mrb_state *mrb, mrb_sym mid, mrb_method_t m, void *p)
@@ -243,7 +243,7 @@ mrb_obj_methods_m(mrb_state *mrb, mrb_value self)
static mrb_value
mrb_obj_private_methods(mrb_state *mrb, mrb_value self)
{
return mrb_obj_methods(mrb, self, MT_PRIVATE);
return mrb_obj_methods(mrb, self, MRB_MT_PRIVATE);
}
/* 15.3.1.3.37 */
@@ -273,7 +273,7 @@ mrb_obj_protected_methods(mrb_state *mrb, mrb_value self)
static mrb_value
mrb_obj_public_methods(mrb_state *mrb, mrb_value self)
{
return mrb_obj_methods(mrb, self, MT_PUBLIC);
return mrb_obj_methods(mrb, self, MRB_MT_PUBLIC);
}
static mrb_value
@@ -286,12 +286,12 @@ mrb_obj_singleton_methods(mrb_state *mrb, mrb_bool recur, mrb_value obj)
klass = mrb_class(mrb, obj);
if (klass && (klass->tt == MRB_TT_SCLASS)) {
method_entry_loop(mrb, klass, set, MT_PUBLIC);
method_entry_loop(mrb, klass, set, MRB_MT_PUBLIC);
klass = klass->super;
}
if (recur) {
while (klass && ((klass->tt == MRB_TT_SCLASS) || (klass->tt == MRB_TT_ICLASS))) {
method_entry_loop(mrb, klass, set, MT_PUBLIC);
method_entry_loop(mrb, klass, set, MRB_MT_PUBLIC);
klass = klass->super;
}
}
@@ -563,13 +563,13 @@ mrb_mod_instance_methods(mrb_state *mrb, mrb_value mod)
static mrb_value
mrb_mod_public_instance_methods(mrb_state *mrb, mrb_value mod)
{
return mod_instance_methods(mrb, mod, MT_PUBLIC);
return mod_instance_methods(mrb, mod, MRB_MT_PUBLIC);
}
static mrb_value
mrb_mod_private_instance_methods(mrb_state *mrb, mrb_value mod)
{
return mod_instance_methods(mrb, mod, MT_PRIVATE);
return mod_instance_methods(mrb, mod, MRB_MT_PRIVATE);
}
static mrb_value
@@ -692,7 +692,7 @@ mrb_mod_s_nesting(mrb_state *mrb, mrb_value mod)
/* ---------------------------*/
#define METAPROG_KRN_ROM_MT_SIZE 15
static struct {
union mt_ptr vals[METAPROG_KRN_ROM_MT_SIZE];
union mrb_mt_ptr vals[METAPROG_KRN_ROM_MT_SIZE];
mrb_sym keys[METAPROG_KRN_ROM_MT_SIZE];
} metaprog_krn_rom_data = {
.vals = {
@@ -713,31 +713,31 @@ static struct {
{ .func = mrb_f_public_send },
},
.keys = {
MT_KEY(MRB_SYM(global_variables), MT_FUNC|MT_NOARG|MT_PRIVATE),
MT_KEY(MRB_SYM(local_variables), MT_FUNC|MT_NOARG|MT_PRIVATE),
MT_KEY(MRB_SYM(singleton_class), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(instance_variable_defined), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(instance_variable_get), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(instance_variable_set), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(instance_variables), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(methods), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(private_methods), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(protected_methods), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(public_methods), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(singleton_methods), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(define_singleton_method), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(send), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(public_send), MT_FUNC|MT_PUBLIC),
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 mt_tbl metaprog_krn_rom_mt = {
static mrb_mt_tbl metaprog_krn_rom_mt = {
METAPROG_KRN_ROM_MT_SIZE, METAPROG_KRN_ROM_MT_SIZE,
(union mt_ptr*)&metaprog_krn_rom_data, NULL
(union mrb_mt_ptr*)&metaprog_krn_rom_data, NULL
};
#define METAPROG_MOD_ROM_MT_SIZE 14
static struct {
union mt_ptr vals[METAPROG_MOD_ROM_MT_SIZE];
union mrb_mt_ptr vals[METAPROG_MOD_ROM_MT_SIZE];
mrb_sym keys[METAPROG_MOD_ROM_MT_SIZE];
} metaprog_mod_rom_data = {
.vals = {
@@ -757,25 +757,25 @@ static struct {
{ .func = mrb_mod_constants },
},
.keys = {
MT_KEY(MRB_SYM(class_variables), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(remove_class_variable), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(class_variable_defined), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(class_variable_get), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(class_variable_set), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(included_modules), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(instance_methods), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(public_instance_methods), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(private_instance_methods), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(protected_instance_methods), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(undefined_instance_methods), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(remove_method), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(method_removed), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(constants), MT_FUNC|MT_PUBLIC),
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 mt_tbl metaprog_mod_rom_mt = {
static mrb_mt_tbl metaprog_mod_rom_mt = {
METAPROG_MOD_ROM_MT_SIZE, METAPROG_MOD_ROM_MT_SIZE,
(union mt_ptr*)&metaprog_mod_rom_data, NULL
(union mrb_mt_ptr*)&metaprog_mod_rom_data, NULL
};
void
mrbgems/mruby-method/src/method.c
+41 -41
View File
@@ -834,7 +834,7 @@ method_name(mrb_state *mrb, mrb_value self)
/* ---------------------------*/
#define METHOD_UBM_ROM_MT_SIZE 12
static struct {
union mt_ptr vals[METHOD_UBM_ROM_MT_SIZE];
union mrb_mt_ptr vals[METHOD_UBM_ROM_MT_SIZE];
mrb_sym keys[METHOD_UBM_ROM_MT_SIZE];
} method_ubm_rom_data = {
.vals = {
@@ -852,28 +852,28 @@ static struct {
{ .func = method_name },
},
.keys = {
MT_KEY(MRB_SYM(bind), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(super_method), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_OPSYM(eq), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(eql), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(to_s), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(inspect), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(arity), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(source_location), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(parameters), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(bind_call), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(owner), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(name), MT_FUNC|MT_NOARG|MT_PUBLIC),
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 mt_tbl method_ubm_rom_mt = {
static mrb_mt_tbl method_ubm_rom_mt = {
METHOD_UBM_ROM_MT_SIZE, METHOD_UBM_ROM_MT_SIZE,
(union mt_ptr*)&method_ubm_rom_data, NULL
(union mrb_mt_ptr*)&method_ubm_rom_data, NULL
};
#define METHOD_MTD_ROM_MT_SIZE 14
static struct {
union mt_ptr vals[METHOD_MTD_ROM_MT_SIZE];
union mrb_mt_ptr vals[METHOD_MTD_ROM_MT_SIZE];
mrb_sym keys[METHOD_MTD_ROM_MT_SIZE];
} method_mtd_rom_data = {
.vals = {
@@ -893,30 +893,30 @@ static struct {
{ .func = method_name },
},
.keys = {
MT_KEY(MRB_OPSYM(eq), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(eql), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(to_s), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(inspect), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(call), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(aref), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(unbind), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(super_method), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(arity), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(source_location), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(parameters), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(owner), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(receiver), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(name), MT_FUNC|MT_NOARG|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(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 mt_tbl method_mtd_rom_mt = {
static mrb_mt_tbl method_mtd_rom_mt = {
METHOD_MTD_ROM_MT_SIZE, METHOD_MTD_ROM_MT_SIZE,
(union mt_ptr*)&method_mtd_rom_data, NULL
(union mrb_mt_ptr*)&method_mtd_rom_data, NULL
};
#define METHOD_KRN_ROM_MT_SIZE 2
static struct {
union mt_ptr vals[METHOD_KRN_ROM_MT_SIZE];
union mrb_mt_ptr vals[METHOD_KRN_ROM_MT_SIZE];
mrb_sym keys[METHOD_KRN_ROM_MT_SIZE];
} method_krn_rom_data = {
.vals = {
@@ -924,30 +924,30 @@ static struct {
{ .func = mrb_kernel_singleton_method },
},
.keys = {
MT_KEY(MRB_SYM(method), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(singleton_method), MT_FUNC|MT_PUBLIC),
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 mt_tbl method_krn_rom_mt = {
static mrb_mt_tbl method_krn_rom_mt = {
METHOD_KRN_ROM_MT_SIZE, METHOD_KRN_ROM_MT_SIZE,
(union mt_ptr*)&method_krn_rom_data, NULL
(union mrb_mt_ptr*)&method_krn_rom_data, NULL
};
#define METHOD_MOD_ROM_MT_SIZE 1
static struct {
union mt_ptr vals[METHOD_MOD_ROM_MT_SIZE];
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 = {
MT_KEY(MRB_SYM(instance_method), MT_FUNC|MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(instance_method), MRB_MT_FUNC|MRB_MT_PUBLIC),
}
};
static mt_tbl method_mod_rom_mt = {
static mrb_mt_tbl method_mod_rom_mt = {
METHOD_MOD_ROM_MT_SIZE, METHOD_MOD_ROM_MT_SIZE,
(union mt_ptr*)&method_mod_rom_data, NULL
(union mrb_mt_ptr*)&method_mod_rom_data, NULL
};
void
mrbgems/mruby-numeric-ext/src/numeric_ext.c
+12 -12
View File
@@ -482,7 +482,7 @@ int_sqrt(mrb_state *mrb, mrb_value self)
#define INTEGER_EXT_ROM_MT_SIZE 9
static struct {
union mt_ptr vals[INTEGER_EXT_ROM_MT_SIZE];
union mrb_mt_ptr vals[INTEGER_EXT_ROM_MT_SIZE];
mrb_sym keys[INTEGER_EXT_ROM_MT_SIZE];
} integer_ext_rom_data = {
.vals = {
@@ -497,20 +497,20 @@ static struct {
{ .func = int_lcm },
},
.keys = {
MT_KEY(MRB_SYM(remainder), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(pow), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(digits), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(size), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(bit_length), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(odd), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(even), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(gcd), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(lcm), MT_FUNC|MT_PUBLIC),
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 mt_tbl integer_ext_rom_mt = {
static mrb_mt_tbl integer_ext_rom_mt = {
INTEGER_EXT_ROM_MT_SIZE, INTEGER_EXT_ROM_MT_SIZE,
(union mt_ptr*)&integer_ext_rom_data, NULL
(union mrb_mt_ptr*)&integer_ext_rom_data, NULL
};
void
mrbgems/mruby-object-ext/src/object.c
+14 -14
View File
@@ -99,7 +99,7 @@ obj_instance_exec(mrb_state *mrb, mrb_value self)
#define NIL_EXT_ROM_MT_SIZE 3
static struct {
union mt_ptr vals[NIL_EXT_ROM_MT_SIZE];
union mrb_mt_ptr vals[NIL_EXT_ROM_MT_SIZE];
mrb_sym keys[NIL_EXT_ROM_MT_SIZE];
} nil_ext_rom_data = {
.vals = {
@@ -108,48 +108,48 @@ static struct {
{ .func = nil_to_i },
},
.keys = {
MT_KEY(MRB_SYM(to_a), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(to_h), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(to_i), MT_FUNC|MT_NOARG|MT_PUBLIC),
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 mt_tbl nil_ext_rom_mt = {
static mrb_mt_tbl nil_ext_rom_mt = {
NIL_EXT_ROM_MT_SIZE, NIL_EXT_ROM_MT_SIZE,
(union mt_ptr*)&nil_ext_rom_data, NULL
(union mrb_mt_ptr*)&nil_ext_rom_data, NULL
};
#define KERNEL_EXT_ROM_MT_SIZE 1
static struct {
union mt_ptr vals[KERNEL_EXT_ROM_MT_SIZE];
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 = {
MT_KEY(MRB_SYM(itself), MT_FUNC|MT_NOARG|MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(itself), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
}
};
static mt_tbl kernel_ext_rom_mt = {
static mrb_mt_tbl kernel_ext_rom_mt = {
KERNEL_EXT_ROM_MT_SIZE, KERNEL_EXT_ROM_MT_SIZE,
(union mt_ptr*)&kernel_ext_rom_data, NULL
(union mrb_mt_ptr*)&kernel_ext_rom_data, NULL
};
#define BOB_EXT_ROM_MT_SIZE 1
static struct {
union mt_ptr vals[BOB_EXT_ROM_MT_SIZE];
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 = {
MT_KEY(MRB_SYM(instance_exec), MT_FUNC|MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(instance_exec), MRB_MT_FUNC|MRB_MT_PUBLIC),
}
};
static mt_tbl bob_ext_rom_mt = {
static mrb_mt_tbl bob_ext_rom_mt = {
BOB_EXT_ROM_MT_SIZE, BOB_EXT_ROM_MT_SIZE,
(union mt_ptr*)&bob_ext_rom_data, NULL
(union mrb_mt_ptr*)&bob_ext_rom_data, NULL
};
void
mrbgems/mruby-proc-ext/src/proc.c
+12 -12
View File
@@ -246,7 +246,7 @@ mrb_proc_parameters(mrb_state *mrb, mrb_value self)
/* ---------------------------*/
#define PROC_EXT_ROM_MT_SIZE 5
static struct {
union mt_ptr vals[PROC_EXT_ROM_MT_SIZE];
union mrb_mt_ptr vals[PROC_EXT_ROM_MT_SIZE];
mrb_sym keys[PROC_EXT_ROM_MT_SIZE];
} proc_ext_rom_data = {
.vals = {
@@ -257,33 +257,33 @@ static struct {
{ .func = proc_inspect },
},
.keys = {
MT_KEY(MRB_SYM(inspect), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(lambda), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(parameters), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(source_location), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(to_s), MT_FUNC|MT_NOARG|MT_PUBLIC),
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 mt_tbl proc_ext_rom_mt = {
static mrb_mt_tbl proc_ext_rom_mt = {
PROC_EXT_ROM_MT_SIZE, PROC_EXT_ROM_MT_SIZE,
(union mt_ptr*)&proc_ext_rom_data, NULL
(union mrb_mt_ptr*)&proc_ext_rom_data, NULL
};
#define KERNEL_EXT_ROM_MT_SIZE 1
static struct {
union mt_ptr vals[KERNEL_EXT_ROM_MT_SIZE];
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 = {
MT_KEY(MRB_SYM(proc), MT_FUNC|MT_PRIVATE),
MRB_MT_KEY(MRB_SYM(proc), MRB_MT_FUNC|MRB_MT_PRIVATE),
}
};
static mt_tbl kernel_ext_rom_mt = {
static mrb_mt_tbl kernel_ext_rom_mt = {
KERNEL_EXT_ROM_MT_SIZE, KERNEL_EXT_ROM_MT_SIZE,
(union mt_ptr*)&kernel_ext_rom_data, NULL
(union mrb_mt_ptr*)&kernel_ext_rom_data, NULL
};
void
mrbgems/mruby-random/src/random.c
+18 -18
View File
@@ -570,7 +570,7 @@ random_f_bytes(mrb_state *mrb, mrb_value self)
#define KERNEL_RAND_ROM_MT_SIZE 2
static struct {
union mt_ptr vals[KERNEL_RAND_ROM_MT_SIZE];
union mrb_mt_ptr vals[KERNEL_RAND_ROM_MT_SIZE];
mrb_sym keys[KERNEL_RAND_ROM_MT_SIZE];
} kernel_rand_rom_data = {
.vals = {
@@ -578,18 +578,18 @@ static struct {
{ .func = random_f_srand },
},
.keys = {
MT_KEY(MRB_SYM(rand), MT_FUNC|MT_PRIVATE),
MT_KEY(MRB_SYM(srand), MT_FUNC|MT_PRIVATE),
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 mt_tbl kernel_rand_rom_mt = {
static mrb_mt_tbl kernel_rand_rom_mt = {
KERNEL_RAND_ROM_MT_SIZE, KERNEL_RAND_ROM_MT_SIZE,
(union mt_ptr*)&kernel_rand_rom_data, NULL
(union mrb_mt_ptr*)&kernel_rand_rom_data, NULL
};
#define RANDOM_ROM_MT_SIZE 4
static struct {
union mt_ptr vals[RANDOM_ROM_MT_SIZE];
union mrb_mt_ptr vals[RANDOM_ROM_MT_SIZE];
mrb_sym keys[RANDOM_ROM_MT_SIZE];
} random_rom_data = {
.vals = {
@@ -599,20 +599,20 @@ static struct {
{ .func = random_m_bytes },
},
.keys = {
MT_KEY(MRB_SYM(initialize), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(rand), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(srand), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(bytes), MT_FUNC|MT_PUBLIC),
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 mt_tbl random_rom_mt = {
static mrb_mt_tbl random_rom_mt = {
RANDOM_ROM_MT_SIZE, RANDOM_ROM_MT_SIZE,
(union mt_ptr*)&random_rom_data, NULL
(union mrb_mt_ptr*)&random_rom_data, NULL
};
#define ARRAY_RAND_ROM_MT_SIZE 3
static struct {
union mt_ptr vals[ARRAY_RAND_ROM_MT_SIZE];
union mrb_mt_ptr vals[ARRAY_RAND_ROM_MT_SIZE];
mrb_sym keys[ARRAY_RAND_ROM_MT_SIZE];
} array_rand_rom_data = {
.vals = {
@@ -621,14 +621,14 @@ static struct {
{ .func = mrb_ary_sample },
},
.keys = {
MT_KEY(MRB_SYM(shuffle), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM_B(shuffle), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(sample), MT_FUNC|MT_PUBLIC),
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 mt_tbl array_rand_rom_mt = {
static mrb_mt_tbl array_rand_rom_mt = {
ARRAY_RAND_ROM_MT_SIZE, ARRAY_RAND_ROM_MT_SIZE,
(union mt_ptr*)&array_rand_rom_data, NULL
(union mrb_mt_ptr*)&array_rand_rom_data, NULL
};
void mrb_mruby_random_gem_init(mrb_state *mrb)
mrbgems/mruby-range-ext/src/range.c
+6 -6
View File
@@ -218,7 +218,7 @@ range_empty_p(mrb_state *mrb, mrb_value range)
#define RANGE_EXT_ROM_MT_SIZE 3
static struct {
union mt_ptr vals[RANGE_EXT_ROM_MT_SIZE];
union mrb_mt_ptr vals[RANGE_EXT_ROM_MT_SIZE];
mrb_sym keys[RANGE_EXT_ROM_MT_SIZE];
} range_ext_rom_data = {
.vals = {
@@ -227,14 +227,14 @@ static struct {
{ .func = range_empty_p },
},
.keys = {
MT_KEY(MRB_SYM_Q(cover), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(size), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(__empty_range), MT_FUNC|MT_PUBLIC),
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 mt_tbl range_ext_rom_mt = {
static mrb_mt_tbl range_ext_rom_mt = {
RANGE_EXT_ROM_MT_SIZE, RANGE_EXT_ROM_MT_SIZE,
(union mt_ptr*)&range_ext_rom_data, NULL
(union mrb_mt_ptr*)&range_ext_rom_data, NULL
};
void
mrbgems/mruby-rational/src/rational.c
+29 -29
View File
@@ -1230,7 +1230,7 @@ rational_hash(mrb_state *mrb, mrb_value rat)
/* ---------------------------*/
#define RATIONAL_ROM_MT_SIZE 14
static struct {
union mt_ptr vals[RATIONAL_ROM_MT_SIZE];
union mrb_mt_ptr vals[RATIONAL_ROM_MT_SIZE];
mrb_sym keys[RATIONAL_ROM_MT_SIZE];
} rational_rom_data = {
.vals = {
@@ -1250,76 +1250,76 @@ static struct {
{ .func = rational_hash },
},
.keys = {
MT_KEY(MRB_SYM(numerator), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(denominator), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(to_i), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(to_r), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(negative), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_OPSYM(eq), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(minus), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_OPSYM(add), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(sub), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(mul), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(div), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(quo), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(pow), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(hash), MT_FUNC|MT_NOARG|MT_PUBLIC),
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 mt_tbl rational_rom_mt = {
static mrb_mt_tbl rational_rom_mt = {
RATIONAL_ROM_MT_SIZE, RATIONAL_ROM_MT_SIZE,
(union mt_ptr*)&rational_rom_data, NULL
(union mrb_mt_ptr*)&rational_rom_data, NULL
};
#define INTEGER_TO_R_ROM_MT_SIZE 1
static struct {
union mt_ptr vals[INTEGER_TO_R_ROM_MT_SIZE];
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 = {
MT_KEY(MRB_SYM(to_r), MT_FUNC|MT_NOARG|MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(to_r), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
}
};
static mt_tbl integer_to_r_rom_mt = {
static mrb_mt_tbl integer_to_r_rom_mt = {
INTEGER_TO_R_ROM_MT_SIZE, INTEGER_TO_R_ROM_MT_SIZE,
(union mt_ptr*)&integer_to_r_rom_data, NULL
(union mrb_mt_ptr*)&integer_to_r_rom_data, NULL
};
#define NIL_TO_R_ROM_MT_SIZE 1
static struct {
union mt_ptr vals[NIL_TO_R_ROM_MT_SIZE];
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 = {
MT_KEY(MRB_SYM(to_r), MT_FUNC|MT_NOARG|MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(to_r), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
}
};
static mt_tbl nil_to_r_rom_mt = {
static mrb_mt_tbl nil_to_r_rom_mt = {
NIL_TO_R_ROM_MT_SIZE, NIL_TO_R_ROM_MT_SIZE,
(union mt_ptr*)&nil_to_r_rom_data, NULL
(union mrb_mt_ptr*)&nil_to_r_rom_data, NULL
};
#define KERNEL_RATIONAL_ROM_MT_SIZE 1
static struct {
union mt_ptr vals[KERNEL_RATIONAL_ROM_MT_SIZE];
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 = {
MT_KEY(MRB_SYM(Rational), MT_FUNC|MT_PRIVATE),
MRB_MT_KEY(MRB_SYM(Rational), MRB_MT_FUNC|MRB_MT_PRIVATE),
}
};
static mt_tbl kernel_rational_rom_mt = {
static mrb_mt_tbl kernel_rational_rom_mt = {
KERNEL_RATIONAL_ROM_MT_SIZE, KERNEL_RATIONAL_ROM_MT_SIZE,
(union mt_ptr*)&kernel_rational_rom_data, NULL
(union mrb_mt_ptr*)&kernel_rational_rom_data, NULL
};
void mrb_mruby_rational_gem_init(mrb_state *mrb)
mrbgems/mruby-set/src/set.c
+46 -46
View File
@@ -1466,7 +1466,7 @@ set_s_create(mrb_state *mrb, mrb_value klass)
#define SET_ROM_MT_SIZE 43
static struct {
union mt_ptr vals[SET_ROM_MT_SIZE];
union mrb_mt_ptr vals[SET_ROM_MT_SIZE];
mrb_sym keys[SET_ROM_MT_SIZE];
} set_rom_data = {
.vals = {
@@ -1515,54 +1515,54 @@ static struct {
{ .func = set_flatten_bang },
},
.keys = {
MT_KEY(MRB_SYM(size), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(length), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(empty), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(clear), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(to_a), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(include), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(member), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(eqq), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(add), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(lshift), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(add), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(delete), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(delete), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(__init), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(__merge), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(__subtract), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(__union), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(__difference), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(__intersection), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(__xor), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(eq), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(hash), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(join), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(inspect), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(to_s), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(reset), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(add_all), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(delete_all), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(include_all), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(include_any), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(superset), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(ge), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(proper_superset), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(gt), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(subset), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(le), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(proper_subset), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(lt), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(intersect), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(disjoint), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(cmp), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(flatten), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_B(flatten), MT_FUNC|MT_NOARG|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_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 mt_tbl set_rom_mt = {
static mrb_mt_tbl set_rom_mt = {
SET_ROM_MT_SIZE, SET_ROM_MT_SIZE,
(union mt_ptr*)&set_rom_data, NULL
(union mrb_mt_ptr*)&set_rom_data, NULL
};
void
mrbgems/mruby-socket/src/socket.c
+36 -36
View File
@@ -1273,7 +1273,7 @@ mrb_win32_basicsocket_syswrite(mrb_state *mrb, mrb_value self)
/* ---------------------------*/
#define ADDRINFO_ROM_MT_SIZE 2
static struct {
union mt_ptr vals[ADDRINFO_ROM_MT_SIZE];
union mrb_mt_ptr vals[ADDRINFO_ROM_MT_SIZE];
mrb_sym keys[ADDRINFO_ROM_MT_SIZE];
} addrinfo_rom_data = {
.vals = {
@@ -1281,18 +1281,18 @@ static struct {
{ .func = mrb_addrinfo_unix_path },
},
.keys = {
MT_KEY(MRB_SYM(getnameinfo), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(unix_path), MT_FUNC|MT_NOARG|MT_PUBLIC),
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 mt_tbl addrinfo_rom_mt = {
static mrb_mt_tbl addrinfo_rom_mt = {
ADDRINFO_ROM_MT_SIZE, ADDRINFO_ROM_MT_SIZE,
(union mt_ptr*)&addrinfo_rom_data, NULL
(union mrb_mt_ptr*)&addrinfo_rom_data, NULL
};
#define BASICSOCKET_ROM_MT_SIZE 11
static struct {
union mt_ptr vals[BASICSOCKET_ROM_MT_SIZE];
union mrb_mt_ptr vals[BASICSOCKET_ROM_MT_SIZE];
mrb_sym keys[BASICSOCKET_ROM_MT_SIZE];
} basicsocket_rom_data = {
.vals = {
@@ -1309,44 +1309,44 @@ static struct {
{ .func = mrb_basicsocket_set_is_socket },
},
.keys = {
MT_KEY(MRB_SYM(_recvfrom), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(_setnonblock), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(getpeereid), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(getpeername), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(getsockname), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(getsockopt), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(recv), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(send), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(setsockopt), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(shutdown), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM_E(_is_socket), MT_FUNC|MT_PUBLIC),
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 mt_tbl basicsocket_rom_mt = {
static mrb_mt_tbl basicsocket_rom_mt = {
BASICSOCKET_ROM_MT_SIZE, BASICSOCKET_ROM_MT_SIZE,
(union mt_ptr*)&basicsocket_rom_data, NULL
(union mrb_mt_ptr*)&basicsocket_rom_data, NULL
};
#define IPSOCKET_ROM_MT_SIZE 1
static struct {
union mt_ptr vals[IPSOCKET_ROM_MT_SIZE];
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 = {
MT_KEY(MRB_SYM(recvfrom), MT_FUNC|MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(recvfrom), MRB_MT_FUNC|MRB_MT_PUBLIC),
}
};
static mt_tbl ipsocket_rom_mt = {
static mrb_mt_tbl ipsocket_rom_mt = {
IPSOCKET_ROM_MT_SIZE, IPSOCKET_ROM_MT_SIZE,
(union mt_ptr*)&ipsocket_rom_data, NULL
(union mrb_mt_ptr*)&ipsocket_rom_data, NULL
};
#define SOCKET_OPTION_ROM_MT_SIZE 10
static struct {
union mt_ptr vals[SOCKET_OPTION_ROM_MT_SIZE];
union mrb_mt_ptr vals[SOCKET_OPTION_ROM_MT_SIZE];
mrb_sym keys[SOCKET_OPTION_ROM_MT_SIZE];
} socket_option_rom_data = {
.vals = {
@@ -1362,21 +1362,21 @@ static struct {
{ .func = socket_option_notimp },
},
.keys = {
MT_KEY(MRB_SYM(initialize), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(inspect), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(family), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(level), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(optname), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(data), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(bool), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(int), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(linger), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(unpack), MT_FUNC|MT_PUBLIC),
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 mt_tbl socket_option_rom_mt = {
static mrb_mt_tbl socket_option_rom_mt = {
SOCKET_OPTION_ROM_MT_SIZE, SOCKET_OPTION_ROM_MT_SIZE,
(union mt_ptr*)&socket_option_rom_data, NULL
(union mrb_mt_ptr*)&socket_option_rom_data, NULL
};
void
mrbgems/mruby-string-ext/src/string.c
+60 -60
View File
@@ -2221,7 +2221,7 @@ str_prepend(mrb_state *mrb, mrb_value self)
/* ---------------------------*/
#define STRING_EXT_ROM_MT_SIZE 53
static struct {
union mt_ptr vals[STRING_EXT_ROM_MT_SIZE];
union mrb_mt_ptr vals[STRING_EXT_ROM_MT_SIZE];
mrb_sym keys[STRING_EXT_ROM_MT_SIZE];
} string_ext_rom_data = {
.vals = {
@@ -2280,81 +2280,81 @@ static struct {
{ .func = str_center_core },
},
.keys = {
MT_KEY(MRB_SYM(dump), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_B(swapcase), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_B(slice), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(swapcase), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(clear), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_OPSYM(lshift), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(concat), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(append_as_bytes), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(count), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(tr), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(partition), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(rpartition), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(insert), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(prepend), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM_B(tr), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(tr_s), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM_B(tr_s), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(squeeze), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM_B(squeeze), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(delete), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM_B(delete), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(start_with), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(end_with), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(hex), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(oct), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(chr), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(succ), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_B(succ), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(next), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_B(next), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(ord), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_B(delete_prefix), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(delete_prefix), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM_B(delete_suffix), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(delete_suffix), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(casecmp), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(casecmp), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(plus), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(minus), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(ascii_only), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(b), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(__lines), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(__codepoints), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(lstrip), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(rstrip), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(strip), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_B(lstrip), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_B(rstrip), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_B(strip), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(__chars), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(ljust), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(rjust), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(center), MT_FUNC|MT_PUBLIC),
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 mt_tbl string_ext_rom_mt = {
static mrb_mt_tbl string_ext_rom_mt = {
STRING_EXT_ROM_MT_SIZE, STRING_EXT_ROM_MT_SIZE,
(union mt_ptr*)&string_ext_rom_data, NULL
(union mrb_mt_ptr*)&string_ext_rom_data, NULL
};
#define INTEGER_CHR_ROM_MT_SIZE 1
static struct {
union mt_ptr vals[INTEGER_CHR_ROM_MT_SIZE];
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 = {
MT_KEY(MRB_SYM(chr), MT_FUNC|MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(chr), MRB_MT_FUNC|MRB_MT_PUBLIC),
}
};
static mt_tbl integer_chr_rom_mt = {
static mrb_mt_tbl integer_chr_rom_mt = {
INTEGER_CHR_ROM_MT_SIZE, INTEGER_CHR_ROM_MT_SIZE,
(union mt_ptr*)&integer_chr_rom_data, NULL
(union mrb_mt_ptr*)&integer_chr_rom_data, NULL
};
void
mrbgems/mruby-struct/src/struct.c
+18 -18
View File
@@ -778,7 +778,7 @@ mrb_struct_to_s(mrb_state *mrb, mrb_value self)
/* ---------------------------*/
#define STRUCT_ROM_MT_SIZE 15
static struct {
union mt_ptr vals[STRUCT_ROM_MT_SIZE];
union mrb_mt_ptr vals[STRUCT_ROM_MT_SIZE];
mrb_sym keys[STRUCT_ROM_MT_SIZE];
} struct_rom_data = {
.vals = {
@@ -799,26 +799,26 @@ static struct {
{ .func = mrb_struct_values_at },
},
.keys = {
MT_KEY(MRB_OPSYM(eq), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(aref), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(aset), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(members), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(initialize), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(initialize_copy), MT_FUNC|MT_PRIVATE),
MT_KEY(MRB_SYM_Q(eql), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(to_s), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(inspect), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(size), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(length), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(to_a), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(values), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(to_h), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(values_at), MT_FUNC|MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(eq), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(aref), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(aset), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(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 mt_tbl struct_rom_mt = {
static mrb_mt_tbl struct_rom_mt = {
STRUCT_ROM_MT_SIZE, STRUCT_ROM_MT_SIZE,
(union mt_ptr*)&struct_rom_data, NULL
(union mrb_mt_ptr*)&struct_rom_data, NULL
};
void
mrbgems/mruby-symbol-ext/src/symbol.c
+5 -5
View File
@@ -60,7 +60,7 @@ mrb_sym_length(mrb_state *mrb, mrb_value self)
#define SYMBOL_EXT_ROM_MT_SIZE 2
static struct {
union mt_ptr vals[SYMBOL_EXT_ROM_MT_SIZE];
union mrb_mt_ptr vals[SYMBOL_EXT_ROM_MT_SIZE];
mrb_sym keys[SYMBOL_EXT_ROM_MT_SIZE];
} symbol_ext_rom_data = {
.vals = {
@@ -68,13 +68,13 @@ static struct {
{ .func = mrb_sym_length },
},
.keys = {
MT_KEY(MRB_SYM(length), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(size), MT_FUNC|MT_NOARG|MT_PUBLIC),
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 mt_tbl symbol_ext_rom_mt = {
static mrb_mt_tbl symbol_ext_rom_mt = {
SYMBOL_EXT_ROM_MT_SIZE, SYMBOL_EXT_ROM_MT_SIZE,
(union mt_ptr*)&symbol_ext_rom_data, NULL
(union mrb_mt_ptr*)&symbol_ext_rom_data, NULL
};
void
mrbgems/mruby-time/src/time.c
+49 -49
View File
@@ -1666,7 +1666,7 @@ time_utc_offset(mrb_state *mrb, mrb_value self)
/* ---------------------------*/
#define TIME_ROM_MT_SIZE 46
static struct {
union mt_ptr vals[TIME_ROM_MT_SIZE];
union mrb_mt_ptr vals[TIME_ROM_MT_SIZE];
mrb_sym keys[TIME_ROM_MT_SIZE];
} time_rom_data = {
.vals = {
@@ -1718,57 +1718,57 @@ static struct {
{ .func = time_utc_offset },
},
.keys = {
MT_KEY(MRB_SYM(hash), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(eql), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(eq), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(cmp), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(add), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(sub), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(to_s), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(inspect), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(asctime), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(ctime), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(day), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(dst), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(getgm), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(getlocal), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(getutc), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(gmt), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(gmtime), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(hour), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(localtime), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(mday), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(min), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(mon), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(month), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(sec), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(to_i), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(usec), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(nsec), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(tv_nsec), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(utc), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(utc), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(wday), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(yday), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(year), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(zone), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(initialize), MT_FUNC|MT_PRIVATE),
MT_KEY(MRB_SYM(initialize_copy), MT_FUNC|MT_PRIVATE),
MT_KEY(MRB_SYM_Q(sunday), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(monday), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(tuesday), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(wednesday), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(thursday), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(friday), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(saturday), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(gmt_offset), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(gmtoff), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(utc_offset), MT_FUNC|MT_NOARG|MT_PUBLIC),
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 mt_tbl time_rom_mt = {
static mrb_mt_tbl time_rom_mt = {
TIME_ROM_MT_SIZE, TIME_ROM_MT_SIZE,
(union mt_ptr*)&time_rom_data, NULL
(union mrb_mt_ptr*)&time_rom_data, NULL
};
void
src/array.c
+39 -39
View File
@@ -2251,7 +2251,7 @@ mrb_ary_to_a(mrb_state *mrb, mrb_value self)
/* ---------------------------*/
#define ARRAY_ROM_MT_SIZE 36
static struct {
union mt_ptr vals[ARRAY_ROM_MT_SIZE];
union mrb_mt_ptr vals[ARRAY_ROM_MT_SIZE];
mrb_sym keys[ARRAY_ROM_MT_SIZE];
} array_rom_data = {
.vals = {
@@ -2293,47 +2293,47 @@ static struct {
{ .func = mrb_ary_svalue },
},
.keys = {
MT_KEY(MRB_OPSYM(add), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(mul), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(lshift), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(aref), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(aset), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(clear), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_OPSYM(cmp), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(concat), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(delete), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(delete_at), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(empty), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_OPSYM(eq), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(eql), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(first), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(index), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(initialize), MT_FUNC|MT_PRIVATE),
MT_KEY(MRB_SYM(initialize_copy), MT_FUNC|MT_PRIVATE),
MT_KEY(MRB_SYM(join), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(last), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(length), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(pop), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(push), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(replace), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(reverse), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_B(reverse), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(rindex), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(shift), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(size), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(slice), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(unshift), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(to_a), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(entries), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(to_s), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(inspect), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_B(sort), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(__svalue), MT_FUNC|MT_NOARG|MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(add), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(mul), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(lshift), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(aref), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(aset), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(clear), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(cmp), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(concat), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(delete), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(delete_at), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_Q(empty), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(eq), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_Q(eql), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(first), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(index), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(initialize), MRB_MT_FUNC|MRB_MT_PRIVATE),
MRB_MT_KEY(MRB_SYM(initialize_copy), MRB_MT_FUNC|MRB_MT_PRIVATE),
MRB_MT_KEY(MRB_SYM(join), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(last), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(length), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(pop), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(push), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(replace), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(reverse), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_B(reverse), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(rindex), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(shift), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(size), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(slice), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(unshift), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(to_a), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(entries), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(to_s), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(inspect), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_B(sort), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(__svalue), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
}
};
static mt_tbl array_rom_mt = {
static mrb_mt_tbl array_rom_mt = {
ARRAY_ROM_MT_SIZE, ARRAY_ROM_MT_SIZE,
(union mt_ptr*)&array_rom_data, NULL
(union mrb_mt_ptr*)&array_rom_data, NULL
};
void
src/class.c
+133 -133
View File
@@ -21,41 +21,41 @@
#define METHOD_MID(m) MT_KEY_SYM((m).flags)
/* mt_tbl, union mt_ptr, MT_KEY(), MT_READONLY_BIT, etc. defined in internal.h */
#define MT_KEY_MASK ((1<<MT_KEY_SHIFT)-1)
#define MT_KEY_P(k) (((k)>>MT_KEY_SHIFT) != 0)
/* mrb_mt_tbl, union mrb_mt_ptr, MRB_MT_KEY(), etc. defined in internal.h */
#define MT_KEY_MASK ((1<<MRB_MT_KEY_SHIFT)-1)
#define MT_KEY_P(k) (((k)>>MRB_MT_KEY_SHIFT) != 0)
#define MT_PROTECTED MRB_METHOD_PROTECTED_FL
#define MT_VDEFAULT MRB_METHOD_VDEFAULT_FL
#define MT_VMASK MRB_METHOD_VISIBILITY_MASK
#define MT_EMPTY 0
#define MT_DELETED 1
#define MT_KEY_SYM(k) ((k)>>MT_KEY_SHIFT)
#define MT_KEY_SYM(k) ((k)>>MRB_MT_KEY_SHIFT)
#define MT_KEY_FLG(k) ((k)&MT_KEY_MASK)
#define MT_ALLOC(t) ((t)->alloc & ~MT_READONLY_BIT)
#define mt_readonly_p(t) ((t)->alloc & MT_READONLY_BIT)
#define MT_ALLOC(t) ((t)->alloc & ~MRB_MT_READONLY_BIT)
#define mt_readonly_p(t) ((t)->alloc & MRB_MT_READONLY_BIT)
/* Helper to get keys array from method table */
static inline mrb_sym*
mt_keys(mt_tbl *t) {
mt_keys(mrb_mt_tbl *t) {
return (mrb_sym*)&t->ptr[MT_ALLOC(t)];
}
/* Helper to get values array from method table */
static union mt_ptr*
mt_vals(mt_tbl *t) {
static union mrb_mt_ptr*
mt_vals(mrb_mt_tbl *t) {
return t->ptr;
}
/* Allocates or grows the method table block to exactly new_alloc entries */
static void
mt_grow(mrb_state *mrb, mt_tbl *t, int new_alloc)
mt_grow(mrb_state *mrb, mrb_mt_tbl *t, int new_alloc)
{
int old_alloc = MT_ALLOC(t);
size_t new_block = new_alloc * (sizeof(union mt_ptr) + sizeof(mrb_sym));
size_t new_block = new_alloc * (sizeof(union mrb_mt_ptr) + sizeof(mrb_sym));
t->ptr = (union mt_ptr*)mrb_realloc(mrb, t->ptr, new_block);
t->ptr = (union mrb_mt_ptr*)mrb_realloc(mrb, t->ptr, new_block);
if (old_alloc > 0) {
/* keys used to live at &ptr[old_alloc] */
mrb_sym *old_keys = (mrb_sym*)&t->ptr[old_alloc];
@@ -69,12 +69,12 @@ mt_grow(mrb_state *mrb, mt_tbl *t, int new_alloc)
}
/* Creates a new empty method table */
static mt_tbl*
static mrb_mt_tbl*
mt_new(mrb_state *mrb)
{
mt_tbl *t;
mrb_mt_tbl *t;
t = (mt_tbl*)mrb_malloc(mrb, sizeof(mt_tbl));
t = (mrb_mt_tbl*)mrb_malloc(mrb, sizeof(mrb_mt_tbl));
t->size = 0;
t->alloc = 0;
t->ptr = NULL;
@@ -111,9 +111,9 @@ mt_bsearch_idx(mrb_sym *keys, int size, mrb_sym target)
/* Inserts or updates an entry in the method table */
static void
mt_put(mrb_state *mrb, mt_tbl *t, mrb_sym sym, mrb_sym flags, union mt_ptr ptrval)
mt_put(mrb_state *mrb, mrb_mt_tbl *t, mrb_sym sym, mrb_sym flags, union mrb_mt_ptr ptrval)
{
mrb_sym key = MT_KEY(sym, flags);
mrb_sym key = MRB_MT_KEY(sym, flags);
/* Ensure there is capacity */
if (MT_ALLOC(t) == 0) {
@@ -124,7 +124,7 @@ mt_put(mrb_state *mrb, mt_tbl *t, mrb_sym sym, mrb_sym flags, union mt_ptr ptrva
}
mrb_sym *keys = mt_keys(t);
union mt_ptr *vals = mt_vals(t);
union mrb_mt_ptr *vals = mt_vals(t);
/*
* If table is empty, insertion index is 0.
@@ -142,7 +142,7 @@ mt_put(mrb_state *mrb, mt_tbl *t, mrb_sym sym, mrb_sym flags, union mt_ptr ptrva
/* Shift existing entries to make room at index lo */
if (t->size > lo) {
int move_count = t->size - lo;
memmove(&vals[lo+1], &vals[lo], move_count * sizeof(union mt_ptr));
memmove(&vals[lo+1], &vals[lo], move_count * sizeof(union mrb_mt_ptr));
memmove(&keys[lo+1], &keys[lo], move_count * sizeof(mrb_sym));
}
@@ -154,15 +154,15 @@ mt_put(mrb_state *mrb, mt_tbl *t, mrb_sym sym, mrb_sym flags, union mt_ptr ptrva
/* Retrieves a value from the method table (walks chain) */
static mrb_sym
mt_get(mrb_state *mrb, mt_tbl *t, mrb_sym sym, union mt_ptr *pp)
mt_get(mrb_state *mrb, mrb_mt_tbl *t, mrb_sym sym, union mrb_mt_ptr *pp)
{
while (t) {
if (t->size > 0) {
mrb_sym *keys = mt_keys(t);
union mt_ptr *vals = mt_vals(t);
union mrb_mt_ptr *vals = mt_vals(t);
int lo = mt_bsearch_idx(keys, t->size, sym);
if (lo < t->size && MT_KEY_SYM(keys[lo]) == sym) {
if (MT_REMOVED_P(keys[lo], vals[lo])) return 0; /* removed tombstone */
if (MRB_MT_REMOVED_P(keys[lo], vals[lo])) return 0; /* removed tombstone */
*pp = vals[lo];
return keys[lo];
}
@@ -174,13 +174,13 @@ mt_get(mrb_state *mrb, mt_tbl *t, mrb_sym sym, union mt_ptr *pp)
/* Deletes an entry from the method table */
static mrb_bool
mt_del(mrb_state *mrb, mt_tbl *t, mrb_sym sym)
mt_del(mrb_state *mrb, mrb_mt_tbl *t, mrb_sym sym)
{
/* Return FALSE if table is null or empty */
if (!t || t->size == 0) return FALSE;
mrb_sym *keys = mt_keys(t);
union mt_ptr *vals = mt_vals(t);
union mrb_mt_ptr *vals = mt_vals(t);
/* Find the index of `sym` in a branch-free manner */
int lo = mt_bsearch_idx(keys, t->size, sym);
@@ -189,7 +189,7 @@ mt_del(mrb_state *mrb, mt_tbl *t, mrb_sym sym)
if (lo < t->size && MT_KEY_SYM(keys[lo]) == sym) {
int move_count = t->size - lo - 1;
/* shift left to remove entry */
memmove(&vals[lo], &vals[lo + 1], move_count * sizeof(union mt_ptr));
memmove(&vals[lo], &vals[lo + 1], move_count * sizeof(union mrb_mt_ptr));
memmove(&keys[lo], &keys[lo + 1], move_count * sizeof(mrb_sym));
t->size--;
return TRUE;
@@ -201,7 +201,7 @@ mt_del(mrb_state *mrb, mt_tbl *t, mrb_sym sym)
/* Checks if any layer in the chain contains the given symbol */
static mrb_bool
mt_chain_has(mt_tbl *t, mrb_sym sym)
mt_chain_has(mrb_mt_tbl *t, mrb_sym sym)
{
while (t) {
if (t->size > 0) {
@@ -215,22 +215,22 @@ mt_chain_has(mt_tbl *t, mrb_sym sym)
}
/* Creates a copy of the method table */
static mt_tbl*
mt_copy(mrb_state *mrb, mt_tbl *t)
static mrb_mt_tbl*
mt_copy(mrb_state *mrb, mrb_mt_tbl *t)
{
if (!t) return NULL;
if (mt_readonly_p(t)) {
/* source is ROM — new class gets empty mutable top + shared ROM chain */
if (t->size == 0 && !t->next) return NULL;
mt_tbl *t2 = mt_new(mrb);
mrb_mt_tbl *t2 = mt_new(mrb);
t2->next = t;
return t2;
}
if (t->size == 0 && !t->next) return NULL;
mt_tbl *t2 = mt_new(mrb);
mrb_mt_tbl *t2 = mt_new(mrb);
if (t->size > 0) {
mt_grow(mrb, t2, t->size);
memcpy(mt_vals(t2), mt_vals(t), t->size * sizeof(union mt_ptr));
memcpy(mt_vals(t2), mt_vals(t), t->size * sizeof(union mrb_mt_ptr));
memcpy(mt_keys(t2), mt_keys(t), t->size * sizeof(mrb_sym));
t2->size = t->size;
}
@@ -240,10 +240,10 @@ mt_copy(mrb_state *mrb, mt_tbl *t)
/* Frees memory of the method table (skips readonly/ROM layers) */
static void
mt_free(mrb_state *mrb, mt_tbl *t)
mt_free(mrb_state *mrb, mrb_mt_tbl *t)
{
while (t && !mt_readonly_p(t)) {
mt_tbl *next = t->next;
mrb_mt_tbl *next = t->next;
mrb_free(mrb, t->ptr);
mrb_free(mrb, t);
t = next;
@@ -252,11 +252,11 @@ mt_free(mrb_state *mrb, mt_tbl *t)
/* Sorts parallel vals/keys arrays by key symbol (insertion sort) */
static void
mt_sort(union mt_ptr *vals, mrb_sym *keys, int n)
mt_sort(union mrb_mt_ptr *vals, mrb_sym *keys, int n)
{
for (int i = 1; i < n; i++) {
mrb_sym key = keys[i];
union mt_ptr val = vals[i];
union mrb_mt_ptr val = vals[i];
mrb_sym sym = MT_KEY_SYM(key);
int j = i;
while (j > 0 && MT_KEY_SYM(keys[j-1]) > sym) {
@@ -271,15 +271,15 @@ mt_sort(union mt_ptr *vals, mrb_sym *keys, int n)
/* Sorts a static ROM table, sets readonly flag, and pushes it to the class */
void
mrb_mt_init_rom(struct RClass *c, mt_tbl *rom)
mrb_mt_init_rom(struct RClass *c, mrb_mt_tbl *rom)
{
union mt_ptr *vals = rom->ptr;
union mrb_mt_ptr *vals = rom->ptr;
mrb_sym *keys = (mrb_sym*)&vals[rom->size];
mt_sort(vals, keys, rom->size);
rom->alloc = rom->size | MT_READONLY_BIT;
rom->alloc = rom->size | MRB_MT_READONLY_BIT;
/* push ROM layer */
mt_tbl *t = c->mt;
mrb_mt_tbl *t = c->mt;
if (!t || mt_readonly_p(t)) {
rom->next = t;
c->mt = rom;
@@ -292,7 +292,7 @@ mrb_mt_init_rom(struct RClass *c, mt_tbl *rom)
/* Creates a method value structure from key and pointer */
static inline mrb_method_t
create_method_value(mrb_state *mrb, mrb_sym key, union mt_ptr val)
create_method_value(mrb_state *mrb, mrb_sym key, union mrb_mt_ptr val)
{
mrb_method_t m = { key, { val.proc } };
return m;
@@ -302,15 +302,15 @@ create_method_value(mrb_state *mrb, mrb_sym key, union mt_ptr val)
MRB_API void
mrb_mt_foreach(mrb_state *mrb, struct RClass *c, mrb_mt_foreach_func *fn, void *p)
{
mt_tbl *t = c->mt;
mrb_mt_tbl *t = c->mt;
if (!t) return;
/* fast path: single layer */
if (!t->next) {
for (int i = 0; i < t->size; i++) {
union mt_ptr *vals = mt_vals(t);
union mrb_mt_ptr *vals = mt_vals(t);
mrb_sym *keys = mt_keys(t);
if (MT_REMOVED_P(keys[i], vals[i])) continue;
if (MRB_MT_REMOVED_P(keys[i], vals[i])) continue;
if (fn(mrb, MT_KEY_SYM(keys[i]),
create_method_value(mrb, keys[i], vals[i]), p) != 0)
return;
@@ -319,16 +319,16 @@ mrb_mt_foreach(mrb_state *mrb, struct RClass *c, mrb_mt_foreach_func *fn, void *
}
/* multi-layer: iterate each layer, skip if shadowed by a higher one */
for (mt_tbl *layer = t; layer; layer = layer->next) {
for (mrb_mt_tbl *layer = t; layer; layer = layer->next) {
mrb_sym *keys = mt_keys(layer);
union mt_ptr *vals = mt_vals(layer);
union mrb_mt_ptr *vals = mt_vals(layer);
for (int i = 0; i < layer->size; i++) {
if (MT_REMOVED_P(keys[i], vals[i])) continue;
if (MRB_MT_REMOVED_P(keys[i], vals[i])) continue;
mrb_sym sym = MT_KEY_SYM(keys[i]);
/* check if shadowed by a higher layer */
if (layer != t) {
mrb_bool shadowed = FALSE;
for (mt_tbl *upper = t; upper != layer; upper = upper->next) {
for (mrb_mt_tbl *upper = t; upper != layer; upper = upper->next) {
if (upper->size > 0) {
mrb_sym *ukeys = mt_keys(upper);
int lo = mt_bsearch_idx(ukeys, upper->size, sym);
@@ -351,13 +351,13 @@ size_t
mrb_gc_mark_mt(mrb_state *mrb, struct RClass *c)
{
size_t children = 0;
for (mt_tbl *t = c->mt; t; t = t->next) {
for (mrb_mt_tbl *t = c->mt; t; t = t->next) {
if (mt_readonly_p(t)) continue; /* ROM layers need no GC marking */
if (t->size == 0) continue;
mrb_sym *keys = mt_keys(t);
union mt_ptr *vals = mt_vals(t);
union mrb_mt_ptr *vals = mt_vals(t);
for (int i = 0; i < t->size; i++) {
if (MT_KEY_P(keys[i]) && (keys[i] & MT_FUNC) == 0) {
if (MT_KEY_P(keys[i]) && (keys[i] & MRB_MT_FUNC) == 0) {
mrb_gc_mark(mrb, (struct RBasic*)vals[i].proc);
}
}
@@ -371,9 +371,9 @@ size_t
mrb_class_mt_memsize(mrb_state *mrb, struct RClass *c)
{
size_t total = 0;
for (mt_tbl *h = c->mt; h && !mt_readonly_p(h); h = h->next)
total += sizeof(mt_tbl) + (size_t)MT_ALLOC(h) *
(sizeof(union mt_ptr) + sizeof(mrb_sym));
for (mrb_mt_tbl *h = c->mt; h && !mt_readonly_p(h); h = h->next)
total += sizeof(mrb_mt_tbl) + (size_t)MT_ALLOC(h) *
(sizeof(union mrb_mt_ptr) + sizeof(mrb_sym));
return total;
}
@@ -1075,11 +1075,11 @@ find_visibility_scope(mrb_state *mrb, const struct RClass *c, int n, mrb_callinf
MRB_API void
mrb_define_method_raw(mrb_state *mrb, struct RClass *c, mrb_sym mid, mrb_method_t m)
{
union mt_ptr ptr;
union mrb_mt_ptr ptr;
MRB_CLASS_ORIGIN(c);
mt_tbl *h = c->mt;
mrb_mt_tbl *h = c->mt;
if (c->tt == MRB_TT_SCLASS && mrb_frozen_p(c)) {
mrb_value v = mrb_iv_get(mrb, mrb_obj_value(c), MRB_SYM(__attached__));
mrb_check_frozen_value(mrb, v);
@@ -1092,7 +1092,7 @@ mrb_define_method_raw(mrb_state *mrb, struct RClass *c, mrb_sym mid, mrb_method_
}
else if (mt_readonly_p(h)) {
/* COW: create mutable top layer, chain to ROM */
mt_tbl *top = mt_new(mrb);
mrb_mt_tbl *top = mt_new(mrb);
top->next = h;
h = c->mt = top;
}
@@ -1123,12 +1123,12 @@ mrb_define_method_raw(mrb_state *mrb, struct RClass *c, mrb_sym mid, mrb_method_
if (mid == MRB_SYM(initialize) ||
mid == MRB_SYM(initialize_copy) ||
mid == MRB_SYM_Q(respond_to_missing)) {
MRB_SET_VISIBILITY_FLAGS(flags, MT_PRIVATE);
MRB_SET_VISIBILITY_FLAGS(flags, MRB_MT_PRIVATE);
}
else if ((flags & MT_VMASK) == MT_VDEFAULT) {
/* singleton methods are always public */
if (c->tt == MRB_TT_SCLASS) {
MRB_SET_VISIBILITY_FLAGS(flags, MT_PUBLIC);
MRB_SET_VISIBILITY_FLAGS(flags, MRB_MT_PUBLIC);
}
else {
mrb_callinfo *ci;
@@ -1171,7 +1171,7 @@ define_method_id(mrb_state *mrb, struct RClass *c, mrb_sym mid, mrb_func_t func,
MRB_API void
mrb_define_method_id(mrb_state *mrb, struct RClass *c, mrb_sym mid, mrb_func_t func, mrb_aspec aspec)
{
define_method_id(mrb, c, mid, func, aspec, MT_PUBLIC);
define_method_id(mrb, c, mid, func, aspec, MRB_MT_PUBLIC);
}
/*
@@ -1206,7 +1206,7 @@ mrb_define_method(mrb_state *mrb, struct RClass *c, const char *name, mrb_func_t
MRB_API void
mrb_define_private_method_id(mrb_state *mrb, struct RClass *c, mrb_sym mid, mrb_func_t func, mrb_aspec aspec)
{
define_method_id(mrb, c, mid, func, aspec, MT_PRIVATE);
define_method_id(mrb, c, mid, func, aspec, MRB_MT_PRIVATE);
}
/*
@@ -2368,13 +2368,13 @@ mrb_mod_visibility(mrb_state *mrb, mrb_value mod, int vis)
}
}
else {
mt_tbl *h = c->mt;
mrb_mt_tbl *h = c->mt;
for (int i=0; i<argc; i++) {
mrb_check_type(mrb, argv[i], MRB_TT_SYMBOL);
mrb_sym mid = mrb_symbol(argv[i]);
mrb_method_t m = mrb_method_search(mrb, c, mid);
MRB_METHOD_SET_VISIBILITY(m, vis);
union mt_ptr ptr;
union mrb_mt_ptr ptr;
if (MRB_METHOD_PROC_P(m)) {
ptr.proc = MRB_METHOD_PROC(m);
}
@@ -2390,14 +2390,14 @@ mrb_mod_visibility(mrb_state *mrb, mrb_value mod, int vis)
static mrb_value
mrb_mod_public(mrb_state *mrb, mrb_value mod)
{
mrb_mod_visibility(mrb, mod, MT_PUBLIC);
mrb_mod_visibility(mrb, mod, MRB_MT_PUBLIC);
return mod;
}
static mrb_value
mrb_mod_private(mrb_state *mrb, mrb_value mod)
{
mrb_mod_visibility(mrb, mod, MT_PRIVATE);
mrb_mod_visibility(mrb, mod, MRB_MT_PRIVATE);
return mod;
}
@@ -2412,7 +2412,7 @@ static mrb_value
top_public(mrb_state *mrb, mrb_value self)
{
self = mrb_obj_value(mrb->object_class);
mrb_mod_visibility(mrb, self, MT_PUBLIC);
mrb_mod_visibility(mrb, self, MRB_MT_PUBLIC);
return self;
}
@@ -2420,7 +2420,7 @@ static mrb_value
top_private(mrb_state *mrb, mrb_value self)
{
self = mrb_obj_value(mrb->object_class);
mrb_mod_visibility(mrb, self, MT_PRIVATE);
mrb_mod_visibility(mrb, self, MRB_MT_PRIVATE);
return self;
}
@@ -2711,10 +2711,10 @@ mrb_vm_find_method(mrb_state *mrb, struct RClass *c, struct RClass **cp, mrb_sym
#endif
while (c) {
mt_tbl *h = c->mt;
mrb_mt_tbl *h = c->mt;
if (h) {
union mt_ptr ptr;
union mrb_mt_ptr ptr;
mrb_sym ret = mt_get(mrb, h, mid, &ptr);
if (ret) {
if (ptr.proc == 0) break;
@@ -3646,20 +3646,20 @@ mrb_remove_method(mrb_state *mrb, struct RClass *c0, mrb_sym mid)
mrb_bool found = FALSE;
MRB_CLASS_ORIGIN(c);
mt_tbl *h = c->mt;
mrb_mt_tbl *h = c->mt;
if (h) {
found = mt_del(mrb, h, mid);
/* insert removed tombstone to block ROM chain lookup */
if (h->next && mt_chain_has(h->next, mid)) {
union mt_ptr tombstone;
union mrb_mt_ptr tombstone;
tombstone.func = NULL;
found = TRUE;
if (mt_readonly_p(h)) {
mt_tbl *top = mt_new(mrb);
mrb_mt_tbl *top = mt_new(mrb);
top->next = h;
h = c->mt = top;
}
mt_put(mrb, h, mid, MT_FUNC, tombstone);
mt_put(mrb, h, mid, MRB_MT_FUNC, tombstone);
}
}
if (!found) {
@@ -3907,7 +3907,7 @@ define_method_m(mrb_state *mrb, struct RClass *c, int vis)
mrb_value
mrb_mod_define_method_m(mrb_state *mrb, struct RClass *c)
{
return define_method_m(mrb, c, MT_PUBLIC);
return define_method_m(mrb, c, MRB_MT_PUBLIC);
}
static mrb_value
@@ -3919,7 +3919,7 @@ mod_define_method(mrb_state *mrb, mrb_value self)
static mrb_value
top_define_method(mrb_state *mrb, mrb_value self)
{
return define_method_m(mrb, mrb->object_class, MT_PRIVATE);
return define_method_m(mrb, mrb->object_class, MRB_MT_PRIVATE);
}
static mrb_value
@@ -3965,7 +3965,7 @@ mrb_mod_module_function(mrb_state *mrb, mrb_value mod)
mrb_method_t m = mrb_method_search(mrb, rclass, mid);
prepare_singleton_class(mrb, (struct RBasic*)rclass);
MRB_METHOD_SET_VISIBILITY(m, MT_PUBLIC);
MRB_METHOD_SET_VISIBILITY(m, MRB_MT_PUBLIC);
mrb_define_method_raw(mrb, rclass->c, mid, m);
mrb_gc_arena_restore(mrb, ai);
}
@@ -4354,7 +4354,7 @@ static const struct RProc neq_proc = {
/* ---------------------------*/
#define BOB_ROM_MT_SIZE 11
static struct {
union mt_ptr vals[BOB_ROM_MT_SIZE];
union mrb_mt_ptr vals[BOB_ROM_MT_SIZE];
mrb_sym keys[BOB_ROM_MT_SIZE];
} bob_rom_data = {
.vals = {
@@ -4371,27 +4371,27 @@ static struct {
{ .func = mrb_do_nothing },
},
.keys = {
MT_KEY(MRB_OPSYM(eq), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(not), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(__id__), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(__send__), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(equal), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(initialize), MT_FUNC|MT_NOARG|MT_PRIVATE),
MT_KEY(MRB_SYM(instance_eval), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(method_missing), MT_FUNC|MT_PRIVATE),
MT_KEY(MRB_SYM(singleton_method_added), MT_FUNC|MT_PRIVATE),
MT_KEY(MRB_SYM(singleton_method_removed), MT_FUNC|MT_PRIVATE),
MT_KEY(MRB_SYM(singleton_method_undefined), MT_FUNC|MT_PRIVATE),
MRB_MT_KEY(MRB_OPSYM(eq), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(not), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(__id__), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(__send__), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_Q(equal), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(initialize), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PRIVATE),
MRB_MT_KEY(MRB_SYM(instance_eval), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(method_missing), MRB_MT_FUNC|MRB_MT_PRIVATE),
MRB_MT_KEY(MRB_SYM(singleton_method_added), MRB_MT_FUNC|MRB_MT_PRIVATE),
MRB_MT_KEY(MRB_SYM(singleton_method_removed), MRB_MT_FUNC|MRB_MT_PRIVATE),
MRB_MT_KEY(MRB_SYM(singleton_method_undefined), MRB_MT_FUNC|MRB_MT_PRIVATE),
}
};
static mt_tbl bob_rom_mt = {
static mrb_mt_tbl bob_rom_mt = {
BOB_ROM_MT_SIZE, BOB_ROM_MT_SIZE,
(union mt_ptr*)&bob_rom_data, NULL
(union mrb_mt_ptr*)&bob_rom_data, NULL
};
#define CLS_ROM_MT_SIZE 4
static struct {
union mt_ptr vals[CLS_ROM_MT_SIZE];
union mrb_mt_ptr vals[CLS_ROM_MT_SIZE];
mrb_sym keys[CLS_ROM_MT_SIZE];
} cls_rom_data = {
.vals = {
@@ -4401,20 +4401,20 @@ static struct {
{ .func = mrb_class_superclass },
},
.keys = {
MT_KEY(MRB_SYM(allocate), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(inherited), MT_FUNC|MT_PRIVATE),
MT_KEY(MRB_SYM(initialize), MT_FUNC|MT_PRIVATE),
MT_KEY(MRB_SYM(superclass), MT_FUNC|MT_NOARG|MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(allocate), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(inherited), MRB_MT_FUNC|MRB_MT_PRIVATE),
MRB_MT_KEY(MRB_SYM(initialize), MRB_MT_FUNC|MRB_MT_PRIVATE),
MRB_MT_KEY(MRB_SYM(superclass), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
}
};
static mt_tbl cls_rom_mt = {
static mrb_mt_tbl cls_rom_mt = {
CLS_ROM_MT_SIZE, CLS_ROM_MT_SIZE,
(union mt_ptr*)&cls_rom_data, NULL
(union mrb_mt_ptr*)&cls_rom_data, NULL
};
#define MOD_ROM_MT_SIZE 34
static struct {
union mt_ptr vals[MOD_ROM_MT_SIZE];
union mrb_mt_ptr vals[MOD_ROM_MT_SIZE];
mrb_sym keys[MOD_ROM_MT_SIZE];
} mod_rom_data = {
.vals = {
@@ -4454,45 +4454,45 @@ static struct {
{ .func = mrb_mod_undef },
},
.keys = {
MT_KEY(MRB_OPSYM(eqq), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(alias_method), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(ancestors), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(attr_accessor), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(attr_reader), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(attr_writer), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(class_eval), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(const_added), MT_FUNC|MT_PRIVATE),
MT_KEY(MRB_SYM_Q(const_defined), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(const_get), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(const_missing), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(const_set), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(define_method), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(dup), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(extended), MT_FUNC|MT_PRIVATE),
MT_KEY(MRB_SYM(include), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(include), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(included), MT_FUNC|MT_PRIVATE),
MT_KEY(MRB_SYM(initialize), MT_FUNC|MT_NOARG|MT_PRIVATE),
MT_KEY(MRB_SYM(inspect), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(method_added), MT_FUNC|MT_PRIVATE),
MT_KEY(MRB_SYM(method_removed), MT_FUNC|MT_PRIVATE),
MT_KEY(MRB_SYM_Q(method_defined), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(method_undefined), MT_FUNC|MT_PRIVATE),
MT_KEY(MRB_SYM(module_eval), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(module_function), MT_FUNC|MT_PRIVATE),
MT_KEY(MRB_SYM(prepend), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(prepended), MT_FUNC|MT_PRIVATE),
MT_KEY(MRB_SYM(private), MT_FUNC|MT_PRIVATE),
MT_KEY(MRB_SYM(protected), MT_FUNC|MT_PRIVATE),
MT_KEY(MRB_SYM(public), MT_FUNC|MT_PRIVATE),
MT_KEY(MRB_SYM(remove_const), MT_FUNC|MT_PRIVATE),
MT_KEY(MRB_SYM(to_s), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(undef_method), MT_FUNC|MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(eqq), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(alias_method), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(ancestors), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(attr_accessor), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(attr_reader), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(attr_writer), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(class_eval), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(const_added), MRB_MT_FUNC|MRB_MT_PRIVATE),
MRB_MT_KEY(MRB_SYM_Q(const_defined), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(const_get), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(const_missing), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(const_set), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(define_method), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(dup), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(extended), MRB_MT_FUNC|MRB_MT_PRIVATE),
MRB_MT_KEY(MRB_SYM(include), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_Q(include), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(included), MRB_MT_FUNC|MRB_MT_PRIVATE),
MRB_MT_KEY(MRB_SYM(initialize), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PRIVATE),
MRB_MT_KEY(MRB_SYM(inspect), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(method_added), MRB_MT_FUNC|MRB_MT_PRIVATE),
MRB_MT_KEY(MRB_SYM(method_removed), MRB_MT_FUNC|MRB_MT_PRIVATE),
MRB_MT_KEY(MRB_SYM_Q(method_defined), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(method_undefined), MRB_MT_FUNC|MRB_MT_PRIVATE),
MRB_MT_KEY(MRB_SYM(module_eval), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(module_function), MRB_MT_FUNC|MRB_MT_PRIVATE),
MRB_MT_KEY(MRB_SYM(prepend), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(prepended), MRB_MT_FUNC|MRB_MT_PRIVATE),
MRB_MT_KEY(MRB_SYM(private), MRB_MT_FUNC|MRB_MT_PRIVATE),
MRB_MT_KEY(MRB_SYM(protected), MRB_MT_FUNC|MRB_MT_PRIVATE),
MRB_MT_KEY(MRB_SYM(public), MRB_MT_FUNC|MRB_MT_PRIVATE),
MRB_MT_KEY(MRB_SYM(remove_const), MRB_MT_FUNC|MRB_MT_PRIVATE),
MRB_MT_KEY(MRB_SYM(to_s), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(undef_method), MRB_MT_FUNC|MRB_MT_PUBLIC),
}
};
static mt_tbl mod_rom_mt = {
static mrb_mt_tbl mod_rom_mt = {
MOD_ROM_MT_SIZE, MOD_ROM_MT_SIZE,
(union mt_ptr*)&mod_rom_data, NULL
(union mrb_mt_ptr*)&mod_rom_data, NULL
};
void
src/error.c
+10 -10
View File
@@ -894,7 +894,7 @@ mrb_check_error(mrb_state *mrb)
/* ---------------------------*/
#define EXCEPTION_ROM_MT_SIZE 7
static struct {
union mt_ptr vals[EXCEPTION_ROM_MT_SIZE];
union mrb_mt_ptr vals[EXCEPTION_ROM_MT_SIZE];
mrb_sym keys[EXCEPTION_ROM_MT_SIZE];
} exception_rom_data = {
.vals = {
@@ -907,18 +907,18 @@ static struct {
{ .func = exc_set_backtrace },
},
.keys = {
MT_KEY(MRB_SYM(exception), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(initialize), MT_FUNC|MT_PRIVATE),
MT_KEY(MRB_SYM(to_s), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(message), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(inspect), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(backtrace), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(set_backtrace), MT_FUNC|MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(exception), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(initialize), MRB_MT_FUNC|MRB_MT_PRIVATE),
MRB_MT_KEY(MRB_SYM(to_s), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(message), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(inspect), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(backtrace), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(set_backtrace), MRB_MT_FUNC|MRB_MT_PUBLIC),
}
};
static mt_tbl exception_rom_mt = {
static mrb_mt_tbl exception_rom_mt = {
EXCEPTION_ROM_MT_SIZE, EXCEPTION_ROM_MT_SIZE,
(union mt_ptr*)&exception_rom_data, NULL
(union mrb_mt_ptr*)&exception_rom_data, NULL
};
void
src/hash.c
+39 -39
View File
@@ -2305,7 +2305,7 @@ mrb_hash_eql(mrb_state *mrb, mrb_value hash)
/* ---------------------------*/
#define HASH_ROM_MT_SIZE 36
static struct {
union mt_ptr vals[HASH_ROM_MT_SIZE];
union mrb_mt_ptr vals[HASH_ROM_MT_SIZE];
mrb_sym keys[HASH_ROM_MT_SIZE];
} hash_rom_data = {
.vals = {
@@ -2347,47 +2347,47 @@ static struct {
{ .func = mrb_hash_except_keys },
},
.keys = {
MT_KEY(MRB_OPSYM(eq), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(aref), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(aset), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(clear), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(default), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM_E(default), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(default_proc), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_E(default_proc), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(__delete), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(eql), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(empty), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(has_key), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(has_value), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(include), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(initialize), MT_FUNC|MT_PRIVATE),
MT_KEY(MRB_SYM(initialize_copy), MT_FUNC|MT_PRIVATE),
MT_KEY(MRB_SYM_Q(key), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(keys), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(length), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(member), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(replace), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(shift), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(size), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(store), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(value), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(values), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(to_s), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(inspect), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(rehash), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(to_hash), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(assoc), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(rassoc), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(__merge), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(__compact), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(__pat_values), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(__except), MT_FUNC|MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(eq), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(aref), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(aset), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(clear), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(default), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_E(default), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(default_proc), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_E(default_proc), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(__delete), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_Q(eql), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_Q(empty), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_Q(has_key), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_Q(has_value), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_Q(include), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(initialize), MRB_MT_FUNC|MRB_MT_PRIVATE),
MRB_MT_KEY(MRB_SYM(initialize_copy), MRB_MT_FUNC|MRB_MT_PRIVATE),
MRB_MT_KEY(MRB_SYM_Q(key), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(keys), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(length), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_Q(member), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(replace), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(shift), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(size), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(store), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_Q(value), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(values), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(to_s), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(inspect), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(rehash), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(to_hash), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(assoc), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(rassoc), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(__merge), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(__compact), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(__pat_values), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(__except), MRB_MT_FUNC|MRB_MT_PUBLIC),
}
};
static mt_tbl hash_rom_mt = {
static mrb_mt_tbl hash_rom_mt = {
HASH_ROM_MT_SIZE, HASH_ROM_MT_SIZE,
(union mt_ptr*)&hash_rom_data, NULL
(union mrb_mt_ptr*)&hash_rom_data, NULL
};
void
src/kernel.c
+30 -30
View File
@@ -668,7 +668,7 @@ mrb_p_m(mrb_state *mrb, mrb_value self)
/* ---------------------------*/
#define KERNEL_ROM_MT_SIZE 27
static struct {
union mt_ptr vals[KERNEL_ROM_MT_SIZE];
union mrb_mt_ptr vals[KERNEL_ROM_MT_SIZE];
mrb_sym keys[KERNEL_ROM_MT_SIZE];
} kernel_rom_data = {
.vals = {
@@ -701,38 +701,38 @@ static struct {
{ .func = mrb_obj_method_recursive_p },
},
.keys = {
MT_KEY(MRB_OPSYM(eqq), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(cmp), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(block_given), MT_FUNC|MT_NOARG|MT_PRIVATE),
MT_KEY(MRB_SYM(class), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(clone), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(dup), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(eql), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(freeze), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(frozen), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(extend), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(hash), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(initialize_copy), MT_FUNC|MT_PRIVATE),
MT_KEY(MRB_SYM(inspect), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(instance_of), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(is_a), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(iterator), MT_FUNC|MT_NOARG|MT_PRIVATE),
MT_KEY(MRB_SYM_Q(kind_of), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(nil), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(object_id), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(raise), MT_FUNC|MT_PRIVATE),
MT_KEY(MRB_SYM(remove_instance_variable), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(respond_to), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(to_s), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(__case_eqq), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(__to_int), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(respond_to_missing), MT_FUNC|MT_PRIVATE),
MT_KEY(MRB_SYM_Q(__method_recursive), MT_FUNC|MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(eqq), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(cmp), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_Q(block_given), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PRIVATE),
MRB_MT_KEY(MRB_SYM(class), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(clone), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(dup), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_Q(eql), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(freeze), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_Q(frozen), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(extend), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(hash), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(initialize_copy), MRB_MT_FUNC|MRB_MT_PRIVATE),
MRB_MT_KEY(MRB_SYM(inspect), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_Q(instance_of), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_Q(is_a), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_Q(iterator), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PRIVATE),
MRB_MT_KEY(MRB_SYM_Q(kind_of), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_Q(nil), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(object_id), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(raise), MRB_MT_FUNC|MRB_MT_PRIVATE),
MRB_MT_KEY(MRB_SYM(remove_instance_variable), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_Q(respond_to), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(to_s), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(__case_eqq), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(__to_int), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_Q(respond_to_missing), MRB_MT_FUNC|MRB_MT_PRIVATE),
MRB_MT_KEY(MRB_SYM_Q(__method_recursive), MRB_MT_FUNC|MRB_MT_PUBLIC),
}
};
static mt_tbl kernel_rom_mt = {
static mrb_mt_tbl kernel_rom_mt = {
KERNEL_ROM_MT_SIZE, KERNEL_ROM_MT_SIZE,
(union mt_ptr*)&kernel_rom_data, NULL
(union mrb_mt_ptr*)&kernel_rom_data, NULL
};
void
src/numeric.c
+72 -72
View File
@@ -2301,7 +2301,7 @@ flo_hash(mrb_state *mrb, mrb_value flo)
/* ------------------------------------------------------------------------*/
#define NUMERIC_ROM_MT_SIZE 3
static struct {
union mt_ptr vals[NUMERIC_ROM_MT_SIZE];
union mrb_mt_ptr vals[NUMERIC_ROM_MT_SIZE];
mrb_sym keys[NUMERIC_ROM_MT_SIZE];
} numeric_rom_data = {
.vals = {
@@ -2310,19 +2310,19 @@ static struct {
{ .func = num_eql },
},
.keys = {
MT_KEY(MRB_SYM_Q(finite), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(infinite), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(eql), MT_FUNC|MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_Q(finite), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_Q(infinite), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_Q(eql), MRB_MT_FUNC|MRB_MT_PUBLIC),
}
};
static mt_tbl numeric_rom_mt = {
static mrb_mt_tbl numeric_rom_mt = {
NUMERIC_ROM_MT_SIZE, NUMERIC_ROM_MT_SIZE,
(union mt_ptr*)&numeric_rom_data, NULL
(union mrb_mt_ptr*)&numeric_rom_data, NULL
};
#define INTEGER_ROM_MT_SIZE 31
static struct {
union mt_ptr vals[INTEGER_ROM_MT_SIZE];
union mrb_mt_ptr vals[INTEGER_ROM_MT_SIZE];
mrb_sym keys[INTEGER_ROM_MT_SIZE];
} integer_rom_data = {
.vals = {
@@ -2359,48 +2359,48 @@ static struct {
{ .func = coerce_step_counter },
},
.keys = {
MT_KEY(MRB_OPSYM(pow), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(cmp), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(lt), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(le), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(gt), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(ge), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(to_i), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(to_int), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_OPSYM(add), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(sub), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(mul), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(mod), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(div), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(quo), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(div), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(eq), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(neg), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_OPSYM(and), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(or), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(xor), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(lshift), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(rshift), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(ceil), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(floor), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(round), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(truncate), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(hash), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(to_s), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(inspect), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(divmod), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(__coerce_step_counter), MT_FUNC|MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(pow), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(cmp), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(lt), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(le), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(gt), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(ge), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(to_i), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(to_int), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(add), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(sub), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(mul), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(mod), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(div), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(quo), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(div), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(eq), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(neg), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(and), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(or), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(xor), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(lshift), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(rshift), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(ceil), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(floor), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(round), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(truncate), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(hash), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(to_s), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(inspect), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(divmod), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(__coerce_step_counter), MRB_MT_FUNC|MRB_MT_PUBLIC),
}
};
static mt_tbl integer_rom_mt = {
static mrb_mt_tbl integer_rom_mt = {
INTEGER_ROM_MT_SIZE, INTEGER_ROM_MT_SIZE,
(union mt_ptr*)&integer_rom_data, NULL
(union mrb_mt_ptr*)&integer_rom_data, NULL
};
#ifndef MRB_NO_FLOAT
#define FLOAT_ROM_MT_SIZE 29
static struct {
union mt_ptr vals[FLOAT_ROM_MT_SIZE];
union mrb_mt_ptr vals[FLOAT_ROM_MT_SIZE];
mrb_sym keys[FLOAT_ROM_MT_SIZE];
} float_rom_data = {
.vals = {
@@ -2435,40 +2435,40 @@ static struct {
{ .func = flo_hash },
},
.keys = {
MT_KEY(MRB_OPSYM(pow), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(div), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(quo), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(fdiv), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(div), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(add), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(sub), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(mul), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(mod), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(cmp), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(lt), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(le), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(gt), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(ge), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(eq), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(ceil), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(finite), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(floor), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(infinite), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(round), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(to_f), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(to_i), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(truncate), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(divmod), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(to_s), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(inspect), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(nan), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(abs), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(hash), MT_FUNC|MT_NOARG|MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(pow), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(div), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(quo), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(fdiv), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(div), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(add), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(sub), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(mul), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(mod), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(cmp), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(lt), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(le), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(gt), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(ge), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(eq), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(ceil), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_Q(finite), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(floor), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_Q(infinite), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(round), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(to_f), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(to_i), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(truncate), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(divmod), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(to_s), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(inspect), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_Q(nan), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(abs), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(hash), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
}
};
static mt_tbl float_rom_mt = {
static mrb_mt_tbl float_rom_mt = {
FLOAT_ROM_MT_SIZE, FLOAT_ROM_MT_SIZE,
(union mt_ptr*)&float_rom_data, NULL
(union mrb_mt_ptr*)&float_rom_data, NULL
};
#endif /* !MRB_NO_FLOAT */
src/object.c
+25 -25
View File
@@ -324,7 +324,7 @@ false_to_s(mrb_state *mrb, mrb_value obj)
/* ---------------------------*/
#define NIL_ROM_MT_SIZE 6
static struct {
union mt_ptr vals[NIL_ROM_MT_SIZE];
union mrb_mt_ptr vals[NIL_ROM_MT_SIZE];
mrb_sym keys[NIL_ROM_MT_SIZE];
} nil_rom_data = {
.vals = {
@@ -336,22 +336,22 @@ static struct {
{ .func = nil_inspect },
},
.keys = {
MT_KEY(MRB_OPSYM(and), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(or), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(xor), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(nil), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(to_s), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(inspect), MT_FUNC|MT_NOARG|MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(and), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(or), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(xor), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_Q(nil), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(to_s), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(inspect), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
}
};
static mt_tbl nil_rom_mt = {
static mrb_mt_tbl nil_rom_mt = {
NIL_ROM_MT_SIZE, NIL_ROM_MT_SIZE,
(union mt_ptr*)&nil_rom_data, NULL
(union mrb_mt_ptr*)&nil_rom_data, NULL
};
#define TRUE_ROM_MT_SIZE 5
static struct {
union mt_ptr vals[TRUE_ROM_MT_SIZE];
union mrb_mt_ptr vals[TRUE_ROM_MT_SIZE];
mrb_sym keys[TRUE_ROM_MT_SIZE];
} true_rom_data = {
.vals = {
@@ -362,21 +362,21 @@ static struct {
{ .func = true_to_s },
},
.keys = {
MT_KEY(MRB_OPSYM(and), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(or), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(xor), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(to_s), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(inspect), MT_FUNC|MT_NOARG|MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(and), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(or), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(xor), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(to_s), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(inspect), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
}
};
static mt_tbl true_rom_mt = {
static mrb_mt_tbl true_rom_mt = {
TRUE_ROM_MT_SIZE, TRUE_ROM_MT_SIZE,
(union mt_ptr*)&true_rom_data, NULL
(union mrb_mt_ptr*)&true_rom_data, NULL
};
#define FALSE_ROM_MT_SIZE 5
static struct {
union mt_ptr vals[FALSE_ROM_MT_SIZE];
union mrb_mt_ptr vals[FALSE_ROM_MT_SIZE];
mrb_sym keys[FALSE_ROM_MT_SIZE];
} false_rom_data = {
.vals = {
@@ -387,16 +387,16 @@ static struct {
{ .func = false_to_s },
},
.keys = {
MT_KEY(MRB_OPSYM(and), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(or), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(xor), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(to_s), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(inspect), MT_FUNC|MT_NOARG|MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(and), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(or), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(xor), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(to_s), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(inspect), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
}
};
static mt_tbl false_rom_mt = {
static mrb_mt_tbl false_rom_mt = {
FALSE_ROM_MT_SIZE, FALSE_ROM_MT_SIZE,
(union mt_ptr*)&false_rom_data, NULL
(union mrb_mt_ptr*)&false_rom_data, NULL
};
void
src/proc.c
+8 -8
View File
@@ -547,7 +547,7 @@ mrb_proc_merge_lvar(mrb_state *mrb, mrb_irep *irep, struct REnv *env, int num, c
/* ---------------------------*/
#define PROC_ROM_MT_SIZE 5
static struct {
union mt_ptr vals[PROC_ROM_MT_SIZE];
union mrb_mt_ptr vals[PROC_ROM_MT_SIZE];
mrb_sym keys[PROC_ROM_MT_SIZE];
} proc_rom_data = {
.vals = {
@@ -558,16 +558,16 @@ static struct {
{ .func = proc_hash },
},
.keys = {
MT_KEY(MRB_SYM(initialize_copy), MT_FUNC|MT_PRIVATE),
MT_KEY(MRB_SYM(arity), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_OPSYM(eq), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(eql), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(hash), MT_FUNC|MT_NOARG|MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(initialize_copy), MRB_MT_FUNC|MRB_MT_PRIVATE),
MRB_MT_KEY(MRB_SYM(arity), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(eq), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_Q(eql), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(hash), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
}
};
static mt_tbl proc_rom_mt = {
static mrb_mt_tbl proc_rom_mt = {
PROC_ROM_MT_SIZE, PROC_ROM_MT_SIZE,
(union mt_ptr*)&proc_rom_data, NULL
(union mrb_mt_ptr*)&proc_rom_data, NULL
};
void
src/range.c
+18 -18
View File
@@ -568,7 +568,7 @@ mrb_range_beg_len(mrb_state *mrb, mrb_value range, mrb_int *begp, mrb_int *lenp,
/* ---------------------------*/
#define RANGE_ROM_MT_SIZE 15
static struct {
union mt_ptr vals[RANGE_ROM_MT_SIZE];
union mrb_mt_ptr vals[RANGE_ROM_MT_SIZE];
mrb_sym keys[RANGE_ROM_MT_SIZE];
} range_rom_data = {
.vals = {
@@ -589,26 +589,26 @@ static struct {
{ .func = range_num_to_a },
},
.keys = {
MT_KEY(MRB_SYM(begin), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(end), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_OPSYM(eq), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(eqq), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(exclude_end), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(first), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(include), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(initialize), MT_FUNC|MT_PRIVATE),
MT_KEY(MRB_SYM(last), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(member), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(to_s), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(inspect), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(eql), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(initialize_copy), MT_FUNC|MT_PRIVATE),
MT_KEY(MRB_SYM(__num_to_a), MT_FUNC|MT_NOARG|MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(begin), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(end), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(eq), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(eqq), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_Q(exclude_end), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(first), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_Q(include), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(initialize), MRB_MT_FUNC|MRB_MT_PRIVATE),
MRB_MT_KEY(MRB_SYM(last), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_Q(member), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(to_s), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(inspect), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_Q(eql), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(initialize_copy), MRB_MT_FUNC|MRB_MT_PRIVATE),
MRB_MT_KEY(MRB_SYM(__num_to_a), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
}
};
static mt_tbl range_rom_mt = {
static mrb_mt_tbl range_rom_mt = {
RANGE_ROM_MT_SIZE, RANGE_ROM_MT_SIZE,
(union mt_ptr*)&range_rom_data, NULL
(union mrb_mt_ptr*)&range_rom_data, NULL
};
void
src/string.c
+49 -49
View File
@@ -3510,7 +3510,7 @@ mrb_encoding(mrb_state *mrb, mrb_value self)
/* ---------------------------*/
#define STRING_ROM_MT_SIZE 46
static struct {
union mt_ptr vals[STRING_ROM_MT_SIZE];
union mrb_mt_ptr vals[STRING_ROM_MT_SIZE];
mrb_sym keys[STRING_ROM_MT_SIZE];
} string_rom_data = {
.vals = {
@@ -3562,57 +3562,57 @@ static struct {
{ .func = sub_replace },
},
.keys = {
MT_KEY(MRB_SYM(bytesize), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_OPSYM(cmp), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(eq), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(add), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(mul), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(aref), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(aset), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(capitalize), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_B(capitalize), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(chomp), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM_B(chomp), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(chop), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_B(chop), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(downcase), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_B(downcase), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(empty), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(eql), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(hash), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_Q(include), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(index), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(initialize), MT_FUNC|MT_PRIVATE),
MT_KEY(MRB_SYM(initialize_copy), MT_FUNC|MT_PRIVATE),
MT_KEY(MRB_SYM(intern), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(length), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(replace), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(reverse), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_B(reverse), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(rindex), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(size), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(slice), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(split), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(to_i), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(to_s), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(to_str), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(to_sym), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(upcase), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM_B(upcase), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(inspect), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(bytes), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(getbyte), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(setbyte), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(byteindex), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(byterindex), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(byteslice), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(bytesplice), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_SYM(__sub_replace), MT_FUNC|MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(bytesize), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(cmp), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(eq), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(add), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(mul), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(aref), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(aset), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(capitalize), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_B(capitalize), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(chomp), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_B(chomp), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(chop), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_B(chop), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(downcase), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_B(downcase), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_Q(empty), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_Q(eql), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(hash), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_Q(include), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(index), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(initialize), MRB_MT_FUNC|MRB_MT_PRIVATE),
MRB_MT_KEY(MRB_SYM(initialize_copy), MRB_MT_FUNC|MRB_MT_PRIVATE),
MRB_MT_KEY(MRB_SYM(intern), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(length), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(replace), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(reverse), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_B(reverse), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(rindex), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(size), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(slice), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(split), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(to_i), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(to_s), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(to_str), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(to_sym), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(upcase), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM_B(upcase), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(inspect), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(bytes), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(getbyte), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(setbyte), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(byteindex), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(byterindex), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(byteslice), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(bytesplice), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(__sub_replace), MRB_MT_FUNC|MRB_MT_PUBLIC),
}
};
static mt_tbl string_rom_mt = {
static mrb_mt_tbl string_rom_mt = {
STRING_ROM_MT_SIZE, STRING_ROM_MT_SIZE,
(union mt_ptr*)&string_rom_data, NULL
(union mrb_mt_ptr*)&string_rom_data, NULL
};
void
src/symbol.c
+9 -9
View File
@@ -1003,7 +1003,7 @@ sym_cmp(mrb_state *mrb, mrb_value s1)
/* ---------------------------*/
#define SYMBOL_ROM_MT_SIZE 6
static struct {
union mt_ptr vals[SYMBOL_ROM_MT_SIZE];
union mrb_mt_ptr vals[SYMBOL_ROM_MT_SIZE];
mrb_sym keys[SYMBOL_ROM_MT_SIZE];
} symbol_rom_data = {
.vals = {
@@ -1015,17 +1015,17 @@ static struct {
{ .func = mrb_obj_equal_m },
},
.keys = {
MT_KEY(MRB_SYM(to_s), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(name), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(to_sym), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_SYM(inspect), MT_FUNC|MT_NOARG|MT_PUBLIC),
MT_KEY(MRB_OPSYM(cmp), MT_FUNC|MT_PUBLIC),
MT_KEY(MRB_OPSYM(eq), MT_FUNC|MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(to_s), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(name), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(to_sym), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_SYM(inspect), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(cmp), MRB_MT_FUNC|MRB_MT_PUBLIC),
MRB_MT_KEY(MRB_OPSYM(eq), MRB_MT_FUNC|MRB_MT_PUBLIC),
}
};
static mt_tbl symbol_rom_mt = {
static mrb_mt_tbl symbol_rom_mt = {
SYMBOL_ROM_MT_SIZE, SYMBOL_ROM_MT_SIZE,
(union mt_ptr*)&symbol_rom_data, NULL
(union mrb_mt_ptr*)&symbol_rom_data, NULL
};
void