ruby2d 0.12.0 → 1.0.0

data/assets/{include → platform/include}/mrbconf.h

@@ -18,7 +18,7 @@
 #endif
 
 #if defined(MRB_32BIT) && defined(MRB_64BIT)
-#error Cannot build for 32 and 64 bit architecture at the same time
+#error Cannot build for 32 and 64-bit architecture at the same time
 #endif
 
 /* configuration options: */
@@ -42,21 +42,6 @@
 #error Cannot define MRB_USE_FLOAT32 and MRB_NO_FLOAT at the same time
 #endif
 
-/* add -DMRB_NO_METHOD_CACHE to disable method cache to save memory */
-//#define MRB_NO_METHOD_CACHE
-/* size of the method cache (need to be the power of 2) */
-//#define MRB_METHOD_CACHE_SIZE (1<<8)
-
-/* add -DMRB_USE_METHOD_T_STRUCT on machines that use higher bits of function pointers */
-/* no MRB_USE_METHOD_T_STRUCT requires highest 2 bits of function pointers to be zero */
-#ifndef MRB_USE_METHOD_T_STRUCT
-  // can't use highest 2 bits of function pointers at least on 32bit
-  // Windows and 32bit Linux.
-# ifdef MRB_32BIT
-#   define MRB_USE_METHOD_T_STRUCT
-# endif
-#endif
-
 /* define on big endian machines; used by MRB_NAN_BOXING, etc. */
 #ifndef MRB_ENDIAN_BIG
 # if (defined(BYTE_ORDER) && defined(BIG_ENDIAN) && BYTE_ORDER == BIG_ENDIAN) || \
@@ -79,34 +64,57 @@
 # define MRB_WORD_BOXING
 #endif
 
-/* if defined mruby allocates Float objects in the heap to keep full precision if needed */
-//#define MRB_WORDBOX_NO_FLOAT_TRUNCATE
+/* if defined mruby does not inline float values in word boxing;
+   all floats are heap-allocated as RFloat objects */
+//#define MRB_WORDBOX_NO_INLINE_FLOAT
+
+/* obsolete configuration */
+#if defined(MRB_WORDBOX_NO_FLOAT_TRUNCATE)
+# define MRB_WORDBOX_NO_INLINE_FLOAT
+#endif
 
-/* add -DMRB_INT32 to use 32bit integer for mrb_int; conflict with MRB_INT64;
+/* add -DMRB_INT32 to use 32-bit integer for mrb_int; conflict with MRB_INT64;
    Default for 32-bit CPU mode. */
 //#define MRB_INT32
 
-/* add -DMRB_INT64 to use 64bit integer for mrb_int; conflict with MRB_INT32;
+/* add -DMRB_INT64 to use 64-bit integer for mrb_int; conflict with MRB_INT32;
    Default for 64-bit CPU mode (unless using MRB_NAN_BOXING). */
 //#define MRB_INT64
 
 /* if no specific integer type is chosen */
 #if !defined(MRB_INT32) && !defined(MRB_INT64)
 # if defined(MRB_64BIT) && !defined(MRB_NAN_BOXING)
-/* Use 64bit integers on 64bit architecture (without MRB_NAN_BOXING) */
+/* Use 64-bit integers on 64-bit architecture (without MRB_NAN_BOXING) */
 #  define MRB_INT64
 # else
-/* Otherwise use 32bit integers */
+/* Otherwise use 32-bit integers */
 #  define MRB_INT32
 # endif
 #endif
 
+/* MRB_INT64 on 32-bit with word/NaN boxing causes alignment issues
+   for heap-allocated RInteger (int64_t needs 8-byte alignment but
+   GC heap slots may not guarantee it); use MRB_NO_BOXING instead */
+#if defined(MRB_INT64) && defined(MRB_32BIT) && !defined(MRB_NO_BOXING)
+#error "MRB_INT64 on 32-bit requires MRB_NO_BOXING"
+#endif
+
 /* call malloc_trim(0) from mrb_full_gc() */
 //#define MRB_USE_MALLOC_TRIM
 
 /* string class to handle UTF-8 encoding */
 //#define MRB_UTF8_STRING
 
+/* maximum length of strings */
+/* the default value is 1MB */
+/* set this value to zero to skip the check */
+//#define MRB_STR_LENGTH_MAX 1048576
+
+/* maximum length of arrays */
+/* the default value is 2**17 entries */
+/* set this value to zero to skip the check */
+//#define MRB_ARY_LENGTH_MAX 131072
+
 /* argv max size in mrb_funcall */
 //#define MRB_FUNCALL_ARGC_MAX 16
 
@@ -130,8 +138,8 @@
 /* turn off generational GC by default */
 //#define MRB_GC_TURN_OFF_GENERATIONAL
 
-/* default size of khash table bucket */
-//#define KHASH_DEFAULT_SIZE 32
+/* initial size of khash table bucket */
+//#define KHASH_INITIAL_SIZE 32
 
 /* allocated memory address alignment */
 //#define POOL_ALIGNMENT 4
@@ -158,15 +166,18 @@
 //#define MRB_USE_DEBUG_HOOK /* hooks for debugger */
 //#define MRB_USE_ALL_SYMBOLS /* Symbol.all_symbols */
 
-/* obsolete configurations */
-#ifdef MRB_METHOD_T_STRUCT
-# define MRB_USE_METHOD_T_STRUCT
+/* Symbol table configuration */
+/* Threshold for switching from linear search to hash table */
+#ifndef MRB_SYMBOL_LINEAR_THRESHOLD
+#define MRB_SYMBOL_LINEAR_THRESHOLD 256
 #endif
+
+/* obsolete configurations */
 #if defined(DISABLE_STDIO) || defined(MRB_DISABLE_STDIO)
 # define MRB_NO_STDIO
 #endif
-#ifdef MRB_DISABLE_DIRECT_THREADING
-# define MRB_NO_DIRECT_THREADING
+#if defined(MRB_DISABLE_DIRECT_THREADING) || defined(MRB_NO_DIRECT_THREADING)
+# define MRB_USE_VM_SWITCH_DISPATCH
 #endif
 #if defined(ENABLE_DEBUG) || defined(MRB_ENABLE_DEBUG_HOOK)
 # define MRB_USE_DEBUG_HOOK
@@ -197,8 +208,8 @@
 #  define MRB_NO_METHOD_CACHE
 # endif
 
-# ifndef KHASH_DEFAULT_SIZE
-#  define KHASH_DEFAULT_SIZE 16
+# ifndef KHASH_INITIAL_SIZE
+#  define KHASH_INITIAL_SIZE 16
 # endif
 
 # ifndef MRB_HEAP_PAGE_SIZE

data/assets/{include → platform/include}/mruby/array.h

@@ -20,7 +20,7 @@ typedef struct mrb_shared_array {
   mrb_value *ptr;
 } mrb_shared_array;
 
-#if defined(MRB_32BIT) && defined(MRB_NO_BOXING) && !defined(MRB_USE_FLOAT32) && !defined(MRB_ARY_NO_EMBED)
+#if defined(MRB_32BIT) && defined(MRB_NO_BOXING) && (!defined(MRB_USE_FLOAT32) || defined(MRB_INT64)) && !defined(MRB_ARY_NO_EMBED)
 # define MRB_ARY_NO_EMBED
 #endif
 
@@ -85,8 +85,9 @@ struct RArray {
 #define ARY_SET_SHARED_FLAG(a) ((a)->flags |= MRB_ARY_SHARED)
 #define ARY_UNSET_SHARED_FLAG(a) ((a)->flags &= ~MRB_ARY_SHARED)
 
-void mrb_ary_decref(mrb_state*, mrb_shared_array*);
 MRB_API void mrb_ary_modify(mrb_state*, struct RArray*);
+MRB_API mrb_value mrb_ary_dup(mrb_state*, mrb_value ary);
+MRB_API mrb_value mrb_ary_make_shared_copy(mrb_state*, mrb_value ary);
 MRB_API mrb_value mrb_ary_new_capa(mrb_state*, mrb_int);
 
 /*
@@ -296,8 +297,6 @@ MRB_API mrb_value mrb_ary_join(mrb_state *mrb, mrb_value ary, mrb_value sep);
  */
 MRB_API mrb_value mrb_ary_resize(mrb_state *mrb, mrb_value ary, mrb_int new_len);
 
-/* helper functions */
-mrb_value mrb_ary_subseq(mrb_state *mrb, mrb_value ary, mrb_int beg, mrb_int len);
 
 MRB_END_DECL
 

data/assets/{include → platform/include}/mruby/boxing_nan.h

@@ -98,6 +98,16 @@ mrb_type(mrb_value o)
   }
 }
 
+MRB_INLINE enum mrb_vtype
+mrb_unboxed_type(mrb_value o)
+{
+  if (!mrb_float_p(o) && mrb_nb_tt(o) == MRB_NANBOX_TT_OBJECT && o.u != 0) {
+    return ((struct RBasic*)(uintptr_t)o.u)->tt;
+  } else {
+    return MRB_TT_FALSE;
+  }
+}
+
 #define NANBOX_SET_MISC_VALUE(r,t,i) NANBOX_SET_VALUE(r, MRB_NANBOX_TT_MISC, ((uint64_t)(t)<<32) | (i))
 
 #define mrb_float(o) mrb_nan_boxing_value_float(o)

data/assets/platform/include/mruby/boxing_no.h

@@ -0,0 +1,59 @@
+/**
+** @file mruby/boxing_no.h - unboxed mrb_value definition
+**
+** See Copyright Notice in mruby.h
+*/
+
+#ifndef MRUBY_BOXING_NO_H
+#define MRUBY_BOXING_NO_H
+
+#define MRB_FIXNUM_SHIFT 0
+#define MRB_SYMBOL_SHIFT 0
+#define MRB_FIXNUM_MIN MRB_INT_MIN
+#define MRB_FIXNUM_MAX MRB_INT_MAX
+
+union mrb_value_union {
+#ifndef MRB_NO_FLOAT
+  mrb_float f;
+#endif
+  void *p;
+  mrb_int i;
+  mrb_sym sym;
+};
+
+typedef struct mrb_value {
+  union mrb_value_union value;
+  enum mrb_vtype tt;
+} mrb_value;
+
+#define mrb_ptr(o)          (o).value.p
+#define mrb_cptr(o)         mrb_ptr(o)
+#ifndef MRB_NO_FLOAT
+#define mrb_float(o)        (o).value.f
+#endif
+#define mrb_fixnum(o)       (o).value.i
+#define mrb_integer(o)      mrb_fixnum(o)
+#define mrb_symbol(o)       (o).value.sym
+#define mrb_type(o)         (o).tt
+#define mrb_unboxed_type(o) (o).tt
+
+#define BOXNO_SET_VALUE(o, ttt, attr, v) do {\
+  (o).tt = ttt;\
+  (o).attr = v;\
+} while (0)
+
+#define SET_NIL_VALUE(r) BOXNO_SET_VALUE(r, MRB_TT_FALSE, value.i, 0)
+#define SET_FALSE_VALUE(r) BOXNO_SET_VALUE(r, MRB_TT_FALSE, value.i, 1)
+#define SET_TRUE_VALUE(r) BOXNO_SET_VALUE(r, MRB_TT_TRUE, value.i, 1)
+#define SET_BOOL_VALUE(r,b) BOXNO_SET_VALUE(r, b ? MRB_TT_TRUE : MRB_TT_FALSE, value.i, 1)
+#define SET_INT_VALUE(mrb,r,n) BOXNO_SET_VALUE(r, MRB_TT_INTEGER, value.i, (n))
+#define SET_FIXNUM_VALUE(r,n) BOXNO_SET_VALUE(r, MRB_TT_INTEGER, value.i, (n))
+#ifndef MRB_NO_FLOAT
+#define SET_FLOAT_VALUE(mrb,r,v) BOXNO_SET_VALUE(r, MRB_TT_FLOAT, value.f, (v))
+#endif
+#define SET_SYM_VALUE(r,v) BOXNO_SET_VALUE(r, MRB_TT_SYMBOL, value.sym, (v))
+#define SET_OBJ_VALUE(r,v) BOXNO_SET_VALUE(r, (((struct RObject*)(v))->tt), value.p, (v))
+#define SET_CPTR_VALUE(mrb,r,v) BOXNO_SET_VALUE(r, MRB_TT_CPTR, value.p, v)
+#define SET_UNDEF_VALUE(r) BOXNO_SET_VALUE(r, MRB_TT_UNDEF, value.i, 0)
+
+#endif  /* MRUBY_BOXING_NO_H */

data/assets/{include → platform/include}/mruby/boxing_word.h

@@ -7,15 +7,44 @@
 #ifndef MRUBY_BOXING_WORD_H
 #define MRUBY_BOXING_WORD_H
 
-#if defined(MRB_32BIT) && !defined(MRB_USE_FLOAT32) && !defined(MRB_WORDBOX_NO_FLOAT_TRUNCATE)
-# define MRB_WORDBOX_NO_FLOAT_TRUNCATE
+#if defined(MRB_32BIT) && !defined(MRB_USE_FLOAT32) && !defined(MRB_WORDBOX_NO_INLINE_FLOAT)
+# define MRB_WORDBOX_NO_INLINE_FLOAT
 #endif
 
-#if !defined(MRB_NO_FLOAT) && defined(MRB_WORDBOX_NO_FLOAT_TRUNCATE)
+#ifndef MRB_NO_FLOAT
 struct RFloat {
   MRB_OBJECT_HEADER;
+#ifdef MRB_WORDBOX_NO_INLINE_FLOAT
+  /* avoid 8-byte alignment on 32-bit; use memcpy-based accessors */
+  char f[sizeof(mrb_float)];
+#else
   mrb_float f;
+#endif
 };
+
+#include <string.h>
+
+static inline mrb_float
+mrb_rfloat_value(const struct RFloat *p)
+{
+#ifdef MRB_WORDBOX_NO_INLINE_FLOAT
+  mrb_float f;
+  memcpy(&f, p->f, sizeof(mrb_float));
+  return f;
+#else
+  return p->f;
+#endif
+}
+
+static inline void
+mrb_rfloat_set(struct RFloat *p, mrb_float f)
+{
+#ifdef MRB_WORDBOX_NO_INLINE_FLOAT
+  memcpy(p->f, &f, sizeof(mrb_float));
+#else
+  p->f = f;
+#endif
+}
 #endif
 
 struct RInteger {
@@ -50,8 +79,9 @@ enum mrb_special_consts {
 #define WORDBOX_FIXNUM_FLAG     (1 << (WORDBOX_FIXNUM_BIT_POS - 1))
 #define WORDBOX_FIXNUM_MASK     ((1 << WORDBOX_FIXNUM_BIT_POS) - 1)
 
-#if defined(MRB_WORDBOX_NO_FLOAT_TRUNCATE)
+#if defined(MRB_WORDBOX_NO_INLINE_FLOAT) || defined(MRB_NO_FLOAT)
 /* floats are allocated in heaps */
+#define WORDBOX_IMMEDIATE_MASK  0x03
 #define WORDBOX_SYMBOL_BIT_POS  2
 #define WORDBOX_SYMBOL_SHIFT    WORDBOX_SYMBOL_BIT_POS
 #define WORDBOX_SYMBOL_FLAG     (1 << (WORDBOX_SYMBOL_BIT_POS - 1))
@@ -68,7 +98,9 @@ enum mrb_special_consts {
 #define WORDBOX_SYMBOL_MASK     0x1f
 #endif
 
+#ifndef WORDBOX_IMMEDIATE_MASK
 #define WORDBOX_IMMEDIATE_MASK  0x07
+#endif
 
 #define WORDBOX_SET_SHIFT_VALUE(o,n,v) \
   ((o).w = (((uintptr_t)(v)) << WORDBOX_##n##_SHIFT) | WORDBOX_##n##_FLAG)
@@ -80,34 +112,29 @@ enum mrb_special_consts {
 /*
  * mrb_value representation:
  *
- * 64bit word with inline float:
+ * 64-bit word with inline float (rotation encoding, lossless):
  *   nil   : ...0000 0000 (all bits are 0)
  *   false : ...0000 0100 (mrb_fixnum(v) != 0)
  *   true  : ...0000 1100
  *   undef : ...0001 0100
  *   symbol: ...0001 1100 (use only upper 32-bit as symbol value with MRB_64BIT)
  *   fixnum: ...IIII III1
- *   float : ...FFFF FF10 (51 bit significands; require MRB_64BIT)
+ *   float : ...FFFF FF10 (rotl64(float64-ADDEND, 3); exponent [-255,+256])
  *   object: ...PPPP P000
+ *   (floats outside inline range are heap-allocated as RFloat)
  *
- * 32bit word with inline float:
- *   nil   : ...0000 0000 (all bits are 0)
- *   false : ...0000 0100 (mrb_fixnum(v) != 0)
- *   true  : ...0000 1100
- *   undef : ...0001 0100
- *   symbol: ...SSS1 0100 (symbol occupies 20bits)
- *   fixnum: ...IIII III1
- *   float : ...FFFF FF10 (22 bit significands; require MRB_64BIT)
- *   object: ...PPPP P000
+ * 64-bit word with inline float32 (MRB_USE_FLOAT32):
+ *   float : ...FFFF FF10 (float32 shifted left by 2)
+ *   (other values same as above)
  *
- * and word boxing without inline float (MRB_WORDBOX_NO_FLOAT_TRUNCATE):
+ * word boxing without inline float (MRB_WORDBOX_NO_INLINE_FLOAT):
  *   nil   : ...0000 0000 (all bits are 0)
  *   false : ...0000 0100 (mrb_fixnum(v) != 0)
  *   true  : ...0000 1100
  *   undef : ...0001 0100
  *   fixnum: ...IIII III1
  *   symbol: ...SSSS SS10
- *   object: ...PPPP P000 (any bits are 1)
+ *   object: ...PPPP PP00 (any bits are 1)
  */
 typedef struct mrb_value {
   uintptr_t w;
@@ -117,10 +144,9 @@ union mrb_value_ {
   void *p;
   struct RBasic *bp;
 #ifndef MRB_NO_FLOAT
-#ifndef MRB_WORDBOX_NO_FLOAT_TRUNCATE
-  mrb_float f;
-#else
   struct RFloat *fp;
+#if !defined(MRB_WORDBOX_NO_INLINE_FLOAT) && defined(MRB_USE_FLOAT32)
+  mrb_float f;
 #endif
 #endif
   struct RInteger *ip;
@@ -145,16 +171,20 @@ MRB_API mrb_value mrb_word_boxing_float_value(struct mrb_state*, mrb_float);
 #endif
 MRB_API mrb_value mrb_boxing_int_value(struct mrb_state*, mrb_int);
 
+#if WORDBOX_IMMEDIATE_MASK == 0x3
+#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w <= MRB_Qundef)
+#else
 #define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
+#endif
 
 #define mrb_ptr(o)     mrb_val_union(o).p
 #define mrb_cptr(o)    mrb_val_union(o).vp->p
 #ifndef MRB_NO_FLOAT
-#ifndef MRB_WORDBOX_NO_FLOAT_TRUNCATE
+#ifndef MRB_WORDBOX_NO_INLINE_FLOAT
 MRB_API mrb_float mrb_word_boxing_value_float(mrb_value v);
 #define mrb_float(o) mrb_word_boxing_value_float(o)
 #else
-#define mrb_float(o) mrb_val_union(o).fp->f
+#define mrb_float(o) mrb_rfloat_value(mrb_val_union(o).fp)
 #endif
 #endif
 #define mrb_fixnum(o)  (mrb_int)(((intptr_t)(o).w) >> WORDBOX_FIXNUM_SHIFT)
@@ -175,11 +205,16 @@ mrb_integer_func(mrb_value o) {
 #define mrb_false_p(o) ((o).w == MRB_Qfalse)
 #define mrb_true_p(o)  ((o).w == MRB_Qtrue)
 #ifndef MRB_NO_FLOAT
-#ifndef MRB_WORDBOX_NO_FLOAT_TRUNCATE
+#ifdef MRB_WORDBOX_NO_INLINE_FLOAT
+#define mrb_float_p(o) WORDBOX_OBJ_TYPE_P(o, FLOAT)
+#elif defined(MRB_USE_FLOAT32) && defined(MRB_64BIT)
 #define mrb_float_p(o) WORDBOX_SHIFT_VALUE_P(o, FLOAT)
 #else
-#define mrb_float_p(o) WORDBOX_OBJ_TYPE_P(o, FLOAT)
+/* rotation encoding: most floats inline, edge cases on heap */
+#define mrb_float_p(o) (WORDBOX_SHIFT_VALUE_P(o, FLOAT) || WORDBOX_OBJ_TYPE_P(o, FLOAT))
 #endif
+#else
+#define mrb_float_p(o) FALSE
 #endif
 #define mrb_array_p(o) WORDBOX_OBJ_TYPE_P(o, ARRAY)
 #define mrb_string_p(o) WORDBOX_OBJ_TYPE_P(o, STRING)
@@ -222,10 +257,21 @@ mrb_type(mrb_value o)
          mrb_fixnum_p(o) ? MRB_TT_INTEGER :
          mrb_symbol_p(o) ? MRB_TT_SYMBOL :
          mrb_undef_p(o)  ? MRB_TT_UNDEF :
-#ifndef MRB_NO_FLOAT
          mrb_float_p(o)  ? MRB_TT_FLOAT :
-#endif
          mrb_val_union(o).bp->tt;
 }
 
+MRB_INLINE enum mrb_vtype
+mrb_unboxed_type(mrb_value o)
+{
+  if (mrb_nil_p(o)) {
+    return MRB_TT_FALSE;
+  } else if ((o.w & WORDBOX_IMMEDIATE_MASK) == 0) {
+    return mrb_val_union(o).bp->tt;
+  } else {
+    return MRB_TT_FALSE;
+  }
+}
+
+
 #endif  /* MRUBY_BOXING_WORD_H */

data/assets/platform/include/mruby/class.h

@@ -0,0 +1,157 @@
+/**
+** @file mruby/class.h - Class class
+**
+** See Copyright Notice in mruby.h
+*/
+
+#ifndef MRUBY_CLASS_H
+#define MRUBY_CLASS_H
+
+#include "common.h"
+
+/**
+ * Class class
+ */
+MRB_BEGIN_DECL
+
+struct RClass {
+  MRB_OBJECT_HEADER;
+  struct iv_tbl *iv;
+  struct mrb_mt_tbl *mt;
+  struct RClass *super;
+};
+
+#define mrb_class_ptr(v)    ((struct RClass*)(mrb_ptr(v)))
+
+MRB_INLINE struct RClass*
+mrb_class(mrb_state *mrb, mrb_value v)
+{
+  if (!mrb_immediate_p(v)) {
+    return mrb_obj_ptr(v)->c;
+  }
+
+  switch (mrb_type(v)) {
+  case MRB_TT_FALSE:
+    if (mrb_fixnum(v))
+      return mrb->false_class;
+    return mrb->nil_class;
+  case MRB_TT_TRUE:
+    return mrb->true_class;
+  case MRB_TT_SYMBOL:
+    return mrb->symbol_class;
+  case MRB_TT_INTEGER:
+    return mrb->integer_class;
+#ifndef MRB_NO_FLOAT
+  case MRB_TT_FLOAT:
+    return mrb->float_class;
+#endif
+  case MRB_TT_CPTR:
+    return mrb->object_class;
+  default:
+    return NULL;
+  }
+}
+
+/* flags:
+   20:   frozen
+   19:   is_prepended
+   18:   is_origin
+   17:   is_inherited (used by method cache)
+   7-16: unused
+   6:    prohibit Class#allocate
+   0-5:  instance type
+*/
+#define MRB_FL_CLASS_IS_PREPENDED (1 << 19)
+#define MRB_FL_CLASS_IS_ORIGIN (1 << 18)
+#define MRB_CLASS_ORIGIN(c) do {\
+  if ((c)->flags & MRB_FL_CLASS_IS_PREPENDED) {\
+    (c) = (c)->super;\
+    while (!((c)->flags & MRB_FL_CLASS_IS_ORIGIN)) {\
+      (c) = (c)->super;\
+    }\
+  }\
+} while (0)
+#define MRB_FL_CLASS_IS_INHERITED (1 << 17)
+#define MRB_INSTANCE_TT_MASK (0x1F)
+#define MRB_SET_INSTANCE_TT(c, tt) ((c)->flags = (((c)->flags & ~MRB_INSTANCE_TT_MASK) | (char)(tt)))
+#define MRB_INSTANCE_TT(c) (enum mrb_vtype)((c)->flags & MRB_INSTANCE_TT_MASK)
+#define MRB_FL_UNDEF_ALLOCATE (1 << 6)
+#define MRB_UNDEF_ALLOCATOR(c) (mrb_assert((c)->tt == MRB_TT_CLASS), (c)->flags |= MRB_FL_UNDEF_ALLOCATE)
+#define MRB_UNDEF_ALLOCATOR_P(c) ((c)->flags & MRB_FL_UNDEF_ALLOCATE)
+#define MRB_DEFINE_ALLOCATOR(c) ((c)->flags &= ~MRB_FL_UNDEF_ALLOCATE)
+
+MRB_API void mrb_define_method_raw(mrb_state*, struct RClass*, mrb_sym, mrb_method_t);
+MRB_API void mrb_alias_method(mrb_state*, struct RClass *c, mrb_sym a, mrb_sym b);
+MRB_API void mrb_remove_method(mrb_state *mrb, struct RClass *c, mrb_sym sym);
+
+MRB_API mrb_method_t mrb_method_search_vm(mrb_state*, struct RClass**, mrb_sym);
+MRB_API mrb_method_t mrb_method_search(mrb_state*, struct RClass*, mrb_sym);
+
+MRB_API struct RClass* mrb_class_real(struct RClass* cl);
+MRB_API struct RClass* mrb_class_outer(mrb_state *mrb, struct RClass *c);
+
+#ifndef MRB_NO_METHOD_CACHE
+void mrb_mc_clear_by_class(mrb_state *mrb, struct RClass* c);
+#else
+#define mrb_mc_clear_by_class(mrb,c)
+#endif
+
+/* return non zero to break the loop */
+typedef int (mrb_mt_foreach_func)(mrb_state*,mrb_sym,mrb_method_t,void*);
+MRB_API void mrb_mt_foreach(mrb_state*, struct RClass*, mrb_mt_foreach_func*, void*);
+
+/* ROM method table types for static method registration */
+union mrb_mt_ptr {
+  const struct RProc *proc;
+  mrb_func_t func;
+};
+
+/* entry combining function pointer, symbol key, and flags */
+typedef struct mrb_mt_entry {
+  union mrb_mt_ptr val;
+  mrb_sym key;              /* pure symbol ID (no flags packed) */
+  uint32_t flags;           /* method flags + aspec */
+} mrb_mt_entry;
+
+typedef struct mrb_mt_tbl {
+  int               size;
+  int               alloc;  /* bit 30: MRB_MT_READONLY_BIT, bit 29: MRB_MT_FROZEN_BIT */
+  mrb_mt_entry     *ptr;
+  struct mrb_mt_tbl *next;
+} mrb_mt_tbl;
+
+#define MRB_MT_READONLY_BIT  (1 << 30)
+#define MRB_MT_FROZEN_BIT    (1 << 29)
+#define MRB_MT_FUNC    (1 << 24)  /* MRB_METHOD_FUNC_FL */
+#define MRB_MT_PUBLIC  0
+#define MRB_MT_PRIVATE (1 << 25)  /* MRB_METHOD_PRIVATE_FL */
+
+/* ROM table entry: 3rd param is MRB_ARGS_*() optionally OR'd with MRB_MT_PRIVATE. */
+#define MRB_MT_ENTRY(fn, sym, flags) \
+  { { .func = (fn) }, (sym), (flags) | MRB_MT_FUNC }
+#define MRB_MT_ASPEC(flags) ((mrb_aspec)((flags) & 0xffffff))
+
+/* "removed" tombstone: MRB_MT_FUNC flag set with NULL function pointer.
+   This combination never occurs naturally (C functions are never NULL).
+   Unlike undef (proc=NULL without MRB_MT_FUNC), a removed marker makes
+   mt_get() return 0 ("not found"), blocking ROM chain walk while
+   allowing superclass lookup. */
+#define MRB_MT_REMOVED_P(e) (((e).flags&MRB_MT_FUNC) && (e).val.func==NULL)
+
+/* Singly-linked list node for tracking heap-allocated ROM wrappers. */
+struct mrb_mt_rom_list {
+  mrb_mt_tbl *tbl;
+  struct mrb_mt_rom_list *next;
+};
+
+/* Allocate a per-state ROM layer wrapping the const entries array,
+   and push it onto the class's method table chain. */
+void mrb_mt_init_rom(mrb_state *mrb, struct RClass *c,
+                     const mrb_mt_entry *entries, int size);
+#define MRB_MT_INIT_ROM(mrb, cls, entries) \
+  mrb_mt_init_rom(mrb, cls, entries, \
+                  (int)(sizeof(entries)/sizeof(entries[0])))
+
+MRB_END_DECL
+
+#endif  /* MRUBY_CLASS_H */

data/assets/{include → platform/include}/mruby/common.h

@@ -59,6 +59,35 @@ MRB_BEGIN_DECL
 # define mrb_deprecated
 #endif
 
+/** Branch prediction hints for optimization. */
+#if defined(__GNUC__) || defined(__clang__)
+# define mrb_likely(x)   __builtin_expect(!!(x), 1)
+# define mrb_unlikely(x) __builtin_expect(!!(x), 0)
+#else
+# define mrb_likely(x)   (x)
+# define mrb_unlikely(x) (x)
+#endif
+
+/** Declare a type or object as an alignment requirement. */
+#ifndef mrb_alignas
+# if defined(__cplusplus) && __cplusplus >= 201103L
+#  // https://en.cppreference.com/w/cpp/language/alignas
+#  define mrb_alignas(n) alignas(n)
+# elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
+#  // https://en.cppreference.com/w/c/language/_Alignas
+#  define mrb_alignas(n) _Alignas(n)
+# elif defined(_MSC_VER) || defined(__INTEL_COMPILER)
+#  // https://learn.microsoft.com/en-us/cpp/cpp/align-cpp?view=msvc-170
+#  define mrb_alignas(n) __declspec(align(n))
+# elif defined(__GNUC__) || defined(__clang__)
+#  // https://gcc.gnu.org/onlinedocs/gcc/Common-Type-Attributes.html#index-aligned-type-attribute
+#  define mrb_alignas(n) __attribute__((aligned(n)))
+# else
+#  // `mrb_alignas` defined as dummy. If necessary, send issues to https://github.com/mruby/mruby .
+#  define mrb_alignas(n)
+# endif
+#endif
+
 /** Declare a function as always inlined. */
 #if defined _MSC_VER && _MSC_VER < 1900
 # ifndef __cplusplus
@@ -67,7 +96,7 @@ MRB_BEGIN_DECL
 #endif
 #define MRB_INLINE static inline
 
-/** Declare a public MRuby API function. */
+/** Declare a public mruby API function. */
 #ifndef MRB_API
 #if defined(MRB_BUILD_AS_DLL)
 #if defined(MRB_CORE) || defined(MRB_LIB)