Merge remote-tracking branch 'upstream/master'

11 files changed, 125 insertions, 156 deletions

diff --git a/src/array.c b/src/array.c
index 92359b033..ed087515a 100644
--- a/src/array.c
+++ b/src/array.c
@@ -1056,39 +1056,26 @@ static mrb_value
 mrb_ary_equal(mrb_state *mrb, mrb_value ary1)
 {
   mrb_value ary2;
-  mrb_bool equal_p;
+  mrb_int i;
 
   mrb_get_args(mrb, "o", &ary2);
-  if (mrb_obj_equal(mrb, ary1, ary2)) {
-    equal_p = 1;
-  }
-  else if (mrb_special_const_p(ary2)) {
-    equal_p = 0;
-  }
-  else if (!mrb_array_p(ary2)) {
+  if (mrb_obj_equal(mrb, ary1, ary2)) return mrb_true_value();
+  if (mrb_special_const_p(ary2)) return mrb_false_value();
+  if (!mrb_array_p(ary2)) {
     if (!mrb_respond_to(mrb, ary2, mrb_intern2(mrb, "to_ary", 6))) {
-        equal_p = 0;
+      return mrb_false_value();
     }
     else {
-      equal_p = mrb_equal(mrb, ary2, ary1);
+      return mrb_bool_value(mrb_equal(mrb, ary2, ary1));
     }
   }
-  else if (RARRAY_LEN(ary1) != RARRAY_LEN(ary2)) {
-    equal_p = 0;
-  }
-  else {
-    mrb_int i;
-
-    equal_p = 1;
-    for (i=0; i<RARRAY_LEN(ary1); i++) {
-      if (!mrb_equal(mrb, ary_elt(ary1, i), ary_elt(ary2, i))) {
-        equal_p = 0;
-        break;
-      }
+  if (RARRAY_LEN(ary1) != RARRAY_LEN(ary2)) return mrb_false_value();
+  for (i=0; i<RARRAY_LEN(ary1); i++) {
+    if (!mrb_equal(mrb, ary_elt(ary1, i), ary_elt(ary2, i))) {
+      return mrb_false_value();
     }
   }
-
-  return mrb_bool_value(equal_p);
+  return mrb_true_value();
 }
 
 /* 15.2.12.5.34 (x) */
@@ -1104,30 +1091,18 @@ static mrb_value
 mrb_ary_eql(mrb_state *mrb, mrb_value ary1)
 {
   mrb_value ary2;
-  mrb_bool eql_p;
+  mrb_int i;
 
   mrb_get_args(mrb, "o", &ary2);
-  if (mrb_obj_equal(mrb, ary1, ary2)) {
-    eql_p = 1;
-  }
-  else if (!mrb_array_p(ary2)) {
-    eql_p = 0;
-  }
-  else if (RARRAY_LEN(ary1) != RARRAY_LEN(ary2)) {
-    eql_p = 0;
-  }
-  else {
-    mrb_int i;
-    eql_p = 1;
-    for (i=0; i<RARRAY_LEN(ary1); i++) {
-      if (!mrb_eql(mrb, ary_elt(ary1, i), ary_elt(ary2, i))) {
-        eql_p = 0;
-        break;
-      }
+  if (mrb_obj_equal(mrb, ary1, ary2)) return mrb_true_value();
+  if (!mrb_array_p(ary2)) return mrb_false_value();
+  if (RARRAY_LEN(ary1) != RARRAY_LEN(ary2)) return mrb_false_value();
+  for (i=0; i<RARRAY_LEN(ary1); i++) {
+    if (!mrb_eql(mrb, ary_elt(ary1, i), ary_elt(ary2, i))) {
+      return mrb_false_value();
     }
   }
-
-  return mrb_bool_value(eql_p);
+  return mrb_true_value();
 }
 
 void
diff --git a/src/class.c b/src/class.c
index f94f9a933..0d71886d3 100644
--- a/src/class.c
+++ b/src/class.c
@@ -159,9 +159,7 @@ mrb_define_class_id(mrb_state *mrb, mrb_sym name, struct RClass *super)
 struct RClass*
 mrb_define_class(mrb_state *mrb, const char *name, struct RClass *super)
 {
-  struct RClass *c;
-  c = mrb_define_class_id(mrb, mrb_intern(mrb, name), super);
-  return c;
+  return mrb_define_class_id(mrb, mrb_intern(mrb, name), super);
 }
 
 struct RClass*
@@ -227,7 +225,13 @@ class_from_sym(mrb_state *mrb, struct RClass *klass, mrb_sym id)
 struct RClass *
 mrb_class_get(mrb_state *mrb, const char *name)
 {
-  return class_from_sym(mrb, mrb->object_class, mrb_intern(mrb, name));
+  return mrb_class_get_under(mrb, mrb->object_class, name);
+}
+
+struct RClass *
+mrb_class_get_under(mrb_state *mrb, struct RClass *outer, const char *name)
+{
+  return class_from_sym(mrb, outer, mrb_intern(mrb, name));
 }
 
 /*!
@@ -371,20 +375,22 @@ to_hash(mrb_state *mrb, mrb_value val)
 
   format specifiers:
 
-   o: Object [mrb_value]
-   S: String [mrb_value]
-   A: Array [mrb_value]
-   H: Hash [mrb_value]
-   s: String [char*,int]
-   z: String [char*]
-   a: Array [mrb_value*,mrb_int]
-   f: Float [mrb_float]
-   i: Integer [mrb_int]
-   b: Boolean [mrb_bool]
-   n: Symbol [mrb_sym]
-   &: Block [mrb_value]
-   *: rest argument [mrb_value*,int]
-   |: optional
+    string  mruby type     C type                 note
+    ----------------------------------------------------------------------------------------------
+    o:      Object         [mrb_value]
+    S:      String         [mrb_value]
+    A:      Array          [mrb_value]
+    H:      Hash           [mrb_value]
+    s:      String         [char*,int]            Receive two arguments.
+    z:      String         [char*]                NUL terminated string.
+    a:      Array          [mrb_value*,mrb_int]   Receive two arguments.
+    f:      Float          [mrb_float]
+    i:      Integer        [mrb_int]
+    b:      Boolean        [mrb_bool]
+    n:      Symbol         [mrb_sym]
+    &:      Block          [mrb_value]
+    *:      rest argument  [mrb_value*,int]       Receive the rest of the arguments as an array.
+    |:      optional                              Next argument of '|' and later are optional.
  */
 int
 mrb_get_args(mrb_state *mrb, const char *format, ...)
@@ -487,7 +493,7 @@ mrb_get_args(mrb_state *mrb, const char *format, ...)
         if (i < argc) {
           ss = to_str(mrb, *sp++);
           s = mrb_str_ptr(ss);
-          if (strlen(s->ptr) != s->len) {
+          if (strlen(s->ptr) < s->len) {
             mrb_raise(mrb, E_ARGUMENT_ERROR, "String contains NUL");
           }
           *ps = s->ptr;
diff --git a/src/codegen.c b/src/codegen.c
index cfbbe7286..e240995e5 100644
--- a/src/codegen.c
+++ b/src/codegen.c
@@ -59,7 +59,7 @@ typedef struct scope {
   int icapa;
 
   mrb_irep *irep;
-  int pcapa;
+  size_t pcapa;
   int scapa;
 
   int nlocals;
@@ -426,8 +426,7 @@ push_(codegen_scope *s)
 static inline int
 new_lit(codegen_scope *s, mrb_value val)
 {
-  int i;
-
+  size_t i;
   
   switch (mrb_type(val)) {
   case MRB_TT_STRING:
@@ -462,7 +461,7 @@ new_lit(codegen_scope *s, mrb_value val)
 static inline int
 new_msym(codegen_scope *s, mrb_sym sym)
 {
-  int i, len;
+  size_t i, len;
 
   len = s->irep->slen;
   if (len > 256) len = 256;
@@ -481,7 +480,7 @@ new_msym(codegen_scope *s, mrb_sym sym)
 static inline int
 new_sym(codegen_scope *s, mrb_sym sym)
 {
-  int i;
+  size_t i;
 
   for (i=0; i<s->irep->slen; i++) {
     if (s->irep->syms[i] == sym) return i;
@@ -2506,7 +2505,8 @@ codedump(mrb_state *mrb, int n)
 {
 #ifdef ENABLE_STDIO
   mrb_irep *irep = mrb->irep[n];
-  int i, ai;
+  uint32_t i;
+  int ai;
   mrb_code c;
 
   if (!irep) return;
diff --git a/src/crc.c b/src/crc.c
index 463c7abe6..3bda7bc26 100644
--- a/src/crc.c
+++ b/src/crc.c
@@ -6,7 +6,7 @@
 
 #include <limits.h>
 #include <stdint.h>
-#include <sys/types.h>
+#include <stddef.h>
 
 // Calculate CRC (CRC-16-CCITT)
 //
diff --git a/src/dump.c b/src/dump.c
index c2b987bc8..72ca9e0c3 100644
--- a/src/dump.c
+++ b/src/dump.c
@@ -334,8 +334,7 @@ static int
 write_lineno_record(mrb_state *mrb, mrb_irep *irep, uint8_t* bin)
 {
   uint8_t *cur = bin;
-  size_t filename_len = 0;
-  int iseq_no;
+  size_t filename_len = 0, iseq_no;
 
   cur += sizeof(uint32_t); /* record size */
 
@@ -365,13 +364,13 @@ write_lineno_record(mrb_state *mrb, mrb_irep *irep, uint8_t* bin)
 }
 
 static int
-mrb_write_section_lineno(mrb_state *mrb, int start_index, uint8_t *bin)
+mrb_write_section_lineno(mrb_state *mrb, size_t start_index, uint8_t *bin)
 {
-  int irep_no;
+  size_t irep_no;
   uint32_t section_size = 0, rlen = 0; /* size of irep record */
   uint8_t *cur = bin;
 
-  if (mrb == NULL || start_index < 0 || start_index >= mrb->irep_len || bin == NULL) {
+  if (mrb == NULL || start_index >= mrb->irep_len || bin == NULL) {
     return MRB_DUMP_INVALID_ARGUMENT;
   }
 
diff --git a/src/gc.c b/src/gc.c
index 3e33c052c..d1d6ea1ee 100644
--- a/src/gc.c
+++ b/src/gc.c
@@ -148,29 +148,39 @@ gettimeofday_time(void)
 
 #define GC_STEP_SIZE 1024
 
+
 void*
-mrb_realloc(mrb_state *mrb, void *p, size_t len)
+mrb_realloc_simple(mrb_state *mrb, void *p,  size_t len)
 {
   void *p2;
 
   p2 = (mrb->allocf)(mrb, p, len, mrb->ud);
-
   if (!p2 && len > 0 && mrb->heaps) {
     mrb_garbage_collect(mrb);
     p2 = (mrb->allocf)(mrb, p, len, mrb->ud);
   }
 
+  return p2;
+}
+
+
+void*
+mrb_realloc(mrb_state *mrb, void *p, size_t len)
+{
+  void *p2;
+
+  p2 = mrb_realloc_simple(mrb, p, len);
   if (!p2 && len) {
     if (mrb->out_of_memory) {
       /* mrb_panic(mrb); */
     }
     else {
-      mrb->out_of_memory = 1;
+      mrb->out_of_memory = TRUE;
       mrb_raise(mrb, E_RUNTIME_ERROR, "Out of memory");
     }
   }
   else {
-    mrb->out_of_memory = 0;
+    mrb->out_of_memory = FALSE;
   }
 
   return p2;
@@ -183,6 +193,12 @@ mrb_malloc(mrb_state *mrb, size_t len)
 }
 
 void*
+mrb_malloc_simple(mrb_state *mrb, size_t len)
+{
+  return mrb_realloc_simple(mrb, 0, len);
+}
+
+void*
 mrb_calloc(mrb_state *mrb, size_t nelem, size_t len)
 {
   void *p;
@@ -614,8 +630,7 @@ obj_free(mrb_state *mrb, struct RBasic *obj)
 static void
 root_scan_phase(mrb_state *mrb)
 {
-  int j;
-  size_t i, e;
+  size_t i, e, j;
 
   if (!is_minor_gc(mrb)) {
     mrb->gray_list = 0;
diff --git a/src/hash.c b/src/hash.c
index 5d78a6ea7..3684b3b40 100644
--- a/src/hash.c
+++ b/src/hash.c
@@ -145,7 +145,9 @@ mrb_hash_set(mrb_state *mrb, mrb_value hash, mrb_value key, mrb_value val) /* mr
   k = kh_get(ht, h, key);
   if (k == kh_end(h)) {
     /* expand */
+    int ai = mrb_gc_arena_save(mrb);
     k = kh_put(ht, h, KEY(key));
+    mrb_gc_arena_restore(mrb, ai);
   }
 
   kh_value(h, k) = val;
@@ -169,7 +171,9 @@ mrb_hash_dup(mrb_state *mrb, mrb_value hash)
 
     for (k = kh_begin(h); k != kh_end(h); k++) {
       if (kh_exist(h,k)) {
+        int ai = mrb_gc_arena_save(mrb);
         ret_k = kh_put(ht, ret_h, KEY(kh_key(h,k)));
+        mrb_gc_arena_restore(mrb, ai);
         kh_val(ret_h, ret_k) = kh_val(h,k);
       }
     }
@@ -772,16 +776,9 @@ mrb_value
 mrb_hash_empty_p(mrb_state *mrb, mrb_value self)
 {
   khash_t(ht) *h = RHASH_TBL(self);
-  mrb_bool empty_p;
 
-  if (h) {
-    empty_p = (kh_size(h) == 0);
-  }
-  else {
-    empty_p = 1;
-  }
-
-  return mrb_bool_value(empty_p);
+  if (h) return mrb_bool_value(kh_size(h) == 0);
+  return mrb_true_value();
 }
 
 static mrb_value
@@ -921,17 +918,12 @@ mrb_hash_has_keyWithKey(mrb_state *mrb, mrb_value hash, mrb_value key)
 {
   khash_t(ht) *h = RHASH_TBL(hash);
   khiter_t k;
-  mrb_bool result;
 
   if (h) {
     k = kh_get(ht, h, key);
-    result = (k != kh_end(h));
-  }
-  else {
-    result = 0;
+    return mrb_bool_value(k != kh_end(h));
   }
-
-  return mrb_bool_value(result);
+  return mrb_false_value();
 }
 
 /* 15.2.13.4.13 */
diff --git a/src/load.c b/src/load.c
index e832de628..092ddbde8 100644
--- a/src/load.c
+++ b/src/load.c
@@ -187,7 +187,6 @@ read_rite_section_irep(mrb_state *mrb, const uint8_t *bin)
 {
   int result;
   size_t sirep;
-  size_t i;
   uint32_t len;
   uint16_t nirep;
   uint16_t n;
@@ -200,14 +199,14 @@ read_rite_section_irep(mrb_state *mrb, const uint8_t *bin)
   nirep = bin_to_uint16(header->nirep);
 
   //Read Binary Data Section
-  for (n = 0, i = sirep; n < nirep; n++, i++) {
+  for (n = 0; n < nirep; n++) {
     result = read_rite_irep_record(mrb, bin, &len);
     if (result != MRB_DUMP_OK)
       goto error_exit;
     bin += len;
   }
 
-  result = sirep + bin_to_uint16(header->sirep);
+  result = nirep;
 error_exit:
   if (result < MRB_DUMP_OK) {
     irep_free(sirep, mrb);
@@ -368,7 +367,7 @@ mrb_read_irep(mrb_state *mrb, const uint8_t *bin)
     bin += bin_to_uint32(section_header->section_size);
   } while (memcmp(section_header->section_identify, RITE_BINARY_EOF, sizeof(section_header->section_identify)) != 0);
 
-  return total_nirep;
+  return sirep;
 }
 
 static void
@@ -464,7 +463,6 @@ read_rite_section_irep_file(mrb_state *mrb, FILE *fp)
 {
   int32_t result;
   size_t sirep;
-  size_t i;
   uint16_t nirep;
   uint16_t n;
   uint32_t len, buf_size;
@@ -488,7 +486,7 @@ read_rite_section_irep_file(mrb_state *mrb, FILE *fp)
   }
 
   //Read Binary Data Section
-  for (n = 0, i = sirep; n < nirep; n++, i++) {
+  for (n = 0; n < nirep; n++) {
     void *ptr;
 
     if (fread(buf, record_header_size, 1, fp) == 0) {
@@ -516,7 +514,7 @@ read_rite_section_irep_file(mrb_state *mrb, FILE *fp)
       goto error_exit;
   }
 
-  result = sirep + bin_to_uint16(header.sirep);
+  result = nirep;
 error_exit:
   if (buf) {
     mrb_free(mrb, buf);
@@ -567,7 +565,7 @@ mrb_read_irep_file(mrb_state *mrb, FILE* fp)
   fpos = ftell(fp);
   /* You don't need use SIZE_ERROR as block_size is enough small. */
   for (i = 0; i < block_fallback_count; i++,block_size >>= 1){
-    buf = mrb_malloc(mrb, block_size);
+    buf = mrb_malloc_simple(mrb, block_size);
     if (buf) break;  
   }
   if (!buf) {
@@ -614,7 +612,7 @@ mrb_read_irep_file(mrb_state *mrb, FILE* fp)
     fseek(fp, fpos + section_size, SEEK_SET);
   } while (memcmp(section_header.section_identify, RITE_BINARY_EOF, sizeof(section_header.section_identify)) != 0);
 
-  return total_nirep;
+  return sirep;
 }
 
 mrb_value
diff --git a/src/object.c b/src/object.c
index a2162f77f..50f2c3ab9 100644
--- a/src/object.c
+++ b/src/object.c
@@ -5,6 +5,7 @@
 */
 
 #include "mruby.h"
+#include "mruby/array.h"
 #include "mruby/class.h"
 #include "mruby/numeric.h"
 #include "mruby/string.h"
@@ -16,7 +17,7 @@ mrb_obj_eq(mrb_state *mrb, mrb_value v1, mrb_value v2)
   if (mrb_type(v1) != mrb_type(v2)) return FALSE;
   switch (mrb_type(v1)) {
   case MRB_TT_TRUE:
-    return 1;
+    return TRUE;
 
   case MRB_TT_FALSE:
   case MRB_TT_FIXNUM:
diff --git a/src/parse.y b/src/parse.y
index f5dbdb6fd..fda66e92c 100644
--- a/src/parse.y
+++ b/src/parse.y
@@ -3293,7 +3293,7 @@ peek_n(parser_state *p, int c, int n)
     list = push(list, (node*)(intptr_t)c0);
   } while(n--);
   if (p->pb) {
-    p->pb = push(p->pb, (node*)list);
+    p->pb = append(p->pb, (node*)list);
   }
   else {
     p->pb = list;
@@ -3620,12 +3620,14 @@ parse_string(parser_state *p)
 	  tokadd(p, '\n');
 	}
 	else {
-	  pushback(p, c);
-
-	  if(type & STR_FUNC_REGEXP)
+	  if (type & STR_FUNC_REGEXP) {
 	    tokadd(p, '\\');
-
-	  tokadd(p, read_escape(p));
+	    if (c != -1)
+	      tokadd(p, c);
+	  } else {
+	    pushback(p, c);
+	    tokadd(p, read_escape(p));
+	  }
 	  if (hinf)
 	    hinf->line_head = FALSE;
 	}
diff --git a/src/range.c b/src/range.c
index 7e3e03136..992e47bd2 100644
--- a/src/range.c
+++ b/src/range.c
@@ -152,30 +152,22 @@ mrb_range_eq(mrb_state *mrb, mrb_value range)
   struct RRange *rr;
   struct RRange *ro;
   mrb_value obj;
-  mrb_bool eq_p;
 
   mrb_get_args(mrb, "o", &obj);
 
-  if (mrb_obj_equal(mrb, range, obj)) {
-    eq_p = 1;
-  }
-  else if (!mrb_obj_is_instance_of(mrb, obj, mrb_obj_class(mrb, range))) { /* same class? */
-    eq_p = 0;
-  }
-  else {
-    rr = mrb_range_ptr(range);
-    ro = mrb_range_ptr(obj);
-    if (!mrb_obj_equal(mrb, rr->edges->beg, ro->edges->beg) ||
-        !mrb_obj_equal(mrb, rr->edges->end, ro->edges->end) ||
-        rr->excl != ro->excl) {
-      eq_p = 0;
-    }
-    else {
-      eq_p = 1;
-    }
+  if (mrb_obj_equal(mrb, range, obj)) return mrb_true_value();
+  if (!mrb_obj_is_instance_of(mrb, obj, mrb_obj_class(mrb, range))) { /* same class? */
+    return mrb_false_value();
   }
 
-  return mrb_bool_value(eq_p);
+  rr = mrb_range_ptr(range);
+  ro = mrb_range_ptr(obj);
+  if (!mrb_bool(mrb_funcall(mrb, rr->edges->beg, "==", 1, ro->edges->beg)) ||
+      !mrb_bool(mrb_funcall(mrb, rr->edges->end, "==", 1, ro->edges->end)) ||
+      rr->excl != ro->excl) {
+    return mrb_false_value();
+  }
+  return mrb_true_value();
 }
 
 static int
@@ -385,34 +377,23 @@ range_eql(mrb_state *mrb, mrb_value range)
 {
   mrb_value obj;
   struct RRange *r, *o;
-  mrb_bool eql_p;
 
   mrb_get_args(mrb, "o", &obj);
-  if (mrb_obj_equal(mrb, range, obj)) {
-    eql_p = 1;
-  }
-  else if (!mrb_obj_is_kind_of(mrb, obj, RANGE_CLASS)) {
-    eql_p = 0;
+
+  if (mrb_obj_equal(mrb, range, obj)) return mrb_true_value();
+  if (!mrb_obj_is_kind_of(mrb, obj, RANGE_CLASS)) {
+    return mrb_false_value();
   }
-  else {
-    r = mrb_range_ptr(range);
-    if (mrb_type(obj) != MRB_TT_RANGE) {
-      eql_p = 0;
-    }
-    else {
-      o = mrb_range_ptr(obj);
-      if (!mrb_eql(mrb, r->edges->beg, o->edges->beg) ||
-          !mrb_eql(mrb, r->edges->end, o->edges->end) ||
-          (r->excl != o->excl)) {
-        eql_p = 0;
-      }
-      else {
-        eql_p = 1;
-      }
-    }
+  if (mrb_type(obj) != MRB_TT_RANGE) return mrb_false_value();
+
+  r = mrb_range_ptr(range);
+  o = mrb_range_ptr(obj);
+  if (!mrb_eql(mrb, r->edges->beg, o->edges->beg) ||
+      !mrb_eql(mrb, r->edges->end, o->edges->end) ||
+      (r->excl != o->excl)) {
+    return mrb_false_value();
   }
-
-  return mrb_bool_value(eql_p);
+  return mrb_true_value();
 }
 
 /* 15.2.14.4.15(x) */