webruby 0.2.7 → 0.9.1

data/modules/mruby/include/mruby/dump.h

@@ -14,35 +14,36 @@ extern "C" {
 #include "mruby.h"
 #include "mruby/irep.h"
 
+int mrb_dump_irep(mrb_state *mrb, mrb_irep *irep, int debug_info, uint8_t **bin, size_t *bin_size);
 #ifdef ENABLE_STDIO
 int mrb_dump_irep_binary(mrb_state*, mrb_irep*, int, FILE*);
 int mrb_dump_irep_cfunc(mrb_state *mrb, mrb_irep*, int, FILE *f, const char *initname);
 mrb_irep *mrb_read_irep_file(mrb_state*, FILE*);
-mrb_value mrb_load_irep_file(mrb_state*,FILE*);
-mrb_value mrb_load_irep_file_cxt(mrb_state*, FILE*, mrbc_context*);
+MRB_API mrb_value mrb_load_irep_file(mrb_state*,FILE*);
+MRB_API mrb_value mrb_load_irep_file_cxt(mrb_state*, FILE*, mrbc_context*);
 #endif
-mrb_irep *mrb_read_irep(mrb_state*, const uint8_t*);
+MRB_API mrb_irep *mrb_read_irep(mrb_state*, const uint8_t*);
 
 /* dump/load error code
  *
  * NOTE: MRB_DUMP_GENERAL_FAILURE is caused by
  * unspecified issues like malloc failed.
  */
-#define MRB_DUMP_OK                   0
-#define MRB_DUMP_GENERAL_FAILURE      -1
-#define MRB_DUMP_WRITE_FAULT          -2
-#define MRB_DUMP_READ_FAULT           -3
-#define MRB_DUMP_CRC_ERROR            -4
-#define MRB_DUMP_INVALID_FILE_HEADER  -5
-#define MRB_DUMP_INVALID_IREP         -6
-#define MRB_DUMP_INVALID_ARGUMENT     -7
+#define MRB_DUMP_OK                     0
+#define MRB_DUMP_GENERAL_FAILURE      (-1)
+#define MRB_DUMP_WRITE_FAULT          (-2)
+#define MRB_DUMP_READ_FAULT           (-3)
+#define MRB_DUMP_CRC_ERROR            (-4)
+#define MRB_DUMP_INVALID_FILE_HEADER  (-5)
+#define MRB_DUMP_INVALID_IREP         (-6)
+#define MRB_DUMP_INVALID_ARGUMENT     (-7)
 
 /* null symbol length */
 #define MRB_DUMP_NULL_SYM_LEN         0xFFFF
 
 /* Rite Binary File header */
 #define RITE_BINARY_IDENTIFIER         "RITE"
-#define RITE_BINARY_FORMAT_VER         "0002"
+#define RITE_BINARY_FORMAT_VER         "0003"
 #define RITE_COMPILER_NAME             "MATZ"
 #define RITE_COMPILER_VERSION          "0000"
 
@@ -52,20 +53,22 @@ mrb_irep *mrb_read_irep(mrb_state*, const uint8_t*);
 #define RITE_SECTION_IREP_IDENTIFIER   "IREP"
 #define RITE_SECTION_LINENO_IDENTIFIER "LINE"
 #define RITE_SECTION_DEBUG_IDENTIFIER  "DBG\0"
+#define RITE_SECTION_LV_IDENTIFIER     "LVAR"
 
 #define MRB_DUMP_DEFAULT_STR_LEN      128
+#define MRB_DUMP_ALIGNMENT            sizeof(uint32_t)
 
-// binary header
+/* binary header */
 struct rite_binary_header {
-  uint8_t binary_identify[4]; // Binary Identifier
-  uint8_t binary_version[4];  // Binary Format Version
-  uint8_t binary_crc[2];      // Binary CRC
-  uint8_t binary_size[4];     // Binary Size
-  uint8_t compiler_name[4];   // Compiler name
+  uint8_t binary_identify[4]; /* Binary Identifier */
+  uint8_t binary_version[4];  /* Binary Format Version */
+  uint8_t binary_crc[2];      /* Binary CRC */
+  uint8_t binary_size[4];     /* Binary Size */
+  uint8_t compiler_name[4];   /* Compiler name */
   uint8_t compiler_version[4];
 };
 
-// section header
+/* section header */
 #define RITE_SECTION_HEADER \
   uint8_t section_identify[4]; \
   uint8_t section_size[4]
@@ -77,7 +80,7 @@ struct rite_section_header {
 struct rite_section_irep_header {
   RITE_SECTION_HEADER;
 
-  uint8_t rite_version[4];    // Rite Instruction Specification Version
+  uint8_t rite_version[4];    /* Rite Instruction Specification Version */
 };
 
 struct rite_section_lineno_header {
@@ -88,18 +91,24 @@ struct rite_section_debug_header {
   RITE_SECTION_HEADER;
 };
 
+struct rite_section_lv_header {
+  RITE_SECTION_HEADER;
+};
+
+#define RITE_LV_NULL_MARK              UINT16_MAX
+
 struct rite_binary_footer {
   RITE_SECTION_HEADER;
 };
 
-static inline int
+static inline size_t
 uint8_to_bin(uint8_t s, uint8_t *bin)
 {
   *bin = s;
   return sizeof(uint8_t);
 }
 
-static inline int
+static inline size_t
 uint16_to_bin(uint16_t s, uint8_t *bin)
 {
   *bin++ = (s >> 8) & 0xff;
@@ -107,7 +116,7 @@ uint16_to_bin(uint16_t s, uint8_t *bin)
   return sizeof(uint16_t);
 }
 
-static inline int
+static inline size_t
 uint32_to_bin(uint32_t l, uint8_t *bin)
 {
   *bin++ = (l >> 24) & 0xff;

data/modules/mruby/include/mruby/error.h

@@ -0,0 +1,36 @@
+/*
+** mruby/error.h - Exception class
+**
+** See Copyright Notice in mruby.h
+*/
+
+#ifndef MRUBY_ERROR_H
+#define MRUBY_ERROR_H
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+struct RException {
+  MRB_OBJECT_HEADER;
+  struct iv_tbl *iv;
+};
+
+#define mrb_exc_ptr(v) ((struct RException*)mrb_ptr(v))
+
+MRB_API void mrb_sys_fail(mrb_state *mrb, const char *mesg);
+MRB_API mrb_value mrb_exc_new_str(mrb_state *mrb, struct RClass* c, mrb_value str);
+#define mrb_exc_new_str_lit(mrb, c, lit) mrb_exc_new_str(mrb, c, mrb_str_new_lit(mrb, lit))
+MRB_API mrb_value mrb_make_exception(mrb_state *mrb, int argc, const mrb_value *argv);
+MRB_API mrb_value mrb_exc_backtrace(mrb_state *mrb, mrb_value exc);
+MRB_API mrb_value mrb_get_backtrace(mrb_state *mrb);
+MRB_API mrb_noreturn void mrb_no_method_error(mrb_state *mrb, mrb_sym id, mrb_int argc, const mrb_value *argv, const char *fmt, ...);
+
+/* declaration for fail method */
+MRB_API mrb_value mrb_f_raise(mrb_state*, mrb_value);
+
+#if defined(__cplusplus)
+}  /* extern "C" { */
+#endif
+
+#endif  /* MRUBY_ERROR_H */

data/modules/mruby/include/mruby/gc.h

@@ -1,5 +1,5 @@
 /*
-** gc.h - garbage collector for mruby
+** mruby/gc.h - garbage collector for mruby
 **
 ** See Copyright Notice in mruby.h
 */
@@ -7,11 +7,16 @@
 #ifndef MRUBY_GC_H
 #define MRUBY_GC_H
 
-#include "mruby.h"
-#include "mruby/value.h"
+#if defined(__cplusplus)
+extern "C" {
+#endif
 
-typedef void (each_object_callback)(mrb_state *mrb, struct RBasic* obj, void *data);
-void mrb_objspace_each_objects(mrb_state *mrb, each_object_callback* callback, void *data);
-void mrb_free_context(mrb_state *mrb, struct mrb_context *c);
+typedef void (mrb_each_object_callback)(mrb_state *mrb, struct RBasic *obj, void *data);
+void mrb_objspace_each_objects(mrb_state *mrb, mrb_each_object_callback *callback, void *data);
+MRB_API void mrb_free_context(mrb_state *mrb, struct mrb_context *c);
+
+#if defined(__cplusplus)
+}  /* extern "C" { */
+#endif
 
 #endif  /* MRUBY_GC_H */

data/modules/mruby/include/mruby/hash.h

@@ -20,24 +20,24 @@ struct RHash {
 #define mrb_hash_ptr(v)    ((struct RHash*)(mrb_ptr(v)))
 #define mrb_hash_value(p)  mrb_obj_value((void*)(p))
 
-mrb_value mrb_hash_new_capa(mrb_state*, int);
-mrb_value mrb_hash_new(mrb_state *mrb);
-
-void mrb_hash_set(mrb_state *mrb, mrb_value hash, mrb_value key, mrb_value val);
-mrb_value mrb_hash_get(mrb_state *mrb, mrb_value hash, mrb_value key);
-mrb_value mrb_hash_fetch(mrb_state *mrb, mrb_value hash, mrb_value key, mrb_value def);
-mrb_value mrb_hash_delete_key(mrb_state *mrb, mrb_value hash, mrb_value key);
-mrb_value mrb_hash_keys(mrb_state *mrb, mrb_value hash);
-mrb_value mrb_check_hash_type(mrb_state *mrb, mrb_value hash);
-mrb_value mrb_hash_empty_p(mrb_state *mrb, mrb_value self);
-mrb_value mrb_hash_clear(mrb_state *mrb, mrb_value hash);
+MRB_API mrb_value mrb_hash_new_capa(mrb_state*, int);
+MRB_API mrb_value mrb_hash_new(mrb_state *mrb);
+
+MRB_API void mrb_hash_set(mrb_state *mrb, mrb_value hash, mrb_value key, mrb_value val);
+MRB_API mrb_value mrb_hash_get(mrb_state *mrb, mrb_value hash, mrb_value key);
+MRB_API mrb_value mrb_hash_fetch(mrb_state *mrb, mrb_value hash, mrb_value key, mrb_value def);
+MRB_API mrb_value mrb_hash_delete_key(mrb_state *mrb, mrb_value hash, mrb_value key);
+MRB_API mrb_value mrb_hash_keys(mrb_state *mrb, mrb_value hash);
+MRB_API mrb_value mrb_check_hash_type(mrb_state *mrb, mrb_value hash);
+MRB_API mrb_value mrb_hash_empty_p(mrb_state *mrb, mrb_value self);
+MRB_API mrb_value mrb_hash_clear(mrb_state *mrb, mrb_value hash);
 
 /* RHASH_TBL allocates st_table if not available. */
 #define RHASH(obj)   ((struct RHash*)(mrb_ptr(obj)))
 #define RHASH_TBL(h)          (RHASH(h)->ht)
 #define RHASH_IFNONE(h)       mrb_iv_get(mrb, (h), mrb_intern_lit(mrb, "ifnone"))
 #define RHASH_PROCDEFAULT(h)  RHASH_IFNONE(h)
-struct kh_ht * mrb_hash_tbl(mrb_state *mrb, mrb_value hash);
+MRB_API struct kh_ht * mrb_hash_tbl(mrb_state *mrb, mrb_value hash);
 
 #define MRB_HASH_PROC_DEFAULT 256
 #define MRB_RHASH_PROCDEFAULT_P(h) (RHASH(h)->flags & MRB_HASH_PROC_DEFAULT)

data/modules/mruby/include/mruby/irep.h

@@ -19,6 +19,11 @@ enum irep_pool_type {
   IREP_TT_FLOAT,
 };
 
+struct mrb_locals {
+  mrb_sym name;
+  uint16_t r;
+};
+
 /* Program data array struct */
 typedef struct mrb_irep {
   uint16_t nlocals;        /* Number of local variables */
@@ -30,6 +35,7 @@ typedef struct mrb_irep {
   mrb_sym *syms;
   struct mrb_irep **reps;
 
+  struct mrb_locals *lv;
   /* debug info */
   const char *filename;
   uint16_t *lines;
@@ -40,9 +46,9 @@ typedef struct mrb_irep {
 
 #define MRB_ISEQ_NO_FREE 1
 
-mrb_irep *mrb_add_irep(mrb_state *mrb);
-mrb_value mrb_load_irep(mrb_state*, const uint8_t*);
-mrb_value mrb_load_irep_cxt(mrb_state*, const uint8_t*, mrbc_context*);
+MRB_API mrb_irep *mrb_add_irep(mrb_state *mrb);
+MRB_API mrb_value mrb_load_irep(mrb_state*, const uint8_t*);
+MRB_API mrb_value mrb_load_irep_cxt(mrb_state*, const uint8_t*, mrbc_context*);
 void mrb_irep_free(mrb_state*, struct mrb_irep*);
 void mrb_irep_incref(mrb_state*, struct mrb_irep*);
 void mrb_irep_decref(mrb_state*, struct mrb_irep*);

data/modules/mruby/include/mruby/khash.h

@@ -4,8 +4,8 @@
 ** See Copyright Notice in mruby.h
 */
 
-#ifndef KHASH_H
-#define KHASH_H
+#ifndef MRUBY_KHASH_H
+#define MRUBY_KHASH_H
 
 #if defined(__cplusplus)
 extern "C" {
@@ -24,12 +24,12 @@ typedef khint_t khiter_t;
 
 #define UPPER_BOUND(x) ((x)>>2|(x)>>1)
 
-//extern uint8_t __m[];
+/* extern uint8_t __m[]; */
 
 /* mask for flags */
-static const uint8_t __m_empty[8]  = {0x02, 0x08, 0x20, 0x80};
-static const uint8_t __m_del[8]    = {0x01, 0x04, 0x10, 0x40};
-static const uint8_t __m_either[8] = {0x03, 0x0c, 0x30, 0xc0};
+static const uint8_t __m_empty[]  = {0x02, 0x08, 0x20, 0x80};
+static const uint8_t __m_del[]    = {0x01, 0x04, 0x10, 0x40};
+static const uint8_t __m_either[] = {0x03, 0x0c, 0x30, 0xc0};
 
 
 #define __ac_isempty(ed_flag, i) (ed_flag[(i)/4]&__m_empty[(i)%4])
@@ -44,6 +44,8 @@ static const uint8_t __m_either[8] = {0x03, 0x0c, 0x30, 0xc0};
   v |= v >> 16;\
   v++;\
 } while (0)
+#define khash_mask(h) ((h)->n_buckets-1)
+#define khash_upper_bound(h) (UPPER_BOUND((h)->n_buckets))
 
 /* declare struct kh_xxx and kh_xxx_funcs
 
@@ -57,12 +59,9 @@ static const uint8_t __m_either[8] = {0x03, 0x0c, 0x30, 0xc0};
     khint_t n_buckets;                                                  \
     khint_t size;                                                       \
     khint_t n_occupied;                                                 \
-    khint_t upper_bound;                                                \
     uint8_t *ed_flags;                                                  \
     khkey_t *keys;                                                      \
     khval_t *vals;                                                      \
-    khint_t mask;                                                       \
-    khint_t inc;                                                        \
   } kh_##name##_t;                                                      \
   void kh_alloc_##name(mrb_state *mrb, kh_##name##_t *h);               \
   kh_##name##_t *kh_init_##name##_size(mrb_state *mrb, khint_t size);   \
@@ -70,7 +69,7 @@ static const uint8_t __m_either[8] = {0x03, 0x0c, 0x30, 0xc0};
   void kh_destroy_##name(mrb_state *mrb, kh_##name##_t *h);             \
   void kh_clear_##name(mrb_state *mrb, kh_##name##_t *h);               \
   khint_t kh_get_##name(mrb_state *mrb, kh_##name##_t *h, khkey_t key);           \
-  khint_t kh_put_##name(mrb_state *mrb, kh_##name##_t *h, khkey_t key);           \
+  khint_t kh_put_##name(mrb_state *mrb, kh_##name##_t *h, khkey_t key, int *ret); \
   void kh_resize_##name(mrb_state *mrb, kh_##name##_t *h, khint_t new_n_buckets); \
   void kh_del_##name(mrb_state *mrb, kh_##name##_t *h, khint_t x);                \
   kh_##name##_t *kh_copy_##name(mrb_state *mrb, kh_##name##_t *h);
@@ -96,16 +95,13 @@ kh_fill_flags(uint8_t *p, uint8_t c, size_t len)
   void kh_alloc_##name(mrb_state *mrb, kh_##name##_t *h)                \
   {                                                                     \
     khint_t sz = h->n_buckets;                                          \
-    int len = sizeof(khkey_t) + (kh_is_map ? sizeof(khval_t) : 0);      \
-    uint8_t *p = mrb_malloc(mrb, sizeof(uint8_t)*sz/4+len*sz);          \
+    size_t len = sizeof(khkey_t) + (kh_is_map ? sizeof(khval_t) : 0);   \
+    uint8_t *p = (uint8_t*)mrb_malloc(mrb, sizeof(uint8_t)*sz/4+len*sz); \
     h->size = h->n_occupied = 0;                                        \
-    h->upper_bound = UPPER_BOUND(sz);                                   \
     h->keys = (khkey_t *)p;                                             \
     h->vals = kh_is_map ? (khval_t *)(p+sizeof(khkey_t)*sz) : NULL;     \
     h->ed_flags = p+len*sz;                                             \
     kh_fill_flags(h->ed_flags, 0xaa, sz/4);                             \
-    h->mask = sz-1;                                                     \
-    h->inc = sz/2-1;                                                    \
   }                                                                     \
   kh_##name##_t *kh_init_##name##_size(mrb_state *mrb, khint_t size) {  \
     kh_##name##_t *h = (kh_##name##_t*)mrb_calloc(mrb, 1, sizeof(kh_##name##_t)); \
@@ -116,7 +112,7 @@ kh_fill_flags(uint8_t *p, uint8_t c, size_t len)
     kh_alloc_##name(mrb, h);                                            \
     return h;                                                           \
   }                                                                     \
-  kh_##name##_t *kh_init_##name(mrb_state *mrb){                        \
+  kh_##name##_t *kh_init_##name(mrb_state *mrb) {                       \
     return kh_init_##name##_size(mrb, KHASH_DEFAULT_SIZE);              \
   }                                                                     \
   void kh_destroy_##name(mrb_state *mrb, kh_##name##_t *h)              \
@@ -128,6 +124,7 @@ kh_fill_flags(uint8_t *p, uint8_t c, size_t len)
   }                                                                     \
   void kh_clear_##name(mrb_state *mrb, kh_##name##_t *h)                \
   {                                                                     \
+    (void)mrb;                                                          \
     if (h && h->ed_flags) {                                             \
       kh_fill_flags(h->ed_flags, 0xaa, h->n_buckets/4);                 \
       h->size = h->n_occupied = 0;                                      \
@@ -135,14 +132,15 @@ kh_fill_flags(uint8_t *p, uint8_t c, size_t len)
   }                                                                     \
   khint_t kh_get_##name(mrb_state *mrb, kh_##name##_t *h, khkey_t key)  \
   {                                                                     \
-    khint_t k = __hash_func(mrb,key) & (h->mask);                       \
+    khint_t k = __hash_func(mrb,key) & khash_mask(h), step = 0;         \
+    (void)mrb;                                                          \
     while (!__ac_isempty(h->ed_flags, k)) {                             \
       if (!__ac_isdel(h->ed_flags, k)) {                                \
         if (__hash_equal(mrb,h->keys[k], key)) return k;                \
       }                                                                 \
-      k = (k+h->inc) & (h->mask);                                       \
+      k = (k+(++step)) & khash_mask(h);                                 \
     }                                                                   \
-    return h->n_buckets;                                                \
+    return kh_end(h);                                                   \
   }                                                                     \
   void kh_resize_##name(mrb_state *mrb, kh_##name##_t *h, khint_t new_n_buckets) \
   {                                                                     \
@@ -150,50 +148,68 @@ kh_fill_flags(uint8_t *p, uint8_t c, size_t len)
       new_n_buckets = KHASH_MIN_SIZE;                                   \
     khash_power2(new_n_buckets);                                        \
     {                                                                   \
+      kh_##name##_t hh;                                                 \
       uint8_t *old_ed_flags = h->ed_flags;                              \
       khkey_t *old_keys = h->keys;                                      \
       khval_t *old_vals = h->vals;                                      \
       khint_t old_n_buckets = h->n_buckets;                             \
       khint_t i;                                                        \
-      h->n_buckets = new_n_buckets;                                     \
-      kh_alloc_##name(mrb, h);                                          \
+      hh.n_buckets = new_n_buckets;                                     \
+      kh_alloc_##name(mrb, &hh);                                        \
       /* relocate */                                                    \
       for (i=0 ; i<old_n_buckets ; i++) {                               \
         if (!__ac_iseither(old_ed_flags, i)) {                          \
-          khint_t k = kh_put_##name(mrb, h, old_keys[i]);               \
-          if (kh_is_map) kh_value(h,k) = old_vals[i];                   \
+          khint_t k = kh_put_##name(mrb, &hh, old_keys[i], NULL);       \
+          if (kh_is_map) kh_value(&hh,k) = old_vals[i];                 \
         }                                                               \
       }                                                                 \
+      /* copy hh to h */                                                \
+      *h = hh;                                                          \
       mrb_free(mrb, old_keys);                                          \
     }                                                                   \
   }                                                                     \
-  khint_t kh_put_##name(mrb_state *mrb, kh_##name##_t *h, khkey_t key)  \
+  khint_t kh_put_##name(mrb_state *mrb, kh_##name##_t *h, khkey_t key, int *ret) \
   {                                                                     \
-    khint_t k;                                                          \
-    if (h->n_occupied >= h->upper_bound) {                              \
+    khint_t k, del_k, step = 0;                                         \
+    if (h->n_occupied >= khash_upper_bound(h)) {                        \
       kh_resize_##name(mrb, h, h->n_buckets*2);                         \
     }                                                                   \
-    k = __hash_func(mrb,key) & (h->mask);                               \
-    while (!__ac_iseither(h->ed_flags, k)) {                            \
-      if (__hash_equal(mrb,h->keys[k], key)) break;                     \
-      k = (k+h->inc) & (h->mask);                                       \
+    k = __hash_func(mrb,key) & khash_mask(h);                           \
+    del_k = kh_end(h);                                                  \
+    while (!__ac_isempty(h->ed_flags, k)) {                             \
+      if (!__ac_isdel(h->ed_flags, k)) {                                \
+        if (__hash_equal(mrb,h->keys[k], key)) {                        \
+          if (ret) *ret = 0;                                            \
+          return k;                                                     \
+        }                                                               \
+      }                                                                 \
+      else if (del_k == kh_end(h)) {                                    \
+        del_k = k;                                                      \
+      }                                                                 \
+      k = (k+(++step)) & khash_mask(h);                                 \
     }                                                                   \
-    if (__ac_isempty(h->ed_flags, k)) {                                 \
+    if (del_k != kh_end(h)) {                                           \
+      /* put at del */                                                  \
+      h->keys[del_k] = key;                                             \
+      h->ed_flags[del_k/4] &= ~__m_del[del_k%4];                        \
+      h->size++;                                                        \
+      if (ret) *ret = 2;                                                \
+      return del_k;                                                     \
+    }                                                                   \
+    else {                                                              \
       /* put at empty */                                                \
       h->keys[k] = key;                                                 \
       h->ed_flags[k/4] &= ~__m_empty[k%4];                              \
       h->size++;                                                        \
       h->n_occupied++;                                                  \
-    } else if (__ac_isdel(h->ed_flags, k)) {                            \
-      /* put at del */                                                  \
-      h->keys[k] = key;                                                 \
-      h->ed_flags[k/4] &= ~__m_del[k%4];                                \
-      h->size++;                                                        \
+      if (ret) *ret = 1;                                                \
+      return k;                                                         \
     }                                                                   \
-    return k;                                                           \
   }                                                                     \
   void kh_del_##name(mrb_state *mrb, kh_##name##_t *h, khint_t x)       \
   {                                                                     \
+    (void)mrb;                                                          \
+    mrb_assert(x != h->n_buckets && !__ac_iseither(h->ed_flags, x));    \
     h->ed_flags[x/4] |= __m_del[x%4];                                   \
     h->size--;                                                          \
   }                                                                     \
@@ -205,8 +221,8 @@ kh_fill_flags(uint8_t *p, uint8_t c, size_t len)
     h2 = kh_init_##name(mrb);                                           \
     for (k = kh_begin(h); k != kh_end(h); k++) {                        \
       if (kh_exist(h, k)) {                                             \
-        k2 = kh_put_##name(mrb, h2, kh_key(h, k));                      \
-        if(kh_is_map) kh_value(h2, k2) = kh_value(h, k);                \
+        k2 = kh_put_##name(mrb, h2, kh_key(h, k), NULL);                \
+        if (kh_is_map) kh_value(h2, k2) = kh_value(h, k);               \
       }                                                                 \
     }                                                                   \
     return h2;                                                          \
@@ -220,7 +236,8 @@ kh_fill_flags(uint8_t *p, uint8_t c, size_t len)
 #define kh_destroy(name, mrb, h) kh_destroy_##name(mrb, h)
 #define kh_clear(name, mrb, h) kh_clear_##name(mrb, h)
 #define kh_resize(name, mrb, h, s) kh_resize_##name(mrb, h, s)
-#define kh_put(name, mrb, h, k) kh_put_##name(mrb, h, k)
+#define kh_put(name, mrb, h, k) kh_put_##name(mrb, h, k, NULL)
+#define kh_put2(name, mrb, h, k, r) kh_put_##name(mrb, h, k, r)
 #define kh_get(name, mrb, h, k) kh_get_##name(mrb, h, k)
 #define kh_del(name, mrb, h, k) kh_del_##name(mrb, h, k)
 #define kh_copy(name, mrb, h) kh_copy_##name(mrb, h)
@@ -253,4 +270,4 @@ typedef const char *kh_cstr_t;
 }  /* extern "C" { */
 #endif
 
-#endif  /* KHASH_H */
+#endif  /* MRUBY_KHASH_H */

data/modules/mruby/include/mruby/numeric.h

@@ -15,16 +15,50 @@ extern "C" {
 #define NEGFIXABLE(f) ((f) >= MRB_INT_MIN)
 #define FIXABLE(f) (POSFIXABLE(f) && NEGFIXABLE(f))
 
-mrb_value mrb_flo_to_fixnum(mrb_state *mrb, mrb_value val);
-mrb_value mrb_flo_to_str(mrb_state *mrb, mrb_value flo, int max_digit);
-
-mrb_value mrb_fixnum_to_str(mrb_state *mrb, mrb_value x, int base);
+MRB_API mrb_value mrb_flo_to_fixnum(mrb_state *mrb, mrb_value val);
+MRB_API mrb_value mrb_fixnum_to_str(mrb_state *mrb, mrb_value x, int base);
+MRB_API mrb_float mrb_to_flo(mrb_state *mrb, mrb_value x);
 
 mrb_value mrb_fixnum_plus(mrb_state *mrb, mrb_value x, mrb_value y);
 mrb_value mrb_fixnum_minus(mrb_state *mrb, mrb_value x, mrb_value y);
 mrb_value mrb_fixnum_mul(mrb_state *mrb, mrb_value x, mrb_value y);
 mrb_value mrb_num_div(mrb_state *mrb, mrb_value x, mrb_value y);
 
+#define MRB_UINT_MAKE2(n) uint ## n ## _t
+#define MRB_UINT_MAKE(n) MRB_UINT_MAKE2(n)
+#define mrb_uint MRB_UINT_MAKE(MRB_INT_BIT)
+
+#ifdef MRB_WORD_BOXING
+# define MRB_INT_OVERFLOW_MASK ((mrb_uint)1 << (MRB_INT_BIT - 1 - MRB_FIXNUM_SHIFT))
+#else
+# define MRB_INT_OVERFLOW_MASK ((mrb_uint)1 << (MRB_INT_BIT - 1))
+#endif
+
+static inline mrb_bool
+mrb_int_add_overflow(mrb_int augend, mrb_int addend, mrb_int *sum)
+{
+  mrb_uint x = (mrb_uint)augend;
+  mrb_uint y = (mrb_uint)addend;
+  mrb_uint z = (mrb_uint)(x + y);
+  *sum = (mrb_int)z;
+  return !!(((x ^ z) & (y ^ z)) & MRB_INT_OVERFLOW_MASK);
+}
+
+static inline mrb_bool
+mrb_int_sub_overflow(mrb_int minuend, mrb_int subtrahend, mrb_int *difference)
+{
+  mrb_uint x = (mrb_uint)minuend;
+  mrb_uint y = (mrb_uint)subtrahend;
+  mrb_uint z = (mrb_uint)(x - y);
+  *difference = (mrb_int)z;
+  return !!(((x ^ z) & (~y ^ z)) & MRB_INT_OVERFLOW_MASK);
+}
+
+#undef MRB_INT_OVERFLOW_MASK
+#undef mrb_uint
+#undef MRB_UINT_MAKE
+#undef MRB_UINT_MAKE2
+
 #if defined(__cplusplus)
 }  /* extern "C" { */
 #endif

data/modules/mruby/include/mruby/object.h

@@ -0,0 +1,55 @@
+/*
+** mruby/object.h - mruby object definition
+**
+** See Copyright Notice in mruby.h
+*/
+
+#ifndef MRUBY_OBJECT_H
+#define MRUBY_OBJECT_H
+
+#define MRB_OBJECT_HEADER \
+  enum mrb_vtype tt:8;\
+  uint32_t color:3;\
+  uint32_t flags:21;\
+  struct RClass *c;\
+  struct RBasic *gcnext
+
+/* white: 011, black: 100, gray: 000 */
+#define MRB_GC_GRAY 0
+#define MRB_GC_WHITE_A 1
+#define MRB_GC_WHITE_B (1 << 1)
+#define MRB_GC_BLACK (1 << 2)
+#define MRB_GC_WHITES (MRB_GC_WHITE_A | MRB_GC_WHITE_B)
+#define MRB_GC_COLOR_MASK 7
+
+#define paint_gray(o) ((o)->color = MRB_GC_GRAY)
+#define paint_black(o) ((o)->color = MRB_GC_BLACK)
+#define paint_white(o) ((o)->color = MRB_GC_WHITES)
+#define paint_partial_white(s, o) ((o)->color = (s)->current_white_part)
+#define is_gray(o) ((o)->color == MRB_GC_GRAY)
+#define is_white(o) ((o)->color & MRB_GC_WHITES)
+#define is_black(o) ((o)->color & MRB_GC_BLACK)
+#define is_dead(s, o) (((o)->color & other_white_part(s) & MRB_GC_WHITES) || (o)->tt == MRB_TT_FREE)
+#define flip_white_part(s) ((s)->current_white_part = other_white_part(s))
+#define other_white_part(s) ((s)->current_white_part ^ MRB_GC_WHITES)
+
+struct RBasic {
+  MRB_OBJECT_HEADER;
+};
+#define mrb_basic_ptr(v) ((struct RBasic*)(mrb_ptr(v)))
+
+struct RObject {
+  MRB_OBJECT_HEADER;
+  struct iv_tbl *iv;
+};
+#define mrb_obj_ptr(v)   ((struct RObject*)(mrb_ptr(v)))
+
+#define mrb_immediate_p(x) (mrb_type(x) < MRB_TT_HAS_BASIC)
+#define mrb_special_const_p(x) mrb_immediate_p(x)
+
+struct RFiber {
+  MRB_OBJECT_HEADER;
+  struct mrb_context *cxt;
+};
+
+#endif  /* MRUBY_OBJECT_H */