Merge upstream

5 files changed, 89 insertions, 76 deletions

diff --git a/include/mruby.h b/include/mruby.h
index 33a15de0e..dcd2aa5fc 100644
--- a/include/mruby.h
+++ b/include/mruby.h
@@ -73,15 +73,15 @@ enum mrb_fiber_state {
 struct mrb_context {
   struct mrb_context *prev;
 
-  mrb_value *stack;
+  mrb_value *stack;                       /* stack of virtual machine */
   mrb_value *stbase, *stend;
 
   mrb_callinfo *ci;
   mrb_callinfo *cibase, *ciend;
 
-  mrb_code **rescue;
+  mrb_code **rescue;                      /* exception handler stack */
   int rsize;
-  struct RProc **ensure;
+  struct RProc **ensure;                  /* ensure handler stack */
   int esize;
 
   uint8_t status;
@@ -97,19 +97,19 @@ enum gc_state {
 typedef struct mrb_state {
   void *jmp;
 
-  mrb_allocf allocf;
+  mrb_allocf allocf;                      /* memory allocation function */
 
   struct mrb_context *c;
   struct mrb_context *root_c;
 
-  struct RObject *exc;
-  struct iv_tbl *globals;
-  struct mrb_irep **irep;
+  struct RObject *exc;                    /* exception */
+  struct iv_tbl *globals;                 /* global variable table */
+  struct mrb_irep **irep;                 /* program data array */
   size_t irep_len, irep_capa;
 
   mrb_sym init_sym;
   struct RObject *top_self;
-  struct RClass *object_class;
+  struct RClass *object_class;            /* Object class */
   struct RClass *class_class;
   struct RClass *module_class;
   struct RClass *proc_class;
@@ -125,17 +125,17 @@ typedef struct mrb_state {
   struct RClass *symbol_class;
   struct RClass *kernel_module;
 
-  struct heap_page *heaps;
+  struct heap_page *heaps;                /* heaps for GC */
   struct heap_page *sweeps;
   struct heap_page *free_heaps;
   size_t live; /* count of live objects */
-  struct RBasic *arena[MRB_ARENA_SIZE];
+  struct RBasic *arena[MRB_ARENA_SIZE];   /* GC protection array */
   int arena_idx;
 
   enum gc_state gc_state; /* state of gc */
   int current_white_part; /* make white object by white_part */
-  struct RBasic *gray_list; /* list of gray objects */
-  struct RBasic *variable_gray_list; /* list of objects to be traversed atomically */
+  struct RBasic *gray_list; /* list of gray objects to be traversed incrementally */
+  struct RBasic *atomic_gray_list; /* list of objects to be traversed atomically */
   size_t gc_live_after_mark;
   size_t gc_threshold;
   int gc_interval_ratio;
@@ -176,12 +176,13 @@ void mrb_undef_class_method(mrb_state*, struct RClass*, const char*);
 mrb_value mrb_instance_new(mrb_state *mrb, mrb_value cv);
 struct RClass * mrb_class_new(mrb_state *mrb, struct RClass *super);
 struct RClass * mrb_module_new(mrb_state *mrb);
-int mrb_class_defined(mrb_state *mrb, const char *name);
+mrb_bool mrb_class_defined(mrb_state *mrb, const char *name);
 struct RClass * mrb_class_get(mrb_state *mrb, const char *name);
+struct RClass * mrb_class_get_under(mrb_state *mrb, struct RClass *outer, const char *name);
 
 mrb_value mrb_obj_dup(mrb_state *mrb, mrb_value obj);
 mrb_value mrb_check_to_integer(mrb_state *mrb, mrb_value val, const char *method);
-int mrb_obj_respond_to(struct RClass* c, mrb_sym mid);
+mrb_bool mrb_obj_respond_to(struct RClass* c, mrb_sym mid);
 struct RClass * mrb_define_class_under(mrb_state *mrb, struct RClass *outer, const char *name, struct RClass *super);
 struct RClass * mrb_define_module_under(mrb_state *mrb, struct RClass *outer, const char *name);
 
@@ -239,9 +240,11 @@ mrb_sym mrb_intern(mrb_state *mrb,const char *cstr)
   return mrb_intern_cstr(mrb, cstr);
 }
 
-void *mrb_malloc(mrb_state*, size_t);
-void *mrb_calloc(mrb_state*, size_t, size_t);
-void *mrb_realloc(mrb_state*, void*, size_t);
+void *mrb_malloc(mrb_state*, size_t);         /* raise RuntimeError if no mem */
+void *mrb_calloc(mrb_state*, size_t, size_t); /* ditto */
+void *mrb_realloc(mrb_state*, void*, size_t); /* ditto */
+void *mrb_realloc_simple(mrb_state*, void*, size_t); /* return NULL if no memory available */
+void *mrb_malloc_simple(mrb_state*, size_t);  /* return NULL if no memory available */
 struct RBasic *mrb_obj_alloc(mrb_state*, enum mrb_vtype, struct RClass*);
 void mrb_free(mrb_state*, void*);
 
@@ -261,15 +264,16 @@ void mrb_p(mrb_state*, mrb_value);
 mrb_int mrb_obj_id(mrb_value obj);
 mrb_sym mrb_obj_to_sym(mrb_state *mrb, mrb_value name);
 
-int mrb_obj_eq(mrb_state*, mrb_value, mrb_value);
-int mrb_obj_equal(mrb_state*, mrb_value, mrb_value);
-int mrb_equal(mrb_state *mrb, mrb_value obj1, mrb_value obj2);
+mrb_bool mrb_obj_eq(mrb_state*, mrb_value, mrb_value);
+mrb_bool mrb_obj_equal(mrb_state*, mrb_value, mrb_value);
+mrb_bool mrb_equal(mrb_state *mrb, mrb_value obj1, mrb_value obj2);
 mrb_value mrb_Integer(mrb_state *mrb, mrb_value val);
 mrb_value mrb_Float(mrb_state *mrb, mrb_value val);
 mrb_value mrb_inspect(mrb_state *mrb, mrb_value obj);
-int mrb_eql(mrb_state *mrb, mrb_value obj1, mrb_value obj2);
+mrb_bool mrb_eql(mrb_state *mrb, mrb_value obj1, mrb_value obj2);
 
 void mrb_garbage_collect(mrb_state*);
+void mrb_full_gc(mrb_state*);
 void mrb_incremental_gc(mrb_state *);
 int mrb_gc_arena_save(mrb_state*);
 void mrb_gc_arena_restore(mrb_state*,int);
@@ -283,13 +287,13 @@ void mrb_field_write_barrier(mrb_state *, struct RBasic*, struct RBasic*);
 } while (0)
 void mrb_write_barrier(mrb_state *, struct RBasic*);
 
-mrb_value mrb_check_convert_type(mrb_state *mrb, mrb_value val, mrb_int type, const char *tname, const char *method);
+mrb_value mrb_check_convert_type(mrb_state *mrb, mrb_value val, enum mrb_vtype type, const char *tname, const char *method);
 mrb_value mrb_any_to_s(mrb_state *mrb, mrb_value obj);
 const char * mrb_obj_classname(mrb_state *mrb, mrb_value obj);
 struct RClass* mrb_obj_class(mrb_state *mrb, mrb_value obj);
 mrb_value mrb_class_path(mrb_state *mrb, struct RClass *c);
-mrb_value mrb_convert_type(mrb_state *mrb, mrb_value val, mrb_int type, const char *tname, const char *method);
-int mrb_obj_is_kind_of(mrb_state *mrb, mrb_value obj, struct RClass *c);
+mrb_value mrb_convert_type(mrb_state *mrb, mrb_value val, enum mrb_vtype type, const char *tname, const char *method);
+mrb_bool mrb_obj_is_kind_of(mrb_state *mrb, mrb_value obj, struct RClass *c);
 mrb_value mrb_obj_inspect(mrb_state *mrb, mrb_value self);
 mrb_value mrb_obj_clone(mrb_state *mrb, mrb_value self);
 
@@ -366,8 +370,8 @@ void mrb_define_global_const(mrb_state *mrb, const char *name, mrb_value val);
 mrb_value mrb_block_proc(void);
 mrb_value mrb_attr_get(mrb_state *mrb, mrb_value obj, mrb_sym id);
 
-int mrb_respond_to(mrb_state *mrb, mrb_value obj, mrb_sym mid);
-int mrb_obj_is_instance_of(mrb_state *mrb, mrb_value obj, struct RClass* c);
+mrb_bool mrb_respond_to(mrb_state *mrb, mrb_value obj, mrb_sym mid);
+mrb_bool mrb_obj_is_instance_of(mrb_state *mrb, mrb_value obj, struct RClass* c);
 
 /* memory pool implementation */
 typedef struct mrb_pool mrb_pool;
@@ -375,9 +379,16 @@ struct mrb_pool* mrb_pool_open(mrb_state*);
 void mrb_pool_close(struct mrb_pool*);
 void* mrb_pool_alloc(struct mrb_pool*, size_t);
 void* mrb_pool_realloc(struct mrb_pool*, void*, size_t oldlen, size_t newlen);
-int mrb_pool_can_realloc(struct mrb_pool*, void*, size_t);
+mrb_bool mrb_pool_can_realloc(struct mrb_pool*, void*, size_t);
 void* mrb_alloca(mrb_state *mrb, size_t);
 
+#ifdef MRB_DEBUG
+#include <assert.h>
+#define mrb_assert(p) assert(p)
+#else
+#define mrb_assert(p) ((void)0)
+#endif
+
 #if defined(__cplusplus)
 }  /* extern "C" { */
 #endif
diff --git a/include/mruby/irep.h b/include/mruby/irep.h
index 856b12099..498b58ca3 100644
--- a/include/mruby/irep.h
+++ b/include/mruby/irep.h
@@ -11,10 +11,11 @@
 extern "C" {
 #endif
 
+/* Program data array struct */
 typedef struct mrb_irep {
   uint32_t idx;
-  uint16_t nlocals;
-  uint16_t nregs;
+  uint16_t nlocals;        /* Number of local variables */
+  uint16_t nregs;          /* Number of register variables */
   uint8_t flags;
 
   mrb_code *iseq;
diff --git a/include/mruby/khash.h b/include/mruby/khash.h
index db8048f5a..fb11586d2 100644
--- a/include/mruby/khash.h
+++ b/include/mruby/khash.h
@@ -27,12 +27,14 @@ typedef khint_t khiter_t;
 //extern uint8_t __m[];
 
 /* mask for flags */
-static const uint8_t __m[8] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};
+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};
 
 
-#define __ac_isempty(e_flag, d_flag, i) (e_flag[(i)/8]&__m[(i)%8])
-#define __ac_isdel(e_flag, d_flag, i) (d_flag[(i)/8]&__m[(i)%8])
-#define __ac_iseither(e_flag, d_flag, i) (__ac_isempty(e_flag,d_flag,i)||__ac_isdel(e_flag,d_flag,i))
+#define __ac_isempty(ed_flag, i) (ed_flag[(i)/4]&__m_empty[(i)%4])
+#define __ac_isdel(ed_flag, i) (ed_flag[(i)/4]&__m_del[(i)%4])
+#define __ac_iseither(ed_flag, i) (ed_flag[(i)/4]&__m_either[(i)%4])
 #define khash_power2(v) do { \
   v--;\
   v |= v >> 1;\
@@ -56,8 +58,7 @@ static const uint8_t __m[8] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};
     khint_t size;                                                       \
     khint_t n_occupied;                                                 \
     khint_t upper_bound;                                                \
-    uint8_t *e_flags;                                                   \
-    uint8_t *d_flags;                                                   \
+    uint8_t *ed_flags;                                                  \
     khkey_t *keys;                                                      \
     khval_t *vals;                                                      \
     khint_t mask;                                                       \
@@ -96,14 +97,13 @@ kh_fill_flags(uint8_t *p, uint8_t c, size_t len)
   void kh_alloc_##name(kh_##name##_t *h)                                \
   {                                                                     \
     khint_t sz = h->n_buckets;                                          \
+    uint8_t *p = mrb_malloc(h->mrb, sizeof(uint8_t)*sz/4+(sizeof(khkey_t)+sizeof(khval_t))*sz); \
     h->size = h->n_occupied = 0;                                        \
     h->upper_bound = UPPER_BOUND(sz);                                   \
-    h->e_flags = (uint8_t *)mrb_malloc(h->mrb, sizeof(uint8_t)*sz/4);   \
-    h->d_flags = h->e_flags + sz/8;                                     \
-    kh_fill_flags(h->e_flags, 0xff, sz/8);                              \
-    kh_fill_flags(h->d_flags, 0x00, sz/8);                              \
-    h->keys = (khkey_t *)mrb_malloc(h->mrb, sizeof(khkey_t)*sz);        \
-    h->vals = (khval_t *)mrb_malloc(h->mrb, sizeof(khval_t)*sz);        \
+    h->keys = (khkey_t *)p;                                             \
+    h->vals = (khval_t *)(p+sizeof(khkey_t)*sz);                        \
+    h->ed_flags = (p+sizeof(khkey_t)*sz+sizeof(khval_t)*sz);            \
+    kh_fill_flags(h->ed_flags, 0xaa, sz/4);                             \
     h->mask = sz-1;                                                     \
     h->inc = sz/2-1;                                                    \
   }                                                                     \
@@ -124,24 +124,21 @@ kh_fill_flags(uint8_t *p, uint8_t c, size_t len)
   {                                                                     \
     if (h) {                                                            \
       mrb_free(h->mrb, h->keys);                                        \
-      mrb_free(h->mrb, h->vals);                                        \
-      mrb_free(h->mrb, h->e_flags);                                     \
       mrb_free(h->mrb, h);                                              \
     }                                                                   \
   }                                                                     \
   void kh_clear_##name(kh_##name##_t *h)                                \
   {                                                                     \
-    if (h && h->e_flags) {                                              \
-      kh_fill_flags(h->e_flags, 0xff, h->n_buckets/8);                  \
-      kh_fill_flags(h->d_flags, 0x00, h->n_buckets/8);                  \
+    if (h && h->ed_flags) {                                             \
+      kh_fill_flags(h->ed_flags, 0xaa, h->n_buckets/4);                 \
       h->size = h->n_occupied = 0;                                      \
     }                                                                   \
   }                                                                     \
   khint_t kh_get_##name(kh_##name##_t *h, khkey_t key)                  \
   {                                                                     \
     khint_t k = __hash_func(h->mrb,key) & (h->mask);                    \
-    while (!__ac_isempty(h->e_flags, h->d_flags, k)) {                  \
-      if (!__ac_isdel(h->e_flags, h->d_flags, k)) {                     \
+    while (!__ac_isempty(h->ed_flags, k)) {                             \
+      if (!__ac_isdel(h->ed_flags, k)) {                                \
         if (__hash_equal(h->mrb,h->keys[k], key)) return k;             \
       }                                                                 \
       k = (k+h->inc) & (h->mask);                                       \
@@ -154,7 +151,7 @@ kh_fill_flags(uint8_t *p, uint8_t c, size_t len)
       new_n_buckets = KHASH_MIN_SIZE;                                   \
     khash_power2(new_n_buckets);                                        \
     {                                                                   \
-      uint8_t *old_e_flags = h->e_flags;                                \
+      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;                             \
@@ -163,14 +160,12 @@ kh_fill_flags(uint8_t *p, uint8_t c, size_t len)
       kh_alloc_##name(h);                                               \
       /* relocate */                                                    \
       for (i=0 ; i<old_n_buckets ; i++) {                               \
-        if (!__ac_isempty(old_e_flags, old_d_flags, i)) {               \
+        if (!__ac_iseither(old_ed_flags, i)) {                          \
           khint_t k = kh_put_##name(h, old_keys[i]);                    \
           kh_value(h,k) = old_vals[i];                                  \
         }                                                               \
       }                                                                 \
-      mrb_free(h->mrb, old_e_flags);                                    \
       mrb_free(h->mrb, old_keys);                                       \
-      mrb_free(h->mrb, old_vals);                                       \
     }                                                                   \
   }                                                                     \
   khint_t kh_put_##name(kh_##name##_t *h, khkey_t key)                  \
@@ -180,27 +175,27 @@ kh_fill_flags(uint8_t *p, uint8_t c, size_t len)
       kh_resize_##name(h, h->n_buckets*2);                              \
     }                                                                   \
     k = __hash_func(h->mrb,key) & (h->mask);                            \
-    while (!__ac_iseither(h->e_flags, h->d_flags, k)) {                 \
+    while (!__ac_iseither(h->ed_flags, k)) {                            \
       if (__hash_equal(h->mrb,h->keys[k], key)) break;                  \
       k = (k+h->inc) & (h->mask);                                       \
     }                                                                   \
-    if (__ac_isempty(h->e_flags, h->d_flags, k)) {                      \
+    if (__ac_isempty(h->ed_flags, k)) {                                 \
       /* put at empty */                                                \
       h->keys[k] = key;                                                 \
-      h->e_flags[k/8] &= ~__m[k%8];                                     \
+      h->ed_flags[k/4] &= ~__m_empty[k%4];                              \
       h->size++;                                                        \
       h->n_occupied++;                                                  \
-    } else if (__ac_isdel(h->e_flags, h->d_flags, k)) {                 \
+    } else if (__ac_isdel(h->ed_flags, k)) {                            \
       /* put at del */                                                  \
       h->keys[k] = key;                                                 \
-      h->d_flags[k/8] &= ~__m[k%8];                                     \
+      h->ed_flags[k/4] &= ~__m_del[k%4];                                \
       h->size++;                                                        \
     }                                                                   \
     return k;                                                           \
   }                                                                     \
   void kh_del_##name(kh_##name##_t *h, khint_t x)                       \
   {                                                                     \
-    h->d_flags[x/8] |= __m[x%8];                                        \
+    h->ed_flags[x/4] |= __m_del[x%4];                                   \
     h->size--;                                                          \
   }                                                                     \
   kh_##name##_t *kh_copy_##name(mrb_state *mrb, kh_##name##_t *h)       \
@@ -231,7 +226,7 @@ kh_fill_flags(uint8_t *p, uint8_t c, size_t len)
 #define kh_del(name, h, k) kh_del_##name(h, k)
 #define kh_copy(name, mrb, h) kh_copy_##name(mrb, h)
 
-#define kh_exist(h, x) (!__ac_iseither((h)->e_flags, (h)->d_flags, (x)))
+#define kh_exist(h, x) (!__ac_iseither((h)->ed_flags, (x)))
 #define kh_key(h, x) ((h)->keys[x])
 #define kh_val(h, x) ((h)->vals[x])
 #define kh_value(h, x) ((h)->vals[x])
diff --git a/include/mruby/string.h b/include/mruby/string.h
index 26d1344d8..000c80b09 100644
--- a/include/mruby/string.h
+++ b/include/mruby/string.h
@@ -57,7 +57,7 @@ mrb_value mrb_str_to_str(mrb_state *mrb, mrb_value str);
 mrb_int mrb_str_hash(mrb_state *mrb, mrb_value str);
 mrb_value mrb_str_buf_append(mrb_state *mrb, mrb_value str, mrb_value str2);
 mrb_value mrb_str_inspect(mrb_state *mrb, mrb_value str);
-int mrb_str_equal(mrb_state *mrb, mrb_value str1, mrb_value str2);
+mrb_bool mrb_str_equal(mrb_state *mrb, mrb_value str1, mrb_value str2);
 mrb_value mrb_str_dump(mrb_state *mrb, mrb_value str);
 mrb_value mrb_str_cat(mrb_state *mrb, mrb_value str, const char *ptr, size_t len);
 mrb_value mrb_str_append(mrb_state *mrb, mrb_value str, mrb_value str2);
diff --git a/include/mruby/value.h b/include/mruby/value.h
index 06241ec76..e78035b5f 100644
--- a/include/mruby/value.h
+++ b/include/mruby/value.h
@@ -51,23 +51,29 @@
 typedef short mrb_sym;
 
 #ifdef _MSC_VER
-# define _ALLOW_KEYWORD_MACROS
-# include <float.h>
-# define inline __inline
+# ifndef __cplusplus
+#  define inline __inline
+# endif
 # define snprintf _snprintf
-# define isnan _isnan
-# define isinf(n) (!_finite(n) && !_isnan(n))
-# define strtoll _strtoi64
-# define PRId32 "I32d"
-# define PRIi32 "I32i"
-# define PRIo32 "I32o"
-# define PRIx32 "I32x"
-# define PRIX32 "I32X"
-# define PRId64 "I64d"
-# define PRIi64 "I64i"
-# define PRIo64 "I64o"
-# define PRIx64 "I64x"
-# define PRIX64 "I64X"
+# if _MSC_VER < 1800
+#  include <float.h>
+#  define isnan _isnan
+#  define isinf(n) (!_finite(n) && !_isnan(n))
+#  define strtoll _strtoi64
+#  define strtof (float)strtod
+#  define PRId32 "I32d"
+#  define PRIi32 "I32i"
+#  define PRIo32 "I32o"
+#  define PRIx32 "I32x"
+#  define PRIX32 "I32X"
+#  define PRId64 "I64d"
+#  define PRIi64 "I64i"
+#  define PRIo64 "I64o"
+#  define PRIx64 "I64x"
+#  define PRIX64 "I64X"
+# else
+#  include <inttypes.h>
+# endif
 #else
 # include <inttypes.h>
 #endif