diff --git a/doc/guides/rom-method-table.md b/doc/guides/rom-method-table.md
index 3f814c8a8..6bf2366ad 100644
--- a/doc/guides/rom-method-table.md
+++ b/doc/guides/rom-method-table.md
@@ -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) {
diff --git a/include/mruby/class.h b/include/mruby/class.h
index 416ddb873..34bd9139a 100644
--- a/include/mruby/class.h
+++ b/include/mruby/class.h
@@ -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;
 };
 
diff --git a/include/mruby/internal.h b/include/mruby/internal.h
index 7048197ff..dda169f13 100644
--- a/include/mruby/internal.h
+++ b/include/mruby/internal.h
@@ -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);
diff --git a/mrbgems/mruby-array-ext/src/array.c b/mrbgems/mruby-array-ext/src/array.c
index 6ab679c29..e155f3a19 100644
--- a/mrbgems/mruby-array-ext/src/array.c
+++ b/mrbgems/mruby-array-ext/src/array.c
@@ -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
diff --git a/mrbgems/mruby-class-ext/src/class.c b/mrbgems/mruby-class-ext/src/class.c
index 3f4070962..d9a7eaf09 100644
--- a/mrbgems/mruby-class-ext/src/class.c
+++ b/mrbgems/mruby-class-ext/src/class.c
@@ -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
 };
 
 /*
diff --git a/mrbgems/mruby-complex/src/complex.c b/mrbgems/mruby-complex/src/complex.c
index b231cc3c1..081811ffb 100644
--- a/mrbgems/mruby-complex/src/complex.c
+++ b/mrbgems/mruby-complex/src/complex.c
@@ -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)
diff --git a/mrbgems/mruby-hash-ext/src/hash_ext.c b/mrbgems/mruby-hash-ext/src/hash_ext.c
index c7c41d9c7..8340738a7 100644
--- a/mrbgems/mruby-hash-ext/src/hash_ext.c
+++ b/mrbgems/mruby-hash-ext/src/hash_ext.c
@@ -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
diff --git a/mrbgems/mruby-io/src/file.c b/mrbgems/mruby-io/src/file.c
index 0d7dc7d80..2d8962bf9 100644
--- a/mrbgems/mruby-io/src/file.c
+++ b/mrbgems/mruby-io/src/file.c
@@ -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
diff --git a/mrbgems/mruby-io/src/io.c b/mrbgems/mruby-io/src/io.c
index de5bb5fe0..aee6db8cb 100644
--- a/mrbgems/mruby-io/src/io.c
+++ b/mrbgems/mruby-io/src/io.c
@@ -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
diff --git a/mrbgems/mruby-kernel-ext/src/kernel.c b/mrbgems/mruby-kernel-ext/src/kernel.c
index 5854fae83..46036aeed 100644
--- a/mrbgems/mruby-kernel-ext/src/kernel.c
+++ b/mrbgems/mruby-kernel-ext/src/kernel.c
@@ -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
diff --git a/mrbgems/mruby-metaprog/src/metaprog.c b/mrbgems/mruby-metaprog/src/metaprog.c
index 96467aa90..f50c2e243 100644
--- a/mrbgems/mruby-metaprog/src/metaprog.c
+++ b/mrbgems/mruby-metaprog/src/metaprog.c
@@ -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
diff --git a/mrbgems/mruby-method/src/method.c b/mrbgems/mruby-method/src/method.c
index 28f53f9cf..89bca0198 100644
--- a/mrbgems/mruby-method/src/method.c
+++ b/mrbgems/mruby-method/src/method.c
@@ -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
diff --git a/mrbgems/mruby-numeric-ext/src/numeric_ext.c b/mrbgems/mruby-numeric-ext/src/numeric_ext.c
index e2c4f7aa0..d88a04f56 100644
--- a/mrbgems/mruby-numeric-ext/src/numeric_ext.c
+++ b/mrbgems/mruby-numeric-ext/src/numeric_ext.c
@@ -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
diff --git a/mrbgems/mruby-object-ext/src/object.c b/mrbgems/mruby-object-ext/src/object.c
index eb38b7584..6ecd79ed3 100644
--- a/mrbgems/mruby-object-ext/src/object.c
+++ b/mrbgems/mruby-object-ext/src/object.c
@@ -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
diff --git a/mrbgems/mruby-proc-ext/src/proc.c b/mrbgems/mruby-proc-ext/src/proc.c
index 43e49324f..2a0ad2e2d 100644
--- a/mrbgems/mruby-proc-ext/src/proc.c
+++ b/mrbgems/mruby-proc-ext/src/proc.c
@@ -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
diff --git a/mrbgems/mruby-random/src/random.c b/mrbgems/mruby-random/src/random.c
index 65aee46c0..e542b8b4b 100644
--- a/mrbgems/mruby-random/src/random.c
+++ b/mrbgems/mruby-random/src/random.c
@@ -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)
diff --git a/mrbgems/mruby-range-ext/src/range.c b/mrbgems/mruby-range-ext/src/range.c
index 68c761ec2..07e3f8f30 100644
--- a/mrbgems/mruby-range-ext/src/range.c
+++ b/mrbgems/mruby-range-ext/src/range.c
@@ -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
diff --git a/mrbgems/mruby-rational/src/rational.c b/mrbgems/mruby-rational/src/rational.c
index a9b4e4be9..9a849a74b 100644
--- a/mrbgems/mruby-rational/src/rational.c
+++ b/mrbgems/mruby-rational/src/rational.c
@@ -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)
diff --git a/mrbgems/mruby-set/src/set.c b/mrbgems/mruby-set/src/set.c
index c2899023b..8ac1a8867 100644
--- a/mrbgems/mruby-set/src/set.c
+++ b/mrbgems/mruby-set/src/set.c
@@ -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
diff --git a/mrbgems/mruby-socket/src/socket.c b/mrbgems/mruby-socket/src/socket.c
index 627c83976..700e0aee6 100644
--- a/mrbgems/mruby-socket/src/socket.c
+++ b/mrbgems/mruby-socket/src/socket.c
@@ -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
diff --git a/mrbgems/mruby-string-ext/src/string.c b/mrbgems/mruby-string-ext/src/string.c
index 0eaf90bff..0ede53f25 100644
--- a/mrbgems/mruby-string-ext/src/string.c
+++ b/mrbgems/mruby-string-ext/src/string.c
@@ -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
diff --git a/mrbgems/mruby-struct/src/struct.c b/mrbgems/mruby-struct/src/struct.c
index d3ba9da5e..b0bcd88c9 100644
--- a/mrbgems/mruby-struct/src/struct.c
+++ b/mrbgems/mruby-struct/src/struct.c
@@ -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
diff --git a/mrbgems/mruby-symbol-ext/src/symbol.c b/mrbgems/mruby-symbol-ext/src/symbol.c
index 019deb41e..3b30a2c4c 100644
--- a/mrbgems/mruby-symbol-ext/src/symbol.c
+++ b/mrbgems/mruby-symbol-ext/src/symbol.c
@@ -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
diff --git a/mrbgems/mruby-time/src/time.c b/mrbgems/mruby-time/src/time.c
index 87d32e24b..48ff7af8d 100644
--- a/mrbgems/mruby-time/src/time.c
+++ b/mrbgems/mruby-time/src/time.c
@@ -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
diff --git a/src/array.c b/src/array.c
index 5c966db35..c939573d7 100644
--- a/src/array.c
+++ b/src/array.c
@@ -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
diff --git a/src/class.c b/src/class.c
index d744938a3..7dfe87cc0 100644
--- a/src/class.c
+++ b/src/class.c
@@ -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
diff --git a/src/error.c b/src/error.c
index 328655de7..88e07c8a1 100644
--- a/src/error.c
+++ b/src/error.c
@@ -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
diff --git a/src/hash.c b/src/hash.c
index 1e10b2ff7..fb57f55a2 100644
--- a/src/hash.c
+++ b/src/hash.c
@@ -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
diff --git a/src/kernel.c b/src/kernel.c
index 7e2dfff82..612abc16a 100644
--- a/src/kernel.c
+++ b/src/kernel.c
@@ -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
diff --git a/src/numeric.c b/src/numeric.c
index b7ef7516c..daca05ace 100644
--- a/src/numeric.c
+++ b/src/numeric.c
@@ -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 */
 
diff --git a/src/object.c b/src/object.c
index de783192a..d1ac52bdc 100644
--- a/src/object.c
+++ b/src/object.c
@@ -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
diff --git a/src/proc.c b/src/proc.c
index edb0bf982..66afb69be 100644
--- a/src/proc.c
+++ b/src/proc.c
@@ -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
diff --git a/src/range.c b/src/range.c
index 466e8ff0d..d86a34112 100644
--- a/src/range.c
+++ b/src/range.c
@@ -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
diff --git a/src/string.c b/src/string.c
index fe8d96a3e..41b434ed2 100644
--- a/src/string.c
+++ b/src/string.c
@@ -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
diff --git a/src/symbol.c b/src/symbol.c
index c0b96935b..763e37869 100644
--- a/src/symbol.c
+++ b/src/symbol.c
@@ -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