Updated Xcode project build settings in conformity with 10.8/Xcode 4.4

13 files changed, 273 insertions, 169 deletions

diff --git a/include/mrbconf.h b/include/mrbconf.h
index e90b685bb..20f49ec29 100644
--- a/include/mrbconf.h
+++ b/include/mrbconf.h
@@ -8,7 +8,41 @@
 #define MRUBYCONF_H
 
 #include <stdint.h>
-#undef MRB_USE_FLOAT
+
+/* configuration options: */
+/* add -DMRB_USE_FLOAT to use float instead of double for floating point numbers */
+//#define MRB_USE_FLOAT
+
+/* argv max size in mrb_funcall */
+//#define MRB_FUNCALL_ARGC_MAX 16 
+
+/* number of object per heap page */
+//#define MRB_HEAP_PAGE_SIZE 1024
+
+/* initial size for IV khash */
+//#define MRB_IV_INITIAL_SIZE 8
+
+/* default size of khash table bucket */
+//#define KHASH_DEFAULT_SIZE 32
+
+/* allocated memory address alignment */
+//#define POOL_ALIGNMENT 4
+
+/* page size of memory pool */
+//#define POOL_PAGE_SIZE 16000
+
+/* -DDISABLE_XXXX to drop the feature */
+#define DISABLE_REGEXP	        /* regular expression classes */
+//#define DISABLE_SPRINTF	/* Kernel.sprintf method */
+//#define DISABLE_MATH		/* Math functions */
+//#define DISABLE_TIME		/* Time class */
+//#define DISABLE_STRUCT	/* Struct class */
+//#define DISABLE_STDIO		/* use of stdio */
+
+#undef  HAVE_UNISTD_H /* WINDOWS */
+#define HAVE_UNISTD_H /* LINUX */
+
+/* end of configuration */
 
 #ifdef MRB_USE_FLOAT
 typedef float mrb_float;
@@ -19,20 +53,26 @@ typedef double mrb_float;
 
 typedef int mrb_int;
 typedef intptr_t mrb_sym;
-#define readint(p,base) strtol((p),NULL,(base))
-
-#undef  INCLUDE_ENCODING   /* not use encoding classes (ascii only) */
-//#define INCLUDE_ENCODING   /* use UTF-8 encoding classes */
-
-#undef  INCLUDE_REGEXP     /* not use regular expression classes */
-//#define INCLUDE_REGEXP     /* use regular expression classes */
 
-#ifdef  INCLUDE_REGEXP
-# define INCLUDE_ENCODING  /* Regexp depends Encoding */
+/* define ENABLE_XXXX from DISABLE_XXX */
+#ifndef DISABLE_REGEXP
+#define ENABLE_REGEXP
+#endif
+#ifndef DISABLE_SPRINTF
+#define ENABLE_SPRINTF
+#endif
+#ifndef DISABLE_MATH
+#define ENABLE_MATH
+#endif
+#ifndef DISABLE_TIME
+#define ENABLE_TIME
+#endif
+#ifndef DISABLE_STRUCT
+#define ENABLE_STRUCT
+#endif
+#ifndef DISABLE_STDIO
+#define ENABLE_STDIO
 #endif
-
-#undef  HAVE_UNISTD_H /* WINDOWS */
-#define HAVE_UNISTD_H /* LINUX */
 
 #ifndef FALSE
 # define FALSE 0
diff --git a/include/mruby.h b/include/mruby.h
index 3bbc6e6cc..451b4eb8b 100644
--- a/include/mruby.h
+++ b/include/mruby.h
@@ -60,9 +60,7 @@ enum mrb_vtype {
   MRB_TT_FILE,        /*  21 */
   MRB_TT_ENV,         /*  22 */
   MRB_TT_DATA,        /*  23 */
-  MRB_TT_THREAD,      /*  24 */
-  MRB_TT_THREADGRP,   /*  25 */
-  MRB_TT_MAXDEFINE    /*  26 */
+  MRB_TT_MAXDEFINE    /*  24 */
 };
 
 typedef struct mrb_value {
@@ -83,7 +81,7 @@ typedef struct mrb_value {
 #define mrb_symbol(o) (o).value.sym
 #define mrb_object(o) ((struct RBasic *) (o).value.p)
 #define FIXNUM_P(o)   ((o).tt == MRB_TT_FIXNUM)
-#define UNDEF_P(o)    ((o).tt == MRB_TT_UNDEF)
+#define mrb_undef_p(o) ((o).tt == MRB_TT_UNDEF)
 
 #include "mruby/object.h"
 
@@ -147,7 +145,7 @@ mrb_obj_value(void *p)
 }
 
 static inline mrb_value
-mrb_false_value()
+mrb_false_value(void)
 {
   mrb_value v;
 
@@ -157,7 +155,7 @@ mrb_false_value()
 }
 
 static inline mrb_value
-mrb_nil_value()
+mrb_nil_value(void)
 {
   mrb_value v;
 
@@ -167,7 +165,7 @@ mrb_nil_value()
 }
 
 static inline mrb_value
-mrb_true_value()
+mrb_true_value(void)
 {
   mrb_value v;
 
@@ -177,7 +175,7 @@ mrb_true_value()
 }
 
 static inline mrb_value
-mrb_undef_value()
+mrb_undef_value(void)
 {
   mrb_value v;
 
@@ -192,7 +190,9 @@ struct mrb_state;
 
 typedef void* (*mrb_allocf) (struct mrb_state *mrb, void*, size_t);
 
-#define MRB_ARENA_SIZE 1024  //256 up kusuda 2011/04/30
+#ifndef MRB_ARENA_SIZE
+#define MRB_ARENA_SIZE 1024
+#endif
 #define ruby_debug   (mrb_nil_value())
 #define ruby_verbose (mrb_nil_value())
 
@@ -279,7 +279,8 @@ typedef struct mrb_state {
 
   struct RClass *eException_class;
   struct RClass *eStandardError_class;
-  struct RClass *eRuntimeError_class;
+
+  void *ud; /* auxiliary data */
 } mrb_state;
 
 typedef mrb_value (*mrb_func_t)(mrb_state *mrb, mrb_value);
@@ -295,10 +296,10 @@ void mrb_define_singleton_method(mrb_state*, struct RObject*, const char*, mrb_f
 void mrb_define_module_function(mrb_state*, struct RClass*, const char*, mrb_func_t,int);
 void mrb_define_const(mrb_state*, struct RClass*, const char *name, mrb_value);
 void mrb_undef_method(mrb_state*, struct RClass*, const char*);
+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);
-struct RClass * mrb_class_from_sym(mrb_state *mrb, struct RClass *klass, mrb_sym name);
 struct RClass * mrb_class_get(mrb_state *mrb, const char *name);
 struct RClass * mrb_class_obj_get(mrb_state *mrb, const char *name);
 
@@ -329,10 +330,13 @@ struct RClass * mrb_define_module_under(mrb_state *mrb, struct RClass *outer, co
 int mrb_get_args(mrb_state *mrb, const char *format, ...);
 
 mrb_value mrb_funcall(mrb_state*, mrb_value, const char*, int,...);
-mrb_value mrb_funcall_argv(mrb_state*, mrb_value, const char*, int, mrb_value*);
-mrb_value mrb_funcall_with_block(mrb_state*, mrb_value, const char*, int, mrb_value*, mrb_value);
+mrb_value mrb_funcall_argv(mrb_state*, mrb_value, mrb_sym, int, mrb_value*);
+mrb_value mrb_funcall_with_block(mrb_state*, mrb_value, mrb_sym, int, mrb_value*, mrb_value);
 mrb_sym mrb_intern(mrb_state*,const char*);
+mrb_sym mrb_intern2(mrb_state*,const char*,int);
+mrb_sym mrb_intern_str(mrb_state*,mrb_value);
 const char *mrb_sym2name(mrb_state*,mrb_sym);
+const char *mrb_sym2name_len(mrb_state*,mrb_sym,int*);
 mrb_value mrb_str_format(mrb_state *, int, const mrb_value *, mrb_value);
 
 void *mrb_malloc(mrb_state*, size_t);
@@ -353,8 +357,8 @@ int mrb_checkstack(mrb_state*,int);
 mrb_value mrb_top_self(mrb_state *);
 mrb_value mrb_run(mrb_state*, struct RProc*, mrb_value);
 
-mrb_value mrb_p(mrb_state*, mrb_value);
-int mrb_obj_id(mrb_value obj);
+void mrb_p(mrb_state*, mrb_value);
+mrb_int mrb_obj_id(mrb_value obj);
 mrb_sym mrb_to_id(mrb_state *mrb, mrb_value name);
 
 int mrb_obj_equal(mrb_state*, mrb_value, mrb_value);
@@ -416,13 +420,16 @@ mrb_value mrb_check_funcall(mrb_state *mrb, mrb_value recv, mrb_sym mid, int arg
 #define ISXDIGIT(c) (ISASCII(c) && isxdigit((int)(unsigned char)(c)))
 #endif
 
+mrb_value mrb_exc_new(mrb_state *mrb, struct RClass *c, const char *ptr, long len);
+void mrb_exc_raise(mrb_state *mrb, mrb_value exc);
+
 int mrb_block_given_p(void);
 void mrb_raise(mrb_state *mrb, struct RClass *c, const char *fmt, ...);
 void rb_raise(struct RClass *c, const char *fmt, ...);
 void mrb_warn(const char *fmt, ...);
-void mrb_warning(const char *fmt, ...);
 void mrb_bug(const char *fmt, ...);
 
+#define E_RUNTIME_ERROR             (mrb_class_obj_get(mrb, "RuntimeError"))
 #define E_TYPE_ERROR                (mrb_class_obj_get(mrb, "TypeError"))
 #define E_ARGUMENT_ERROR            (mrb_class_obj_get(mrb, "ArgumentError"))
 #define E_INDEX_ERROR               (mrb_class_obj_get(mrb, "IndexError"))
@@ -431,13 +438,9 @@ void mrb_bug(const char *fmt, ...);
 #define E_NOMETHOD_ERROR            (mrb_class_obj_get(mrb, "NoMethodError"))
 #define E_SCRIPT_ERROR              (mrb_class_obj_get(mrb, "ScriptError"))
 #define E_SYNTAX_ERROR              (mrb_class_obj_get(mrb, "SyntaxError"))
-#define E_LOAD_ERROR                (mrb_class_obj_get(mrb, "LoadError"))
-#define E_SYSTEMCALL_ERROR          (mrb_class_obj_get(mrb, "SystemCallError"))
 #define E_LOCALJUMP_ERROR           (mrb_class_obj_get(mrb, "LocalJumpError"))
 #define E_REGEXP_ERROR              (mrb_class_obj_get(mrb, "RegexpError"))
-#define E_ZERODIVISION_ERROR        (mrb_class_obj_get(mrb, "ZeroDivisionError"))
 
-#define E_ENCODING_ERROR            (mrb_class_obj_get(mrb, "EncodingError"))
 #define E_NOTIMP_ERROR              (mrb_class_obj_get(mrb, "NotImplementedError"))
 #define E_FLOATDOMAIN_ERROR         (mrb_class_obj_get(mrb, "FloatDomainError"))
 
@@ -462,20 +465,9 @@ NUM2CHR(mrb_value x)
 
 mrb_value mrb_yield(mrb_state *mrb, mrb_value v, mrb_value blk);
 mrb_value mrb_yield_argv(mrb_state *mrb, mrb_value b, int argc, mrb_value *argv);
-mrb_value mrb_yield_with_self(mrb_state *mrb, mrb_value b, int argc, mrb_value *argv, mrb_value self);
 mrb_value mrb_class_new_instance(mrb_state *mrb, int, mrb_value*, struct RClass *);
 mrb_value mrb_class_new_instance_m(mrb_state *mrb, mrb_value klass);
 
-mrb_value mrb_exec_recursive(mrb_state *mrb, mrb_value(*)(mrb_state *, mrb_value, mrb_value, int),mrb_value,void *);
-
-#ifndef xmalloc
-#define xmalloc     malloc
-#define xrealloc    realloc
-#define xcalloc     calloc
-#define xfree       free
-#endif
-
-void mrb_garbage_collect(mrb_state *mrb);
 void mrb_gc_protect(mrb_state *mrb, mrb_value obj);
 mrb_value mrb_to_int(mrb_state *mrb, mrb_value val);
 void mrb_check_type(mrb_state *mrb, mrb_value x, enum mrb_vtype t);
diff --git a/include/mruby/array.h b/include/mruby/array.h
index e2acee535..bc10d8919 100644
--- a/include/mruby/array.h
+++ b/include/mruby/array.h
@@ -11,11 +11,20 @@
 extern "C" {
 #endif
 
+struct mrb_shared_array {
+  int refcnt;
+  mrb_value *ptr;
+  int len;
+};
+
 struct RArray {
   MRUBY_OBJECT_HEADER;
-  size_t len;
-  size_t capa;
-  mrb_value *buf;
+  int len;
+  union {
+    int capa;
+    struct mrb_shared_array *shared;
+  } aux;
+  mrb_value *ptr;
 };
 
 #define mrb_ary_ptr(v)    ((struct RArray*)((v).value.p))
@@ -23,30 +32,28 @@ struct RArray {
 #define RARRAY(v)  ((struct RArray*)((v).value.p))
 
 #define RARRAY_LEN(a) (RARRAY(a)->len)
-#define RARRAY_PTR(a) (RARRAY(a)->buf)
+#define RARRAY_PTR(a) (RARRAY(a)->ptr)
+#define MRB_ARY_SHARED      256
 
-mrb_value mrb_ary_new_capa(mrb_state*, size_t);
+void mrb_ary_decref(mrb_state*, struct mrb_shared_array*);
+mrb_value mrb_ary_new_capa(mrb_state*, int);
 mrb_value mrb_ary_new(mrb_state *mrb);
-mrb_value mrb_ary_new_elts(mrb_state *mrb, long n, const mrb_value *elts);
+mrb_value mrb_ary_new_elts(mrb_state *mrb, int n, const mrb_value *elts);
 void mrb_ary_concat(mrb_state*, mrb_value, mrb_value);
 mrb_value mrb_ary_splat(mrb_state*, mrb_value);
 void mrb_ary_push(mrb_state*, mrb_value, mrb_value);
 mrb_value mrb_ary_pop(mrb_state *mrb, mrb_value ary);
-mrb_value mrb_ary_new_from_values(mrb_state *mrb, size_t size, mrb_value *vals);
+mrb_value mrb_ary_new_from_values(mrb_state *mrb, int size, mrb_value *vals);
 mrb_value mrb_ary_aget(mrb_state *mrb, mrb_value self);
 mrb_value mrb_ary_ref(mrb_state *mrb, mrb_value ary, mrb_int n);
 void mrb_ary_set(mrb_state *mrb, mrb_value ary, mrb_int n, mrb_value val);
 int mrb_ary_len(mrb_state *mrb, mrb_value ary);
-mrb_value mrb_ary_replace_m(mrb_state *mrb, mrb_value self);
-void mrb_ary_replace(mrb_state *mrb, struct RArray *a, mrb_value *argv, size_t len);
+void mrb_ary_replace(mrb_state *mrb, mrb_value a, mrb_value b);
 mrb_value mrb_check_array_type(mrb_state *mrb, mrb_value self);
 mrb_value mrb_ary_unshift(mrb_state *mrb, mrb_value self, mrb_value item);
-mrb_value mrb_ary_new4(mrb_state *mrb, long n, const mrb_value *elts);
+mrb_value mrb_ary_new4(mrb_state *mrb, int n, const mrb_value *elts);
 mrb_value mrb_assoc_new(mrb_state *mrb, mrb_value car, mrb_value cdr);
-mrb_value mrb_ary_entry(mrb_value ary, long offset);
-void mrb_mem_clear(mrb_value *mem, long size);
-mrb_value mrb_ary_tmp_new(mrb_state *mrb, long capa);
-mrb_value mrb_ary_sort(mrb_state *mrb, mrb_value ary);
+mrb_value mrb_ary_entry(mrb_value ary, int offset);
 mrb_value mrb_ary_shift(mrb_state *mrb, mrb_value self);
 
 #if defined(__cplusplus)
diff --git a/include/mruby/class.h b/include/mruby/class.h
index 0afd331b0..2cc90310e 100644
--- a/include/mruby/class.h
+++ b/include/mruby/class.h
@@ -28,7 +28,7 @@ mrb_class(mrb_state *mrb, mrb_value v)
 {
   switch (mrb_type(v)) {
   case MRB_TT_FALSE:
-    if (v.value.p)
+    if (v.value.i)
       return mrb->false_class;
     return mrb->nil_class;
   case MRB_TT_TRUE:
@@ -40,14 +40,7 @@ mrb_class(mrb_state *mrb, mrb_value v)
   case MRB_TT_FLOAT:
     return mrb->float_class;
 
-#ifdef INCLUDE_REGEXP
-//  case MRB_TT_REGEX:
-//    return mrb->regex_class;
-//  case MRB_TT_MATCH:
-//    return mrb->match_class;
-//  case MRB_TT_DATA:
-//    return mrb->encode_class;
-#else
+#ifdef ENABLE_REGEXP
   case MRB_TT_REGEX:
   case MRB_TT_MATCH:
     mrb_raise(mrb, E_TYPE_ERROR, "type mismatch: %s given",
@@ -78,6 +71,10 @@ struct RClass* mrb_class_real(struct RClass* cl);
 
 void mrb_obj_call_init(mrb_state *mrb, mrb_value obj, int argc, mrb_value *argv);
 
+void mrb_gc_mark_mt(mrb_state*, struct RClass*);
+size_t mrb_gc_mark_mt_size(mrb_state*, struct RClass*);
+void mrb_gc_free_mt(mrb_state*, struct RClass*);
+
 #if defined(__cplusplus)
 }  /* extern "C" { */
 #endif
diff --git a/include/mruby/compile.h b/include/mruby/compile.h
index b41eed57e..aae1b06b1 100644
--- a/include/mruby/compile.h
+++ b/include/mruby/compile.h
@@ -15,12 +15,27 @@ extern "C" {
 #include <stdio.h>
 #include <setjmp.h>
 
+/* load context */
+typedef struct mrbc_context {
+  mrb_sym *syms;
+  int slen;
+  char *filename;
+  int lineno;
+  int capture_errors:1;
+  int dump_result:1;
+  int no_exec:1;
+} mrbc_context;
+
+mrbc_context* mrbc_context_new(mrb_state *mrb);
+void mrbc_context_free(mrb_state *mrb, mrbc_context *cxt);
+const char *mrbc_filename(mrb_state *mrb, mrbc_context *c, const char *s);
+
+/* AST node structure */
 typedef struct mrb_ast_node {
   struct mrb_ast_node *car, *cdr;
 } mrb_ast_node;
 
-#include <stdio.h>
-
+/* lexer states */
 enum mrb_lex_state_enum {
     EXPR_BEG,                   /* ignore newline, +/- is a sign. */
     EXPR_END,                   /* newline significant, +/- is an operator. */
@@ -36,21 +51,23 @@ enum mrb_lex_state_enum {
     EXPR_MAX_STATE
 };
 
+/* saved error message */
 struct mrb_parser_message {
   int lineno;
   int column;
   char* message;
 };
 
+/* parser structure */
 struct mrb_parser_state {
   mrb_state *mrb;
   struct mrb_pool *pool;
   mrb_ast_node *cells;
   const char *s, *send;
   FILE *f;
+  char *filename;
   int lineno;
   int column;
-  const char *filename;
 
   enum mrb_lex_state_enum lstate;
   int sterm;
@@ -59,6 +76,8 @@ struct mrb_parser_state {
   unsigned int cmdarg_stack;
   int paren_nest;
   int lpar_beg;
+  int in_def, in_single, cmd_start;
+  mrb_ast_node *locals;
 
   mrb_ast_node *pb;
   char buf[1024];
@@ -66,9 +85,6 @@ struct mrb_parser_state {
 
   mrb_ast_node *heredoc;
 
-  int in_def, in_single, cmd_start;
-  mrb_ast_node *locals;
-
   void *ylval;
 
   int nerr;
@@ -82,21 +98,24 @@ struct mrb_parser_state {
   jmp_buf jmp;
 };
 
-/* parser structure */
 struct mrb_parser_state* mrb_parser_new(mrb_state*);
+void mrb_parser_free(struct mrb_parser_state*);
 const char *mrb_parser_filename(struct mrb_parser_state*, const char*);
-int mrb_parser_lineno(struct mrb_parser_state*, int);
-void mrb_parser_parse(struct mrb_parser_state*);
+void mrb_parser_parse(struct mrb_parser_state*,mrbc_context*);
 
 /* utility functions */
-struct mrb_parser_state* mrb_parse_file(mrb_state*,FILE*);
-struct mrb_parser_state* mrb_parse_string(mrb_state*,const char*);
-struct mrb_parser_state* mrb_parse_nstring(mrb_state*,const char*,size_t);
+struct mrb_parser_state* mrb_parse_file(mrb_state*,FILE*,mrbc_context*);
+struct mrb_parser_state* mrb_parse_string(mrb_state*,const char*,mrbc_context*);
+struct mrb_parser_state* mrb_parse_nstring(mrb_state*,const char*,int,mrbc_context*);
 int mrb_generate_code(mrb_state*, mrb_ast_node*);
 
-int mrb_compile_file(mrb_state*,FILE*);
-int mrb_compile_string(mrb_state*,char*);
-int mrb_compile_nstring(mrb_state*,char*,size_t);
+/* program load functions */
+mrb_value mrb_load_file(mrb_state*,FILE*);
+mrb_value mrb_load_string(mrb_state *mrb, const char *s);
+mrb_value mrb_load_nstring(mrb_state *mrb, const char *s, int len);
+mrb_value mrb_load_file_cxt(mrb_state*,FILE*, mrbc_context *cxt);
+mrb_value mrb_load_string_cxt(mrb_state *mrb, const char *s, mrbc_context *cxt);
+mrb_value mrb_load_nstring_cxt(mrb_state *mrb, const char *s, int len, mrbc_context *cxt);
 
 #if defined(__cplusplus)
 }  /* extern "C" { */
diff --git a/include/mruby/hash.h b/include/mruby/hash.h
index 1bbd9bd97..f3755eb25 100644
--- a/include/mruby/hash.h
+++ b/include/mruby/hash.h
@@ -17,27 +17,20 @@ struct RHash {
   struct kh_ht *ht;
 };
 
-#define mrb_hash_end(h) st_hash_end(h)
-#define mrb_hash_uint(h, i) st_hash_uint(h, i)
-
 #define mrb_hash_ptr(v)    ((struct RHash*)((v).value.p))
 #define mrb_hash_value(p)  mrb_obj_value((void*)(p))
 
-mrb_value mrb_hash_new_capa(mrb_state*, size_t);
-mrb_value mrb_hash_new(mrb_state *mrb, int capa);
+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_getWithDef(mrb_state *mrb, mrb_value hash, mrb_value vkey, mrb_value def);
-mrb_value mrb_hash_delete_key(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(mrb_state *mrb, mrb_value obj);
-mrb_value mrb_check_hash_type(mrb_state *mrb, mrb_value self);
 
 /* RHASH_TBL allocates st_table if not available. */
 #define RHASH(obj)   ((struct RHash*)((obj).value.p))
 #define RHASH_TBL(h)          (RHASH(h)->ht)
-#define RHASH_SIZE(h)         (RHASH_TBL(h)->size)
-#define RHASH_EMPTY_P(h)      (RHASH_SIZE(h) == 0)
 #define RHASH_IFNONE(h)       mrb_iv_get(mrb, (h), mrb_intern(mrb, "ifnone"))
 #define RHASH_PROCDEFAULT(h)  RHASH_IFNONE(h)
 struct kh_ht * mrb_hash_tbl(mrb_state *mrb, mrb_value hash);
@@ -47,6 +40,11 @@ struct kh_ht * mrb_hash_tbl(mrb_state *mrb, mrb_value hash);
 
 mrb_value mrb_obj_is_proc(mrb_value proc);
 
+/* GC functions */
+void mrb_gc_mark_ht(mrb_state*, struct RHash*);
+size_t mrb_gc_mark_ht_size(mrb_state*, struct RHash*);
+void mrb_gc_free_ht(mrb_state*, struct RHash*);
+
 #if defined(__cplusplus)
 }  /* extern "C" { */
 #endif
diff --git a/include/mruby/khash.h b/include/mruby/khash.h
index 06c451e44..16a35c3d5 100644
--- a/include/mruby/khash.h
+++ b/include/mruby/khash.h
@@ -12,13 +12,16 @@ extern "C" {
 #endif
 
 #include <stdint.h>
-#include <stdlib.h>
 #include <string.h>
 
 typedef uint32_t khint_t;
 typedef khint_t khiter_t;
 
-#define INITIAL_HASH_SIZE 32
+#ifndef KHASH_DEFAULT_SIZE
+# define KHASH_DEFAULT_SIZE 32
+#endif
+#define KHASH_MIN_SIZE 8
+
 #define UPPER_BOUND(x) ((x)>>2|(x>>1))
 
 //extern uint8_t __m[];
@@ -30,18 +33,24 @@ static const uint8_t __m[8] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};
 #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))
-
-
-/* struct kh_xxx
+#define khash_power2(v) do { \
+  v--;\
+  v |= v >> 1;\
+  v |= v >> 2;\
+  v |= v >> 4;\
+  v |= v >> 8;\
+  v |= v >> 16;\
+  v++;\
+} while (0);
+
+/* declare struct kh_xxx and kh_xxx_funcs
 
    name: ash name
    khkey_t: key data type
    khval_t: value data type
-   kh_is_map: (not implemented / not used in RiteVM )
-   __hash_func: hash function
-   __hash_equal: hash comparation function
+   kh_is_map: (not implemented / not used in RiteVM)
 */
-#define KHASH_INIT(name, khkey_t, khval_t, kh_is_map, __hash_func, __hash_equal) \
+#define KHASH_DECLARE(name, khkey_t, khval_t, kh_is_map)                \
   typedef struct kh_##name {                                            \
     khint_t n_buckets;                                                  \
     khint_t size;                                                       \
@@ -55,7 +64,28 @@ static const uint8_t __m[8] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};
     khint_t inc;                                                        \
     mrb_state *mrb;                                                     \
   } kh_##name##_t;                                                      \
-  static void kh_alloc_##name(kh_##name##_t *h)                         \
+  void kh_alloc_##name(kh_##name##_t *h);                               \
+  kh_##name##_t *kh_init_##name##_size(mrb_state *mrb, khint_t size);   \
+  kh_##name##_t *kh_init_##name(mrb_state *mrb);                        \
+  void kh_destroy_##name(kh_##name##_t *h);                             \
+  void kh_clear_##name(kh_##name##_t *h);                               \
+  khint_t kh_get_##name(kh_##name##_t *h, khkey_t key);                 \
+  khint_t kh_put_##name(kh_##name##_t *h, khkey_t key);                 \
+  void kh_resize_##name(kh_##name##_t *h, khint_t new_n_buckets);       \
+  void kh_del_##name(kh_##name##_t *h, khint_t x);                      \
+  kh_##name##_t *kh_copy_##name(mrb_state *mrb, kh_##name##_t *h);
+
+/* define kh_xxx_funcs
+
+   name: ash name
+   khkey_t: key data type
+   khval_t: value data type
+   kh_is_map: (not implemented / not used in RiteVM)
+   __hash_func: hash function
+   __hash_equal: hash comparation function
+*/
+#define KHASH_DEFINE(name, khkey_t, khval_t, kh_is_map, __hash_func, __hash_equal) \
+  void kh_alloc_##name(kh_##name##_t *h)                                \
   {                                                                     \
     khint_t sz = h->n_buckets;                                          \
     h->size = h->n_occupied = 0;                                        \
@@ -69,52 +99,53 @@ static const uint8_t __m[8] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};
     h->mask = sz-1;                                                     \
     h->inc = sz/2-1;                                                    \
   }                                                                     \
-  static inline kh_##name##_t *kh_init_##name(mrb_state *mrb){          \
+  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)); \
-    h->n_buckets = INITIAL_HASH_SIZE;                                   \
+    if (size < KHASH_MIN_SIZE)                                          \
+      size = KHASH_MIN_SIZE;                                            \
+    khash_power2(size);                                                 \
+    h->n_buckets = size;                                                \
     h->mrb = mrb;                                                       \
     kh_alloc_##name(h);                                                 \
     return h;                                                           \
   }                                                                     \
-  static inline void kh_destroy_##name(kh_##name##_t *h)                \
+  kh_##name##_t *kh_init_##name(mrb_state *mrb){                        \
+    return kh_init_##name##_size(mrb, KHASH_DEFAULT_SIZE);              \
+  }                                                                     \
+  void kh_destroy_##name(kh_##name##_t *h)                              \
   {                                                                     \
-    if( h ){                                                            \
+    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);                                              \
     }                                                                   \
   }                                                                     \
-  static inline void kh_clear_##name(kh_##name##_t *h)                  \
+  void kh_clear_##name(kh_##name##_t *h)                                \
   {                                                                     \
-    if( h && h->e_flags ){                                              \
+    if (h && h->e_flags) {                                              \
       memset(h->e_flags, 0xff, h->n_buckets/8*sizeof(uint8_t));         \
       memset(h->d_flags, 0x00, h->n_buckets/8*sizeof(uint8_t));         \
       h->size = h->n_occupied = 0;                                      \
     }                                                                   \
   }                                                                     \
-  static inline khint_t kh_get_##name(kh_##name##_t *h, khkey_t key)    \
+  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) ){                     \
-        if( __hash_equal(h->mrb,h->keys[k], key) ) return k;            \
+    while (!__ac_isempty(h->e_flags, h->d_flags, k)) {                  \
+      if (!__ac_isdel(h->e_flags, h->d_flags, k)) {                     \
+        if (__hash_equal(h->mrb,h->keys[k], key)) return k;             \
       }                                                                 \
       k = (k+h->inc) & (h->mask);                                       \
     }                                                                   \
     return h->n_buckets;                                                \
   }                                                                     \
-  static inline khint_t kh_put_##name(kh_##name##_t *h, khkey_t key);   \
-  static void kh_resize_##name(kh_##name##_t *h, khint_t new_n_buckets) \
+  void kh_resize_##name(kh_##name##_t *h, khint_t new_n_buckets)        \
   {                                                                     \
-    if( new_n_buckets<INITIAL_HASH_SIZE ){                              \
-      new_n_buckets = INITIAL_HASH_SIZE;                                \
-    } else {                                                            \
-      khint_t limit = new_n_buckets;                                    \
-      new_n_buckets = INITIAL_HASH_SIZE;                                \
-      while( new_n_buckets < limit ) new_n_buckets *= 2;                \
-    }                                                                   \
-    {					                                \
+    if (new_n_buckets < KHASH_MIN_SIZE)                                 \
+      new_n_buckets = KHASH_MIN_SIZE;                                   \
+    khash_power2(new_n_buckets);                                        \
+    {                                                                   \
       uint8_t *old_e_flags = h->e_flags;                                \
       khkey_t *old_keys = h->keys;                                      \
       khval_t *old_vals = h->vals;                                      \
@@ -123,32 +154,35 @@ static const uint8_t __m[8] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};
       h->n_buckets = new_n_buckets;                                     \
       kh_alloc_##name(h);                                               \
       /* relocate */                                                    \
-      for( i=0 ; i<old_n_buckets ; i++ ){                               \
-	if( !__ac_isempty(old_e_flags, old_d_flags, i) ){               \
-	  khint_t k = kh_put_##name(h, old_keys[i]);                    \
-	  kh_value(h,k) = old_vals[i];                                  \
-	}                                                               \
+      for (i=0 ; i<old_n_buckets ; i++) {                               \
+        if (!__ac_isempty(old_e_flags, old_d_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);                                       \
     }                                                                   \
   }                                                                     \
-  static inline khint_t kh_put_##name(kh_##name##_t *h, khkey_t key)    \
+  khint_t kh_put_##name(kh_##name##_t *h, khkey_t key)                  \
   {                                                                     \
     khint_t k;                                                          \
-    if( h->n_occupied >= h->upper_bound ){                              \
+    if (h->n_occupied >= h->upper_bound) {                              \
       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) ){                 \
-      if( __hash_equal(h->mrb,h->keys[k], key) ) break;                 \
+    while (!__ac_iseither(h->e_flags, h->d_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->e_flags, h->d_flags, k)) {                      \
       /* put at empty */                                                \
       h->keys[k] = key;                                                 \
       h->e_flags[k/8] &= ~__m[k%8];                                     \
       h->size++;                                                        \
       h->n_occupied++;                                                  \
-    } else if( __ac_isdel(h->e_flags, h->d_flags, k) ) {                \
+    } else if (__ac_isdel(h->e_flags, h->d_flags, k)) {                 \
       /* put at del */                                                  \
       h->keys[k] = key;                                                 \
       h->d_flags[k/8] &= ~__m[k%8];                                     \
@@ -156,22 +190,30 @@ static const uint8_t __m[8] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};
     }                                                                   \
     return k;                                                           \
   }                                                                     \
-  static inline void kh_del_##name(kh_##name##_t *h, khint_t x)         \
+  void kh_del_##name(kh_##name##_t *h, khint_t x)                       \
   {                                                                     \
     h->d_flags[x/8] |= __m[x%8];                                        \
     h->size--;                                                          \
   }                                                                     \
-  static inline void kh_debug_##name(kh_##name##_t *h)                  \
+  kh_##name##_t *kh_copy_##name(mrb_state *mrb, kh_##name##_t *h)       \
   {                                                                     \
-    khint_t i;                                                          \
-    printf("idx:e_flag:d_flag\n");                                      \
-    for( i=0 ; i<h->n_buckets/8 ; i++ ){                                \
-      printf("%4d:%02X:%02X\n", i, h->e_flags[i], h->d_flags[i]);       \
+    kh_##name##_t *h2;                                                  \
+    khiter_t k, k2;                                                     \
+                                                                        \
+    h2 = kh_init_##name(mrb);                                           \
+    for (k = kh_begin(h); k != kh_end(h); k++) {                        \
+      if (kh_exist(h, k)) {                                             \
+        k2 = kh_put_##name(h2, kh_key(h, k));                           \
+        kh_value(h2, k2) = kh_value(h, k);                              \
+      }                                                                 \
     }                                                                   \
-  }                                                                     \
+    return h2;                                                          \
+  }
+
 
 #define khash_t(name) kh_##name##_t
 
+#define kh_init_size(name,mrb,size) kh_init_##name##_size(mrb,size)
 #define kh_init(name,mrb) kh_init_##name(mrb)
 #define kh_destroy(name, h) kh_destroy_##name(h)
 #define kh_clear(name, h) kh_clear_##name(h)
@@ -179,7 +221,7 @@ static const uint8_t __m[8] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};
 #define kh_put(name, h, k) kh_put_##name(h, k)
 #define kh_get(name, h, k) kh_get_##name(h, k)
 #define kh_del(name, h, k) kh_del_##name(h, k)
-#define kh_debug(name, h) kh_debug_##name(h)
+#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_key(h, x) ((h)->keys[x])
@@ -203,11 +245,7 @@ static inline khint_t __ac_X31_hash_string(const char *s)
 #define kh_str_hash_func(mrb,key) __ac_X31_hash_string(key)
 #define kh_str_hash_equal(mrb,a, b) (strcmp(a, b) == 0)
 
-#define KHASH_MAP_INIT_INT(name, khval_t)                               \
-    KHASH_INIT(name, uint32_t, khval_t, 1, kh_int_hash_func, kh_int_hash_equal)
 typedef const char *kh_cstr_t;
-#define KHASH_MAP_INIT_STR(name, khval_t)                               \
-    KHASH_INIT(name, kh_cstr_t, khval_t, 1, kh_str_hash_func, kh_str_hash_equal)
 
 #if defined(__cplusplus)
 }  /* extern "C" { */
diff --git a/include/mruby/numeric.h b/include/mruby/numeric.h
index 1bea51152..867aa27d9 100644
--- a/include/mruby/numeric.h
+++ b/include/mruby/numeric.h
@@ -13,15 +13,18 @@ extern "C" {
 
 #include <limits.h>
 
-#define RSHIFT(x,y) ((x)>>(int)(y))
 #define POSFIXABLE(f) ((f) <= INT_MAX)
 #define NEGFIXABLE(f) ((f) >= INT_MIN)
 #define FIXABLE(f) (POSFIXABLE(f) && NEGFIXABLE(f))
 
 mrb_value mrb_flt2big(mrb_state *mrb, mrb_float d);
-void mrb_num_zerodiv(mrb_state *mrb);
 mrb_value mrb_fix2str(mrb_state *mrb, mrb_value x, int base);
 
+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);
+
 #if defined(__cplusplus)
 }  /* extern "C" { */
 #endif
diff --git a/include/mruby/object.h b/include/mruby/object.h
index 495c34083..4be060078 100644
--- a/include/mruby/object.h
+++ b/include/mruby/object.h
@@ -13,7 +13,7 @@ extern "C" {
 
 #define MRUBY_OBJECT_HEADER \
   enum mrb_vtype tt:8; \
-  int color:3;\
+  unsigned int color:3;\
   unsigned int flags:21;\
   struct RClass *c;\
   struct RBasic *gcnext
diff --git a/include/mruby/proc.h b/include/mruby/proc.h
index 52dc5a98e..f6bef23a5 100644
--- a/include/mruby/proc.h
+++ b/include/mruby/proc.h
@@ -49,6 +49,10 @@ struct RProc {
 struct RProc *mrb_proc_new(mrb_state*, mrb_irep*);
 struct RProc *mrb_proc_new_cfunc(mrb_state*, mrb_func_t);
 struct RProc *mrb_closure_new(mrb_state*, mrb_irep*);
+void mrb_proc_copy(struct RProc *a, struct RProc *b);
+
+#include "mruby/khash.h"
+KHASH_DECLARE(mt, mrb_sym, struct RProc*, 1);
 
 #if defined(__cplusplus)
 }  /* extern "C" { */
diff --git a/include/mruby/string.h b/include/mruby/string.h
index 39f119ae8..c6f7c4ab5 100644
--- a/include/mruby/string.h
+++ b/include/mruby/string.h
@@ -25,34 +25,33 @@ extern "C" {
 
 extern const char mrb_digitmap[];
 
+struct mrb_shared_string {
+  int refcnt;
+  char *ptr;
+  int len;
+};
+
 struct RString {
   MRUBY_OBJECT_HEADER;
   int len;
   union {
     int capa;
-    struct RString *shared;
+    struct mrb_shared_string *shared;
   } aux;
-  char *buf;
+  char *ptr;
 };
 
 #define mrb_str_ptr(s)    ((struct RString*)((s).value.p))
 #define RSTRING(s)        ((struct RString*)((s).value.p))
-#define RSTRING_PTR(s)    (RSTRING(s)->buf)
+#define RSTRING_PTR(s)    (RSTRING(s)->ptr)
 #define RSTRING_LEN(s)    (RSTRING(s)->len)
 #define RSTRING_CAPA(s)   (RSTRING(s)->aux.capa)
-#define RSTRING_END(s)    (RSTRING(s)->buf + RSTRING(s)->len)
-
+#define RSTRING_END(s)    (RSTRING(s)->ptr + RSTRING(s)->len)
 #define MRB_STR_SHARED      256
-#define MRB_STR_SHARED_P(s) (FL_ALL(s, MRB_STR_SHARED))
-#define MRB_STR_NOCAPA      (MRB_STR_SHARED)
-#define MRB_STR_NOCAPA_P(s) (FL_ANY(s, MRB_STR_NOCAPA))
-#define MRB_STR_UNSET_NOCAPA(s) do {\
-  FL_UNSET(s, MRB_STR_NOCAPA);\
-} while (0)
 
+void mrb_str_decref(mrb_state*, struct mrb_shared_string*);
 mrb_value mrb_str_literal(mrb_state*, mrb_value);
 void mrb_str_concat(mrb_state*, mrb_value, mrb_value);
-mrb_value mrb_obj_to_str(mrb_state*, mrb_value);
 mrb_value mrb_str_plus(mrb_state*, mrb_value, mrb_value);
 mrb_value mrb_obj_as_string(mrb_state *mrb, mrb_value obj);
 mrb_value mrb_str_resize(mrb_state *mrb, mrb_value str, int len); /* mrb_str_resize */
@@ -78,8 +77,6 @@ int mrb_str_hash_cmp(mrb_state *mrb, mrb_value str1, mrb_value str2);
 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_value * mrb_svar(mrb_int cnt);
-mrb_value mrb_str_drop_bytes(mrb_state *mrb, mrb_value str, long len);
 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, long len);
 mrb_value mrb_str_append(mrb_state *mrb, mrb_value str, mrb_value str2);
diff --git a/include/mruby/struct.h b/include/mruby/struct.h
index 1aee64883..514f66dfe 100644
--- a/include/mruby/struct.h
+++ b/include/mruby/struct.h
@@ -20,9 +20,6 @@ struct RStruct {
 #define RSTRUCT_LEN(st) ((int)(RSTRUCT(st)->len))
 #define RSTRUCT_PTR(st) (RSTRUCT(st)->ptr)
 
-mrb_value mrb_yield_values(int n, ...);
-mrb_value mrb_mod_module_eval(mrb_state *mrb, int argc, mrb_value *argv, mrb_value mod);
-
 #if defined(__cplusplus)
 }  /* extern "C" { */
 #endif
diff --git a/include/mruby/variable.h b/include/mruby/variable.h
index 880d6217e..e93a77c55 100644
--- a/include/mruby/variable.h
+++ b/include/mruby/variable.h
@@ -14,12 +14,13 @@ extern "C" {
 typedef struct global_variable {
     int   counter;
     mrb_value *data;
-    mrb_value (*getter)();
-    void  (*setter)();
+    mrb_value (*getter)(void);
+    void  (*setter)(void);
     //void  (*marker)();
     //int block_trace;
     //struct trace_var *trace;
 } global_variable;
+
 struct global_entry {
     global_variable *var;
     mrb_sym id;
@@ -41,12 +42,23 @@ mrb_value mrb_obj_iv_get(mrb_state*, struct RObject*, mrb_sym);
 void mrb_obj_iv_set(mrb_state*, struct RObject*, mrb_sym, mrb_value);
 const char * mrb_class2name(mrb_state *mrb, struct RClass* klass);
 mrb_value mrb_iv_get(mrb_state *mrb, mrb_value obj, mrb_sym sym);
-void mrb_iv_set(mrb_state *mrb, mrb_value obj, mrb_sym sym, mrb_value v); /* mrb_iv_set */
-void mrb_copy_generic_ivar(mrb_value clone, mrb_value obj);
+void mrb_iv_set(mrb_state *mrb, mrb_value obj, mrb_sym sym, mrb_value v);
+mrb_value mrb_iv_remove(mrb_state *mrb, mrb_value obj, mrb_sym sym);
 int mrb_const_defined_at(mrb_state *mrb, struct RClass *klass, mrb_sym id);
 mrb_value mrb_f_global_variables(mrb_state *mrb, mrb_value self);
 mrb_value mrb_gv_get(mrb_state *mrb, mrb_sym sym);
 void mrb_gv_set(mrb_state *mrb, mrb_sym sym, mrb_value val);
+mrb_value mrb_obj_instance_variables(mrb_state*, mrb_value);
+
+/* GC functions */
+void mrb_gc_mark_gv(mrb_state*);
+void mrb_gc_free_gv(mrb_state*);
+void mrb_gc_mark_iv(mrb_state*, struct RObject*);
+size_t mrb_gc_mark_iv_size(mrb_state*, struct RObject*);
+void mrb_gc_free_iv(mrb_state*, struct RObject*);
+
+#include "mruby/khash.h"
+KHASH_DECLARE(iv, mrb_sym, mrb_value, 1)
 
 #if defined(__cplusplus)
 }  /* extern "C" { */