Changeset 439 for EcnlProtoTool/trunk/mruby-2.1.1/mrbgems

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/default.gembox

-              r331
+              r439
 MRuby::GemBox.new do |conf|
+  # Meta-programming features
+  conf.gem :core => "mruby-metaprog"
+  # Use standard IO/File class
+  conf.gem :core => "mruby-io"
+  # Use standard Array#pack, String#unpack methods
+  conf.gem :core => "mruby-pack"
   # Use standard Kernel#sprintf method
   conf.gem :core => "mruby-sprintf"
 …
   # Use standard Struct class
   conf.gem :core => "mruby-struct"
+  # Use Comparable module extension
+  conf.gem :core => "mruby-compar-ext"
   # Use Enumerable module extension
 …
   conf.gem :core => "mruby-class-ext"
+  # Use Method/UnboundMethod class
+  conf.gem :core => "mruby-method"
   # Use mruby-compiler to build other mrbgems
   conf.gem :core => "mruby-compiler"

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-array-ext/mrblib/array.rb

-              r331
+              r439
 class Array
-  ##
-  # call-seq:
-  #    Array.try_convert(obj) -> array or nil
+  #
-  # Tries to convert +obj+ into an array, using +to_ary+ method.
-  # converted array or +nil+ if +obj+ cannot be converted for any reason.
-  # This method can be used to check if an argument is an array.
+  #
-  #    Array.try_convert([1])   #=> [1]
-  #    Array.try_convert("1")   #=> nil
+  #
-  #    if tmp = Array.try_convert(arg)
-  #      # the argument is an array
-  #    elsif tmp = String.try_convert(arg)
-  #      # the argument is a string
-  #    end
+  #
-  def self.try_convert(obj)
-    if obj.respond_to?(:to_ary)
-      obj.to_ary
-    else
-      nil
-    end
-  end
   ##
   # call-seq:
 …
+  #
   def uniq!(&block)
+    ary = self.dup
+    result = []
+    hash = {}
     if block
+      self.each do |val|
+        key = block.call(val)
+        hash[key] = val unless hash.key?(key)
+      end
+      result = hash.values
+    else
       hash = {}
+      while ary.size > 0
+        val = ary.shift
+        key = block.call(val)
+        hash[key] = val unless hash.has_key?(key)
+      end
+      hash.each_value do |value|
+        result << value
+      end
+    else
+      while ary.size > 0
+        result << ary.shift
+        ary.delete(result.last)
+      end
+      self.each do |val|
+        hash[val] = val
+      end
+      result = hash.keys
     end
     if result.size == self.size
 …
   def uniq(&block)
     ary = self.dup
+    if block
+      ary.uniq!(&block)
+    else
+      ary.uniq!
+    end
+    ary.uniq!(&block)
     ary
   end
 …
     hash = {}
     array = []
+    elem.each { |x| hash[x] = true }
+    self.each { |x| array << x unless hash[x] }
+    idx = 0
+    len = elem.size
+    while idx < len
+      hash[elem[idx]] = true
+      idx += 1
+    end
+    idx = 0
+    len = size
+    while idx < len
+      v = self[idx]
+      array << v unless hash[v]
+      idx += 1
+    end
     array
+  end
+  ##
+  # call-seq:
+  #    ary.difference(other_ary1, other_ary2, ...)   -> new_ary
+  #
+  # Returns a new array that is a copy of the original array, removing all
+  # occurrences of any item that also appear in +other_ary+. The order is
+  # preserved from the original array.
+  #
+  def difference(*args)
+    ary = self
+    args.each do |x|
+      ary = ary - x
+    end
+    ary
   end
 …
   ##
   # call-seq:
+  #    ary.union(other_ary,...)  -> new_ary
+  #
+  # Set Union---Returns a new array by joining this array with
+  # <i>other_ary</i>, removing duplicates.
+  #
+  #    ["a", "b", "c"].union(["c", "d", "a"], ["a", "c", "e"])
+  #           #=> ["a", "b", "c", "d", "e"]
+  #
+  def union(*args)
+    ary = self.dup
+    args.each do |x|
+      ary.concat(x)
+      ary.uniq!
+    end
+    ary
+  end
+  ##
+  # call-seq:
   #    ary & other_ary      -> new_ary
+  #
 …
     hash = {}
     array = []
+    elem.each{|v| hash[v] = true }
+    self.each do |v|
+    idx = 0
+    len = elem.size
+    while idx < len
+      hash[elem[idx]] = true
+      idx += 1
+    end
+    idx = 0
+    len = size
+    while idx < len
+      v = self[idx]
       if hash[v]
         array << v
         hash.delete v
       end
+      idx += 1
     end
     array
+  end
+  ##
+  # call-seq:
+  #    ary.intersection(other_ary,...)  -> new_ary
+  #
+  # Set Intersection---Returns a new array containing elements common to
+  # this array and <i>other_ary</i>s, removing duplicates. The order is
+  # preserved from the original array.
+  #
+  #    [1, 2, 3].intersection([3, 4, 1], [1, 3, 5])  #=> [1, 3]
+  #
+  def intersection(*args)
+    ary = self
+    args.each do |x|
+      ary = ary & x
+    end
+    ary
   end
 …
+  #
   def flatten(depth=nil)
+    ar = []
+    self.each do |e|
+      if e.is_a?(Array) && (depth.nil? || depth > 0)
+        ar += e.flatten(depth.nil? ? nil : depth - 1)
+      else
+        ar << e
+      end
+    end
+    ar
+    res = dup
+    res.flatten! depth
+    res
   end
 …
     modified = false
     ar = []
+    self.each do |e|
+    idx = 0
+    len = size
+    while idx < len
+      e = self[idx]
       if e.is_a?(Array) && (depth.nil? || depth > 0)
         ar += e.flatten(depth.nil? ? nil : depth - 1)
 …
         ar << e
       end
+      idx += 1
     end
     if modified
 …
   # for efficiency
   def reverse_each(&block)
     return to_enum :reverse_each unless block_given?
+    return to_enum :reverse_each unless block
     i = self.size - 1
 …
   end
-  NONE=Object.new
   ##
   #  call-seq:
 …
+  #
   def fetch(n=nil, ifnone=NONE, &block)
+  def fetch(n, ifnone=NONE, &block)
     warn "block supersedes default value argument" if !n.nil? && ifnone != NONE && block
 …
   def delete_if(&block)
     return to_enum :delete_if unless block_given?
+    return to_enum :delete_if unless block
     idx = 0
 …
   def reject!(&block)
     return to_enum :reject! unless block_given?
+    return to_enum :reject! unless block
     len = self.size
 …
   def bsearch(&block)
+    return to_enum :bsearch unless block_given?
+    return to_enum :bsearch unless block
+    if idx = bsearch_index(&block)
+      self[idx]
+    else
+      nil
+    end
+  end
+  ##
+  #  call-seq:
+  #     ary.bsearch_index {|x| block }  -> int or nil
+  #
+  #  By using binary search, finds an index of a value from this array which
+  #  meets the given condition in O(log n) where n is the size of the array.
+  #
+  #  It supports two modes, depending on the nature of the block and they are
+  #  exactly the same as in the case of #bsearch method with the only difference
+  #  being that this method returns the index of the element instead of the
+  #  element itself. For more details consult the documentation for #bsearch.
+  def bsearch_index(&block)
+    return to_enum :bsearch_index unless block
     low = 0
     high = self.size
+    high = size
     satisfied = false
     while low < high
+      mid = low + ((high - low) / 2).truncate
+      val = self[mid]
+      v = block.call(val)
+      if v.is_a?(Integer)
+        return val if v == 0
+        smaller = v < 0
+      elsif v == true
+      mid = ((low+high)/2).truncate
+      res = block.call self[mid]
+      case res
+      when 0 # find-any mode: Found!
+        return mid
+      when Numeric # find-any mode: Continue...
+        in_lower_half = res < 0
+      when true # find-min mode
+        in_lower_half = true
         satisfied = true
+        smaller = true
+      elsif v == false || v.nil?
+        smaller = false
+      end
+      if smaller
+      when false, nil # find-min mode
+        in_lower_half = false
+      else
+        raise TypeError, 'invalid block result (must be numeric, true, false or nil)'
+      end
+      if in_lower_half
         high = mid
       else
 …
       end
     end
+    return nil if low == self.size
+    return nil unless satisfied
+    self[low]
+  end
+  ##
+  #  call-seq:
+  #     ary.delete_if { |item| block }  -> ary
+  #     ary.delete_if                   -> Enumerator
+  #
+  #  Deletes every element of +self+ for which block evaluates to +true+.
+  #
+  #  The array is changed instantly every time the block is called, not after
+  #  the iteration is over.
+  #
+  #  See also Array#reject!
+  #
+  #  If no block is given, an Enumerator is returned instead.
+  #
+  #     scores = [ 97, 42, 75 ]
+  #     scores.delete_if {|score| score < 80 }   #=> [97]
+  def delete_if(&block)
+    return to_enum :delete_if unless block_given?
+    idx = 0
+    while idx < self.size do
+      if block.call(self[idx])
+        self.delete_at(idx)
+      else
+        idx += 1
+      end
+    end
+    self
+    satisfied ? low : nil
   end
 …
   def keep_if(&block)
     return to_enum :keep_if unless block_given?
+    return to_enum :keep_if unless block
     idx = 0
 …
   def select!(&block)
     return to_enum :select! unless block_given?
+    return to_enum :select! unless block
     result = []
+    self.each do |x|
+      result << x if block.call(x)
+    end
+    return nil if self.size == result.size
+    idx = 0
+    len = size
+    while idx < len
+      elem = self[idx]
+      result << elem if block.call(elem)
+      idx += 1
+    end
+    return nil if len == result.size
     self.replace(result)
   end
 …
     if block
       idx = 0
+      self.each do |*e|
+        return idx if block.call(*e)
+      len = size
+      while idx < len
+        return idx if block.call self[idx]
         idx += 1
       end
 …
     end
     nil
-  end
-  ##
-  #  call-seq:
-  #     ary.to_ary -> ary
+  #
-  #  Returns +self+.
+  #
-  def to_ary
-    self
   end
 …
     end
   end
+  ##
+  # call-seq:
+  #    ary.permutation { |p| block }          -> ary
+  #    ary.permutation                        -> Enumerator
+  #    ary.permutation(n) { |p| block }       -> ary
+  #    ary.permutation(n)                     -> Enumerator
+  #
+  # When invoked with a block, yield all permutations of length +n+ of the
+  # elements of the array, then return the array itself.
+  #
+  # If +n+ is not specified, yield all permutations of all elements.
+  #
+  # The implementation makes no guarantees about the order in which the
+  # permutations are yielded.
+  #
+  # If no block is given, an Enumerator is returned instead.
+  #
+  # Examples:
+  #
+  #  a = [1, 2, 3]
+  #  a.permutation.to_a    #=> [[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]
+  #  a.permutation(1).to_a #=> [[1],[2],[3]]
+  #  a.permutation(2).to_a #=> [[1,2],[1,3],[2,1],[2,3],[3,1],[3,2]]
+  #  a.permutation(3).to_a #=> [[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]
+  #  a.permutation(0).to_a #=> [[]] # one permutation of length 0
+  #  a.permutation(4).to_a #=> []   # no permutations of length 4
+  def permutation(n=self.size, &block)
+    return to_enum(:permutation, n) unless block
+    size = self.size
+    if n == 0
+      yield []
+    elsif 0 < n && n <= size
+      i = 0
+      while i<size
+        result = [self[i]]
+        if n-1 > 0
+          ary = self[0...i] + self[i+1..-1]
+          ary.permutation(n-1) do |c|
+            yield result + c
+          end
+        else
+          yield result
+        end
+        i += 1
+      end
+    end
+    self
+  end
+  ##
+  # call-seq:
+  #    ary.combination(n) { |c| block }    -> ary
+  #    ary.combination(n)                  -> Enumerator
+  #
+  # When invoked with a block, yields all combinations of length +n+ of elements
+  # from the array and then returns the array itself.
+  #
+  # The implementation makes no guarantees about the order in which the
+  # combinations are yielded.
+  #
+  # If no block is given, an Enumerator is returned instead.
+  #
+  # Examples:
+  #
+  #    a = [1, 2, 3, 4]
+  #    a.combination(1).to_a  #=> [[1],[2],[3],[4]]
+  #    a.combination(2).to_a  #=> [[1,2],[1,3],[1,4],[2,3],[2,4],[3,4]]
+  #    a.combination(3).to_a  #=> [[1,2,3],[1,2,4],[1,3,4],[2,3,4]]
+  #    a.combination(4).to_a  #=> [[1,2,3,4]]
+  #    a.combination(0).to_a  #=> [[]] # one combination of length 0
+  #    a.combination(5).to_a  #=> []   # no combinations of length 5
+  def combination(n, &block)
+    return to_enum(:combination, n) unless block
+    size = self.size
+    if n == 0
+       yield []
+    elsif n == 1
+      i = 0
+      while i<size
+        yield [self[i]]
+        i += 1
+      end
+    elsif n <= size
+      i = 0
+      while i<size
+        result = [self[i]]
+        self[i+1..-1].combination(n-1) do |c|
+          yield result + c
+        end
+        i += 1
+      end
+    end
+    self
+  end
+  ##
+  # call-seq:
+  #    ary.transpose -> new_ary
+  #
+  # Assumes that self is an array of arrays and transposes the rows and columns.
+  #
+  # If the length of the subarrays don't match, an IndexError is raised.
+  #
+  # Examples:
+  #
+  #    a = [[1,2], [3,4], [5,6]]
+  #    a.transpose   #=> [[1, 3, 5], [2, 4, 6]]
+  def transpose
+    return [] if empty?
+    column_count = nil
+    self.each do |row|
+      raise TypeError unless row.is_a?(Array)
+      column_count ||= row.size
+      raise IndexError, 'element size differs' unless column_count == row.size
+    end
+    Array.new(column_count) do |column_index|
+      self.map { |row| row[column_index] }
+    end
+  end
+  ##
+  #  call-seq:
+  #    ary.to_h                ->   Hash
+  #    ary.to_h{|item| ... }   ->   Hash
+  #
+  # Returns the result of interpreting <i>aray</i> as an array of
+  # <tt>[key, value]</tt> pairs. If a block is given, it should
+  # return <tt>[key, value]</tt> pairs to construct a hash.
+  #
+  #     [[:foo, :bar], [1, 2]].to_h
+  #       # => {:foo => :bar, 1 => 2}
+  #     [1, 2].to_h{|x| [x, x*2]}
+  #       # => {1 => 2, 2 => 4}
+  #
+  def to_h(&blk)
+    h = {}
+    self.each do |v|
+      v = blk.call(v) if blk
+      raise TypeError, "wrong element type #{v.class}" unless Array === v
+      raise ArgumentError, "wrong array length (expected 2, was #{v.length})" unless v.length == 2
+      h[v[0]] = v[1]
+    end
+    h
+  end
+  alias append push
+  alias prepend unshift
+  alias filter! select!
 end

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-array-ext/src/array.c

-              r331
+              r439
   for (i = 0; i < RARRAY_LEN(ary); ++i) {
     v = RARRAY_PTR(ary)[i];
     if (mrb_type(v) == MRB_TT_ARRAY &&
+    if (mrb_array_p(v) &&
         RARRAY_LEN(v) > 1 &&
         mrb_equal(mrb, RARRAY_PTR(v)[1], value))
 …
+}
-/*
- *  call-seq:
- *     ary.to_h   ->   Hash
+ *
- *  Returns the result of interpreting <i>aray</i> as an array of
- *  <tt>[key, value]</tt> paris.
+ *
- *      [[:foo, :bar], [1, 2]].to_h
- *        # => {:foo => :bar, 1 => 2}
+ *
- */
-static mrb_value
-mrb_ary_to_h(mrb_state *mrb, mrb_value ary)
+{
-  mrb_int i;
-  mrb_value v, hash;
-  hash = mrb_hash_new_capa(mrb, 0);
-  for (i = 0; i < RARRAY_LEN(ary); ++i) {
-    v = mrb_check_array_type(mrb, RARRAY_PTR(ary)[i]);
-    if (mrb_nil_p(v)) {
-      mrb_raisef(mrb, E_TYPE_ERROR, "wrong element type %S at %S (expected array)",
-        mrb_str_new_cstr(mrb,  mrb_obj_classname(mrb, ary_elt(ary, i))),
-        mrb_fixnum_value(i)
-      );
+    }
-    if (RARRAY_LEN(v) != 2) {
-      mrb_raisef(mrb, E_ARGUMENT_ERROR, "wrong array length at %S (expected 2, was %S)",
-        mrb_fixnum_value(i),
-        mrb_fixnum_value(RARRAY_LEN(v))
-      );
+    }
-    mrb_hash_set(mrb, hash, RARRAY_PTR(v)[0], RARRAY_PTR(v)[1]);
+  }
-  return hash;
+}
 /*
 …
+{
   struct RArray *a = mrb_ary_ptr(self);
+  mrb_int i, j, k, len;
+  mrb_value index;
+  mrb_int i, j, k, len, alen;
   mrb_value val;
   mrb_value *ptr;
 …
   mrb_ary_modify(mrb, a);
+  if (mrb_get_args(mrb, "o|i", &index, &len) == 1) {
+  if (mrb_get_argc(mrb) == 1) {
+    mrb_value index;
+    mrb_get_args(mrb, "o|i", &index, &len);
     switch (mrb_type(index)) {
     case MRB_TT_RANGE:
       if (mrb_range_beg_len(mrb, index, &i, &len, a->len, TRUE) == 1) {
+      if (mrb_range_beg_len(mrb, index, &i, &len, ARY_LEN(a), TRUE) == MRB_RANGE_OK) {
         goto delete_pos_len;
+      }
 …
+  }
   i = mrb_fixnum(index);
+  mrb_get_args(mrb, "ii", &i, &len);
  delete_pos_len:
+  if (i < 0) i += a->len;
+  if (i < 0 || a->len < i) return mrb_nil_value();
+  alen = ARY_LEN(a);
+  if (i < 0) i += alen;
+  if (i < 0 || alen < i) return mrb_nil_value();
   if (len < 0) return mrb_nil_value();
   if (a->len == i) return mrb_ary_new(mrb);
   if (len > a->len - i) len = a->len - i;
+  if (alen == i) return mrb_ary_new(mrb);
+  if (len > alen - i) len = alen - i;
   ary = mrb_ary_new_capa(mrb, len);
+  ptr = ARY_PTR(a);
   for (j = i, k = 0; k < len; ++j, ++k) {
     mrb_ary_push(mrb, ary, a->ptr[j]);
+  }
   ptr = a->ptr + i;
   for (j = i; j < a->len - len; ++j) {
+    mrb_ary_push(mrb, ary, ptr[j]);
+  }
+  ptr += i;
+  for (j = i; j < alen - len; ++j) {
     *ptr = *(ptr+len);
     ++ptr;
+  }
   mrb_ary_resize(mrb, self, a->len - len);
+  mrb_ary_resize(mrb, self, alen - len);
   return ary;
+}
 …
   mrb_define_method(mrb, a, "rassoc", mrb_ary_rassoc, MRB_ARGS_REQ(1));
   mrb_define_method(mrb, a, "values_at", mrb_ary_values_at, MRB_ARGS_ANY());
+  mrb_define_method(mrb, a, "to_h",   mrb_ary_to_h, MRB_ARGS_REQ(0));
+  mrb_define_method(mrb, a, "slice!", mrb_ary_slice_bang,   MRB_ARGS_ANY());
+  mrb_define_method(mrb, a, "slice!", mrb_ary_slice_bang,   MRB_ARGS_ARG(1,1));
+}

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-array-ext/test/array.rb

-              r331
+              r439
 # Array(Ext) Test
+assert("Array.try_convert") do
+  assert_nil Array.try_convert(0)
+  assert_nil Array.try_convert(nil)
+  assert_equal [], Array.try_convert([])
+  assert_equal [1,2,3], Array.try_convert([1,2,3])
+def assert_permutation_combination(exp, receiver, meth, *args)
+  act = []
+  ret = receiver.__send__(meth, *args) { |v| act << v }
+  assert "assert_#{meth}" do
+    assert_equal(exp, act.sort)
+    assert_same(receiver, ret)
+  end
+end
+def assert_permutation(exp, receiver, *args)
+  assert_permutation_combination(exp, receiver, :permutation, *args)
+end
+def assert_combination(exp, receiver, *args)
+  assert_permutation_combination(exp, receiver, :combination, *args)
 end
 …
 end
+assert("Array#union") do
+  a = [1, 2, 3, 1]
+  b = [1, 4]
+  c = [1, 5]
+  assert_equal [1, 2, 3, 4, 5], a.union(b,c)
+end
+assert("Array#difference") do
+  a = [1, 2, 3, 1, 6, 7]
+  b = [1, 4, 6]
+  c = [1, 5, 7]
+  assert_equal [2, 3], a.difference(b,c)
+end
 assert("Array#&") do
   a = [1, 2, 3, 1]
 …
   assert_equal [1], (a & b)
   assert_equal [1, 2, 3, 1], a
+end
+assert("Array#intersection") do
+  a = [1, 2, 3, 1, 8, 6, 7, 8]
+  b = [1, 4, 6, 8]
+  c = [1, 5, 7, 8]
+  assert_equal [1, 8], a.intersection(b,c)
 end
 …
   end
   assert_equal [ "d", "c", "b", "a" ], b
-  if Object.const_defined?(:Enumerator)
-    assert_equal [ "d", "c", "b", "a" ], a.reverse_each.to_a
-  else
-    true
-  end
 end
 …
 assert("Array#bsearch") do
   # Find minimum mode
+  a = [0, 4, 7, 10, 12]
+  assert_include [4, 7], a.bsearch {|x| x >= 4 }
+  assert_equal 7, a.bsearch {|x| x >= 6 }
+  assert_equal 0, a.bsearch {|x| x >= -1 }
+  assert_nil a.bsearch {|x| x >= 100 }
+  a = [0, 2, 4]
+  assert_equal 0, a.bsearch{ |x| x >= -1 }
+  assert_equal 0, a.bsearch{ |x| x >= 0 }
+  assert_equal 2, a.bsearch{ |x| x >= 1 }
+  assert_equal 2, a.bsearch{ |x| x >= 2 }
+  assert_equal 4, a.bsearch{ |x| x >= 3 }
+  assert_equal 4, a.bsearch{ |x| x >= 4 }
+  assert_nil      a.bsearch{ |x| x >= 5 }
   # Find any mode
+  a = [0, 4, 7, 10, 12]
+  assert_include [4, 7], a.bsearch {|x| 1 - (x / 4).truncate }
+  assert_nil a.bsearch {|x| 4 - (x / 2).truncate }
+  assert_equal(nil, a.bsearch {|x| 1 })
+  assert_equal(nil, a.bsearch {|x| -1 })
+end
+assert("Array#delete_if") do
+  a = [1, 2, 3, 4, 5]
+  assert_equal [1, 2, 3, 4, 5], a.delete_if { false }
+  assert_equal [1, 2, 3, 4, 5], a
+  a = [1, 2, 3, 4, 5]
+  assert_equal [], a.delete_if { true }
+  assert_equal [], a
+  a = [ 1, 2, 3, 4, 5 ]
+  assert_equal [1, 2, 3], a.delete_if { |val| val > 3 }
+end
+  a = [0, 4, 8]
+  def between(lo, x, hi)
+    if x < lo
+    elsif x > hi
+      -1
+    else
+    end
+  end
+  assert_nil      a.bsearch{ |x| between(-3, x, -1) }
+  assert_equal 0, a.bsearch{ |x| between(-1, x,  1) }
+  assert_nil      a.bsearch{ |x| between( 1, x,  3) }
+  assert_equal 4, a.bsearch{ |x| between( 3, x,  5) }
+  assert_nil      a.bsearch{ |x| between( 5, x,  7) }
+  assert_equal 8, a.bsearch{ |x| between( 7, x,  9) }
+  assert_nil      a.bsearch{ |x| between( 9, x, 11) }
+  assert_equal 0, a.bsearch{ |x| between( 0, x,  3) }
+  assert_equal 4, a.bsearch{ |x| between( 0, x,  4) }
+  assert_equal 4, a.bsearch{ |x| between( 4, x,  8) }
+  assert_equal 8, a.bsearch{ |x| between( 5, x,  8) }
+  # Invalid block result
+  assert_raise TypeError, 'invalid block result (must be numeric, true, false or nil)' do
+    a.bsearch{ 'I like to watch the world burn' }
+  end
+end
+# tested through Array#bsearch
+#assert("Array#bsearch_index") do
+#end
 assert("Array#keep_if") do
 …
 end
-assert('Array#to_h (Modified)') do
-  class A
-    def to_ary
-      $a.clear
-      nil
-    end
-  end
-  $a = [A.new]
-  assert_raise(TypeError) { $a.to_h }
-end
 assert("Array#index (block)") do
   assert_nil (1..10).to_a.index { |i| i % 5 == 0 and i % 7 == 0 }
   assert_equal 34, (1..100).to_a.index { |i| i % 5 == 0 and i % 7 == 0 }
-end
-assert("Array#to_ary") do
-  assert_equal [], [].to_ary
-  assert_equal [1,2,3], [1,2,3].to_ary
 end
 …
   assert_equal(j, nil)
 end
+assert("Array#permutation") do
+  a = [1, 2, 3]
+  assert_permutation([[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]], a)
+  assert_permutation([[1],[2],[3]], a, 1)
+  assert_permutation([[1,2],[1,3],[2,1],[2,3],[3,1],[3,2]], a, 2)
+  assert_permutation([[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]], a, 3)
+  assert_permutation([[]], a, 0)
+  assert_permutation([], a, 4)
+  assert_permutation([], a, -1)
+end
+assert("Array#combination") do
+  a = [1, 2, 3, 4]
+  assert_combination([[1],[2],[3],[4]], a, 1)
+  assert_combination([[1,2],[1,3],[1,4],[2,3],[2,4],[3,4]], a, 2)
+  assert_combination([[1,2,3],[1,2,4],[1,3,4],[2,3,4]], a, 3)
+  assert_combination([[1,2,3,4]], a, 4)
+  assert_combination([[]], a, 0)
+  assert_combination([], a, 5)
+  assert_combination([], a, -1)
+end
+assert('Array#transpose') do
+  assert_equal([].transpose, [])
+  assert_equal([[]].transpose, [])
+  assert_equal([[1]].transpose, [[1]])
+  assert_equal([[1,2,3]].transpose, [[1], [2], [3]])
+  assert_equal([[1], [2], [3]].transpose, [[1,2,3]])
+  assert_equal([[1,2], [3,4], [5,6]].transpose, [[1,3,5], [2,4,6]])
+  assert_raise(TypeError) { [1].transpose }
+  assert_raise(IndexError) { [[1], [2,3,4]].transpose }
+end

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-bin-debugger/bintest/print.rb

-              r331
+              r439
 require 'open3'
 require 'tempfile'
+require 'strscan'
 class BinTest_MrubyBinDebugger
   @debug1=false
   @debug2=true
+#  @debug1=false
+#  @debug2=true
   def self.test(rubysource, testcase)
     script, bin = Tempfile.new(['test', '.rb']), Tempfile.new(['test', '.mrb'])
 …
     stdin_data = testcase.map{|t| t[:cmd]}.join("\n") << "\n"
+    prompt = /^\(#{Regexp.escape(script.path)}:\d+\) /
     ["bin/mrdb #{script.path}","bin/mrdb -b #{bin.path}"].each do |cmd|
       o, s = Open3.capture2(cmd, :stdin_data => stdin_data)
+      exp_vals = testcase.map{|t| t.fetch(:exp, nil)}
+      scanner = StringScanner.new(o)
+      scanner.skip_until(prompt)
+      testcase.each do |tc|
+        exp = tc[:exp]
+        if exp
+          act = scanner.scan_until(/\n/)
+          break unless assert_operator act, :start_with?, exp
+        end
+        scanner.skip_until(prompt)
+      end
 =begin
 if @debug1
 …
       end
 =end
-      idx = 0
-      exp_vals.each do |exp|
-        next if exp.nil?
-        idx = o.index(exp, idx)
-        assert_false idx.nil?
-        break unless idx
-        idx += 1
-      end
     end
   end
 …
   # test case
   tc = []
   tc << {:cmd=>"p (1+2",  :exp=>'$1 = SyntaxError'}
   tc << {:cmd=>"p bar",   :exp=>'$2 = NoMethodError'}
+  tc << {:cmd=>"p (1+2",  :exp=>'$1 = line 1: syntax error'}
+  tc << {:cmd=>"p bar",   :exp=>'$2 = undefined method'}
   BinTest_MrubyBinDebugger.test(src, tc)
 …
 SRC
   # todo: wait for 'break' to be implimented
+  # todo: wait for 'break' to be implemented
   tc = []
 .times { tc << {:cmd=>"s"} }
 …
   tc << {:cmd=>"p 0x100",   :exp=>'$4 = 256'}
   tc << {:cmd=>"p 1_234",   :exp=>'$5 = 1234'}
   tc << {:cmd=>"p 0b1000_0000", :exp=>"$6 = #{0b1000_0000.to_s}"}
   tc << {:cmd=>"p 0x1000_0000", :exp=>"$7 = #{0x1000_0000.to_s}"}
+  tc << {:cmd=>"p 0b1000_0000", :exp=>"$6 = #{0b1000_0000}"}
+  tc << {:cmd=>"p 0x1000_0000", :exp=>"$7 = #{0x1000_0000}"}
   tc << {:cmd=>"p 3.14",    :exp=>'$8 = 3.14'}
   tc << {:cmd=>"p -12.3",   :exp=>'$9 = -12.3'}
   tc << {:cmd=>"p +12.000", :exp=>'$10 = 12.0'}
   tc << {:cmd=>"p 1e4",     :exp=>'$11 = 10000.0'}
+  tc << {:cmd=>"p +12.000", :exp=>'$10 = 12'}
+  tc << {:cmd=>"p 1e4",     :exp=>'$11 = 10000'}
   tc << {:cmd=>"p -0.1e-2", :exp=>'$12 = -0.001'}
 …
   tc << {:cmd=>'p "str"',        :exp=>'$1 = "str"'}
   tc << {:cmd=>'p "s\tt\rr\n"',  :exp=>'$2 = "s\\tt\\rr\\n"'}
   tc << {:cmd=>'p "\C-a\C-z"',   :exp=>'$3 = "\\001\\032"'}
+  tc << {:cmd=>'p "\C-a\C-z"',   :exp=>'$3 = "\\x01\\x1a"'}
   tc << {:cmd=>'p "#{foo+bar}"', :exp=>'$4 = "foobar"'}
 …
   tc << {:cmd=>'p \'s\\tt\\rr\\n\'', :exp=>'$6 = "s\\\\tt\\\\rr\\\\n"'}
   tc << {:cmd=>'p \'\\C-a\\C-z\'',   :exp=>'$7 = "\\\\C-a\\\\C-z"'}
   tc << {:cmd=>'p \'#{foo+bar}\'',   :exp=>'$8 = "#{foo+bar}"'}
+  tc << {:cmd=>'p \'#{foo+bar}\'',   :exp=>'$8 = "\\#{foo+bar}"'}
   tc << {:cmd=>'p %!str!',        :exp=>'$9 = "str"'}
   tc << {:cmd=>'p %!s\tt\rr\n!',  :exp=>'$10 = "s\\tt\\rr\\n"'}
   tc << {:cmd=>'p %!\C-a\C-z!',   :exp=>'$11 = "\\001\\032"'}
+  tc << {:cmd=>'p %!\C-a\C-z!',   :exp=>'$11 = "\\x01\\x1a"'}
   tc << {:cmd=>'p %!#{foo+bar}!', :exp=>'$12 = "foobar"'}
   tc << {:cmd=>'p %Q!str!',        :exp=>'$13 = "str"'}
   tc << {:cmd=>'p %Q!s\tt\rr\n!',  :exp=>'$14 = "s\\tt\\rr\\n"'}
   tc << {:cmd=>'p %Q!\C-a\C-z!',   :exp=>'$15 = "\\001\\032"'}
+  tc << {:cmd=>'p %Q!\C-a\C-z!',   :exp=>'$15 = "\\x01\\x1a"'}
   tc << {:cmd=>'p %Q!#{foo+bar}!', :exp=>'$16 = "foobar"'}
 …
   tc << {:cmd=>'p %q!s\\tt\\rr\\n!', :exp=>'$18 = "s\\\\tt\\\\rr\\\\n"'}
   tc << {:cmd=>'p %q!\\C-a\\C-z!',   :exp=>'$19 = "\\\\C-a\\\\C-z"'}
   tc << {:cmd=>'p %q!#{foo+bar}!',   :exp=>'$20 = "#{foo+bar}"'}
+  tc << {:cmd=>'p %q!#{foo+bar}!',   :exp=>'$20 = "\\#{foo+bar}"'}
   BinTest_MrubyBinDebugger.test(src, tc)
 …
   tc << {:cmd=>'p [ 5,  12,   8,    10, ]', :exp=>'$2 = [5, 12, 8, 10]'}
   tc << {:cmd=>'p [1,2.5,"#{foo+bar}"]',    :exp=>'$3 = [1, 2.5, "foobar"]'}
   tc << {:cmd=>'p %w[3.14 A\ &\ B #{foo}]', :exp=>'$4 = ["3.14", "A & B", "#{foo}"]'}
+  tc << {:cmd=>'p %w[3.14 A\ &\ B #{foo}]', :exp=>'$4 = ["3.14", "A & B", "\#{foo}"]'}
   tc << {:cmd=>'p %W[3.14 A\ &\ B #{foo}]', :exp=>'$5 = ["3.14", "A & B", "foo"]'}
 …
   tc << {:cmd=>'p undefined=-1',      :exp=>'$3 = -1'}
   tc << {:cmd=>'p "#{undefined}"',    :exp=>'$4 = NoMethodError'}
+  tc << {:cmd=>'p "#{undefined}"',    :exp=>'$4 = undefined method'}
   BinTest_MrubyBinDebugger.test(src, tc)
 …
   tc << {:cmd=>'p undefined=-1',    :exp=>'$14 = -1'}
   tc << {:cmd=>'p "#{undefined}"',  :exp=>'$15 = NoMethodError'}
+  tc << {:cmd=>'p "#{undefined}"',  :exp=>'$15 = undefined method'}
   BinTest_MrubyBinDebugger.test(src, tc)
 …
   tc << {:cmd=>'p undefined=-1',    :exp=>'$14 = -1'}
+  tc << {:cmd=>'p "#{undefined}"',  :exp=>'$15 = NoMethodError'}
+  BinTest_MrubyBinDebugger.test(src, tc)
+end
+  tc << {:cmd=>'p "#{undefined}"',  :exp=>'$15 = undefined method'}
+  BinTest_MrubyBinDebugger.test(src, tc)
+end

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-bin-debugger/tools/mrdb/apibreak.c

-              r331
+              r439
 static uint16_t
 check_file_lineno(struct mrb_irep *irep, const char *file, uint16_t lineno)
+check_file_lineno(mrb_state *mrb, struct mrb_irep *irep, const char *file, uint16_t lineno)
+{
   mrb_irep_debug_info_file *info_file;
 …
   for (f_idx = 0; f_idx < irep->debug_info->flen; ++f_idx) {
+    const char *filename;
     info_file = irep->debug_info->files[f_idx];
+    if (!strcmp(info_file->filename, file)) {
+    filename = mrb_sym_name_len(mrb, info_file->filename_sym, NULL);
+    if (!strcmp(filename, file)) {
       result = MRB_DEBUG_BP_FILE_OK;
 …
+    }
     for (i=0; i < irep->rlen; ++i) {
       result  |= check_file_lineno(irep->reps[i], file, lineno);
+      result  |= check_file_lineno(mrb, irep->reps[i], file, lineno);
       if (result == (MRB_DEBUG_BP_FILE_OK | MRB_DEBUG_BP_LINENO_OK)) {
         return result;
 …
+}
-static const char*
-get_class_name(mrb_state *mrb, struct RClass *class_obj)
+{
-  struct RClass *outer;
-  mrb_sym class_sym;
-  outer = mrb_class_outer_module(mrb, class_obj);
-  class_sym = mrb_class_sym(mrb, class_obj, outer);
-  return mrb_sym2name(mrb, class_sym);
+}
 static int32_t
 compare_break_method(mrb_state *mrb, mrb_debug_breakpoint *bp, struct RClass *class_obj, mrb_sym method_sym, mrb_bool* isCfunc)
 …
   const char* class_name;
   const char* method_name;
   struct RProc* m;
+  mrb_method_t m;
   struct RClass* sc;
   const char* sn;
 …
   mrb_bool is_defined;
   method_name = mrb_sym2name(mrb, method_sym);
+  method_name = mrb_sym_name(mrb, method_sym);
   method_p = &bp->point.methodpoint;
   if (strcmp(method_p->method_name, method_name) == 0) {
     class_name = get_class_name(mrb, class_obj);
+    class_name = mrb_class_name(mrb, class_obj);
     if (class_name == NULL) {
       if (method_p->class_name == NULL) {
 …
     else if (method_p->class_name != NULL) {
       m = mrb_method_search_vm(mrb, &class_obj, method_sym);
       if (m == NULL) {
+      if (MRB_METHOD_UNDEF_P(m)) {
         return MRB_DEBUG_OK;
+      }
       if (MRB_PROC_CFUNC_P(m)) {
+      if (MRB_METHOD_CFUNC_P(m)) {
         *isCfunc = TRUE;
+      }
 …
       ssym = mrb_symbol(mrb_check_intern_cstr(mrb, method_p->method_name));
       m = mrb_method_search_vm(mrb, &sc, ssym);
       if (m == NULL) {
+      if (MRB_METHOD_UNDEF_P(m)) {
         return MRB_DEBUG_OK;
+      }
       class_name = get_class_name(mrb, class_obj);
       sn = get_class_name(mrb, sc);
+      class_name = mrb_class_name(mrb, class_obj);
+      sn = mrb_class_name(mrb, sc);
       if (strcmp(sn, class_name) == 0) {
         return bp->bpno;
 …
   /* file and lineno check (line type mrb_debug_line_ary only.) */
   result = check_file_lineno(dbg->root_irep, file, lineno);
+  result = check_file_lineno(mrb, dbg->root_irep, file, lineno);
   if (result == 0) {
     return MRB_DEBUG_BREAK_INVALID_FILE;
 …
+  }
   set_file = mrb_malloc(mrb, strlen(file) + 1);
+  set_file = (char*)mrb_malloc(mrb, strlen(file) + 1);
   index = dbg->bpnum;
 …
   if (class_name != NULL) {
     set_class = mrb_malloc(mrb, strlen(class_name) + 1);
+    set_class = (char*)mrb_malloc(mrb, strlen(class_name) + 1);
     strncpy(set_class, class_name, strlen(class_name) + 1);
+  }
 …
+  }
   set_method = mrb_malloc(mrb, strlen(method_name) + 1);
+  set_method = (char*)mrb_malloc(mrb, strlen(method_name) + 1);
   strncpy(set_method, method_name, strlen(method_name) + 1);
 …
 static mrb_bool
 check_start_pc_for_line(mrb_irep *irep, mrb_code *pc, uint16_t line)
+check_start_pc_for_line(mrb_state *mrb, mrb_irep *irep, const mrb_code *pc, uint16_t line)
+{
   if (pc > irep->iseq) {
     if (line == mrb_debug_get_line(irep, (uint32_t)(pc - irep->iseq - 1))) {
+    if (line == mrb_debug_get_line(mrb, irep, pc - irep->iseq - 1)) {
       return FALSE;
+    }
 …
+  }
   if (!check_start_pc_for_line(dbg->irep, dbg->pc, line)) {
+  if (!check_start_pc_for_line(mrb, dbg->irep, dbg->pc, line)) {
     return MRB_DEBUG_OK;
+  }
 …
   return 0;
+}

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-bin-debugger/tools/mrdb/apilist.c

-              r331
+              r439
+  }
   path = mrb_malloc(mrb, len);
+  path = (char*)mrb_malloc(mrb, len);
   memset(path, 0, len);
 …
+{
   size_t len;
+  char *p, *dir;
+  const char *p;
+  char *dir;
   if (path == NULL) {
 …
   len = p != NULL ? (size_t)(p - path) : strlen(path);
   dir = mrb_malloc(mrb, len + 1);
+  dir = (char*)mrb_malloc(mrb, len + 1);
   strncpy(dir, path, len);
   dir[len] = '\0';
 …
 source_file_new(mrb_state *mrb, mrb_debug_context *dbg, char *filename)
+{
   source_file *file = NULL;
   file = mrb_malloc(mrb, sizeof(source_file));
+  source_file *file;
+  file = (source_file*)mrb_malloc(mrb, sizeof(source_file));
   memset(file, '\0', sizeof(source_file));
 …
   file->lineno = 1;
   file->path = mrb_malloc(mrb, strlen(filename) + 1);
+  file->path = (char*)mrb_malloc(mrb, strlen(filename) + 1);
   strcpy(file->path, filename);
   return file;
 …
   const char *search_path[3];
   char *path = NULL;
+  const char *srcname = strrchr(filename, '/');
+  if (srcname) srcname++;
+  else srcname = filename;
   search_path[0] = srcpath;
   search_path[1] = dirname(mrb, mrb_debug_get_filename(mrdb->dbg->root_irep, 0));
+  search_path[1] = dirname(mrb, mrb_debug_get_filename(mrb, mrdb->dbg->irep, 0));
   search_path[2] = ".";
 …
+    }
     if ((path = build_path(mrb, search_path[i], filename)) == NULL) {
+    if ((path = build_path(mrb, search_path[i], srcname)) == NULL) {
       continue;
+    }

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-bin-debugger/tools/mrdb/apiprint.c

-              r331
+              r439
   c->no_exec = TRUE;
   c->capture_errors = TRUE;
   c->filename = (char*)dbg->prvfile;
+  mrbc_filename(mrb, c, (const char*)dbg->prvfile);
   c->lineno = dbg->prvline;
 …
 mrb_value
 mrb_debug_eval(mrb_state *mrb, mrb_debug_context *dbg, const char *expr, size_t len, mrb_bool *exc)
+mrb_debug_eval(mrb_state *mrb, mrb_debug_context *dbg, const char *expr, size_t len, mrb_bool *exc, int direct_eval)
+{
   void (*tmp)(struct mrb_state *, struct mrb_irep *, mrb_code *, mrb_value *);
+  void (*tmp)(struct mrb_state *, struct mrb_irep *, const mrb_code *, mrb_value *);
   mrb_value ruby_code;
   mrb_value s;
 …
     v = mrb_obj_value(mrb->exc);
     mrb->exc = 0;
+  }
+  else if (direct_eval) {
+    recv = dbg->regs[0];
+    v = mrb_funcall(mrb, recv, expr, 0);
+  }
   else {
 …
+  }
   s = mrb_funcall(mrb, v, "inspect", 0);
+  s = mrb_inspect(mrb, v);
   /* enable code_fetch_hook */

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-bin-debugger/tools/mrdb/apiprint.h

r331	r439
9	9	#include "mrdb.h"
10	10
11		mrb_value mrb_debug_eval(mrb_state, mrb_debug_context, const char, size_t, mrb_bool);
	11	mrb_value mrb_debug_eval(mrb_state, mrb_debug_context, const char, size_t, mrb_bool, int);
12	12
13	13	#endif /* APIPRINT_H_ */

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-bin-debugger/tools/mrdb/cmdbreak.c

-              r331
+              r439
 mrb_debug_bptype
 parse_breakcommand(mrdb_state *mrdb, const char **file, uint32_t *line, char **cname, char **method)
+parse_breakcommand(mrb_state *mrb, mrdb_state *mrdb, const char **file, uint32_t *line, char **cname, char **method)
+{
   mrb_debug_context *dbg = mrdb->dbg;
 …
       if (l <= 65535) {
         *line = l;
         *file = (body == args)? mrb_debug_get_filename(dbg->irep, (uint32_t)(dbg->pc - dbg->irep->iseq)): args;
+        *file = (body == args)? mrb_debug_get_filename(mrb, dbg->irep, dbg->pc - dbg->irep->iseq): args;
+      }
       else {
 …
   int32_t ret;
   type = parse_breakcommand(mrdb, &file, &line, &cname, &method);
+  type = parse_breakcommand(mrb, mrdb, &file, &line, &cname, &method);
   switch (type) {
     case MRB_DEBUG_BPTYPE_LINE:

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-bin-debugger/tools/mrdb/cmdmisc.c

-              r331
+              r439
     "Status of specified breakpoints (all user-settable breakpoints if no argument).\n"
     "Arguments are breakpoint numbers with spaces in between.\n"
+  },
+  {
+    "i[nfo]", "l[ocals]", "Print name of local variables",
+    "Usage: info locals\n"
+    "\n"
+    "Print name of local variables.\n"
   },
+  {
 …
 listcmd_parser_state_new(mrb_state *mrb)
+{
   listcmd_parser_state *st = mrb_malloc(mrb, sizeof(listcmd_parser_state));
+  listcmd_parser_state *st = (listcmd_parser_state*)mrb_malloc(mrb, sizeof(listcmd_parser_state));
   memset(st, 0, sizeof(listcmd_parser_state));
   return st;
 …
   if (len > 0) {
     st->filename = mrb_malloc(mrb, len + 1);
+    st->filename = (char*)mrb_malloc(mrb, len + 1);
     strncpy(st->filename, *sp, len);
     st->filename[len] = '\0';
 …
+{
   size_t len;
+  char *p, *s;
+  const char *p;
+  char *s;
   if (filename == NULL) {
 …
+  }
   s = mrb_malloc(mrb, len + strlen(ext) + 1);
+  s = (char*)mrb_malloc(mrb, len + strlen(ext) + 1);
   memset(s, '\0', len + strlen(ext) + 1);
   strncpy(s, filename, len);
 …
 check_cmd_pattern(const char *pattern, const char *cmd)
+{
   char *lbracket, *rbracket, *p, *q;
+  const char *lbracket, *rbracket, *p, *q;
   if (pattern == NULL && cmd == NULL) {
 …
   if (mrdb->dbg->xm == DBG_QUIT) {
     struct RClass *exc;
     exc = mrb_define_class(mrb, "DebuggerExit", mrb_class_get(mrb, "Exception"));
+    exc = mrb_define_class(mrb, "DebuggerExit", mrb->eException_class);
     mrb_raise(mrb, exc, "Exit mrdb.");
+  }

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-bin-debugger/tools/mrdb/cmdprint.c

-              r331
+              r439
   mrb_value expr;
   mrb_value result;
-  mrb_value s;
   uint8_t wcnt;
   int ai;
 …
+  }
   result = mrb_debug_eval(mrb, mrdb->dbg, RSTRING_PTR(expr), RSTRING_LEN(expr), NULL);
+  result = mrb_debug_eval(mrb, mrdb->dbg, RSTRING_PTR(expr), RSTRING_LEN(expr), NULL, 0);
   /* $print_no = result */
+  s = mrb_str_cat_lit(mrb, result, "\0");
+  printf("$%lu = %s\n", (unsigned long)mrdb->print_no++, RSTRING_PTR(s));
+  printf("$%lu = ", (unsigned long)mrdb->print_no++);
+  fwrite(RSTRING_PTR(result), RSTRING_LEN(result), 1, stdout);
+  putc('\n', stdout);
   if (mrdb->print_no == 0) {
 …
   return dbgcmd_print(mrb, mrdb);
+}
+dbgcmd_state
+dbgcmd_info_local(mrb_state *mrb, mrdb_state *mrdb)
+{
+  mrb_value result;
+  mrb_value s;
+  int ai;
+  ai = mrb_gc_arena_save(mrb);
+  result = mrb_debug_eval(mrb, mrdb->dbg, "local_variables", 0, NULL, 1);
+  s = mrb_str_cat_lit(mrb, result, "\0");
+  printf("$%lu = %s\n", (unsigned long)mrdb->print_no++, RSTRING_PTR(s));
+  if (mrdb->print_no == 0) {
+    mrdb->print_no = 1;
+  }
+  mrb_gc_arena_restore(mrb, ai);
+  return DBGST_PROMPT;
+}

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-bin-debugger/tools/mrdb/cmdrun.c

r331	r439
20	20	struct RClass *exc;
21	21	puts("Start it from the beginning.");
22		exc = mrb_define_class(mrb, "DebuggerRestart", mrb~~_class_get(mrb, "Exception")~~);
	22	exc = mrb_define_class(mrb, "DebuggerRestart", mrb->eException_class);
23	23	mrb_raise(mrb, exc, "Restart mrdb.");
24	24	}

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-bin-debugger/tools/mrdb/mrdb.c

-              r331
+              r439
 #include <stdlib.h>
 #include <string.h>
-#include <stdio.h>
 #include <ctype.h>
 …
   {"help",      NULL,           1, 0, 1, DBGCMD_HELP,           dbgcmd_help},            /* h[elp] */
   {"info",      "breakpoints",  1, 1, 1, DBGCMD_INFO_BREAK,     dbgcmd_info_break},      /* i[nfo] b[reakpoints] */
+  {"info",      "locals",       1, 1, 0, DBGCMD_INFO_LOCAL,     dbgcmd_info_local},      /* i[nfo] l[ocals] */
   {"list",      NULL,           1, 0, 1, DBGCMD_LIST,           dbgcmd_list},            /* l[ist] */
   {"print",     NULL,           1, 0, 0, DBGCMD_PRINT,          dbgcmd_print},           /* p[rint] */
 …
 mrb_debug_context_new(mrb_state *mrb)
+{
   mrb_debug_context *dbg = mrb_malloc(mrb, sizeof(mrb_debug_context));
+  mrb_debug_context *dbg = (mrb_debug_context*)mrb_malloc(mrb, sizeof(mrb_debug_context));
   memset(dbg, 0, sizeof(mrb_debug_context));
 …
 mrdb_state_new(mrb_state *mrb)
+{
   mrdb_state *mrdb = mrb_malloc(mrb, sizeof(mrdb_state));
+  mrdb_state *mrdb = (mrdb_state*)mrb_malloc(mrb, sizeof(mrdb_state));
   memset(mrdb, 0, sizeof(mrdb_state));
   mrdb->dbg = mrb_debug_context_get(mrb);
   mrdb->command = mrb_malloc(mrb, MAX_COMMAND_LINE+1);
+  mrdb->command = (char*)mrb_malloc(mrb, MAX_COMMAND_LINE+1);
   mrdb->print_no = 1;
 …
 static int32_t
 check_method_breakpoint(mrb_state *mrb, mrb_irep *irep, mrb_code *pc, mrb_value *regs)
+check_method_breakpoint(mrb_state *mrb, mrb_irep *irep, const mrb_code *pc, mrb_value *regs)
+{
   struct RClass* c;
 …
   int32_t bpno;
   mrb_bool isCfunc;
+  struct mrb_insn_data insn;
   mrb_debug_context *dbg = mrb_debug_context_get(mrb);
 …
   dbg->method_bpno = 0;
+  switch(GET_OPCODE(*pc)) {
+  insn = mrb_decode_insn(pc);
+  switch(insn.insn) {
     case OP_SEND:
     case OP_SENDB:
       c = mrb_class(mrb, regs[GETARG_A(*pc)]);
       sym = irep->syms[GETARG_B(*pc)];
+      c = mrb_class(mrb, regs[insn.a]);
+      sym = irep->syms[insn.b];
       break;
     case OP_SUPER:
 …
 static void
 mrb_code_fetch_hook(mrb_state *mrb, mrb_irep *irep, mrb_code *pc, mrb_value *regs)
+mrb_code_fetch_hook(mrb_state *mrb, mrb_irep *irep, const mrb_code *pc, mrb_value *regs)
+{
   const char *file;
 …
+  }
   file = mrb_debug_get_filename(irep, (uint32_t)(pc - irep->iseq));
   line = mrb_debug_get_line(irep, (uint32_t)(pc - irep->iseq));
+  file = mrb_debug_get_filename(mrb, irep, pc - irep->iseq);
+  line = mrb_debug_get_line(mrb, irep, pc - irep->iseq);
   switch (dbg->xm) {

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-bin-debugger/tools/mrdb/mrdb.h

-              r331
+              r439
   DBGCMD_BREAK,
   DBGCMD_INFO_BREAK,
+  DBGCMD_INFO_LOCAL,
   DBGCMD_WATCH,
   DBGCMD_INFO_WATCH,
 …
   struct mrb_irep *root_irep;
   struct mrb_irep *irep;
   mrb_code *pc;
+  const mrb_code *pc;
   mrb_value *regs;
 …
 dbgcmd_state dbgcmd_break(mrb_state*, mrdb_state*);
 dbgcmd_state dbgcmd_info_break(mrb_state*, mrdb_state*);
+dbgcmd_state dbgcmd_info_local(mrb_state*, mrdb_state*);
 dbgcmd_state dbgcmd_delete(mrb_state*, mrdb_state*);
 dbgcmd_state dbgcmd_enable(mrb_state*, mrdb_state*);

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-bin-debugger/tools/mrdb/mrdbconf.h

-              r321
+              r439
 #ifndef MRDBCONF_H
 #define MRDBCONF_H
+#ifndef MRB_ENABLE_DEBUG_HOOK
+# error mruby-bin-debugger need 'MRB_ENABLE_DEBUG_HOOK' configuration in your 'build_config.rb'
+#endif
+#ifdef MRB_DISABLE_STDIO
+# error mruby-bin-debugger conflicts 'MRB_DISABLE_STDIO' configuration in your 'build_config.rb'
+#endif
 /* configuration options: */

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-bin-mirb/bintest/mirb.rb

-              r321
+              r439
   assert_true o.include?('=> 3')
 end
+assert('mirb -d option') do
+  o, _ = Open3.capture2('bin/mirb', :stdin_data => "$DEBUG\n")
+  assert_true o.include?('=> false')
+  o, _ = Open3.capture2('bin/mirb -d', :stdin_data => "$DEBUG\n")
+  assert_true o.include?('=> true')
+end
+assert('mirb -r option') do
+  lib = Tempfile.new('lib.rb')
+  lib.write <<EOS
+class Hoge
+  def hoge
+    :hoge
+  end
+end
+EOS
+  lib.flush
+  o, _ = Open3.capture2("bin/mirb -r #{lib.path}", :stdin_data => "Hoge.new.hoge\n")
+  assert_true o.include?('=> :hoge')
+end

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-bin-mirb/tools/mirb/mirb.c

-              r331
+              r439
 */
+#include <mruby.h>
+#ifdef MRB_DISABLE_STDIO
+# error mruby-bin-mirb conflicts 'MRB_DISABLE_STDIO' configuration in your 'build_config.rb'
+#endif
+#include <mruby/array.h>
+#include <mruby/proc.h>
+#include <mruby/compile.h>
+#include <mruby/dump.h>
+#include <mruby/string.h>
+#include <mruby/variable.h>
+#include <mruby/throw.h>
 #include <stdlib.h>
 #include <string.h>
-#include <stdio.h>
 #include <ctype.h>
 …
 #define MIRB_ADD_HISTORY(line) add_history(line)
 #define MIRB_READLINE(ch) readline(ch)
+#if !defined(RL_READLINE_VERSION) || RL_READLINE_VERSION < 0x600
+/* libedit & older readline do not have rl_free() */
+#define MIRB_LINE_FREE(line) free(line)
+#else
+#define MIRB_LINE_FREE(line) rl_free(line)
+#endif
 #define MIRB_WRITE_HISTORY(path) write_history(path)
 #define MIRB_READ_HISTORY(path) read_history(path)
 …
 #define MIRB_ADD_HISTORY(line) linenoiseHistoryAdd(line)
 #define MIRB_READLINE(ch) linenoise(ch)
+#define MIRB_LINE_FREE(line) linenoiseFree(line)
 #define MIRB_WRITE_HISTORY(path) linenoiseHistorySave(path)
 #define MIRB_READ_HISTORY(path) linenoiseHistoryLoad(history_path)
 …
 #define SIGJMP_BUF jmp_buf
 #endif
-#include <mruby.h>
-#include <mruby/array.h>
-#include <mruby/proc.h>
-#include <mruby/compile.h>
-#include <mruby/string.h>
 #ifdef ENABLE_READLINE
 …
+{
   mrb_value val;
+  char* msg;
   val = mrb_funcall(mrb, obj, "inspect", 0);
 …
     val = mrb_obj_as_string(mrb, obj);
+  }
+  fwrite(RSTRING_PTR(val), RSTRING_LEN(val), 1, stdout);
+  msg = mrb_locale_from_utf8(RSTRING_PTR(val), (int)RSTRING_LEN(val));
+  fwrite(msg, strlen(msg), 1, stdout);
+  mrb_locale_free(msg);
   putc('\n', stdout);
+}
 …
   /* check for heredoc */
   if (parser->parsing_heredoc != NULL) return TRUE;
-  if (parser->heredoc_end_now) {
-    parser->heredoc_end_now = FALSE;
-    return FALSE;
+  }
   /* check for unterminated string */
 …
   FILE *rfp;
   mrb_bool verbose      : 1;
+  mrb_bool debug        : 1;
   int argc;
   char** argv;
+  int libc;
+  char **libv;
 };
 …
   static const char *const usage_msg[] = {
   "switches:",
+  "-d           set $DEBUG to true (same as `mruby -d`)",
+  "-r library   same as `mruby -r`",
   "-v           print version number, then run in verbose mode",
   "--verbose    run in verbose mode",
 …
   const char *const *p = usage_msg;
   printf("Usage: %s [switches]\n", name);
+  printf("Usage: %s [switches] [programfile] [arguments]\n", name);
   while (*p)
     printf("  %s\n", *p++);
+}
+static char *
+dup_arg_item(mrb_state *mrb, const char *item)
+{
+  size_t buflen = strlen(item) + 1;
+  char *buf = (char*)mrb_malloc(mrb, buflen);
+  memcpy(buf, item, buflen);
+  return buf;
+}
 static int
 parse_args(mrb_state *mrb, int argc, char **argv, struct _args *args)
+{
+  char **origargv = argv;
   static const struct _args args_zero = { 0 };
 …
     item = argv[0] + 1;
     switch (*item++) {
+    case 'd':
+      args->debug = TRUE;
+      break;
+    case 'r':
+      if (!item[0]) {
+        if (argc <= 1) {
+          printf("%s: No library specified for -r\n", *origargv);
+          return EXIT_FAILURE;
+        }
+        argc--; argv++;
+        item = argv[0];
+      }
+      if (args->libc == 0) {
+        args->libv = (char**)mrb_malloc(mrb, sizeof(char*));
+      }
+      else {
+        args->libv = (char**)mrb_realloc(mrb, args->libv, sizeof(char*) * (args->libc + 1));
+      }
+      args->libv[args->libc++] = dup_arg_item(mrb, item);
+      break;
     case 'v':
       if (!args->verbose) mrb_show_version(mrb);
 …
     fclose(args->rfp);
   mrb_free(mrb, args->argv);
+  if (args->libc) {
+    while (args->libc--) {
+      mrb_free(mrb, args->libv[args->libc]);
+    }
+    mrb_free(mrb, args->libv);
+  }
   mrb_close(mrb);
+}
 …
   /* skip preceding spaces */
   while (*p && isspace((unsigned char)*p)) {
+  while (*p && ISSPACE(*p)) {
     p++;
+  }
 …
   /* skip trailing spaces */
   while (*p) {
     if (!isspace((unsigned char)*p)) return 0;
+    if (!ISSPACE(*p)) return 0;
     p++;
+  }
 …
+{
   MIRB_SIGLONGJMP(ctrl_c_buf, 1);
+}
+#endif
+#ifndef DISABLE_MIRB_UNDERSCORE
+void decl_lv_underscore(mrb_state *mrb, mrbc_context *cxt)
+{
+  struct RProc *proc;
+  struct mrb_parser_state *parser;
+  parser = mrb_parse_string(mrb, "_=nil", cxt);
+  if (parser == NULL) {
+    fputs("create parser state error\n", stderr);
+    mrb_close(mrb);
+    exit(EXIT_FAILURE);
+  }
+  proc = mrb_generate_code(mrb, parser);
+  mrb_vm_run(mrb, proc, mrb_top_self(mrb), 0);
+  mrb_parser_free(parser);
+}
 #endif
 …
+  }
   mrb_define_global_const(mrb, "ARGV", ARGV);
+  mrb_gv_set(mrb, mrb_intern_lit(mrb, "$DEBUG"), mrb_bool_value(args.debug));
 #ifdef ENABLE_READLINE
 …
   cxt = mrbc_context_new(mrb);
+#ifndef DISABLE_MIRB_UNDERSCORE
+  decl_lv_underscore(mrb, cxt);
+#endif
+  /* Load libraries */
+  for (i = 0; i < args.libc; i++) {
+    FILE *lfp = fopen(args.libv[i], "r");
+    if (lfp == NULL) {
+      printf("Cannot open library file. (%s)\n", args.libv[i]);
+      cleanup(mrb, &args);
+      return EXIT_FAILURE;
+    }
+    mrb_load_file_cxt(mrb, lfp, cxt);
+    fclose(lfp);
+  }
   cxt->capture_errors = TRUE;
   cxt->lineno = 1;
 …
   while (TRUE) {
     char *utf8;
+    struct mrb_jmpbuf c_jmp;
+    MRB_TRY(&c_jmp);
+    mrb->jmp = &c_jmp;
     if (args.rfp) {
       if (fgets(last_code_line, sizeof(last_code_line)-1, args.rfp) != NULL)
 …
     strcat(last_code_line, "\n");
     MIRB_ADD_HISTORY(line);
+    free(line);
+#endif
+done:
+    MIRB_LINE_FREE(line);
+#endif
+  done:
     if (code_block_open) {
       if (strlen(ruby_code)+strlen(last_code_line) > sizeof(ruby_code)-1) {
 …
+    }
     else {
+      if (0 < parser->nwarn) {
+        /* warning */
+        char* msg = mrb_locale_from_utf8(parser->warn_buffer[0].message, -1);
+        printf("line %d: %s\n", parser->warn_buffer[0].lineno, msg);
+        mrb_locale_free(msg);
+      }
       if (0 < parser->nerr) {
         /* syntax error */
+        printf("line %d: %s\n", parser->error_buffer[0].lineno, parser->error_buffer[0].message);
+        char* msg = mrb_locale_from_utf8(parser->error_buffer[0].message, -1);
+        printf("line %d: %s\n", parser->error_buffer[0].lineno, msg);
+        mrb_locale_free(msg);
+      }
       else {
 …
         if (args.verbose) {
           mrb_codedump_all(mrb, proc);
+        }
+        /* adjust stack length of toplevel environment */
+        if (mrb->c->cibase->env) {
+          struct REnv *e = mrb->c->cibase->env;
+          if (e && MRB_ENV_STACK_LEN(e) < proc->body.irep->nlocals) {
+            MRB_ENV_SET_STACK_LEN(e, proc->body.irep->nlocals);
+          }
+        }
         /* pass a proc for evaluation */
 …
+          }
           p(mrb, result, 1);
+#ifndef DISABLE_MIRB_UNDERSCORE
+          *(mrb->c->stack + 1) = result;
+#endif
+        }
+      }
 …
     mrb_parser_free(parser);
     cxt->lineno++;
+    MRB_CATCH(&c_jmp) {
+      p(mrb, mrb_obj_value(mrb->exc), 0);
+      mrb->exc = 0;
+    }
+    MRB_END_EXC(&c_jmp);
+  }
 …
 #endif
+  if (args.rfp) fclose(args.rfp);
+  mrb_free(mrb, args.argv);
+  if (args.libv) {
+    for (i = 0; i < args.libc; ++i) {
+      mrb_free(mrb, args.libv[i]);
+    }
+    mrb_free(mrb, args.libv);
+  }
   mrbc_context_free(mrb, cxt);
   mrb_close(mrb);

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-bin-mrbc/mrbgem.rake

r321	r439
9	9	mrbc_objs = Dir.glob("#{spec.dir}/tools/mrbc/*.c").map { \|f\| objfile(f.pathmap("#{spec.build_dir}/tools/mrbc/%n")) }.flatten
10	10
11		file exec => mrbc_objs + [~~libfile("#{build.build_dir}/lib/libmruby_core")~~] do \|t\|
	11	file exec => mrbc_objs + [build.libmruby_core_static] do \|t\|
12	12	build.linker.run t.name, t.prerequisites
13	13	end

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-bin-mrbc/tools/mrbc/mrbc.c

-              r331
+              r439
+#include <stdio.h>
+#include <mruby.h>
+#ifdef MRB_DISABLE_STDIO
+# error mruby-bin-mrbc conflicts 'MRB_DISABLE_STDIO' configuration in your 'build_config.rb'
+#endif
 #include <stdlib.h>
 #include <string.h>
-#include <mruby.h>
 #include <mruby/compile.h>
 #include <mruby/dump.h>
 …
   mrb_bool check_syntax : 1;
   mrb_bool verbose      : 1;
+  mrb_bool remove_lv    : 1;
   unsigned int flags    : 4;
 };
 …
   "-e           generate little endian iseq data",
   "-E           generate big endian iseq data",
+  "--remove-lv  remove local variables",
   "--verbose    run at verbose mode",
   "--version    print the version",
 …
 parse_args(mrb_state *mrb, int argc, char **argv, struct mrbc_args *args)
+{
-  char *outfile = NULL;
   static const struct mrbc_args args_zero = { 0 };
   int i;
 …
         if (args->outfile) {
           fprintf(stderr, "%s: an output file is already specified. (%s)\n",
                   args->prog, outfile);
+                  args->prog, args->outfile);
           return -1;
+        }
 …
           exit(EXIT_SUCCESS);
+        }
+        else if (strcmp(argv[i] + 2, "remove-lv") == 0) {
+          args->remove_lv = TRUE;
+          break;
+        }
         return -1;
       default:
 …
+  }
   fn = args->argv[args->idx++];
   p->f = fopen(fn, "r");
+  p->f = fopen(fn, "rb");
   if (p->f == NULL) {
     fprintf(stderr, "%s: cannot open program file. (%s)\n", args->prog, fn);
 …
   else {
     need_close = TRUE;
     if ((infile = fopen(input, "r")) == NULL) {
+    if ((infile = fopen(input, "rb")) == NULL) {
       fprintf(stderr, "%s: cannot open program file. (%s)\n", args->prog, input);
       return mrb_nil_value();
 …
   mrb_irep *irep = proc->body.irep;
+  if (args->remove_lv) {
+    mrb_irep_remove_lv(mrb, irep);
+  }
   if (args->initname) {
     n = mrb_dump_irep_cfunc(mrb, irep, args->flags, wfp, args->initname);

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-bin-mruby/bintest/mruby.rb

-              r331
+              r439
 require 'tempfile'
+require 'open3'
+def assert_mruby(exp_out, exp_err, exp_success, args)
+  out, err, stat = Open3.capture3(cmd("mruby"), *args)
+  assert "assert_mruby" do
+    assert_operator(exp_out, :===, out, "standard output")
+    assert_operator(exp_err, :===, err, "standard error")
+    assert_equal(exp_success, stat.success?, "exit success?")
+  end
+end
 assert('regression for #1564') do
+  o = `#{cmd('mruby')} -e #{shellquote('<<')} 2>&1`
+  assert_include o, "-e:1:2: syntax error"
+  o = `#{cmd('mruby')} -e #{shellquote('<<-')} 2>&1`
+  assert_include o, "-e:1:3: syntax error"
+  assert_mruby("", /\A-e:1:2: syntax error, .*\n\z/, false, %w[-e <<])
+  assert_mruby("", /\A-e:1:3: syntax error, .*\n\z/, false, %w[-e <<-])
 end
 …
   system "#{cmd('mrbc')} -g -o #{bin.path} #{script.path}"
   o = `#{cmd('mruby')} -b #{bin.path}`.strip
   assert_equal o, '"ok"'
+  assert_equal '"ok"', o
 end
 …
   # one liner
   assert_equal '"-e"', `#{cmd('mruby')} -e #{shellquote('p $0')}`.chomp
+end
+assert 'ARGV value' do
+  assert_mruby(%{["ab", "cde"]\n}, "", true, %w[-e p(ARGV) ab cde])
+  assert_mruby("[]\n", "", true, %w[-e p(ARGV)])
+end
+assert('float literal') do
+  script, bin = Tempfile.new('test.rb'), Tempfile.new('test.mrb')
+  File.write script.path, 'p [3.21, 2e308.infinite?, -2e308.infinite?]'
+  system "#{cmd('mrbc')} -g -o #{bin.path} #{script.path}"
+  assert_equal "[3.21, 1, -1]", `#{cmd('mruby')} -b #{bin.path}`.chomp!
 end
 …
   assert_equal 0, $?.exitstatus
 end
+assert('mruby -c option') do
+  assert_mruby("Syntax OK\n", "", true, ["-c", "-e", "p 1"])
+  assert_mruby("", /\A-e:1:7: syntax error, .*\n\z/, false, ["-c", "-e", "p 1; 1."])
+end
+assert('mruby -d option') do
+  assert_mruby("false\n", "", true, ["-e", "p $DEBUG"])
+  assert_mruby("true\n", "", true, ["-dep $DEBUG"])
+end
+assert('mruby -e option (no code specified)') do
+  assert_mruby("", /\A.*: No code specified for -e\n\z/, false, %w[-e])
+end
+assert('mruby -h option') do
+  assert_mruby(/\AUsage: #{Regexp.escape cmd("mruby")} .*/m, "", true, %w[-h])
+end
+assert('mruby -r option') do
+  lib = Tempfile.new('lib.rb')
+  lib.write <<EOS
+class Hoge
+  def hoge
+    :hoge
+  end
+end
+EOS
+  lib.flush
+  script = Tempfile.new('test.rb')
+  script.write <<EOS
+print Hoge.new.hoge
+EOS
+  script.flush
+  assert_equal 'hoge', `#{cmd('mruby')} -r #{lib.path} #{script.path}`
+  assert_equal 0, $?.exitstatus
+  assert_equal 'hogeClass', `#{cmd('mruby')} -r #{lib.path} -r #{script.path} -e #{shellquote('print Hoge.class')}`
+  assert_equal 0, $?.exitstatus
+end
+assert('mruby -r option (no library specified)') do
+  assert_mruby("", /\A.*: No library specified for -r\n\z/, false, %w[-r])
+end
+assert('mruby -r option (file not found)') do
+  assert_mruby("", /\A.*: Cannot open library file: .*\n\z/, false, %w[-r _no_exists_])
+end
+assert('mruby -v option') do
+  ver_re = '\Amruby \d+\.\d+\.\d+ \(\d+-\d+-\d+\)\n'
+  assert_mruby(/#{ver_re}\z/, "", true, %w[-v])
+  assert_mruby(/#{ver_re}^[^\n]*NODE.*\n:end\n\z/m, "", true, %w[-v -e p(:end)])
+end
+assert('mruby --verbose option') do
+  assert_mruby(/\A[^\n]*NODE.*\n:end\n\z/m, "", true, %w[--verbose -e p(:end)])
+end
+assert('mruby --') do
+  assert_mruby(%{["-x", "1"]\n}, "", true, %w[-e p(ARGV) -- -x 1])
+end
+assert('mruby invalid short option') do
+  assert_mruby("", /\A.*: invalid option -1 .*\n\z/, false, %w[-1])
+end
+assert('mruby invalid long option') do
+  assert_mruby("", /\A.*: invalid option --longopt .*\n\z/, false, %w[--longopt])
+end
+assert('unhandled exception') do
+  assert_mruby("", /\bEXCEPTION\b.*\n\z/, false, %w[-e raise("EXCEPTION")])
+end
+assert('program file not found') do
+  assert_mruby("", /\A.*: Cannot open program file: .*\n\z/, false, %w[_no_exists_])
+end
+assert('codegen error') do
+  code = "def f(#{(1..100).map{|n| "a#{n}"} * ","}); end"
+  assert_mruby("", /\Acodegen error:.*\n\z/, false, ["-e", code])
+end

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-bin-mruby/mrbgem.rake

-              r331
+              r439
   spec.add_dependency('mruby-compiler', :core => 'mruby-compiler')
   spec.add_dependency('mruby-error', :core => 'mruby-error')
+  spec.add_test_dependency('mruby-print', :core => 'mruby-print')
   if build.cxx_exception_enabled?
+    @objs << build.compile_as_cxx("#{spec.dir}/tools/mruby/mruby.c", "#{spec.build_dir}/tools/mruby/mruby.cxx")
+    @objs.delete_if { |v| v == objfile("#{spec.build_dir}/tools/mruby/mruby") }
+    build.compile_as_cxx("#{spec.dir}/tools/mruby/mruby.c", "#{spec.build_dir}/tools/mruby/mruby.cxx")
   end
 end

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-bin-mruby/tools/mruby/mruby.c

-              r331
+              r439
+#include <stdio.h>
+#include <mruby.h>
+#ifdef MRB_DISABLE_STDIO
+# error mruby-bin-mruby conflicts 'MRB_DISABLE_STDIO' configuration in your 'build_config.rb'
+#endif
 #include <stdlib.h>
 #include <string.h>
-#include <mruby.h>
 #include <mruby/array.h>
 #include <mruby/compile.h>
 …
 #include <mruby/variable.h>
-#ifdef MRB_DISABLE_STDIO
-static void
-p(mrb_state *mrb, mrb_value obj)
+{
-  mrb_value val = mrb_inspect(mrb, obj);
-  fwrite(RSTRING_PTR(val), RSTRING_LEN(val), 1, stdout);
-  putc('\n', stdout);
+}
-#else
-#define p(mrb,obj) mrb_p(mrb,obj)
-#endif
 struct _args {
   FILE *rfp;
   char* cmdline;
+  char *cmdline;
   mrb_bool fname        : 1;
   mrb_bool mrbfile      : 1;
   mrb_bool check_syntax : 1;
   mrb_bool verbose      : 1;
+  mrb_bool version      : 1;
+  mrb_bool debug        : 1;
   int argc;
+  char** argv;
+  char **argv;
+  int libc;
+  char **libv;
+};
+struct options {
+  int argc;
+  char **argv;
+  char *program;
+  char *opt;
+  char short_opt[2];
 };
 …
   "-b           load and execute RiteBinary (mrb) file",
   "-c           check syntax only",
+  "-d           set debugging flags (set $DEBUG to true)",
   "-e 'command' one line of script",
+  "-r library   load the library before executing your script",
   "-v           print version number, then run in verbose mode",
   "--verbose    run in verbose mode",
 …
   const char *const *p = usage_msg;
   printf("Usage: %s [switches] programfile\n", name);
+  printf("Usage: %s [switches] [programfile] [arguments]\n", name);
   while (*p)
     printf("  %s\n", *p++);
+}
+static void
+options_init(struct options *opts, int argc, char **argv)
+{
+  opts->argc = argc;
+  opts->argv = argv;
+  opts->program = *argv;
+  *opts->short_opt = 0;
+}
+static const char *
+options_opt(struct options *opts)
+{
+  /* concatenated short options (e.g. `-cv`) */
+  if (*opts->short_opt && *++opts->opt) {
+   short_opt:
+    opts->short_opt[0] = *opts->opt;
+    opts->short_opt[1] = 0;
+    return opts->short_opt;
+  }
+  while (++opts->argv, --opts->argc) {
+    opts->opt = *opts->argv;
+    /*  empty         || not start with `-`  || `-` */
+    if (!opts->opt[0] || opts->opt[0] != '-' || !opts->opt[1]) return NULL;
+    if (opts->opt[1] == '-') {
+      /* `--` */
+      if (!opts->opt[2]) {
+        ++opts->argv, --opts->argc;
+        return NULL;
+      }
+      /* long option */
+      opts->opt += 2;
+      *opts->short_opt = 0;
+      return opts->opt;
+    }
+    else {
+      /* short option */
+      ++opts->opt;
+      goto short_opt;
+    }
+  }
+  return NULL;
+}
+static const char *
+options_arg(struct options *opts)
+{
+  if (*opts->short_opt && opts->opt[1]) {
+    /* concatenated short option and option argument (e.g. `-rLIBRARY`) */
+    *opts->short_opt = 0;
+    return opts->opt + 1;
+  }
+  --opts->argc, ++opts->argv;
+  return opts->argc ? *opts->argv : NULL;
+}
+static char *
+dup_arg_item(mrb_state *mrb, const char *item)
+{
+  size_t buflen = strlen(item) + 1;
+  char *buf = (char*)mrb_malloc(mrb, buflen);
+  memcpy(buf, item, buflen);
+  return buf;
+}
 static int
 parse_args(mrb_state *mrb, int argc, char **argv, struct _args *args)
+{
-  char **origargv = argv;
   static const struct _args args_zero = { 0 };
+  struct options opts[1];
+  const char *opt, *item;
   *args = args_zero;
+  for (argc--,argv++; argc > 0; argc--,argv++) {
+    char *item;
+    if (argv[0][0] != '-') break;
+    if (strlen(*argv) <= 1) {
+      argc--; argv++;
+      args->rfp = stdin;
+      break;
+    }
+    item = argv[0] + 1;
+    switch (*item++) {
+    case 'b':
+  options_init(opts, argc, argv);
+  while ((opt = options_opt(opts))) {
+    if (strcmp(opt, "b") == 0) {
       args->mrbfile = TRUE;
       break;
     case 'c':
+    }
+    else if (strcmp(opt, "c") == 0) {
       args->check_syntax = TRUE;
+      break;
+    case 'e':
+      if (item[0]) {
+        goto append_cmdline;
+      }
+      else if (argc > 1) {
+        argc--; argv++;
+        item = argv[0];
+append_cmdline:
+    }
+    else if (strcmp(opt, "d") == 0) {
+      args->debug = TRUE;
+    }
+    else if (strcmp(opt, "e") == 0) {
+      if ((item = options_arg(opts))) {
         if (!args->cmdline) {
+          size_t buflen;
+          char *buf;
+          buflen = strlen(item) + 1;
+          buf = (char *)mrb_malloc(mrb, buflen);
+          memcpy(buf, item, buflen);
+          args->cmdline = buf;
+          args->cmdline = dup_arg_item(mrb, item);
+        }
         else {
 …
+      }
       else {
+        printf("%s: No code specified for -e\n", *origargv);
+        return EXIT_SUCCESS;
+      }
+      break;
+    case 'v':
+      if (!args->verbose) mrb_show_version(mrb);
+        fprintf(stderr, "%s: No code specified for -e\n", opts->program);
+        return EXIT_FAILURE;
+      }
+    }
+    else if (strcmp(opt, "h") == 0) {
+      usage(opts->program);
+      exit(EXIT_SUCCESS);
+    }
+    else if (strcmp(opt, "r") == 0) {
+      if ((item = options_arg(opts))) {
+        if (args->libc == 0) {
+          args->libv = (char**)mrb_malloc(mrb, sizeof(char*));
+        }
+        else {
+          args->libv = (char**)mrb_realloc(mrb, args->libv, sizeof(char*) * (args->libc + 1));
+        }
+        args->libv[args->libc++] = dup_arg_item(mrb, item);
+      }
+      else {
+        fprintf(stderr, "%s: No library specified for -r\n", opts->program);
+        return EXIT_FAILURE;
+      }
+    }
+    else if (strcmp(opt, "v") == 0) {
+      if (!args->verbose) {
+        mrb_show_version(mrb);
+        args->version = TRUE;
+      }
       args->verbose = TRUE;
       break;
     case '-':
       if (strcmp((*argv) + 2, "version") == 0) {
         mrb_show_version(mrb);
         exit(EXIT_SUCCESS);
+      }
       else if (strcmp((*argv) + 2, "verbose") == 0) {
         args->verbose = TRUE;
         break;
+      }
       else if (strcmp((*argv) + 2, "copyright") == 0) {
         mrb_show_copyright(mrb);
         exit(EXIT_SUCCESS);
+      }
     default:
+    }
+    else if (strcmp(opt, "version") == 0) {
+      mrb_show_version(mrb);
+      exit(EXIT_SUCCESS);
+    }
+    else if (strcmp(opt, "verbose") == 0) {
+      args->verbose = TRUE;
+    }
+    else if (strcmp(opt, "copyright") == 0) {
+      mrb_show_copyright(mrb);
+      exit(EXIT_SUCCESS);
+    }
+    else {
+      fprintf(stderr, "%s: invalid option %s%s (-h will show valid options)\n",
+              opts->program, opt[1] ? "--" : "-", opt);
       return EXIT_FAILURE;
+    }
+  }
+  if (args->rfp == NULL && args->cmdline == NULL) {
+    if (*argv == NULL) args->rfp = stdin;
+    else {
+      args->rfp = fopen(argv[0], args->mrbfile ? "rb" : "r");
+  argc = opts->argc; argv = opts->argv;
+  if (args->cmdline == NULL) {
+    if (*argv == NULL) {
+      if (args->version) exit(EXIT_SUCCESS);
+      args->rfp = stdin;
+    }
+    else {
+      args->rfp = strcmp(argv[0], "-") == 0 ?
+        stdin : fopen(argv[0], args->mrbfile ? "rb" : "r");
       if (args->rfp == NULL) {
         printf("%s: Cannot open program file. (%s)\n", *origargv, *argv);
+        fprintf(stderr, "%s: Cannot open program file: %s\n", opts->program, argv[0]);
         return EXIT_FAILURE;
+      }
 …
     mrb_free(mrb, args->cmdline);
   mrb_free(mrb, args->argv);
+  if (args->libc) {
+    while (args->libc--) {
+      mrb_free(mrb, args->libv[args->libc]);
+    }
+    mrb_free(mrb, args->libv);
+  }
   mrb_close(mrb);
+}
 …
   if (mrb == NULL) {
     fputs("Invalid mrb_state, exiting mruby\n", stderr);
+    fprintf(stderr, "%s: Invalid mrb_state, exiting mruby\n", *argv);
     return EXIT_FAILURE;
+  }
 …
   if (n == EXIT_FAILURE || (args.cmdline == NULL && args.rfp == NULL)) {
     cleanup(mrb, &args);
-    usage(argv[0]);
     return n;
+  }
 …
+    }
     mrb_define_global_const(mrb, "ARGV", ARGV);
+    mrb_gv_set(mrb, mrb_intern_lit(mrb, "$DEBUG"), mrb_bool_value(args.debug));
     c = mrbc_context_new(mrb);
 …
+    }
+    /* Load libraries */
+    for (i = 0; i < args.libc; i++) {
+      FILE *lfp = fopen(args.libv[i], args.mrbfile ? "rb" : "r");
+      if (lfp == NULL) {
+        fprintf(stderr, "%s: Cannot open library file: %s\n", *argv, args.libv[i]);
+        mrbc_context_free(mrb, c);
+        cleanup(mrb, &args);
+        return EXIT_FAILURE;
+      }
+      if (args.mrbfile) {
+        v = mrb_load_irep_file_cxt(mrb, lfp, c);
+      }
+      else {
+        v = mrb_load_file_cxt(mrb, lfp, c);
+      }
+      fclose(lfp);
+    }
     /* Load program */
     if (args.mrbfile) {
 …
     mrbc_context_free(mrb, c);
     if (mrb->exc) {
+      if (mrb_undef_p(v)) {
+        mrb_p(mrb, mrb_obj_value(mrb->exc));
+      }
+      else {
+      if (!mrb_undef_p(v)) {
         mrb_print_error(mrb);
+      }
       n = -1;
+      n = EXIT_FAILURE;
+    }
     else if (args.check_syntax) {
       printf("Syntax OK\n");
+      puts("Syntax OK");
+    }
+  }
   cleanup(mrb, &args);
   return n == 0 ? EXIT_SUCCESS : EXIT_FAILURE;
+}
+  return n;
+}

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-bin-strip/bintest/mruby-strip.rb

-              r321
+              r439
   `#{cmd('mruby-strip')} -l #{without_lv.path}`
   assert_true without_lv.size < with_lv.size
   assert_equal '[:a, :b]', `#{cmd('mruby')} -b #{with_lv.path}`.chomp
   assert_equal '[]', `#{cmd('mruby')} -b #{without_lv.path}`.chomp
+#
+#  assert_equal '[:a, :b]', `#{cmd('mruby')} -b #{with_lv.path}`.chomp
+#  assert_equal '[]', `#{cmd('mruby')} -b #{without_lv.path}`.chomp
 end

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-bin-strip/tools/mruby-strip/mruby-strip.c

-              r331
+              r439
+#include <stdio.h>
+#include <mruby.h>
+#ifdef MRB_DISABLE_STDIO
+# error mruby-bin-strip conflicts 'MRB_DISABLE_STDIO' configuration in your 'build_config.rb'
+#endif
 #include <stdlib.h>
 #include <string.h>
-#include <mruby.h>
 #include <mruby/irep.h>
 #include <mruby/dump.h>
 …
   mrb_bool lvar;
 };
-static void
-irep_remove_lv(mrb_state *mrb, mrb_irep *irep)
+{
-  size_t i;
-  if (irep->lv) {
-    mrb_free(mrb, irep->lv);
-    irep->lv = NULL;
+  }
-  for (i = 0; i < irep->rlen; ++i) {
-    irep_remove_lv(mrb, irep->reps[i]);
+  }
+}
 static void
 …
     /* clear lv if --lvar is enabled */
     if (args->lvar) {
       irep_remove_lv(mrb, irep);
+      mrb_irep_remove_lv(mrb, irep);
+    }

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-class-ext/src/class.c

-              r331
+              r439
 mrb_mod_name(mrb_state *mrb, mrb_value self)
+{
+  mrb_value name = mrb_class_path(mrb, mrb_class_ptr(self));
+  return mrb_nil_p(name)? name : mrb_str_dup(mrb, name);
+  mrb_value name =  mrb_class_path(mrb, mrb_class_ptr(self));
+  if (mrb_string_p(name)) {
+    MRB_SET_FROZEN_FLAG(mrb_basic_ptr(name));
+  }
+  return name;
+}
+static mrb_value
+mrb_mod_singleton_class_p(mrb_state *mrb, mrb_value self)
+{
+  return mrb_bool_value(mrb_sclass_p(self));
+}
+/*
+ *  call-seq:
+ *     module_exec(arg...) {|var...| block } -> obj
+ *     class_exec(arg...) {|var...| block } -> obj
+ *
+ * Evaluates the given block in the context of the
+ * class/module. The method defined in the block will belong
+ * to the receiver. Any arguments passed to the method will be
+ * passed to the block. This can be used if the block needs to
+ * access instance variables.
+ *
+ *     class Thing
+ *     end
+ *     Thing.class_exec{
+ *       def hello() "Hello there!" end
+ *     }
+ *     puts Thing.new.hello()
+ */
+static mrb_value
+mrb_mod_module_exec(mrb_state *mrb, mrb_value self)
+{
+  const mrb_value *argv;
+  mrb_int argc;
+  mrb_value blk;
+  mrb_get_args(mrb, "*&!", &argv, &argc, &blk);
+  mrb->c->ci->target_class = mrb_class_ptr(self);
+  return mrb_yield_cont(mrb, blk, self, argc, argv);
+}
 …
   mrb_define_method(mrb, mod, "name", mrb_mod_name, MRB_ARGS_NONE());
+  mrb_define_method(mrb, mod, "singleton_class?", mrb_mod_singleton_class_p, MRB_ARGS_NONE());
+  mrb_define_method(mrb, mod, "module_exec", mrb_mod_module_exec, MRB_ARGS_ANY()|MRB_ARGS_BLOCK());
+  mrb_define_method(mrb, mod, "class_exec", mrb_mod_module_exec, MRB_ARGS_ANY()|MRB_ARGS_BLOCK());
+}

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-class-ext/test/module.rb

-              r331
+              r439
+assert 'Module#<' do
+  a = Class.new
+  b = Class.new(a)
+  c = Class.new(a)
+  d = Module.new
+  e = Class.new { include d }
+  f = Module.new { include d }
+  # compare class to class
+  assert_true b < a
+  assert_false b < b
+  assert_false a < b
+  assert_nil c < b
+  # compare class to module
+  assert_true e < d
+  assert_false d < e
+  assert_nil a < d
+  # compare module to module
+  assert_true f < d
+  assert_false f < f
+  assert_false d < f
+  assert_raise(TypeError) { a < Object.new }
+end
+assert 'Module#<=' do
+  a = Class.new
+  b = Class.new(a)
+  c = Class.new(a)
+  d = Module.new
+  e = Class.new { include d }
+  f = Module.new { include d }
+  # compare class to class
+  assert_true b <= a
+  assert_true b <= b
+  assert_false a <= b
+  assert_nil c <= b
+  # compare class to module
+  assert_true e <= d
+  assert_false d <= e
+  assert_nil a <= d
+  # compare module to module
+  assert_true f <= d
+  assert_true f <= f
+  assert_false d <= f
+  assert_raise(TypeError) { a <= Object.new }
+end
 assert 'Module#name' do
+  module A
+    class B
+  module Outer
+    class Inner; end
+    const_set :SetInner, Class.new
+  end
+  assert_equal 'Outer', Outer.name
+  assert_equal 'Outer::Inner', Outer::Inner.name
+  assert_equal 'Outer::SetInner', Outer::SetInner.name
+  outer = Module.new do
+    const_set :SetInner, Class.new
+  end
+  Object.const_set :SetOuter, outer
+  assert_equal 'SetOuter', SetOuter.name
+  assert_equal 'SetOuter::SetInner', SetOuter::SetInner.name
+  mod = Module.new
+  cls = Class.new
+  assert_nil mod.name
+  assert_nil cls.name
+end
+assert 'Module#singleton_class?' do
+  mod = Module.new
+  cls = Class.new
+  scl = (class <<cls; self; end)
+  assert_false mod.singleton_class?
+  assert_false cls.singleton_class?
+  assert_true scl.singleton_class?
+end
+assert 'Module#module_eval' do
+  mod = Module.new
+  mod.class_exec(1,2,3) do |a,b,c|
+    assert_equal([1,2,3], [a,b,c])
+    def hi
+      "hi"
     end
   end
+  assert_nil A::B.singleton_class.name
+  assert_equal 'Fixnum', Fixnum.name
+  assert_equal 'A::B', A::B.name
+  cls = Class.new
+  cls.class_exec(42) do |x|
+    assert_equal(42, x)
+    include mod
+    def hello
+      "hello"
+    end
+  end
+  obj = cls.new
+  assert_equal("hi", obj.hi)
+  assert_equal("hello", obj.hello)
 end

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-compiler/core/codegen.c

-              r331
+              r439
 #include <stdlib.h>
 #include <string.h>
+#include <math.h>
 #include <mruby.h>
 #include <mruby/compile.h>
 …
 #endif
+#define MAXARG_S (1<<16)
 typedef mrb_ast_node node;
 typedef struct mrb_parser_state parser_state;
 …
 struct loopinfo {
   enum looptype type;
   int pc1, pc2, pc3, acc;
+  int pc0, pc1, pc2, pc3, acc;
   int ensure_level;
   struct loopinfo *prev;
 …
   node *lv;
+  int sp;
+  int pc;
+  int lastlabel;
+  uint16_t sp;
+  uint16_t pc;
+  uint16_t lastpc;
+  uint16_t lastlabel;
   int ainfo:15;
   mrb_bool mscope:1;
 …
   struct loopinfo *loop;
   int ensure_level;
   char const *filename;
+  mrb_sym filename_sym;
   uint16_t lineno;
   mrb_code *iseq;
   uint16_t *lines;
   int icapa;
+  uint32_t icapa;
   mrb_irep *irep;
+  size_t pcapa;
+  size_t scapa;
+  size_t rcapa;
+  uint32_t pcapa, scapa, rcapa;
   uint16_t nlocals;
 …
     codegen_scope *tmp = s->prev;
     mrb_free(s->mrb, s->iseq);
+    mrb_free(s->mrb, s->lines);
     mrb_pool_close(s->mpool);
     s = tmp;
+  }
 #ifndef MRB_DISABLE_STDIO
+  if (s->filename && s->lineno) {
+    fprintf(stderr, "codegen error:%s:%d: %s\n", s->filename, s->lineno, message);
+  if (s->filename_sym && s->lineno) {
+    const char *filename = mrb_sym_name_len(s->mrb, s->filename_sym, NULL);
+    fprintf(stderr, "codegen error:%s:%d: %s\n", filename, s->lineno, message);
+  }
   else {
 …
 static void*
-codegen_malloc(codegen_scope *s, size_t len)
+{
-  void *p = mrb_malloc_simple(s->mrb, len);
-  if (!p) codegen_error(s, "mrb_malloc");
-  return p;
+}
-static void*
 codegen_realloc(codegen_scope *s, void *p, size_t len)
+{
 …
 new_label(codegen_scope *s)
+{
+  s->lastlabel = s->pc;
+  return s->pc;
+}
+static inline int
+genop(codegen_scope *s, mrb_code i)
+{
+  if (s->pc == s->icapa) {
+  return s->lastlabel = s->pc;
+}
+static void
+emit_B(codegen_scope *s, uint32_t pc, uint8_t i)
+{
+  if (pc >= MAXARG_S || s->icapa >= MAXARG_S) {
+    codegen_error(s, "too big code block");
+  }
+  if (pc >= s->icapa) {
     s->icapa *= 2;
+    if (s->icapa > MAXARG_S) {
+      s->icapa = MAXARG_S;
+    }
     s->iseq = (mrb_code *)codegen_realloc(s, s->iseq, sizeof(mrb_code)*s->icapa);
     if (s->lines) {
+      s->lines = (uint16_t*)codegen_realloc(s, s->lines, sizeof(short)*s->icapa);
+      s->irep->lines = s->lines;
+    }
+  }
+  s->iseq[s->pc] = i;
+      s->lines = (uint16_t*)codegen_realloc(s, s->lines, sizeof(uint16_t)*s->icapa);
+    }
+  }
   if (s->lines) {
+    s->lines[s->pc] = s->lineno;
+  }
+  return s->pc++;
+    if (s->lineno > 0 || pc == 0)
+      s->lines[pc] = s->lineno;
+    else
+      s->lines[pc] = s->lines[pc-1];
+  }
+  s->iseq[pc] = i;
+}
+static void
+emit_S(codegen_scope *s, int pc, uint16_t i)
+{
+  uint8_t hi = i>>8;
+  uint8_t lo = i&0xff;
+  emit_B(s, pc,   hi);
+  emit_B(s, pc+1, lo);
+}
+static void
+gen_B(codegen_scope *s, uint8_t i)
+{
+  emit_B(s, s->pc, i);
+  s->pc++;
+}
+static void
+gen_S(codegen_scope *s, uint16_t i)
+{
+  emit_S(s, s->pc, i);
+  s->pc += 2;
+}
+static void
+genop_0(codegen_scope *s, mrb_code i)
+{
+  s->lastpc = s->pc;
+  gen_B(s, i);
+}
+static void
+genop_1(codegen_scope *s, mrb_code i, uint16_t a)
+{
+  s->lastpc = s->pc;
+  if (a > 0xff) {
+    gen_B(s, OP_EXT1);
+    gen_B(s, i);
+    gen_S(s, a);
+  }
+  else {
+    gen_B(s, i);
+    gen_B(s, (uint8_t)a);
+  }
+}
+static void
+genop_2(codegen_scope *s, mrb_code i, uint16_t a, uint16_t b)
+{
+  s->lastpc = s->pc;
+  if (a > 0xff && b > 0xff) {
+    gen_B(s, OP_EXT3);
+    gen_B(s, i);
+    gen_S(s, a);
+    gen_S(s, b);
+  }
+  else if (b > 0xff) {
+    gen_B(s, OP_EXT2);
+    gen_B(s, i);
+    gen_B(s, (uint8_t)a);
+    gen_S(s, b);
+  }
+  else if (a > 0xff) {
+    gen_B(s, OP_EXT1);
+    gen_B(s, i);
+    gen_S(s, a);
+    gen_B(s, (uint8_t)b);
+  }
+  else {
+    gen_B(s, i);
+    gen_B(s, (uint8_t)a);
+    gen_B(s, (uint8_t)b);
+  }
+}
+static void
+genop_3(codegen_scope *s, mrb_code i, uint16_t a, uint16_t b, uint8_t c)
+{
+  genop_2(s, i, a, b);
+  gen_B(s, c);
+}
+static void
+genop_2S(codegen_scope *s, mrb_code i, uint16_t a, uint16_t b)
+{
+  genop_1(s, i, a);
+  gen_S(s, b);
+}
+static void
+genop_W(codegen_scope *s, mrb_code i, uint32_t a)
+{
+  uint8_t a1 = (a>>16) & 0xff;
+  uint8_t a2 = (a>>8) & 0xff;
+  uint8_t a3 = a & 0xff;
+  s->lastpc = s->pc;
+  gen_B(s, i);
+  gen_B(s, a1);
+  gen_B(s, a2);
+  gen_B(s, a3);
+}
 …
+}
+static int
+genop_peep(codegen_scope *s, mrb_code i, int val)
+{
+  /* peephole optimization */
+  if (!no_optimize(s) && s->lastlabel != s->pc && s->pc > 0) {
+    mrb_code i0 = s->iseq[s->pc-1];
+    int c1 = GET_OPCODE(i);
+    int c0 = GET_OPCODE(i0);
+    switch (c1) {
+static
+mrb_bool
+on_eval(codegen_scope *s)
+{
+  if (s && s->parser && s->parser->on_eval)
+    return TRUE;
+  return FALSE;
+}
+struct mrb_insn_data
+mrb_decode_insn(const mrb_code *pc)
+{
+  struct mrb_insn_data data = { 0 };
+  mrb_code insn = READ_B();
+  uint16_t a = 0;
+  uint16_t b = 0;
+  uint8_t  c = 0;
+  switch (insn) {
+#define FETCH_Z() /* empty */
+#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
+#include "mruby/ops.h"
+#undef OPCODE
+  }
+  switch (insn) {
+  case OP_EXT1:
+    insn = READ_B();
+    switch (insn) {
+#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
+#include "mruby/ops.h"
+#undef OPCODE
+    }
+    break;
+  case OP_EXT2:
+    insn = READ_B();
+    switch (insn) {
+#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
+#include "mruby/ops.h"
+#undef OPCODE
+    }
+    break;
+  case OP_EXT3:
+    insn = READ_B();
+    switch (insn) {
+#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
+#include "mruby/ops.h"
+#undef OPCODE
+    }
+    break;
+  default:
+    break;
+  }
+  data.insn = insn;
+  data.a = a;
+  data.b = b;
+  data.c = c;
+  return data;
+}
+static struct mrb_insn_data
+mrb_last_insn(codegen_scope *s)
+{
+  if (s->pc == s->lastpc) {
+    struct mrb_insn_data data;
+    data.insn = OP_NOP;
+    return data;
+  }
+  return mrb_decode_insn(&s->iseq[s->lastpc]);
+}
+static mrb_bool
+no_peephole(codegen_scope *s)
+{
+  return no_optimize(s) || s->lastlabel == s->pc || s->pc == 0 || s->pc == s->lastpc;
+}
+static uint16_t
+genjmp(codegen_scope *s, mrb_code i, uint16_t pc)
+{
+  uint16_t pos;
+  s->lastpc = s->pc;
+  gen_B(s, i);
+  pos = s->pc;
+  gen_S(s, pc);
+  return pos;
+}
+static uint16_t
+genjmp2(codegen_scope *s, mrb_code i, uint16_t a, int pc, int val)
+{
+  uint16_t pos;
+  if (!no_peephole(s) && !val) {
+    struct mrb_insn_data data = mrb_last_insn(s);
+    if (data.insn == OP_MOVE && data.a == a) {
+      s->pc = s->lastpc;
+      a = data.b;
+    }
+  }
+  s->lastpc = s->pc;
+  if (a > 0xff) {
+    gen_B(s, OP_EXT1);
+    gen_B(s, i);
+    gen_S(s, a);
+    pos = s->pc;
+    gen_S(s, pc);
+  }
+  else {
+    gen_B(s, i);
+    gen_B(s, (uint8_t)a);
+    pos = s->pc;
+    gen_S(s, pc);
+  }
+  return pos;
+}
+static void
+gen_move(codegen_scope *s, uint16_t dst, uint16_t src, int nopeep)
+{
+  if (no_peephole(s)) {
+  normal:
+    genop_2(s, OP_MOVE, dst, src);
+    if (on_eval(s)) {
+      genop_0(s, OP_NOP);
+    }
+    return;
+  }
+  else {
+    struct mrb_insn_data data = mrb_last_insn(s);
+    switch (data.insn) {
     case OP_MOVE:
+      if (GETARG_A(i) == GETARG_B(i)) {
+        /* skip useless OP_MOVE */
+        return 0;
+      }
+      if (val) break;
+      switch (c0) {
+      case OP_MOVE:
+        if (GETARG_A(i) == GETARG_A(i0)) {
+          /* skip overriden OP_MOVE */
+          s->pc--;
+          s->iseq[s->pc] = i;
+        }
+        if (GETARG_B(i) == GETARG_A(i0) && GETARG_A(i) == GETARG_B(i0)) {
+          /* skip swapping OP_MOVE */
+          return 0;
+        }
+        if (GETARG_B(i) == GETARG_A(i0) && GETARG_A(i0) >= s->nlocals) {
+          s->pc--;
+          return genop_peep(s, MKOP_AB(OP_MOVE, GETARG_A(i), GETARG_B(i0)), val);
+        }
+        break;
+      case OP_LOADI:
+        if (GETARG_B(i) == GETARG_A(i0) && GETARG_A(i0) >= s->nlocals) {
+          s->iseq[s->pc-1] = MKOP_AsBx(OP_LOADI, GETARG_A(i), GETARG_sBx(i0));
+          return 0;
+        }
+        break;
+      case OP_ARRAY:
+      case OP_HASH:
+      case OP_RANGE:
+      case OP_AREF:
+      case OP_GETUPVAR:
+        if (GETARG_B(i) == GETARG_A(i0) && GETARG_A(i0) >= s->nlocals) {
+          s->iseq[s->pc-1] = MKOP_ABC(c0, GETARG_A(i), GETARG_B(i0), GETARG_C(i0));
+          return 0;
+        }
+        break;
+      case OP_LOADSYM:
+      case OP_GETGLOBAL:
+      case OP_GETIV:
+      case OP_GETCV:
+      case OP_GETCONST:
+      case OP_GETSPECIAL:
+      case OP_LOADL:
+      case OP_STRING:
+        if (GETARG_B(i) == GETARG_A(i0) && GETARG_A(i0) >= s->nlocals) {
+          s->iseq[s->pc-1] = MKOP_ABx(c0, GETARG_A(i), GETARG_Bx(i0));
+          return 0;
+        }
+        break;
+      case OP_SCLASS:
+        if (GETARG_B(i) == GETARG_A(i0) && GETARG_A(i0) >= s->nlocals) {
+          s->iseq[s->pc-1] = MKOP_AB(c0, GETARG_A(i), GETARG_B(i0));
+          return 0;
+        }
+        break;
+      case OP_LOADNIL:
+      case OP_LOADSELF:
+      case OP_LOADT:
+      case OP_LOADF:
+      case OP_OCLASS:
+        if (GETARG_B(i) == GETARG_A(i0) && GETARG_A(i0) >= s->nlocals) {
+          s->iseq[s->pc-1] = MKOP_A(c0, GETARG_A(i));
+          return 0;
+        }
+        break;
+      default:
+        break;
+      }
+      if (dst == src) return;             /* remove useless MOVE */
+      if (data.b == dst && data.a == src) /* skip swapping MOVE */
+        return;
+      goto normal;
+    case OP_LOADNIL: case OP_LOADSELF: case OP_LOADT: case OP_LOADF:
+    case OP_LOADI__1:
+    case OP_LOADI_0: case OP_LOADI_1: case OP_LOADI_2: case OP_LOADI_3:
+    case OP_LOADI_4: case OP_LOADI_5: case OP_LOADI_6: case OP_LOADI_7:
+      if (nopeep || data.a != src || data.a < s->nlocals) goto normal;
+      s->pc = s->lastpc;
+      genop_1(s, data.insn, dst);
       break;
+    case OP_SETIV:
+    case OP_SETCV:
+    case OP_SETCONST:
+    case OP_SETMCNST:
+    case OP_SETGLOBAL:
+      if (val) break;
+      if (c0 == OP_MOVE) {
+        if (GETARG_A(i) == GETARG_A(i0)) {
+          s->iseq[s->pc-1] = MKOP_ABx(c1, GETARG_B(i0), GETARG_Bx(i));
+          return 0;
+        }
+      }
+      break;
+    case OP_SETUPVAR:
+      if (val) break;
+      if (c0 == OP_MOVE) {
+        if (GETARG_A(i) == GETARG_A(i0)) {
+          s->iseq[s->pc-1] = MKOP_ABC(c1, GETARG_B(i0), GETARG_B(i), GETARG_C(i));
+          return 0;
+        }
+      }
+      break;
+    case OP_EPOP:
+      if (c0 == OP_EPOP) {
+        s->iseq[s->pc-1] = MKOP_A(OP_EPOP, GETARG_A(i0)+GETARG_A(i));
+        return 0;
+      }
+      break;
+    case OP_POPERR:
+      if (c0 == OP_POPERR) {
+        s->iseq[s->pc-1] = MKOP_A(OP_POPERR, GETARG_A(i0)+GETARG_A(i));
+        return 0;
+      }
+      break;
+    case OP_RETURN:
+      switch (c0) {
+      case OP_RETURN:
+        return 0;
+      case OP_MOVE:
+        if (GETARG_A(i0) >= s->nlocals) {
+          s->iseq[s->pc-1] = MKOP_AB(OP_RETURN, GETARG_B(i0), OP_R_NORMAL);
+          return 0;
+        }
+        break;
+      case OP_SETIV:
+      case OP_SETCV:
+      case OP_SETCONST:
+      case OP_SETMCNST:
+      case OP_SETUPVAR:
+      case OP_SETGLOBAL:
+        s->pc--;
+        genop_peep(s, i0, NOVAL);
+        i0 = s->iseq[s->pc-1];
+        return genop(s, MKOP_AB(OP_RETURN, GETARG_A(i0), OP_R_NORMAL));
+#if 0
+      case OP_SEND:
+        if (GETARG_B(i) == OP_R_NORMAL && GETARG_A(i) == GETARG_A(i0)) {
+          s->iseq[s->pc-1] = MKOP_ABC(OP_TAILCALL, GETARG_A(i0), GETARG_B(i0), GETARG_C(i0));
+          return;
+        }
+        break;
+#endif
+      default:
+        break;
+      }
+      break;
+    case OP_ADD:
+    case OP_SUB:
+      if (c0 == OP_LOADI) {
+        int c = GETARG_sBx(i0);
+        if (c1 == OP_SUB) c = -c;
+        if (c > 127 || c < -127) break;
+        if (0 <= c)
+          s->iseq[s->pc-1] = MKOP_ABC(OP_ADDI, GETARG_A(i), GETARG_B(i), c);
+        else
+          s->iseq[s->pc-1] = MKOP_ABC(OP_SUBI, GETARG_A(i), GETARG_B(i), -c);
+        return 0;
+      }
+    case OP_STRCAT:
+      if (c0 == OP_STRING) {
+        mrb_value v = s->irep->pool[GETARG_Bx(i0)];
+        if (mrb_string_p(v) && RSTRING_LEN(v) == 0) {
+          s->pc--;
+          return 0;
+        }
+      }
+      if (c0 == OP_LOADNIL) {
+        if (GETARG_B(i) == GETARG_A(i0)) {
+          s->pc--;
+          return 0;
+        }
+      }
+      break;
+    case OP_JMPIF:
+    case OP_JMPNOT:
+      if (c0 == OP_MOVE && GETARG_A(i) == GETARG_A(i0)) {
+        s->iseq[s->pc-1] = MKOP_AsBx(c1, GETARG_B(i0), GETARG_sBx(i));
+        return s->pc-1;
+      }
+    case OP_LOADI: case OP_LOADINEG: case OP_LOADL: case OP_LOADSYM:
+    case OP_GETGV: case OP_GETSV: case OP_GETIV: case OP_GETCV:
+    case OP_GETCONST: case OP_STRING:
+    case OP_LAMBDA: case OP_BLOCK: case OP_METHOD: case OP_BLKPUSH:
+      if (nopeep || data.a != src || data.a < s->nlocals) goto normal;
+      s->pc = s->lastpc;
+      genop_2(s, data.insn, dst, data.b);
       break;
     default:
+      goto normal;
+    }
+  }
+}
+static void
+gen_return(codegen_scope *s, uint8_t op, uint16_t src)
+{
+  if (no_peephole(s)) {
+    genop_1(s, op, src);
+  }
+  else {
+    struct mrb_insn_data data = mrb_last_insn(s);
+    if (data.insn == OP_MOVE && src == data.a) {
+      s->pc = s->lastpc;
+      genop_1(s, op, data.b);
+    }
+    else if (data.insn != OP_RETURN) {
+      genop_1(s, op, src);
+    }
+  }
+}
+static void
+gen_addsub(codegen_scope *s, uint8_t op, uint16_t dst)
+{
+  if (no_peephole(s)) {
+  normal:
+    genop_1(s, op, dst);
+    return;
+  }
+  else {
+    struct mrb_insn_data data = mrb_last_insn(s);
+    switch (data.insn) {
+    case OP_LOADI__1:
+      if (op == OP_ADD) op = OP_SUB;
+      else op = OP_ADD;
+      data.b = 1;
+      goto replace;
+    case OP_LOADI_0: case OP_LOADI_1: case OP_LOADI_2: case OP_LOADI_3:
+    case OP_LOADI_4: case OP_LOADI_5: case OP_LOADI_6: case OP_LOADI_7:
+      data.b = data.insn - OP_LOADI_0;
+      /* fall through */
+    case OP_LOADI:
+    replace:
+      if (data.b >= 128) goto normal;
+      s->pc = s->lastpc;
+      if (op == OP_ADD) {
+        genop_2(s, OP_ADDI, dst, (uint8_t)data.b);
+      }
+      else {
+        genop_2(s, OP_SUBI, dst, (uint8_t)data.b);
+      }
       break;
+    }
+  }
+  return genop(s, i);
+    default:
+      goto normal;
+    }
+  }
+}
+static int
+dispatch(codegen_scope *s, uint16_t pos0)
+{
+  uint16_t newpos;
+  s->lastlabel = s->pc;
+  newpos = PEEK_S(s->iseq+pos0);
+  emit_S(s, pos0, s->pc);
+  return newpos;
+}
 static void
+scope_error(codegen_scope *s)
+{
+  exit(EXIT_FAILURE);
+}
+static inline void
+dispatch(codegen_scope *s, int pc)
+{
+  int diff = s->pc - pc;
+  mrb_code i = s->iseq[pc];
+  int c = GET_OPCODE(i);
+  s->lastlabel = s->pc;
+  switch (c) {
+  case OP_JMP:
+  case OP_JMPIF:
+  case OP_JMPNOT:
+  case OP_ONERR:
+    break;
+  default:
+#ifndef MRB_DISABLE_STDIO
+    fprintf(stderr, "bug: dispatch on non JMP op\n");
+#endif
+    scope_error(s);
+    break;
+  }
+  if (diff > MAXARG_sBx) {
+    codegen_error(s, "too distant jump address");
+  }
+  s->iseq[pc] = MKOP_AsBx(c, GETARG_A(i), diff);
+}
+static void
+dispatch_linked(codegen_scope *s, int pc)
+{
+  mrb_code i;
+  int pos;
+  if (!pc) return;
+dispatch_linked(codegen_scope *s, uint16_t pos)
+{
+  if (pos==0) return;
   for (;;) {
+    i = s->iseq[pc];
+    pos = GETARG_sBx(i);
+    dispatch(s, pc);
+    if (!pos) break;
+    pc = pos;
+    pos = dispatch(s, pos);
+    if (pos==0) break;
+  }
+}
 …
 #define nregs_update do {if (s->sp > s->nregs) s->nregs = s->sp;} while (0)
 static void
+push_(codegen_scope *s)
+{
+  if (s->sp > 511) {
+    codegen_error(s, "too complex expression");
+  }
+  s->sp++;
+  nregs_update;
+}
+static void
+push_n_(codegen_scope *s, size_t n)
+{
+  if (s->sp+n > 511) {
+push_n_(codegen_scope *s, int n)
+{
+  if (s->sp+n >= 0xffff) {
     codegen_error(s, "too complex expression");
+  }
 …
+}
+#define push() push_(s)
+static void
+pop_n_(codegen_scope *s, int n)
+{
+  if ((int)s->sp-n < 0) {
+    codegen_error(s, "stack pointer underflow");
+  }
+  s->sp-=n;
+}
+#define push() push_n_(s,1)
 #define push_n(n) push_n_(s,n)
+#define pop_(s) ((s)->sp--)
+#define pop() pop_(s)
+#define pop_n(n) (s->sp-=(n))
+#define pop() pop_n_(s,1)
+#define pop_n(n) pop_n_(s,n)
 #define cursp() (s->sp)
 …
 new_lit(codegen_scope *s, mrb_value val)
+{
   size_t i;
+  int i;
   mrb_value *pv;
 …
       pv = &s->irep->pool[i];
       if (mrb_type(*pv) != MRB_TT_STRING) continue;
+      if (!mrb_string_p(*pv)) continue;
       if ((len = RSTRING_LEN(*pv)) != RSTRING_LEN(val)) continue;
       if (memcmp(RSTRING_PTR(*pv), RSTRING_PTR(val), len) == 0)
 …
+    }
     break;
+#ifndef MRB_WITHOUT_FLOAT
   case MRB_TT_FLOAT:
     for (i=0; i<s->irep->plen; i++) {
+      mrb_float f1, f2;
       pv = &s->irep->pool[i];
+      if (mrb_type(*pv) != MRB_TT_FLOAT) continue;
+      if (mrb_float(*pv) == mrb_float(val)) return i;
+    }
+    break;
+      if (!mrb_float_p(*pv)) continue;
+      f1 = mrb_float(*pv);
+      f2 = mrb_float(val);
+      if (f1 == f2 && !signbit(f1) == !signbit(f2)) return i;
+    }
+    break;
+#endif
   case MRB_TT_FIXNUM:
     for (i=0; i<s->irep->plen; i++) {
 …
   switch (mrb_type(val)) {
   case MRB_TT_STRING:
+    *pv = mrb_str_pool(s->mrb, val);
+    break;
+    *pv = mrb_str_pool(s->mrb, RSTRING_PTR(val), RSTRING_LEN(val), RSTR_NOFREE_P(RSTRING(val)));
+    break;
+#ifndef MRB_WITHOUT_FLOAT
   case MRB_TT_FLOAT:
 #ifdef MRB_WORD_BOXING
 …
     break;
 #endif
+#endif
   case MRB_TT_FIXNUM:
     *pv = val;
 …
+}
-/* method symbols should be fit in 9 bits */
-#define MAXMSYMLEN 512
 /* maximum symbol numbers */
 #define MAXSYMLEN 65536
+#define MAXSYMLEN 0x10000
 static int
 new_msym(codegen_scope *s, mrb_sym sym)
+{
   size_t i, len;
+new_sym(codegen_scope *s, mrb_sym sym)
+{
+  int i, len;
   mrb_assert(s->irep);
   len = s->irep->slen;
-  if (len > MAXMSYMLEN) len = MAXMSYMLEN;
   for (i=0; i<len; i++) {
     if (s->irep->syms[i] == sym) return i;
+    if (s->irep->syms[i] == 0) break;
+  }
+  if (i == MAXMSYMLEN) {
+    codegen_error(s, "too many symbols (max " MRB_STRINGIZE(MAXMSYMLEN) ")");
+  }
+  s->irep->syms[i] = sym;
+  if (i == s->irep->slen) s->irep->slen++;
+  return i;
+}
+static int
+new_sym(codegen_scope *s, mrb_sym sym)
+{
+  size_t i;
+  for (i=0; i<s->irep->slen; i++) {
+    if (s->irep->syms[i] == sym) return i;
+  }
+  if (s->irep->slen == MAXSYMLEN) {
+    codegen_error(s, "too many symbols (max " MRB_STRINGIZE(MAXSYMLEN) ")");
+  }
+  if (s->irep->slen > MAXMSYMLEN/2 && s->scapa == MAXMSYMLEN) {
+    s->scapa = MAXSYMLEN;
+    s->irep->syms = (mrb_sym *)codegen_realloc(s, s->irep->syms, sizeof(mrb_sym)*MAXSYMLEN);
+    for (i = s->irep->slen; i < MAXMSYMLEN; i++) {
+      static const mrb_sym mrb_sym_zero = { 0 };
+      s->irep->syms[i] = mrb_sym_zero;
+    }
+    s->irep->slen = MAXMSYMLEN;
+  }
+  if (s->irep->slen >= s->scapa) {
+    s->scapa *= 2;
+    s->irep->syms = (mrb_sym*)codegen_realloc(s, s->irep->syms, sizeof(mrb_sym)*s->scapa);
+  }
   s->irep->syms[s->irep->slen] = sym;
 …
+}
+#define sym(x) ((mrb_sym)(intptr_t)(x))
+#define lv_name(lv) sym((lv)->car)
+#define nint(x) ((int)(intptr_t)(x))
+#define nchar(x) ((char)(intptr_t)(x))
+#define nsym(x) ((mrb_sym)(intptr_t)(x))
+#define lv_name(lv) nsym((lv)->car)
 static int
 lv_idx(codegen_scope *s, mrb_sym id)
 …
   struct loopinfo *lp;
   node *n2;
-  mrb_code c;
   /* generate receiver */
 …
   /* generate loop-block */
   s = scope_new(s->mrb, s, NULL);
-  if (s == NULL) {
-    raise_error(prev, "unexpected scope");
+  }
   push();                       /* push for a block parameter */
 …
   /* generate loop variable */
   n2 = tree->car;
   genop(s, MKOP_Ax(OP_ENTER, 0x40000));
+  genop_W(s, OP_ENTER, 0x40000);
   if (n2->car && !n2->car->cdr && !n2->cdr) {
     gen_assignment(s, n2->car->car, 1, NOVAL);
 …
   codegen(s, tree->cdr->cdr->car, VAL);
   pop();
+  if (s->pc > 0) {
+    c = s->iseq[s->pc-1];
+    if (GET_OPCODE(c) != OP_RETURN || GETARG_B(c) != OP_R_NORMAL || s->pc == s->lastlabel)
+      genop_peep(s, MKOP_AB(OP_RETURN, cursp(), OP_R_NORMAL), NOVAL);
+  }
+  gen_return(s, OP_RETURN, cursp());
   loop_pop(s, NOVAL);
   scope_finish(s);
   s = prev;
+  genop(s, MKOP_Abc(OP_LAMBDA, cursp(), s->irep->rlen-1, OP_L_BLOCK));
+  genop_2(s, OP_BLOCK, cursp(), s->irep->rlen-1);
+  push();pop(); /* space for a block */
   pop();
   idx = new_msym(s, mrb_intern_lit(s->mrb, "each"));
   genop(s, MKOP_ABC(OP_SENDB, cursp(), idx, 0));
+  idx = new_sym(s, mrb_intern_lit(s->mrb, "each"));
+  genop_3(s, OP_SENDB, cursp(), idx, 0);
+}
 …
 lambda_body(codegen_scope *s, node *tree, int blk)
+{
-  mrb_code c;
   codegen_scope *parent = s;
   s = scope_new(s->mrb, s, tree->car);
-  if (s == NULL) {
-    raise_error(parent, "unexpected scope");
+  }
   s->mscope = !blk;
 …
   if (blk) {
     struct loopinfo *lp = loop_push(s, LOOP_BLOCK);
     lp->pc1 = new_label(s);
+    lp->pc0 = new_label(s);
+  }
   tree = tree->cdr;
+  if (tree->car) {
+  if (tree->car == NULL) {
+    genop_W(s, OP_ENTER, 0);
+  }
+  else {
     mrb_aspec a;
     int ma, oa, ra, pa, ka, kd, ba;
     int pos, i;
+    node *n, *opt;
+    node *opt;
+    node *margs, *pargs;
+    node *tail;
+    /* mandatory arguments */
     ma = node_len(tree->car->car);
     n = tree->car->car;
     while (n) {
+      n = n->cdr;
+    }
+    margs = tree->car->car;
+    tail = tree->car->cdr->cdr->cdr->cdr;
+    /* optional arguments */
     oa = node_len(tree->car->cdr->car);
+    /* rest argument? */
     ra = tree->car->cdr->cdr->car ? 1 : 0;
+    /* mandatory arugments after rest argument */
     pa = node_len(tree->car->cdr->cdr->cdr->car);
+    ka = kd = 0;
+    ba = tree->car->cdr->cdr->cdr->cdr ? 1 : 0;
+    pargs = tree->car->cdr->cdr->cdr->car;
+    /* keyword arguments */
+    ka = tail? node_len(tail->cdr->car) : 0;
+    /* keyword dictionary? */
+    kd = tail && tail->cdr->cdr->car? 1 : 0;
+    /* block argument? */
+    ba = tail && tail->cdr->cdr->cdr->car ? 1 : 0;
     if (ma > 0x1f || oa > 0x1f || pa > 0x1f || ka > 0x1f) {
       codegen_error(s, "too many formal arguments");
+    }
+    a = ((mrb_aspec)(ma & 0x1f) << 18)
+      | ((mrb_aspec)(oa & 0x1f) << 13)
+      | ((ra & 1) << 12)
+      | ((pa & 0x1f) << 7)
+      | ((ka & 0x1f) << 2)
+      | ((kd & 1)<< 1)
+      | (ba & 1);
+    s->ainfo = (((ma+oa) & 0x3f) << 6) /* (12bits = 6:1:5) */
+      | ((ra & 1) << 5)
+      | (pa & 0x1f);
+    genop(s, MKOP_Ax(OP_ENTER, a));
+    a = MRB_ARGS_REQ(ma)
+      | MRB_ARGS_OPT(oa)
+      | (ra? MRB_ARGS_REST() : 0)
+      | MRB_ARGS_POST(pa)
+      | MRB_ARGS_KEY(ka, kd)
+      | (ba? MRB_ARGS_BLOCK() : 0);
+    s->ainfo = (((ma+oa) & 0x3f) << 7) /* (12bits = 5:1:5:1) */
+      | ((ra & 0x1) << 6)
+      | ((pa & 0x1f) << 1)
+      | ((ka | kd) != 0 ? 0x01 : 0x00);
+    genop_W(s, OP_ENTER, a);
+    /* generate jump table for optional arguments initializer */
     pos = new_label(s);
     for (i=0; i<oa; i++) {
       new_label(s);
       genop(s, MKOP_sBx(OP_JMP, 0));
+      genjmp(s, OP_JMP, 0);
+    }
     if (oa > 0) {
       genop(s, MKOP_sBx(OP_JMP, 0));
+      genjmp(s, OP_JMP, 0);
+    }
     opt = tree->car->cdr->car;
 …
       int idx;
       dispatch(s, pos+i);
+      dispatch(s, pos+i*3+1);
       codegen(s, opt->car->cdr, VAL);
-      idx = lv_idx(s, (mrb_sym)(intptr_t)opt->car->car);
       pop();
+      genop_peep(s, MKOP_AB(OP_MOVE, idx, cursp()), NOVAL);
+      idx = lv_idx(s, nsym(opt->car->car));
+      gen_move(s, idx, cursp(), 0);
       i++;
       opt = opt->cdr;
+    }
     if (oa > 0) {
+      dispatch(s, pos+i);
+    }
+  }
+      dispatch(s, pos+i*3+1);
+    }
+    /* keyword arguments */
+    if (tail) {
+      node *kwds = tail->cdr->car;
+      int kwrest = 0;
+      if (tail->cdr->cdr->car) {
+        kwrest = 1;
+      }
+      mrb_assert(nint(tail->car) == NODE_ARGS_TAIL);
+      mrb_assert(node_len(tail) == 4);
+      while (kwds) {
+        int jmpif_key_p, jmp_def_set = -1;
+        node *kwd = kwds->car, *def_arg = kwd->cdr->cdr->car;
+        mrb_sym kwd_sym = nsym(kwd->cdr->car);
+        mrb_assert(nint(kwd->car) == NODE_KW_ARG);
+        if (def_arg) {
+          genop_2(s, OP_KEY_P, lv_idx(s, kwd_sym), new_sym(s, kwd_sym));
+          jmpif_key_p = genjmp2(s, OP_JMPIF, lv_idx(s, kwd_sym), 0, 0);
+          codegen(s, def_arg, VAL);
+          pop();
+          gen_move(s, lv_idx(s, kwd_sym), cursp(), 0);
+          jmp_def_set = genjmp(s, OP_JMP, 0);
+          dispatch(s, jmpif_key_p);
+        }
+        genop_2(s, OP_KARG, lv_idx(s, kwd_sym), new_sym(s, kwd_sym));
+        if (jmp_def_set != -1) {
+          dispatch(s, jmp_def_set);
+        }
+        i++;
+        kwds = kwds->cdr;
+      }
+      if (tail->cdr->car && !kwrest) {
+        genop_0(s, OP_KEYEND);
+      }
+    }
+    /* argument destructuring */
+    if (margs) {
+      node *n = margs;
+      pos = 1;
+      while (n) {
+        if (nint(n->car->car) == NODE_MASGN) {
+          gen_vmassignment(s, n->car->cdr->car, pos, NOVAL);
+        }
+        pos++;
+        n = n->cdr;
+      }
+    }
+    if (pargs) {
+      node *n = margs;
+      pos = ma+oa+ra+1;
+      while (n) {
+        if (nint(n->car->car) == NODE_MASGN) {
+          gen_vmassignment(s, n->car->cdr->car, pos, NOVAL);
+        }
+        pos++;
+        n = n->cdr;
+      }
+    }
+  }
   codegen(s, tree->cdr->car, VAL);
   pop();
   if (s->pc > 0) {
+    c = s->iseq[s->pc-1];
+    if (GET_OPCODE(c) != OP_RETURN || GETARG_B(c) != OP_R_NORMAL || s->pc == s->lastlabel) {
+      if (s->nregs == 0) {
+        genop(s, MKOP_A(OP_LOADNIL, 0));
+        genop(s, MKOP_AB(OP_RETURN, 0, OP_R_NORMAL));
+      }
+      else {
+        genop_peep(s, MKOP_AB(OP_RETURN, cursp(), OP_R_NORMAL), NOVAL);
+      }
+    }
+    gen_return(s, OP_RETURN, cursp());
+  }
   if (blk) {
 …
+{
   codegen_scope *scope = scope_new(s->mrb, s, tree->car);
-  if (scope == NULL) {
-    raise_error(s, "unexpected scope");
+  }
   codegen(scope, tree->cdr, VAL);
+  gen_return(scope, OP_RETURN, scope->sp-1);
   if (!s->iseq) {
+    genop(scope, MKOP_A(OP_STOP, 0));
+  }
+  else if (!val) {
+    genop(scope, MKOP_AB(OP_RETURN, 0, OP_R_NORMAL));
+  }
+  else {
+    if (scope->nregs == 0) {
+      genop(scope, MKOP_A(OP_LOADNIL, 0));
+      genop(scope, MKOP_AB(OP_RETURN, 0, OP_R_NORMAL));
+    }
+    else {
+      genop_peep(scope, MKOP_AB(OP_RETURN, scope->sp-1, OP_R_NORMAL), NOVAL);
+    }
+    genop_0(scope, OP_STOP);
+  }
   scope_finish(scope);
 …
+{
   while (t) {
     if ((intptr_t)t->car->car == NODE_SPLAT) return FALSE;
+    if (nint(t->car->car) == NODE_SPLAT) return FALSE;
     t = t->cdr;
+  }
 …
   char *name2;
   name = mrb_sym2name_len(s->mrb, a, &len);
+  name = mrb_sym_name_len(s->mrb, a, &len);
   name2 = (char *)codegen_palloc(s,
                                  (size_t)len
 …
   while (t) {
     is_splat = (intptr_t)t->car->car == NODE_SPLAT; /* splat mode */
+    is_splat = nint(t->car->car) == NODE_SPLAT; /* splat mode */
     if (
       n+extra >= CALL_MAXARGS - 1 /* need to subtract one because vm.c expects an array if n == CALL_MAXARGS */
       || is_splat) {
       if (val) {
         if (is_splat && n == 0 && (intptr_t)t->car->cdr->car == NODE_ARRAY) {
+        if (is_splat && n == 0 && nint(t->car->cdr->car) == NODE_ARRAY) {
           codegen(s, t->car->cdr, VAL);
           pop();
 …
         else {
           pop_n(n);
+          genop(s, MKOP_ABC(OP_ARRAY, cursp(), cursp(), n));
+          if (n == 0 && is_splat) {
+            genop_1(s, OP_LOADNIL, cursp());
+          }
+          else {
+            genop_2(s, OP_ARRAY, cursp(), n);
+          }
           push();
           codegen(s, t->car, VAL);
           pop(); pop();
           if (is_splat) {
             genop(s, MKOP_AB(OP_ARYCAT, cursp(), cursp()+1));
+            genop_1(s, OP_ARYCAT, cursp());
+          }
           else {
             genop(s, MKOP_AB(OP_ARYPUSH, cursp(), cursp()+1));
+            genop_1(s, OP_ARYPUSH, cursp());
+          }
+        }
 …
           codegen(s, t->car, VAL);
           pop(); pop();
           if ((intptr_t)t->car->car == NODE_SPLAT) {
             genop(s, MKOP_AB(OP_ARYCAT, cursp(), cursp()+1));
+          if (nint(t->car->car) == NODE_SPLAT) {
+            genop_1(s, OP_ARYCAT, cursp());
+          }
           else {
             genop(s, MKOP_AB(OP_ARYPUSH, cursp(), cursp()+1));
+            genop_1(s, OP_ARYPUSH, cursp());
+          }
           t = t->cdr;
 …
 gen_call(codegen_scope *s, node *tree, mrb_sym name, int sp, int val, int safe)
+{
   mrb_sym sym = name ? name : sym(tree->cdr->car);
   int idx, skip = 0;
+  mrb_sym sym = name ? name : nsym(tree->cdr->car);
+  int skip = 0;
   int n = 0, noop = 0, sendv = 0, blk = 0;
 …
   if (safe) {
     int recv = cursp()-1;
+    genop(s, MKOP_A(OP_LOADNIL, cursp()));
+    push();
+    genop(s, MKOP_AB(OP_MOVE, cursp(), recv));
+    push(); pop();              /* space for a block */
+    pop();
+    idx = new_msym(s, mrb_intern_lit(s->mrb, "=="));
+    genop(s, MKOP_ABC(OP_EQ, cursp(), idx, 1));
+    skip = genop(s, MKOP_AsBx(OP_JMPIF, cursp(), 0));
+  }
+  idx = new_msym(s, sym);
+    gen_move(s, cursp(), recv, 1);
+    skip = genjmp2(s, OP_JMPNIL, cursp(), 0, val);
+  }
   tree = tree->cdr->cdr->car;
   if (tree) {
 …
+    }
+  }
   if (sp) {
+  if (sp) {                     /* last argument pushed (attr=) */
     if (sendv) {
+      gen_move(s, cursp(), sp, 0);
       pop();
       genop(s, MKOP_AB(OP_ARYPUSH, cursp(), sp));
+      genop_1(s, OP_ARYPUSH, cursp());
       push();
+    }
     else {
       genop(s, MKOP_AB(OP_MOVE, cursp(), sp));
+      gen_move(s, cursp(), sp, 0);
       push();
       n++;
 …
     codegen(s, tree->cdr, VAL);
     pop();
+  }
+  else {
+    blk = cursp();
+    blk = 1;
+  }
   push();pop();
 …
+  {
     mrb_int symlen;
     const char *symname = mrb_sym2name_len(s->mrb, sym, &symlen);
+    const char *symname = mrb_sym_name_len(s->mrb, sym, &symlen);
     if (!noop && symlen == 1 && symname[0] == '+' && n == 1)  {
       genop_peep(s, MKOP_ABC(OP_ADD, cursp(), idx, n), val);
+      gen_addsub(s, OP_ADD, cursp());
+    }
     else if (!noop && symlen == 1 && symname[0] == '-' && n == 1)  {
       genop_peep(s, MKOP_ABC(OP_SUB, cursp(), idx, n), val);
+      gen_addsub(s, OP_SUB, cursp());
+    }
     else if (!noop && symlen == 1 && symname[0] == '*' && n == 1)  {
       genop(s, MKOP_ABC(OP_MUL, cursp(), idx, n));
+      genop_1(s, OP_MUL, cursp());
+    }
     else if (!noop && symlen == 1 && symname[0] == '/' && n == 1)  {
       genop(s, MKOP_ABC(OP_DIV, cursp(), idx, n));
+      genop_1(s, OP_DIV, cursp());
+    }
     else if (!noop && symlen == 1 && symname[0] == '<' && n == 1)  {
       genop(s, MKOP_ABC(OP_LT, cursp(), idx, n));
+      genop_1(s, OP_LT, cursp());
+    }
     else if (!noop && symlen == 2 && symname[0] == '<' && symname[1] == '=' && n == 1)  {
       genop(s, MKOP_ABC(OP_LE, cursp(), idx, n));
+      genop_1(s, OP_LE, cursp());
+    }
     else if (!noop && symlen == 1 && symname[0] == '>' && n == 1)  {
       genop(s, MKOP_ABC(OP_GT, cursp(), idx, n));
+      genop_1(s, OP_GT, cursp());
+    }
     else if (!noop && symlen == 2 && symname[0] == '>' && symname[1] == '=' && n == 1)  {
       genop(s, MKOP_ABC(OP_GE, cursp(), idx, n));
+      genop_1(s, OP_GE, cursp());
+    }
     else if (!noop && symlen == 2 && symname[0] == '=' && symname[1] == '=' && n == 1)  {
       genop(s, MKOP_ABC(OP_EQ, cursp(), idx, n));
+      genop_1(s, OP_EQ, cursp());
+    }
     else {
+      if (sendv) n = CALL_MAXARGS;
+      if (blk > 0) {                   /* no block */
+        genop(s, MKOP_ABC(OP_SEND, cursp(), idx, n));
+      int idx = new_sym(s, sym);
+      if (sendv) {
+        genop_2(s, blk ? OP_SENDVB : OP_SENDV, cursp(), idx);
+      }
       else {
         genop(s, MKOP_ABC(OP_SENDB, cursp(), idx, n));
+        genop_3(s, blk ? OP_SENDB : OP_SEND, cursp(), idx, n);
+      }
+    }
 …
+{
   int idx;
   int type = (intptr_t)tree->car;
+  int type = nint(tree->car);
   tree = tree->cdr;
   switch (type) {
   case NODE_GVAR:
+    idx = new_sym(s, sym(tree));
+    genop_peep(s, MKOP_ABx(OP_SETGLOBAL, sp, idx), val);
+    break;
+    idx = new_sym(s, nsym(tree));
+    genop_2(s, OP_SETGV, sp, idx);
+    break;
+  case NODE_ARG:
   case NODE_LVAR:
     idx = lv_idx(s, sym(tree));
+    idx = lv_idx(s, nsym(tree));
     if (idx > 0) {
       if (idx != sp) {
+        genop_peep(s, MKOP_AB(OP_MOVE, idx, sp), val);
+        gen_move(s, idx, sp, val);
+        if (val && on_eval(s)) genop_0(s, OP_NOP);
+      }
       break;
 …
       while (up) {
         idx = lv_idx(up, sym(tree));
+        idx = lv_idx(up, nsym(tree));
         if (idx > 0) {
           genop_peep(s, MKOP_ABC(OP_SETUPVAR, sp, idx, lv), val);
+          genop_3(s, OP_SETUPVAR, sp, idx, lv);
           break;
+        }
 …
+    }
     break;
+  case NODE_NVAR:
+    idx = nint(tree);
+    codegen_error(s, "Can't assign to numbered parameter");
+    break;
   case NODE_IVAR:
     idx = new_sym(s, sym(tree));
     genop_peep(s, MKOP_ABx(OP_SETIV, sp, idx), val);
+    idx = new_sym(s, nsym(tree));
+    genop_2(s, OP_SETIV, sp, idx);
     break;
   case NODE_CVAR:
     idx = new_sym(s, sym(tree));
     genop_peep(s, MKOP_ABx(OP_SETCV, sp, idx), val);
+    idx = new_sym(s, nsym(tree));
+    genop_2(s, OP_SETCV, sp, idx);
     break;
   case NODE_CONST:
     idx = new_sym(s, sym(tree));
     genop_peep(s, MKOP_ABx(OP_SETCONST, sp, idx), val);
+    idx = new_sym(s, nsym(tree));
+    genop_2(s, OP_SETCONST, sp, idx);
     break;
   case NODE_COLON2:
+    idx = new_sym(s, sym(tree->cdr));
+    genop_peep(s, MKOP_AB(OP_MOVE, cursp(), sp), NOVAL);
+    gen_move(s, cursp(), sp, 0);
     push();
     codegen(s, tree->car, VAL);
     pop_n(2);
+    genop_peep(s, MKOP_ABx(OP_SETMCNST, cursp(), idx), val);
+    idx = new_sym(s, nsym(tree->cdr));
+    genop_2(s, OP_SETMCNST, sp, idx);
     break;
 …
   case NODE_SCALL:
     push();
     gen_call(s, tree, attrsym(s, sym(tree->cdr->car)), sp, NOVAL,
+    gen_call(s, tree, attrsym(s, nsym(tree->cdr->car)), sp, NOVAL,
              type == NODE_SCALL);
     pop();
     if (val) {
       genop_peep(s, MKOP_AB(OP_MOVE, cursp(), sp), val);
+      gen_move(s, cursp(), sp, 0);
+    }
     break;
 …
     n = 0;
     while (t) {
+      genop(s, MKOP_ABC(OP_AREF, cursp(), rhs, n));
+      gen_assignment(s, t->car, cursp(), NOVAL);
+      int sp = cursp();
+      genop_3(s, OP_AREF, sp, rhs, n);
+      push();
+      gen_assignment(s, t->car, sp, NOVAL);
+      pop();
       n++;
       t = t->cdr;
 …
+      }
+    }
+    if (val) {
+      genop(s, MKOP_AB(OP_MOVE, cursp(), rhs));
+    }
+    else {
+      pop();
+    }
+    push_n(post);
+    pop_n(post);
+    genop(s, MKOP_ABC(OP_APOST, cursp(), n, post));
+    gen_move(s, cursp(), rhs, val);
+    push_n(post+1);
+    pop_n(post+1);
+    genop_3(s, OP_APOST, cursp(), n, post);
     n = 1;
     if (t->car) {               /* rest */
+    if (t->car && t->car != (node*)-1) { /* rest */
       gen_assignment(s, t->car, cursp(), NOVAL);
+    }
 …
+      }
+    }
     if (!val) {
       push();
+    if (val) {
+      gen_move(s, cursp(), rhs, 0);
+    }
+  }
 …
 static void
 gen_send_intern(codegen_scope *s)
+gen_intern(codegen_scope *s)
+{
   pop();
   genop(s, MKOP_ABC(OP_SEND, cursp(), new_msym(s, mrb_intern_lit(s->mrb, "intern")), 0));
+  genop_1(s, OP_INTERN, cursp());
   push();
+}
 static void
 gen_literal_array(codegen_scope *s, node *tree, mrb_bool sym, int val)
 …
     while (tree) {
       switch ((intptr_t)tree->car->car) {
+      switch (nint(tree->car->car)) {
       case NODE_STR:
         if ((tree->cdr == NULL) && ((intptr_t)tree->car->cdr->cdr == 0))
+        if ((tree->cdr == NULL) && (nint(tree->car->cdr->cdr) == 0))
           break;
         /* fall through */
 …
           ++i;
           if (sym)
             gen_send_intern(s);
+            gen_intern(s);
+        }
         break;
+      }
       if (j >= 2) {
+      while (j >= 2) {
         pop(); pop();
         genop_peep(s, MKOP_AB(OP_STRCAT, cursp(), cursp()+1), VAL);
+        genop_1(s, OP_STRCAT, cursp());
         push();
         j = 1;
+        j--;
+      }
       tree = tree->cdr;
 …
       ++i;
       if (sym)
         gen_send_intern(s);
+        gen_intern(s);
+    }
     pop_n(i);
     genop(s, MKOP_ABC(OP_ARRAY, cursp(), cursp(), i));
+    genop_2(s, OP_ARRAY, cursp(), i);
     push();
+  }
   else {
     while (tree) {
       switch ((intptr_t)tree->car->car) {
+      switch (nint(tree->car->car)) {
       case NODE_BEGIN: case NODE_BLOCK:
         codegen(s, tree->car, NOVAL);
 …
   int idx = new_lit(s, mrb_str_new_cstr(s->mrb, msg));
+  genop(s, MKOP_ABx(OP_ERR, 1, idx));
+}
+  genop_1(s, OP_ERR, idx);
+}
+#ifndef MRB_WITHOUT_FLOAT
 static double
 readint_float(codegen_scope *s, const char *p, int base)
 …
   return f;
+}
+#endif
 static mrb_int
 …
 gen_retval(codegen_scope *s, node *tree)
+{
+  if ((intptr_t)tree->car == NODE_SPLAT) {
+    genop(s, MKOP_ABC(OP_ARRAY, cursp(), cursp(), 0));
+    push();
+  if (nint(tree->car) == NODE_SPLAT) {
     codegen(s, tree, VAL);
     pop(); pop();
     genop(s, MKOP_AB(OP_ARYCAT, cursp(), cursp()+1));
+    pop();
+    genop_1(s, OP_ARYDUP, cursp());
+  }
   else {
 …
   if (!tree) {
     if (val) {
       genop(s, MKOP_A(OP_LOADNIL, cursp()));
+      genop_1(s, OP_LOADNIL, cursp());
       push();
+    }
 …
+  }
   if (s->irep && s->filename_index != tree->filename_index) {
+    s->irep->filename = mrb_parser_get_filename(s->parser, s->filename_index);
+    mrb_debug_info_append_file(s->mrb, s->irep, s->debug_start_pos, s->pc);
+    mrb_sym fname = mrb_parser_get_filename(s->parser, s->filename_index);
+    const char *filename = mrb_sym_name_len(s->mrb, fname, NULL);
+    mrb_debug_info_append_file(s->mrb, s->irep->debug_info,
+                               filename, s->lines, s->debug_start_pos, s->pc);
     s->debug_start_pos = s->pc;
     s->filename_index = tree->filename_index;
     s->filename = mrb_parser_get_filename(s->parser, tree->filename_index);
+  }
   nt = (intptr_t)tree->car;
+    s->filename_sym = mrb_parser_get_filename(s->parser, tree->filename_index);
+  }
+  nt = nint(tree->car);
   s->lineno = tree->lineno;
   tree = tree->cdr;
 …
   case NODE_BEGIN:
     if (val && !tree) {
       genop(s, MKOP_A(OP_LOADNIL, cursp()));
+      genop_1(s, OP_LOADNIL, cursp());
       push();
+    }
 …
   case NODE_RESCUE:
+    {
       int onerr, noexc, exend, pos1, pos2, tmp;
+      int noexc, exend, pos1, pos2, tmp;
       struct loopinfo *lp;
       if (tree->car == NULL) goto exit;
-      onerr = genop(s, MKOP_Bx(OP_ONERR, 0));
       lp = loop_push(s, LOOP_BEGIN);
+      lp->pc1 = onerr;
+      lp->pc0 = new_label(s);
+      lp->pc1 = genjmp(s, OP_ONERR, 0);
       codegen(s, tree->car, VAL);
       pop();
       lp->type = LOOP_RESCUE;
       noexc = genop(s, MKOP_Bx(OP_JMP, 0));
       dispatch(s, onerr);
+      noexc = genjmp(s, OP_JMP, 0);
+      dispatch(s, lp->pc1);
       tree = tree->cdr;
       exend = 0;
 …
         int exc = cursp();
         genop(s, MKOP_ABC(OP_RESCUE, exc, 0, 0));
+        genop_1(s, OP_EXCEPT, exc);
         push();
         while (n2) {
 …
           pos2 = 0;
           do {
             if (n4 && n4->car && (intptr_t)n4->car->car == NODE_SPLAT) {
+            if (n4 && n4->car && nint(n4->car->car) == NODE_SPLAT) {
               codegen(s, n4->car, VAL);
+              genop(s, MKOP_AB(OP_MOVE, cursp(), exc));
+              gen_move(s, cursp(), exc, 0);
+              push_n(2); pop_n(2); /* space for one arg and a block */
               pop();
               genop(s, MKOP_ABC(OP_SEND, cursp(), new_msym(s, mrb_intern_lit(s->mrb, "__case_eqq")), 1));
+              genop_3(s, OP_SEND, cursp(), new_sym(s, mrb_intern_lit(s->mrb, "__case_eqq")), 1);
+            }
             else {
 …
+              }
               else {
                 genop(s, MKOP_ABx(OP_GETCONST, cursp(), new_msym(s, mrb_intern_lit(s->mrb, "StandardError"))));
+                genop_2(s, OP_GETCONST, cursp(), new_sym(s, mrb_intern_lit(s->mrb, "StandardError")));
                 push();
+              }
               pop();
               genop(s, MKOP_ABC(OP_RESCUE, exc, cursp(), 1));
+              genop_2(s, OP_RESCUE, exc, cursp());
+            }
             tmp = genop(s, MKOP_AsBx(OP_JMPIF, cursp(), pos2));
+            tmp = genjmp2(s, OP_JMPIF, cursp(), pos2, val);
             pos2 = tmp;
             if (n4) {
 …
+            }
           } while (n4);
           pos1 = genop(s, MKOP_sBx(OP_JMP, 0));
+          pos1 = genjmp(s, OP_JMP, 0);
           dispatch_linked(s, pos2);
 …
             if (val) pop();
+          }
           tmp = genop(s, MKOP_sBx(OP_JMP, exend));
+          tmp = genjmp(s, OP_JMP, exend);
           exend = tmp;
           n2 = n2->cdr;
 …
         if (pos1) {
           dispatch(s, pos1);
           genop(s, MKOP_A(OP_RAISE, exc));
+          genop_1(s, OP_RAISE, exc);
+        }
+      }
 …
       tree = tree->cdr;
       dispatch(s, noexc);
       genop(s, MKOP_A(OP_POPERR, 1));
+      genop_1(s, OP_POPERR, 1);
       if (tree->car) {
         codegen(s, tree->car, val);
 …
   case NODE_ENSURE:
     if (!tree->cdr || !tree->cdr->cdr ||
         ((intptr_t)tree->cdr->cdr->car == NODE_BEGIN &&
+        (nint(tree->cdr->cdr->car) == NODE_BEGIN &&
          tree->cdr->cdr->cdr)) {
       int idx;
+      int epush = s->pc;
+      genop(s, MKOP_Bx(OP_EPUSH, 0));
       s->ensure_level++;
+      idx = scope_body(s, tree->cdr, NOVAL);
+      genop_1(s, OP_EPUSH, idx);
       codegen(s, tree->car, val);
-      idx = scope_body(s, tree->cdr, NOVAL);
-      s->iseq[epush] = MKOP_Bx(OP_EPUSH, idx);
       s->ensure_level--;
       genop_peep(s, MKOP_A(OP_EPOP, 1), NOVAL);
+      genop_1(s, OP_EPOP, 1);
+    }
     else {                      /* empty ensure ignored */
 …
       int idx = lambda_body(s, tree, 1);
       genop(s, MKOP_Abc(OP_LAMBDA, cursp(), idx, OP_L_LAMBDA));
+      genop_2(s, OP_LAMBDA, cursp(), idx);
       push();
+    }
 …
       int idx = lambda_body(s, tree, 1);
       genop(s, MKOP_Abc(OP_LAMBDA, cursp(), idx, OP_L_BLOCK));
+      genop_2(s, OP_BLOCK, cursp(), idx);
       push();
+    }
 …
   case NODE_IF:
+    {
       int pos1, pos2;
       node *e = tree->cdr->cdr->car;
+      int pos1, pos2, nil_p = FALSE;
+      node *elsepart = tree->cdr->cdr->car;
       if (!tree->car) {
         codegen(s, e, val);
+        codegen(s, elsepart, val);
         goto exit;
+      }
       switch ((intptr_t)tree->car->car) {
+      switch (nint(tree->car->car)) {
       case NODE_TRUE:
       case NODE_INT:
 …
       case NODE_FALSE:
       case NODE_NIL:
         codegen(s, e, val);
+        codegen(s, elsepart, val);
         goto exit;
+      }
+      codegen(s, tree->car, VAL);
+      case NODE_CALL:
+        {
+          node *n = tree->car->cdr;
+          mrb_sym mid = nsym(n->cdr->car);
+          mrb_sym mnil = mrb_intern_lit(s->mrb, "nil?");
+          if (mid == mnil && n->cdr->cdr->car == NULL) {
+            nil_p = TRUE;
+            codegen(s, n->car, VAL);
+          }
+        }
+        break;
+      }
+      if (!nil_p) {
+        codegen(s, tree->car, VAL);
+      }
       pop();
+      pos1 = genop_peep(s, MKOP_AsBx(OP_JMPNOT, cursp(), 0), NOVAL);
+      codegen(s, tree->cdr->car, val);
+      if (e) {
+      if (val || tree->cdr->car) {
+        if (nil_p) {
+          pos2 = genjmp2(s, OP_JMPNIL, cursp(), 0, val);
+          pos1 = genjmp(s, OP_JMP, 0);
+          dispatch(s, pos2);
+        }
+        else {
+          pos1 = genjmp2(s, OP_JMPNOT, cursp(), 0, val);
+        }
+        codegen(s, tree->cdr->car, val);
         if (val) pop();
+        pos2 = genop(s, MKOP_sBx(OP_JMP, 0));
+        dispatch(s, pos1);
+        codegen(s, e, val);
+        dispatch(s, pos2);
+      }
+      else {
+        if (val) {
+          pop();
+          pos2 = genop(s, MKOP_sBx(OP_JMP, 0));
+        if (elsepart || val) {
+          pos2 = genjmp(s, OP_JMP, 0);
           dispatch(s, pos1);
           genop(s, MKOP_A(OP_LOADNIL, cursp()));
+          codegen(s, elsepart, val);
           dispatch(s, pos2);
-          push();
+        }
         else {
           dispatch(s, pos1);
+        }
+      }
+      else {                    /* empty then-part */
+        if (elsepart) {
+          if (nil_p) {
+            pos1 = genjmp2(s, OP_JMPNIL, cursp(), 0, val);
+          }
+          else {
+            pos1 = genjmp2(s, OP_JMPIF, cursp(), 0, val);
+          }
+          codegen(s, elsepart, val);
+          dispatch(s, pos1);
+        }
+        else if (val && !nil_p) {
+          genop_1(s, OP_LOADNIL, cursp());
+          push();
+        }
+      }
 …
       codegen(s, tree->car, VAL);
       pop();
       pos = genop(s, MKOP_AsBx(OP_JMPNOT, cursp(), 0));
+      pos = genjmp2(s, OP_JMPNOT, cursp(), 0, val);
       codegen(s, tree->cdr, val);
       dispatch(s, pos);
 …
       codegen(s, tree->car, VAL);
       pop();
       pos = genop(s, MKOP_AsBx(OP_JMPIF, cursp(), 0));
+      pos = genjmp2(s, OP_JMPIF, cursp(), 0, val);
       codegen(s, tree->cdr, val);
       dispatch(s, pos);
 …
       struct loopinfo *lp = loop_push(s, LOOP_NORMAL);
+      lp->pc1 = genop(s, MKOP_sBx(OP_JMP, 0));
+      lp->pc0 = new_label(s);
+      lp->pc1 = genjmp(s, OP_JMP, 0);
       lp->pc2 = new_label(s);
       codegen(s, tree->cdr, NOVAL);
 …
       codegen(s, tree->car, VAL);
       pop();
       genop(s, MKOP_AsBx(OP_JMPIF, cursp(), lp->pc2 - s->pc));
+      genjmp2(s, OP_JMPIF, cursp(), lp->pc2, NOVAL);
       loop_pop(s, val);
 …
       struct loopinfo *lp = loop_push(s, LOOP_NORMAL);
+      lp->pc1 = genop(s, MKOP_sBx(OP_JMP, 0));
+      lp->pc0 = new_label(s);
+      lp->pc1 = genjmp(s, OP_JMP, 0);
       lp->pc2 = new_label(s);
       codegen(s, tree->cdr, NOVAL);
 …
       codegen(s, tree->car, VAL);
       pop();
       genop(s, MKOP_AsBx(OP_JMPNOT, cursp(), lp->pc2 - s->pc));
+      genjmp2(s, OP_JMPNOT, cursp(), lp->pc2, NOVAL);
       loop_pop(s, val);
 …
           codegen(s, n->car, VAL);
           if (head) {
             genop(s, MKOP_AB(OP_MOVE, cursp(), head));
             pop();
             if ((intptr_t)n->car->car == NODE_SPLAT) {
               genop(s, MKOP_ABC(OP_SEND, cursp(), new_msym(s, mrb_intern_lit(s->mrb, "__case_eqq")), 1));
+            gen_move(s, cursp(), head, 0);
+            push(); push(); pop(); pop(); pop();
+            if (nint(n->car->car) == NODE_SPLAT) {
+              genop_3(s, OP_SEND, cursp(), new_sym(s, mrb_intern_lit(s->mrb, "__case_eqq")), 1);
+            }
             else {
               genop(s, MKOP_ABC(OP_SEND, cursp(), new_msym(s, mrb_intern_lit(s->mrb, "===")), 1));
+              genop_3(s, OP_SEND, cursp(), new_sym(s, mrb_intern_lit(s->mrb, "===")), 1);
+            }
+          }
 …
             pop();
+          }
           tmp = genop(s, MKOP_AsBx(OP_JMPIF, cursp(), pos2));
+          tmp = genjmp2(s, OP_JMPIF, cursp(), pos2, NOVAL);
           pos2 = tmp;
           n = n->cdr;
+        }
         if (tree->car->car) {
           pos1 = genop(s, MKOP_sBx(OP_JMP, 0));
+          pos1 = genjmp(s, OP_JMP, 0);
           dispatch_linked(s, pos2);
+        }
         codegen(s, tree->car->cdr, val);
         if (val) pop();
         tmp = genop(s, MKOP_sBx(OP_JMP, pos3));
+        tmp = genjmp(s, OP_JMP, pos3);
         pos3 = tmp;
         if (pos1) dispatch(s, pos1);
 …
       if (val) {
         int pos = cursp();
         genop(s, MKOP_A(OP_LOADNIL, cursp()));
+        genop_1(s, OP_LOADNIL, cursp());
         if (pos3) dispatch_linked(s, pos3);
         if (head) pop();
         if (cursp() != pos) {
           genop(s, MKOP_AB(OP_MOVE, cursp(), pos));
+          gen_move(s, cursp(), pos, 0);
+        }
         push();
 …
     if (val) {
       pop(); pop();
       genop(s, MKOP_ABC(OP_RANGE, cursp(), cursp(), FALSE));
+      genop_1(s, OP_RANGE_INC, cursp());
       push();
+    }
 …
     if (val) {
       pop(); pop();
       genop(s, MKOP_ABC(OP_RANGE, cursp(), cursp(), TRUE));
+      genop_1(s, OP_RANGE_EXC, cursp());
       push();
+    }
 …
   case NODE_COLON2:
+    {
       int sym = new_sym(s, sym(tree->cdr));
+      int sym = new_sym(s, nsym(tree->cdr));
       codegen(s, tree->car, VAL);
       pop();
       genop(s, MKOP_ABx(OP_GETMCNST, cursp(), sym));
+      genop_2(s, OP_GETMCNST, cursp(), sym);
       if (val) push();
+    }
 …
   case NODE_COLON3:
+    {
       int sym = new_sym(s, sym(tree));
       genop(s, MKOP_A(OP_OCLASS, cursp()));
       genop(s, MKOP_ABx(OP_GETMCNST, cursp(), sym));
+      int sym = new_sym(s, nsym(tree));
+      genop_1(s, OP_OCLASS, cursp());
+      genop_2(s, OP_GETMCNST, cursp(), sym);
       if (val) push();
+    }
 …
         if (val) {
           pop_n(n);
           genop(s, MKOP_ABC(OP_ARRAY, cursp(), cursp(), n));
+          genop_2(s, OP_ARRAY, cursp(), n);
           push();
+        }
 …
   case NODE_HASH:
+  case NODE_KW_HASH:
+    {
       int len = 0;
 …
       while (tree) {
+        codegen(s, tree->car->car, val);
+        codegen(s, tree->car->cdr, val);
+        len++;
+        if (nint(tree->car->car->car) == NODE_KW_REST_ARGS) {
+          if (len > 0) {
+            pop_n(len*2);
+            if (!update) {
+              genop_2(s, OP_HASH, cursp(), len);
+            }
+            else {
+              pop();
+              genop_2(s, OP_HASHADD, cursp(), len);
+            }
+            push();
+          }
+          codegen(s, tree->car->cdr, VAL);
+          if (len > 0 || update) {
+            pop(); pop();
+            genop_1(s, OP_HASHCAT, cursp());
+            push();
+          }
+          update = TRUE;
+          len = 0;
+        }
+        else {
+          codegen(s, tree->car->car, val);
+          codegen(s, tree->car->cdr, val);
+          len++;
+        }
         tree = tree->cdr;
         if (val && len == 126) {
+        if (val && len == 255) {
           pop_n(len*2);
+          genop(s, MKOP_ABC(OP_HASH, cursp(), cursp(), len));
+          if (update) {
+          if (!update) {
+            genop_2(s, OP_HASH, cursp(), len);
+          }
+          else {
             pop();
             genop(s, MKOP_ABC(OP_SEND, cursp(), new_msym(s, mrb_intern_lit(s->mrb, "__update")), 1));
+            genop_2(s, OP_HASHADD, cursp(), len);
+          }
           push();
 …
       if (val) {
         pop_n(len*2);
+        genop(s, MKOP_ABC(OP_HASH, cursp(), cursp(), len));
+        if (update) {
+        if (!update) {
+          genop_2(s, OP_HASH, cursp(), len);
+        }
+        else {
           pop();
+          genop(s, MKOP_ABC(OP_SEND, cursp(), new_msym(s, mrb_intern_lit(s->mrb, "__update")), 1));
+          if (len > 0) {
+            genop_2(s, OP_HASHADD, cursp(), len);
+          }
+        }
         push();
 …
       int rhs = cursp();
       if ((intptr_t)t->car == NODE_ARRAY && t->cdr && nosplat(t->cdr)) {
+      if (nint(t->car) == NODE_ARRAY && t->cdr && nosplat(t->cdr)) {
         /* fixed rhs */
         t = t->cdr;
 …
+            }
             else {
               genop(s, MKOP_A(OP_LOADNIL, rhs+n));
+              genop_1(s, OP_LOADNIL, rhs+n);
               gen_assignment(s, t->car, rhs+n, NOVAL);
+            }
 …
               rn = len - post - n;
+            }
             genop(s, MKOP_ABC(OP_ARRAY, cursp(), rhs+n, rn));
+            genop_3(s, OP_ARRAY2, cursp(), rhs+n, rn);
             gen_assignment(s, t->car, cursp(), NOVAL);
             n += rn;
 …
         pop_n(len);
         if (val) {
           genop(s, MKOP_ABC(OP_ARRAY, rhs, rhs, len));
+          genop_2(s, OP_ARRAY, rhs, len);
           push();
+        }
 …
   case NODE_OP_ASGN:
+    {
       mrb_sym sym = sym(tree->cdr->car);
+      mrb_sym sym = nsym(tree->cdr->car);
       mrb_int len;
       const char *name = mrb_sym2name_len(s->mrb, sym, &len);
+      const char *name = mrb_sym_name_len(s->mrb, sym, &len);
       int idx, callargs = -1, vsp = -1;
       if ((len == 2 && name[0] == '|' && name[1] == '|') &&
           ((intptr_t)tree->car->car == NODE_CONST ||
            (intptr_t)tree->car->car == NODE_CVAR)) {
+          (nint(tree->car->car) == NODE_CONST ||
+           nint(tree->car->car) == NODE_CVAR)) {
         int onerr, noexc, exc;
         struct loopinfo *lp;
         onerr = genop(s, MKOP_Bx(OP_ONERR, 0));
+        onerr = genjmp(s, OP_ONERR, 0);
         lp = loop_push(s, LOOP_BEGIN);
         lp->pc1 = onerr;
 …
         codegen(s, tree->car, VAL);
         lp->type = LOOP_RESCUE;
         genop(s, MKOP_A(OP_POPERR, 1));
         noexc = genop(s, MKOP_Bx(OP_JMP, 0));
+        genop_1(s, OP_POPERR, 1);
+        noexc = genjmp(s, OP_JMP, 0);
         dispatch(s, onerr);
         genop(s, MKOP_ABC(OP_RESCUE, exc, 0, 0));
         genop(s, MKOP_A(OP_LOADF, exc));
+        genop_1(s, OP_EXCEPT, exc);
+        genop_1(s, OP_LOADF, exc);
         dispatch(s, noexc);
         loop_pop(s, NOVAL);
+      }
       else if ((intptr_t)tree->car->car == NODE_CALL) {
+      else if (nint(tree->car->car) == NODE_CALL) {
         node *n = tree->car->cdr;
+        int base, i, nargs = 0;
+        callargs = 0;
         if (val) {
 …
+        }
         codegen(s, n->car, VAL);   /* receiver */
+        idx = new_msym(s, sym(n->cdr->car));
+        idx = new_sym(s, nsym(n->cdr->car));
+        base = cursp()-1;
         if (n->cdr->cdr->car) {
+          int base = cursp()-1;
+          int nargs = gen_values(s, n->cdr->cdr->car->car, VAL, 1);
+          /* copy receiver and arguments */
+          nargs = gen_values(s, n->cdr->cdr->car->car, VAL, 1);
           if (nargs >= 0) {
-            int i;
-            genop(s, MKOP_AB(OP_MOVE, cursp(), base));
-            for (i=0; i<nargs; i++) {
-              genop(s, MKOP_AB(OP_MOVE, cursp()+i+1, base+i+1));
+            }
-            push_n(nargs+1);
-            pop_n(nargs+1);
             callargs = nargs;
+          }
+          else {
+            /* varargs */
+          else { /* varargs */
             push();
+            genop(s, MKOP_AB(OP_MOVE, cursp(), base));
+            genop(s, MKOP_AB(OP_MOVE, cursp()+1, base+1));
+            nargs = 1;
             callargs = CALL_MAXARGS;
+          }
+          genop(s, MKOP_ABC(OP_SEND, cursp(), idx, callargs));
+        }
+        else {
+          genop(s, MKOP_AB(OP_MOVE, cursp(), cursp()-1));
+          genop(s, MKOP_ABC(OP_SEND, cursp(), idx, 0));
+          callargs = 0;
+        }
+        }
+        /* copy receiver and arguments */
+        gen_move(s, cursp(), base, 1);
+        for (i=0; i<nargs; i++) {
+          gen_move(s, cursp()+i+1, base+i+1, 1);
+        }
+        push_n(nargs+2);pop_n(nargs+2); /* space for receiver, arguments and a block */
+        genop_3(s, OP_SEND, cursp(), idx, callargs);
         push();
+      }
 …
         if (val) {
           if (vsp >= 0) {
             genop(s, MKOP_AB(OP_MOVE, vsp, cursp()));
+          }
           pos = genop(s, MKOP_AsBx(name[0]=='|'?OP_JMPIF:OP_JMPNOT, cursp(), 0));
+            gen_move(s, vsp, cursp(), 1);
+          }
+          pos = genjmp2(s, name[0]=='|'?OP_JMPIF:OP_JMPNOT, cursp(), 0, val);
+        }
         else {
           pos = genop_peep(s, MKOP_AsBx(name[0]=='|'?OP_JMPIF:OP_JMPNOT, cursp(), 0), NOVAL);
+          pos = genjmp2(s, name[0]=='|'?OP_JMPIF:OP_JMPNOT, cursp(), 0, val);
+        }
         codegen(s, tree->cdr->cdr->car, VAL);
         pop();
         if (val && vsp >= 0) {
+          genop(s, MKOP_AB(OP_MOVE, vsp, cursp()));
+        }
+        if ((intptr_t)tree->car->car == NODE_CALL) {
+          mrb_sym m = sym(tree->car->cdr->cdr->car);
+          mrb_sym m2 = attrsym(s, m);
+          idx = new_msym(s, m2);
+          pop();
+          gen_move(s, vsp, cursp(), 1);
+        }
+        if (nint(tree->car->car) == NODE_CALL) {
           if (callargs == CALL_MAXARGS) {
-            genop(s, MKOP_AB(OP_ARYPUSH, cursp(), cursp()+1));
             pop();
             genop(s, MKOP_ABC(OP_SEND, cursp(), idx, callargs));
+            genop_1(s, OP_ARYPUSH, cursp());
+          }
           else {
             pop_n(callargs);
+            genop(s, MKOP_ABC(OP_SEND, cursp(), idx, callargs+1));
+          }
+            callargs++;
+          }
+          pop();
+          idx = new_sym(s, attrsym(s, nsym(tree->car->cdr->cdr->car)));
+          genop_3(s, OP_SEND, cursp(), idx, callargs);
+        }
         else {
 …
       pop(); pop();
-      idx = new_msym(s, sym);
       if (len == 1 && name[0] == '+')  {
         genop_peep(s, MKOP_ABC(OP_ADD, cursp(), idx, 1), val);
+        gen_addsub(s, OP_ADD, cursp());
+      }
       else if (len == 1 && name[0] == '-')  {
         genop_peep(s, MKOP_ABC(OP_SUB, cursp(), idx, 1), val);
+        gen_addsub(s, OP_SUB, cursp());
+      }
       else if (len == 1 && name[0] == '*')  {
         genop(s, MKOP_ABC(OP_MUL, cursp(), idx, 1));
+        genop_1(s, OP_MUL, cursp());
+      }
       else if (len == 1 && name[0] == '/')  {
         genop(s, MKOP_ABC(OP_DIV, cursp(), idx, 1));
+        genop_1(s, OP_DIV, cursp());
+      }
       else if (len == 1 && name[0] == '<')  {
         genop(s, MKOP_ABC(OP_LT, cursp(), idx, 1));
+        genop_1(s, OP_LT, cursp());
+      }
       else if (len == 2 && name[0] == '<' && name[1] == '=')  {
         genop(s, MKOP_ABC(OP_LE, cursp(), idx, 1));
+        genop_1(s, OP_LE, cursp());
+      }
       else if (len == 1 && name[0] == '>')  {
         genop(s, MKOP_ABC(OP_GT, cursp(), idx, 1));
+        genop_1(s, OP_GT, cursp());
+      }
       else if (len == 2 && name[0] == '>' && name[1] == '=')  {
         genop(s, MKOP_ABC(OP_GE, cursp(), idx, 1));
+        genop_1(s, OP_GE, cursp());
+      }
       else {
+        genop(s, MKOP_ABC(OP_SEND, cursp(), idx, 1));
+        idx = new_sym(s, sym);
+        genop_3(s, OP_SEND, cursp(), idx, 1);
+      }
       if (callargs < 0) {
 …
       else {
         if (val && vsp >= 0) {
           genop(s, MKOP_AB(OP_MOVE, vsp, cursp()));
+          gen_move(s, vsp, cursp(), 0);
+        }
         if (callargs == CALL_MAXARGS) {
           pop();
           genop(s, MKOP_AB(OP_ARYPUSH, cursp(), cursp()+1));
+          genop_1(s, OP_ARYPUSH, cursp());
+        }
         else {
 …
+        }
         pop();
         idx = new_msym(s, attrsym(s,sym(tree->car->cdr->cdr->car)));
         genop(s, MKOP_ABC(OP_SEND, cursp(), idx, callargs));
+        idx = new_sym(s, attrsym(s,nsym(tree->car->cdr->cdr->car)));
+        genop_3(s, OP_SEND, cursp(), idx, callargs);
+      }
+    }
 …
         if (!s2) break;
+      }
       genop(s, MKOP_ABx(OP_ARGARY, cursp(), (lv & 0xf)));
+      genop_2S(s, OP_ARGARY, cursp(), (lv & 0xf));
       push(); push();         /* ARGARY pushes two values */
       pop(); pop();
 …
+      }
       else {
         genop(s, MKOP_A(OP_LOADNIL, cursp()));
+        genop_1(s, OP_LOADNIL, cursp());
         push(); pop();
+      }
       pop_n(n+1);
       if (sendv) n = CALL_MAXARGS;
       genop(s, MKOP_ABC(OP_SUPER, cursp(), 0, n));
+      genop_2(s, OP_SUPER, cursp(), n);
       if (val) push();
+    }
 …
+      }
       if (s2) ainfo = s2->ainfo;
       genop(s, MKOP_ABx(OP_ARGARY, cursp(), (ainfo<<4)|(lv & 0xf)));
+      genop_2S(s, OP_ARGARY, cursp(), (ainfo<<4)|(lv & 0xf));
       push(); push(); pop();    /* ARGARY pushes two values */
       if (tree && tree->cdr) {
 …
+      }
       pop(); pop();
       genop(s, MKOP_ABC(OP_SUPER, cursp(), 0, CALL_MAXARGS));
+      genop_2(s, OP_SUPER, cursp(), CALL_MAXARGS);
       if (val) push();
+    }
 …
+    }
     else {
       genop(s, MKOP_A(OP_LOADNIL, cursp()));
+      genop_1(s, OP_LOADNIL, cursp());
+    }
     if (s->loop) {
       genop(s, MKOP_AB(OP_RETURN, cursp(), OP_R_RETURN));
+      gen_return(s, OP_RETURN_BLK, cursp());
+    }
     else {
       genop_peep(s, MKOP_AB(OP_RETURN, cursp(), OP_R_NORMAL), NOVAL);
+      gen_return(s, OP_RETURN, cursp());
+    }
     if (val) push();
 …
+        }
+      }
+      push();pop(); /* space for a block */
       pop_n(n+1);
       genop(s, MKOP_ABx(OP_BLKPUSH, cursp(), (ainfo<<4)|(lv & 0xf)));
+      genop_2S(s, OP_BLKPUSH, cursp(), (ainfo<<4)|(lv & 0xf));
       if (sendv) n = CALL_MAXARGS;
       genop(s, MKOP_ABC(OP_SEND, cursp(), new_msym(s, mrb_intern_lit(s->mrb, "call")), n));
+      genop_3(s, OP_SEND, cursp(), new_sym(s, mrb_intern_lit(s->mrb, "call")), n);
       if (val) push();
+    }
 …
     else if (s->loop->type == LOOP_NORMAL) {
       if (s->ensure_level > s->loop->ensure_level) {
         genop_peep(s, MKOP_A(OP_EPOP, s->ensure_level - s->loop->ensure_level), NOVAL);
+        genop_1(s, OP_EPOP, s->ensure_level - s->loop->ensure_level);
+      }
       codegen(s, tree, NOVAL);
       genop(s, MKOP_sBx(OP_JMP, s->loop->pc1 - s->pc));
+      genjmp(s, OP_JMP, s->loop->pc0);
+    }
     else {
 …
+      }
       else {
         genop(s, MKOP_A(OP_LOADNIL, cursp()));
+      }
       genop_peep(s, MKOP_AB(OP_RETURN, cursp(), OP_R_NORMAL), NOVAL);
+        genop_1(s, OP_LOADNIL, cursp());
+      }
+      gen_return(s, OP_RETURN, cursp());
+    }
     if (val) push();
 …
     else {
       if (s->ensure_level > s->loop->ensure_level) {
         genop_peep(s, MKOP_A(OP_EPOP, s->ensure_level - s->loop->ensure_level), NOVAL);
+      }
       genop(s, MKOP_sBx(OP_JMP, s->loop->pc2 - s->pc));
+        genop_1(s, OP_EPOP, s->ensure_level - s->loop->ensure_level);
+      }
+      genjmp(s, OP_JMP, s->loop->pc2);
+    }
     if (val) push();
 …
         else {
           if (n > 0) {
+            while (n--) {
+              genop_peep(s, MKOP_A(OP_POPERR, 1), NOVAL);
+            }
+            genop_1(s, OP_POPERR, n);
+          }
           if (s->ensure_level > lp->ensure_level) {
             genop_peep(s, MKOP_A(OP_EPOP, s->ensure_level - lp->ensure_level), NOVAL);
+          }
           genop(s, MKOP_sBx(OP_JMP, lp->pc1 - s->pc));
+            genop_1(s, OP_EPOP, s->ensure_level - lp->ensure_level);
+          }
+          genjmp(s, OP_JMP, lp->pc0);
+        }
+      }
 …
   case NODE_LVAR:
     if (val) {
       int idx = lv_idx(s, sym(tree));
+      int idx = lv_idx(s, nsym(tree));
       if (idx > 0) {
+        genop_peep(s, MKOP_AB(OP_MOVE, cursp(), idx), NOVAL);
+        gen_move(s, cursp(), idx, val);
+        if (val && on_eval(s)) genop_0(s, OP_NOP);
+      }
       else {
 …
         while (up) {
           idx = lv_idx(up, sym(tree));
+          idx = lv_idx(up, nsym(tree));
           if (idx > 0) {
             genop(s, MKOP_ABC(OP_GETUPVAR, cursp(), idx, lv));
+            genop_3(s, OP_GETUPVAR, cursp(), idx, lv);
             break;
+          }
 …
     break;
+  case NODE_NVAR:
+    if (val) {
+      int idx = nint(tree);
+      gen_move(s, cursp(), idx, val);
+      if (val && on_eval(s)) genop_0(s, OP_NOP);
+      push();
+    }
+    break;
   case NODE_GVAR:
     if (val) {
       int sym = new_sym(s, sym(tree));
       genop(s, MKOP_ABx(OP_GETGLOBAL, cursp(), sym));
       push();
+    {
+      int sym = new_sym(s, nsym(tree));
+      genop_2(s, OP_GETGV, cursp(), sym);
+      if (val) push();
+    }
     break;
   case NODE_IVAR:
     if (val) {
       int sym = new_sym(s, sym(tree));
       genop(s, MKOP_ABx(OP_GETIV, cursp(), sym));
       push();
+    {
+      int sym = new_sym(s, nsym(tree));
+      genop_2(s, OP_GETIV, cursp(), sym);
+      if (val) push();
+    }
     break;
   case NODE_CVAR:
     if (val) {
       int sym = new_sym(s, sym(tree));
       genop(s, MKOP_ABx(OP_GETCV, cursp(), sym));
       push();
+    {
+      int sym = new_sym(s, nsym(tree));
+      genop_2(s, OP_GETCV, cursp(), sym);
+      if (val) push();
+    }
     break;
 …
   case NODE_CONST:
+    {
+      int sym = new_sym(s, sym(tree));
+      genop(s, MKOP_ABx(OP_GETCONST, cursp(), sym));
+      if (val) {
+        push();
+      }
+    }
+    break;
+  case NODE_DEFINED:
+    codegen(s, tree, VAL);
+      int sym = new_sym(s, nsym(tree));
+      genop_2(s, OP_GETCONST, cursp(), sym);
+      if (val) push();
+    }
     break;
   case NODE_BACK_REF:
     if (val) {
+      char buf[3];
+      int sym;
+      buf[0] = '$';
+      buf[1] = (char)(intptr_t)tree;
+      buf[2] = 0;
+      sym = new_sym(s, mrb_intern_cstr(s->mrb, buf));
+      genop(s, MKOP_ABx(OP_GETGLOBAL, cursp(), sym));
+      char buf[] = {'$', nchar(tree)};
+      int sym = new_sym(s, mrb_intern(s->mrb, buf, sizeof(buf)));
+      genop_2(s, OP_GETGV, cursp(), sym);
       push();
+    }
 …
       int sym;
       str = mrb_format(mrb, "$%S", mrb_fixnum_value((mrb_int)(intptr_t)tree));
+      str = mrb_format(mrb, "$%d", nint(tree));
       sym = new_sym(s, mrb_intern_str(mrb, str));
       genop(s, MKOP_ABx(OP_GETGLOBAL, cursp(), sym));
+      genop_2(s, OP_GETGV, cursp(), sym);
       push();
+    }
 …
   case NODE_BLOCK_ARG:
     codegen(s, tree, VAL);
+    codegen(s, tree, val);
     break;
 …
     if (val) {
       char *p = (char*)tree->car;
       int base = (intptr_t)tree->cdr->car;
+      int base = nint(tree->cdr->car);
       mrb_int i;
-      mrb_code co;
       mrb_bool overflow;
       i = readint_mrb_int(s, p, base, FALSE, &overflow);
+#ifndef MRB_WITHOUT_FLOAT
       if (overflow) {
         double f = readint_float(s, p, base);
         int off = new_lit(s, mrb_float_value(s->mrb, f));
+        genop(s, MKOP_ABx(OP_LOADL, cursp(), off));
+      }
+      else {
+        if (i < MAXARG_sBx && i > -MAXARG_sBx) {
+          co = MKOP_AsBx(OP_LOADI, cursp(), i);
+        }
+        genop_2(s, OP_LOADL, cursp(), off);
+      }
+      else
+#endif
+      {
+        if (i == -1) genop_1(s, OP_LOADI__1, cursp());
+        else if (i < 0) genop_2(s, OP_LOADINEG, cursp(), (uint16_t)-i);
+        else if (i < 8) genop_1(s, OP_LOADI_0 + (uint8_t)i, cursp());
+        else if (i <= 0xffff) genop_2(s, OP_LOADI, cursp(), (uint16_t)i);
         else {
           int off = new_lit(s, mrb_fixnum_value(i));
+          co = MKOP_ABx(OP_LOADL, cursp(), off);
+        }
+        genop(s, co);
+          genop_2(s, OP_LOADL, cursp(), off);
+        }
+      }
       push();
 …
     break;
+#ifndef MRB_WITHOUT_FLOAT
   case NODE_FLOAT:
     if (val) {
 …
       int off = new_lit(s, mrb_float_value(s->mrb, f));
       genop(s, MKOP_ABx(OP_LOADL, cursp(), off));
+      genop_2(s, OP_LOADL, cursp(), off);
       push();
+    }
     break;
+#endif
   case NODE_NEGATE:
+    {
+      nt = (intptr_t)tree->car;
+      tree = tree->cdr;
+      nt = nint(tree->car);
       switch (nt) {
+#ifndef MRB_WITHOUT_FLOAT
       case NODE_FLOAT:
         if (val) {
           char *p = (char*)tree;
+          char *p = (char*)tree->cdr;
           mrb_float f = mrb_float_read(p, NULL);
           int off = new_lit(s, mrb_float_value(s->mrb, -f));
           genop(s, MKOP_ABx(OP_LOADL, cursp(), off));
+          genop_2(s, OP_LOADL, cursp(), off);
           push();
+        }
         break;
+#endif
       case NODE_INT:
         if (val) {
           char *p = (char*)tree->car;
           int base = (intptr_t)tree->cdr->car;
+          char *p = (char*)tree->cdr->car;
+          int base = nint(tree->cdr->cdr->car);
           mrb_int i;
-          mrb_code co;
           mrb_bool overflow;
           i = readint_mrb_int(s, p, base, TRUE, &overflow);
+#ifndef MRB_WITHOUT_FLOAT
           if (overflow) {
             double f = readint_float(s, p, base);
             int off = new_lit(s, mrb_float_value(s->mrb, -f));
             genop(s, MKOP_ABx(OP_LOADL, cursp(), off));
+            genop_2(s, OP_LOADL, cursp(), off);
+          }
           else {
+            if (i < MAXARG_sBx && i > -MAXARG_sBx) {
+              co = MKOP_AsBx(OP_LOADI, cursp(), i);
+#endif
+            if (i == -1) genop_1(s, OP_LOADI__1, cursp());
+            else if (i >= -0xffff) {
+              genop_2(s, OP_LOADINEG, cursp(), (uint16_t)-i);
+            }
             else {
               int off = new_lit(s, mrb_fixnum_value(i));
               co = MKOP_ABx(OP_LOADL, cursp(), off);
+              genop_2(s, OP_LOADL, cursp(), off);
+            }
+            genop(s, co);
+          }
+#ifndef MRB_WITHOUT_FLOAT
+          }
+#endif
           push();
+        }
 …
       default:
         if (val) {
+          int sym = new_msym(s, mrb_intern_lit(s->mrb, "-"));
+          genop(s, MKOP_ABx(OP_LOADI, cursp(), 0));
+          int sym = new_sym(s, mrb_intern_lit(s->mrb, "-@"));
+          codegen(s, tree, VAL);
+          pop();
+          genop_3(s, OP_SEND, cursp(), sym, 0);
           push();
-          codegen(s, tree, VAL);
-          pop(); pop();
-          genop(s, MKOP_ABC(OP_SUB, cursp(), sym, 2));
+        }
         else {
 …
       mrb_gc_arena_restore(s->mrb, ai);
       genop(s, MKOP_ABx(OP_STRING, cursp(), off));
+      genop_2(s, OP_STRING, cursp(), off);
       push();
+    }
 …
       if (!n) {
         genop(s, MKOP_A(OP_LOADNIL, cursp()));
+        genop_1(s, OP_LOADNIL, cursp());
         push();
         break;
 …
         codegen(s, n->car, VAL);
         pop(); pop();
         genop_peep(s, MKOP_AB(OP_STRCAT, cursp(), cursp()+1), VAL);
+        genop_1(s, OP_STRCAT, cursp());
         push();
         n = n->cdr;
 …
       while (n) {
         if ((intptr_t)n->car->car != NODE_STR) {
+        if (nint(n->car->car) != NODE_STR) {
           codegen(s, n->car, NOVAL);
+        }
 …
       int sym = new_sym(s, mrb_intern_lit(s->mrb, "Kernel"));
       genop(s, MKOP_A(OP_LOADSELF, cursp()));
+      genop_1(s, OP_LOADSELF, cursp());
       push();
       codegen(s, tree->car, VAL);
       n = tree->cdr;
       while (n) {
         if ((intptr_t)n->car->car == NODE_XSTR) {
+        if (nint(n->car->car) == NODE_XSTR) {
           n->car->car = (struct mrb_ast_node*)(intptr_t)NODE_STR;
           mrb_assert(!n->cdr); /* must be the end */
 …
         codegen(s, n->car, VAL);
         pop(); pop();
         genop_peep(s, MKOP_AB(OP_STRCAT, cursp(), cursp()+1), VAL);
+        genop_1(s, OP_STRCAT, cursp());
         push();
         n = n->cdr;
 …
       pop_n(3);
       sym = new_sym(s, mrb_intern_lit(s->mrb, "`"));
       genop(s, MKOP_ABC(OP_SEND, cursp(), sym, 1));
+      genop_3(s, OP_SEND, cursp(), sym, 1);
       if (val) push();
       mrb_gc_arena_restore(s->mrb, ai);
 …
       int sym;
       genop(s, MKOP_A(OP_LOADSELF, cursp()));
+      genop_1(s, OP_LOADSELF, cursp());
       push();
       genop(s, MKOP_ABx(OP_STRING, cursp(), off));
+      genop_2(s, OP_STRING, cursp(), off);
       push(); push();
       pop_n(3);
       sym = new_sym(s, mrb_intern_lit(s->mrb, "`"));
       genop(s, MKOP_ABC(OP_SEND, cursp(), sym, 1));
+      genop_3(s, OP_SEND, cursp(), sym, 1);
       if (val) push();
       mrb_gc_arena_restore(s->mrb, ai);
 …
       int argc = 1;
       genop(s, MKOP_A(OP_OCLASS, cursp()));
       genop(s, MKOP_ABx(OP_GETMCNST, cursp(), sym));
+      genop_1(s, OP_OCLASS, cursp());
+      genop_2(s, OP_GETMCNST, cursp(), sym);
       push();
+      genop(s, MKOP_ABx(OP_STRING, cursp(), off));
+      genop_2(s, OP_STRING, cursp(), off);
+      push();
       if (p2 || p3) {
+        if (p2) { /* opt */
+          off = new_lit(s, mrb_str_new_cstr(s->mrb, p2));
+          genop_2(s, OP_STRING, cursp(), off);
+        }
+        else {
+          genop_1(s, OP_LOADNIL, cursp());
+        }
         push();
-        if (p2) {
-          off = new_lit(s, mrb_str_new_cstr(s->mrb, p2));
-          genop(s, MKOP_ABx(OP_STRING, cursp(), off));
+        }
-        else {
-          genop(s, MKOP_A(OP_LOADNIL, cursp()));
+        }
         argc++;
+        if (p3) {
+        if (p3) { /* enc */
+          off = new_lit(s, mrb_str_new(s->mrb, p3, 1));
+          genop_2(s, OP_STRING, cursp(), off);
           push();
-          off = new_lit(s, mrb_str_new(s->mrb, p3, 1));
-          genop(s, MKOP_ABx(OP_STRING, cursp(), off));
           argc++;
+          pop();
+        }
+        pop();
+      }
+      pop();
+        }
+      }
+      push(); /* space for a block */
+      pop_n(argc+2);
       sym = new_sym(s, mrb_intern_lit(s->mrb, "compile"));
       genop(s, MKOP_ABC(OP_SEND, cursp(), sym, argc));
+      genop_3(s, OP_SEND, cursp(), sym, argc);
       mrb_gc_arena_restore(s->mrb, ai);
       push();
 …
       char *p;
       genop(s, MKOP_A(OP_OCLASS, cursp()));
       genop(s, MKOP_ABx(OP_GETMCNST, cursp(), sym));
+      genop_1(s, OP_OCLASS, cursp());
+      genop_2(s, OP_GETMCNST, cursp(), sym);
       push();
       codegen(s, n->car, VAL);
 …
         codegen(s, n->car, VAL);
         pop(); pop();
         genop_peep(s, MKOP_AB(OP_STRCAT, cursp(), cursp()+1), VAL);
+        genop_1(s, OP_STRCAT, cursp());
         push();
         n = n->cdr;
+      }
       n = tree->cdr->cdr;
       if (n->car) {
+      if (n->car) { /* tail */
         p = (char*)n->car;
         off = new_lit(s, mrb_str_new_cstr(s->mrb, p));
         codegen(s, tree->car, VAL);
         genop(s, MKOP_ABx(OP_STRING, cursp(), off));
+        genop_2(s, OP_STRING, cursp(), off);
         pop();
+        genop_peep(s, MKOP_AB(OP_STRCAT, cursp(), cursp()+1), VAL);
+      }
+      if (n->cdr->car) {
+        genop_1(s, OP_STRCAT, cursp());
+        push();
+      }
+      if (n->cdr->car) { /* opt */
         char *p2 = (char*)n->cdr->car;
+        off = new_lit(s, mrb_str_new_cstr(s->mrb, p2));
+        genop_2(s, OP_STRING, cursp(), off);
         push();
+        argc++;
+      }
+      if (n->cdr->cdr) { /* enc */
+        char *p2 = (char*)n->cdr->cdr;
         off = new_lit(s, mrb_str_new_cstr(s->mrb, p2));
+        genop(s, MKOP_ABx(OP_STRING, cursp(), off));
+        genop_2(s, OP_STRING, cursp(), off);
+        push();
         argc++;
+      }
+      if (n->cdr->cdr) {
+        char *p2 = (char*)n->cdr->cdr;
+        push();
+        off = new_lit(s, mrb_str_new_cstr(s->mrb, p2));
+        genop(s, MKOP_ABx(OP_STRING, cursp(), off));
+        argc++;
+      }
+      pop_n(argc);
+      push(); /* space for a block */
+      pop_n(argc+2);
       sym = new_sym(s, mrb_intern_lit(s->mrb, "compile"));
       genop(s, MKOP_ABC(OP_SEND, cursp(), sym, argc));
+      genop_3(s, OP_SEND, cursp(), sym, argc);
       mrb_gc_arena_restore(s->mrb, ai);
       push();
 …
       while (n) {
         if ((intptr_t)n->car->car != NODE_STR) {
+        if (nint(n->car->car) != NODE_STR) {
           codegen(s, n->car, NOVAL);
+        }
 …
   case NODE_SYM:
     if (val) {
       int sym = new_sym(s, sym(tree));
       genop(s, MKOP_ABx(OP_LOADSYM, cursp(), sym));
+      int sym = new_sym(s, nsym(tree));
+      genop_2(s, OP_LOADSYM, cursp(), sym);
       push();
+    }
 …
     codegen(s, tree, val);
     if (val) {
       gen_send_intern(s);
+      gen_intern(s);
+    }
     break;
 …
   case NODE_SELF:
     if (val) {
       genop(s, MKOP_A(OP_LOADSELF, cursp()));
+      genop_1(s, OP_LOADSELF, cursp());
       push();
+    }
 …
   case NODE_NIL:
     if (val) {
       genop(s, MKOP_A(OP_LOADNIL, cursp()));
+      genop_1(s, OP_LOADNIL, cursp());
       push();
+    }
 …
   case NODE_TRUE:
     if (val) {
       genop(s, MKOP_A(OP_LOADT, cursp()));
+      genop_1(s, OP_LOADT, cursp());
       push();
+    }
 …
   case NODE_FALSE:
     if (val) {
       genop(s, MKOP_A(OP_LOADF, cursp()));
+      genop_1(s, OP_LOADF, cursp());
       push();
+    }
 …
   case NODE_ALIAS:
+    {
+      int a = new_msym(s, sym(tree->car));
+      int b = new_msym(s, sym(tree->cdr));
+      int c = new_msym(s, mrb_intern_lit(s->mrb, "alias_method"));
+      genop(s, MKOP_A(OP_TCLASS, cursp()));
+      push();
+      genop(s, MKOP_ABx(OP_LOADSYM, cursp(), a));
+      push();
+      genop(s, MKOP_ABx(OP_LOADSYM, cursp(), b));
+      push();
+      genop(s, MKOP_A(OP_LOADNIL, cursp()));
+      push();
+      pop_n(4);
+      genop(s, MKOP_ABC(OP_SEND, cursp(), c, 2));
+      int a = new_sym(s, nsym(tree->car));
+      int b = new_sym(s, nsym(tree->cdr));
+      genop_2(s, OP_ALIAS, a, b);
       if (val) {
+        genop_1(s, OP_LOADNIL, cursp());
         push();
+      }
 …
   case NODE_UNDEF:
+    {
-      int undef = new_msym(s, mrb_intern_lit(s->mrb, "undef_method"));
-      int num = 0;
       node *t = tree;
-      genop(s, MKOP_A(OP_TCLASS, cursp()));
-      push();
       while (t) {
+        int symbol;
+        if (num >= CALL_MAXARGS - 1) {
+          pop_n(num);
+          genop(s, MKOP_ABC(OP_ARRAY, cursp(), cursp(), num));
+          while (t) {
+            symbol = new_msym(s, sym(t->car));
+            push();
+            genop(s, MKOP_ABx(OP_LOADSYM, cursp(), symbol));
+            pop();
+            genop(s, MKOP_AB(OP_ARYPUSH, cursp(), cursp()+1));
+            t = t->cdr;
+          }
+          num = CALL_MAXARGS;
+          break;
+        }
+        symbol = new_msym(s, sym(t->car));
+        genop(s, MKOP_ABx(OP_LOADSYM, cursp(), symbol));
+        push();
+        int symbol = new_sym(s, nsym(t->car));
+        genop_1(s, OP_UNDEF, symbol);
         t = t->cdr;
+        num++;
+      }
+      pop();
+      if (num < CALL_MAXARGS) {
+        pop_n(num);
+      }
+      genop(s, MKOP_ABC(OP_SEND, cursp(), undef, num));
+      }
       if (val) {
+        genop_1(s, OP_LOADNIL, cursp());
         push();
+      }
 …
+    {
       int idx;
+      node *body;
       if (tree->car->car == (node*)0) {
         genop(s, MKOP_A(OP_LOADNIL, cursp()));
+        genop_1(s, OP_LOADNIL, cursp());
         push();
+      }
       else if (tree->car->car == (node*)1) {
         genop(s, MKOP_A(OP_OCLASS, cursp()));
+        genop_1(s, OP_OCLASS, cursp());
         push();
+      }
 …
+      }
       else {
         genop(s, MKOP_A(OP_LOADNIL, cursp()));
+        genop_1(s, OP_LOADNIL, cursp());
         push();
+      }
       pop(); pop();
+      idx = new_msym(s, sym(tree->car->cdr));
+      genop(s, MKOP_AB(OP_CLASS, cursp(), idx));
+      idx = scope_body(s, tree->cdr->cdr->car, val);
+      genop(s, MKOP_ABx(OP_EXEC, cursp(), idx));
+      idx = new_sym(s, nsym(tree->car->cdr));
+      genop_2(s, OP_CLASS, cursp(), idx);
+      body = tree->cdr->cdr->car;
+      if (nint(body->cdr->car) == NODE_BEGIN && body->cdr->cdr == NULL) {
+        genop_1(s, OP_LOADNIL, cursp());
+      }
+      else {
+        idx = scope_body(s, body, val);
+        genop_2(s, OP_EXEC, cursp(), idx);
+      }
       if (val) {
         push();
 …
       if (tree->car->car == (node*)0) {
         genop(s, MKOP_A(OP_LOADNIL, cursp()));
+        genop_1(s, OP_LOADNIL, cursp());
         push();
+      }
       else if (tree->car->car == (node*)1) {
         genop(s, MKOP_A(OP_OCLASS, cursp()));
+        genop_1(s, OP_OCLASS, cursp());
         push();
+      }
 …
+      }
       pop();
+      idx = new_msym(s, sym(tree->car->cdr));
+      genop(s, MKOP_AB(OP_MODULE, cursp(), idx));
+      idx = scope_body(s, tree->cdr->car, val);
+      genop(s, MKOP_ABx(OP_EXEC, cursp(), idx));
+      idx = new_sym(s, nsym(tree->car->cdr));
+      genop_2(s, OP_MODULE, cursp(), idx);
+      if (nint(tree->cdr->car->cdr->car) == NODE_BEGIN &&
+          tree->cdr->car->cdr->cdr == NULL) {
+        genop_1(s, OP_LOADNIL, cursp());
+      }
+      else {
+        idx = scope_body(s, tree->cdr->car, val);
+        genop_2(s, OP_EXEC, cursp(), idx);
+      }
       if (val) {
         push();
 …
       codegen(s, tree->car, VAL);
       pop();
+      genop(s, MKOP_AB(OP_SCLASS, cursp(), cursp()));
+      idx = scope_body(s, tree->cdr->car, val);
+      genop(s, MKOP_ABx(OP_EXEC, cursp(), idx));
+      genop_1(s, OP_SCLASS, cursp());
+      if (nint(tree->cdr->car->cdr->car) == NODE_BEGIN &&
+          tree->cdr->car->cdr->cdr == NULL) {
+        genop_1(s, OP_LOADNIL, cursp());
+      }
+      else {
+        idx = scope_body(s, tree->cdr->car, val);
+        genop_2(s, OP_EXEC, cursp(), idx);
+      }
       if (val) {
         push();
 …
   case NODE_DEF:
+    {
       int sym = new_msym(s, sym(tree->car));
+      int sym = new_sym(s, nsym(tree->car));
       int idx = lambda_body(s, tree->cdr, 0);
       genop(s, MKOP_A(OP_TCLASS, cursp()));
+      genop_1(s, OP_TCLASS, cursp());
       push();
       genop(s, MKOP_Abc(OP_LAMBDA, cursp(), idx, OP_L_METHOD));
+      genop_2(s, OP_METHOD, cursp(), idx);
       push(); pop();
       pop();
       genop(s, MKOP_AB(OP_METHOD, cursp(), sym));
+      genop_2(s, OP_DEF, cursp(), sym);
       if (val) {
         genop(s, MKOP_ABx(OP_LOADSYM, cursp(), sym));
+        genop_2(s, OP_LOADSYM, cursp(), sym);
         push();
+      }
 …
+    {
       node *recv = tree->car;
       int sym = new_msym(s, sym(tree->cdr->car));
+      int sym = new_sym(s, nsym(tree->cdr->car));
       int idx = lambda_body(s, tree->cdr->cdr, 0);
       codegen(s, recv, VAL);
       pop();
       genop(s, MKOP_AB(OP_SCLASS, cursp(), cursp()));
+      genop_1(s, OP_SCLASS, cursp());
       push();
       genop(s, MKOP_Abc(OP_LAMBDA, cursp(), idx, OP_L_METHOD));
+      genop_2(s, OP_METHOD, cursp(), idx);
       pop();
       genop(s, MKOP_AB(OP_METHOD, cursp(), sym));
+      genop_2(s, OP_DEF, cursp(), sym);
       if (val) {
         genop(s, MKOP_ABx(OP_LOADSYM, cursp(), sym));
+        genop_2(s, OP_LOADSYM, cursp(), sym);
         push();
+      }
 …
   codegen_scope *p = (codegen_scope *)mrb_pool_alloc(pool, sizeof(codegen_scope));
+  if (!p) return NULL;
+  if (!p) {
+    if (prev)
+      codegen_error(prev, "unexpected scope");
+    return NULL;
+  }
   *p = codegen_scope_zero;
   p->mrb = mrb;
 …
   p->irep->plen = 0;
   p->scapa = MAXMSYMLEN;
+  p->scapa = 256;
   p->irep->syms = (mrb_sym*)mrb_malloc(mrb, sizeof(mrb_sym)*p->scapa);
   p->irep->slen = 0;
 …
   p->ai = mrb_gc_arena_save(mrb);
   p->filename = prev->filename;
   if (p->filename) {
+  p->filename_sym = prev->filename_sym;
+  if (p->filename_sym) {
     p->lines = (uint16_t*)mrb_malloc(mrb, sizeof(short)*p->icapa);
+  }
 …
   /* debug setting */
   p->debug_start_pos = 0;
   if (p->filename) {
+  if (p->filename_sym) {
     mrb_debug_info_alloc(mrb, p->irep);
-    p->irep->filename = p->filename;
-    p->irep->lines = p->lines;
+  }
   else {
 …
   mrb_state *mrb = s->mrb;
   mrb_irep *irep = s->irep;
+  size_t fname_len;
+  char *fname;
+  if (s->nlocals >= 0x3ff) {
+    codegen_error(s, "too many local variables");
+  }
   irep->flags = 0;
   if (s->iseq) {
     irep->iseq = (mrb_code *)codegen_realloc(s, s->iseq, sizeof(mrb_code)*s->pc);
     irep->ilen = s->pc;
-    if (s->lines) {
-      irep->lines = (uint16_t *)codegen_realloc(s, s->lines, sizeof(uint16_t)*s->pc);
+    }
-    else {
-      irep->lines = 0;
+    }
+  }
   irep->pool = (mrb_value*)codegen_realloc(s, irep->pool, sizeof(mrb_value)*irep->plen);
   irep->syms = (mrb_sym*)codegen_realloc(s, irep->syms, sizeof(mrb_sym)*irep->slen);
   irep->reps = (mrb_irep**)codegen_realloc(s, irep->reps, sizeof(mrb_irep*)*irep->rlen);
+  if (s->filename) {
+    irep->filename = mrb_parser_get_filename(s->parser, s->filename_index);
+    mrb_debug_info_append_file(mrb, irep, s->debug_start_pos, s->pc);
+    fname_len = strlen(s->filename);
+    fname = (char*)codegen_malloc(s, fname_len + 1);
+    memcpy(fname, s->filename, fname_len);
+    fname[fname_len] = '\0';
+    irep->filename = fname;
+    irep->own_filename = TRUE;
+  }
+  if (s->filename_sym) {
+    mrb_sym fname = mrb_parser_get_filename(s->parser, s->filename_index);
+    const char *filename = mrb_sym_name_len(s->mrb, fname, NULL);
+    mrb_debug_info_append_file(s->mrb, s->irep->debug_info,
+                               filename, s->lines, s->debug_start_pos, s->pc);
+  }
+  mrb_free(s->mrb, s->lines);
   irep->nlocals = s->nlocals;
 …
   p->type = t;
   p->pc1 = p->pc2 = p->pc3 = 0;
+  p->pc0 = p->pc1 = p->pc2 = p->pc3 = 0;
   p->prev = s->loop;
   p->ensure_level = s->ensure_level;
 …
   else {
     struct loopinfo *loop;
+    int n = 0;
     if (tree) {
 …
     loop = s->loop;
+    while (loop && loop->type == LOOP_BEGIN) {
+      genop_peep(s, MKOP_A(OP_POPERR, 1), NOVAL);
+      loop = loop->prev;
+    }
+    while (loop && loop->type == LOOP_RESCUE) {
+      loop = loop->prev;
+    while (loop) {
+      if (loop->type == LOOP_BEGIN) {
+        n++;
+        loop = loop->prev;
+      }
+      else if (loop->type == LOOP_RESCUE) {
+        loop = loop->prev;
+      }
+      else{
+        break;
+      }
+    }
     if (!loop) {
 …
       return;
+    }
+    if (n > 0) {
+      genop_1(s, OP_POPERR, n);
+    }
     if (loop->type == LOOP_NORMAL) {
 …
       if (s->ensure_level > s->loop->ensure_level) {
         genop_peep(s, MKOP_A(OP_EPOP, s->ensure_level - s->loop->ensure_level), NOVAL);
+        genop_1(s, OP_EPOP, s->ensure_level - s->loop->ensure_level);
+      }
       if (tree) {
         genop_peep(s, MKOP_AB(OP_MOVE, loop->acc, cursp()), NOVAL);
+      }
       tmp = genop(s, MKOP_sBx(OP_JMP, loop->pc3));
+        gen_move(s, loop->acc, cursp(), 0);
+      }
+      tmp = genjmp(s, OP_JMP, loop->pc3);
       loop->pc3 = tmp;
+    }
     else {
       if (!tree) {
         genop(s, MKOP_A(OP_LOADNIL, cursp()));
+      }
       genop(s, MKOP_AB(OP_RETURN, cursp(), OP_R_BREAK));
+        genop_1(s, OP_LOADNIL, cursp());
+      }
+      gen_return(s, OP_BREAK, cursp());
+    }
+  }
 …
 loop_pop(codegen_scope *s, int val)
+{
+  if (val) {
+    genop_1(s, OP_LOADNIL, cursp());
+  }
   dispatch_linked(s, s->loop->pc3);
-  if (val) {
-    genop(s, MKOP_A(OP_LOADNIL, cursp()));
+  }
   s->loop = s->loop->prev;
   if (val) push();
+}
 MRB_API struct RProc*
 mrb_generate_code(mrb_state *mrb, parser_state *p)
+static struct RProc*
+generate_code(mrb_state *mrb, parser_state *p, int val)
+{
   codegen_scope *scope = scope_new(mrb, 0, 0);
 …
   struct mrb_jmpbuf *prev_jmp = mrb->jmp;
-  if (!scope) {
-    return NULL;
+  }
   scope->mrb = mrb;
   scope->parser = p;
   scope->filename = p->filename;
+  scope->filename_sym = p->filename_sym;
   scope->filename_index = p->current_filename_index;
   MRB_TRY(&scope->jmp) {
     mrb->jmp = &scope->jmp;
+    mrb->jmp = &scope->jmp;
     /* prepare irep */
     codegen(scope, p->tree, NOVAL);
+    codegen(scope, p->tree, val);
     proc = mrb_proc_new(mrb, scope->irep);
     mrb_irep_decref(mrb, scope->irep);
     mrb_pool_close(scope->mpool);
     proc->c = NULL;
+    if (mrb->c->cibase && mrb->c->cibase->proc == proc->upper) {
+      proc->upper = NULL;
+    }
     mrb->jmp = prev_jmp;
     return proc;
 …
   MRB_END_EXC(&scope->jmp);
+}
+MRB_API struct RProc*
+mrb_generate_code(mrb_state *mrb, parser_state *p)
+{
+  return generate_code(mrb, p, VAL);
+}
+void
+mrb_irep_remove_lv(mrb_state *mrb, mrb_irep *irep)
+{
+  int i;
+  if (irep->lv) {
+    mrb_free(mrb, irep->lv);
+    irep->lv = NULL;
+  }
+  for (i = 0; i < irep->rlen; ++i) {
+    mrb_irep_remove_lv(mrb, irep->reps[i]);
+  }
+}
+#undef OPCODE
+#define Z 1
+#define S 3
+#define W 4
+/* instruction sizes */
+uint8_t mrb_insn_size[] = {
+#define B 2
+#define BB 3
+#define BBB 4
+#define BS 4
+#define SB 4
+#define OPCODE(_,x) x,
+#include "mruby/ops.h"
+#undef OPCODE
+#undef B
+#undef BB
+#undef BS
+#undef SB
+#undef BBB
+};
+/* EXT1 instruction sizes */
+uint8_t mrb_insn_size1[] = {
+#define B 3
+#define BB 4
+#define BBB 5
+#define BS 5
+#define SB 5
+#define OPCODE(_,x) x,
+#include "mruby/ops.h"
+#undef OPCODE
+#undef B
+};
+/* EXT2 instruction sizes */
+uint8_t mrb_insn_size2[] = {
+#define B 2
+#define OPCODE(_,x) x,
+#include "mruby/ops.h"
+#undef OPCODE
+#undef BB
+#undef BBB
+#undef BS
+#undef SB
+};
+/* EXT3 instruction sizes */
+#define BB 5
+#define BBB 6
+#define BS 4
+#define SB 5
+uint8_t mrb_insn_size3[] = {
+#define OPCODE(_,x) x,
+#include "mruby/ops.h"
+};

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-compiler/core/keywords

-              r270
+              r439
 %{
 struct kwtable {const char *name; int id[2]; enum mrb_lex_state_enum state;};
-const struct kwtable *mrb_reserved_word(const char *, unsigned int);
-static const struct kwtable *reserved_word(const char *, unsigned int);
-#define mrb_reserved_word(str, len) reserved_word(str, len)
 %}

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-compiler/core/lex.def

-              r331
+              r439
 /* ANSI-C code produced by gperf version 3.0.4 */
+/* ANSI-C code produced by gperf version 3.1 */
 /* Command-line: gperf -L ANSI-C -C -p -j1 -i 1 -g -o -t -N mrb_reserved_word -k'1,3,$' /home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords  */
 …
       && ('{' == 123) && ('|' == 124) && ('}' == 125) && ('~' == 126))
 /* The character set is not based on ISO-646.  */
 #error "gperf generated tables don't work with this execution character set. Please report a bug to <bug-gnu-gperf@gnu.org>."
+#error "gperf generated tables don't work with this execution character set. Please report a bug to <bug-gperf@gnu.org>."
 #endif
 …
 struct kwtable {const char *name; int id[2]; enum mrb_lex_state_enum state;};
+const struct kwtable *mrb_reserved_word(const char *, unsigned int);
+static const struct kwtable *reserved_word(const char *, unsigned int);
+#define mrb_reserved_word(str, len) reserved_word(str, len)
+#line 8 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
+#line 5 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
 struct kwtable;
 …
 #endif
 static unsigned int
 hash (register const char *str, register unsigned int len)
+hash (register const char *str, register size_t len)
+{
   static const unsigned char asso_values[] =
 …
 , 51, 51, 51, 51, 51
     };
   register int hval = len;
+  register unsigned int hval = len;
   switch (hval)
 …
+}
-#ifdef __GNUC__
-__inline
-#if defined __GNUC_STDC_INLINE__ || defined __GNUC_GNU_INLINE__
-__attribute__ ((__gnu_inline__))
-#endif
-#endif
 const struct kwtable *
 mrb_reserved_word (register const char *str, register unsigned int len)
+mrb_reserved_word (register const char *str, register size_t len)
+{
   static const struct kwtable wordlist[] =
+    {
       {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
+#line 15 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
+      {"break",        {keyword_break,       keyword_break},       EXPR_MID},
+#line 20 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
+      {"else",         {keyword_else,        keyword_else},        EXPR_BEG},
+#line 30 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
+      {"nil",          {keyword_nil,         keyword_nil},         EXPR_END},
+#line 23 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
+      {"ensure",       {keyword_ensure,      keyword_ensure},      EXPR_BEG},
+#line 22 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
+      {"end",          {keyword_end,         keyword_end},         EXPR_END},
+#line 39 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
+      {"then",         {keyword_then,        keyword_then},        EXPR_BEG},
+#line 31 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
+      {"not",          {keyword_not,         keyword_not},         EXPR_ARG},
+#line 24 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
+      {"false",        {keyword_false,       keyword_false},       EXPR_END},
+#line 37 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
+      {"self",         {keyword_self,        keyword_self},        EXPR_END},
+#line 21 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
+      {"elsif",        {keyword_elsif,       keyword_elsif},       EXPR_VALUE},
+#line 34 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
+      {"rescue",       {keyword_rescue,      modifier_rescue},     EXPR_MID},
+#line 40 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
+      {"true",         {keyword_true,        keyword_true},        EXPR_END},
+#line 43 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
+      {"until",        {keyword_until,       modifier_until},      EXPR_VALUE},
+#line 42 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
+      {"unless",       {keyword_unless,      modifier_unless},     EXPR_VALUE},
+#line 36 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
+      {"return",       {keyword_return,      keyword_return},      EXPR_MID},
 #line 18 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
+      {"break",        {keyword_break,       keyword_break},       EXPR_MID},
+#line 23 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
+      {"else",         {keyword_else,        keyword_else},        EXPR_BEG},
+      {"def",          {keyword_def,         keyword_def},         EXPR_FNAME},
+#line 13 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
+      {"and",          {keyword_and,         keyword_and},         EXPR_VALUE},
+#line 19 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
+      {"do",           {keyword_do,          keyword_do},          EXPR_BEG},
+#line 46 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
+      {"yield",        {keyword_yield,       keyword_yield},       EXPR_ARG},
+#line 25 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
+      {"for",          {keyword_for,         keyword_for},         EXPR_VALUE},
+#line 41 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
+      {"undef",        {keyword_undef,       keyword_undef},       EXPR_FNAME},
+#line 32 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
+      {"or",           {keyword_or,          keyword_or},          EXPR_VALUE},
+#line 27 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
+      {"in",           {keyword_in,          keyword_in},          EXPR_VALUE},
+#line 44 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
+      {"when",         {keyword_when,        keyword_when},        EXPR_VALUE},
+#line 35 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
+      {"retry",        {keyword_retry,       keyword_retry},       EXPR_END},
+#line 26 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
+      {"if",           {keyword_if,          modifier_if},         EXPR_VALUE},
+#line 16 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
+      {"case",         {keyword_case,        keyword_case},        EXPR_VALUE},
 #line 33 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
+      {"nil",          {keyword_nil,         keyword_nil},         EXPR_END},
+#line 26 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
+      {"ensure",       {keyword_ensure,      keyword_ensure},      EXPR_BEG},
+#line 25 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
+      {"end",          {keyword_end,         keyword_end},         EXPR_END},
+#line 42 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
+      {"then",         {keyword_then,        keyword_then},        EXPR_BEG},
+#line 34 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
+      {"not",          {keyword_not,         keyword_not},         EXPR_ARG},
+#line 27 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
+      {"false",        {keyword_false,       keyword_false},       EXPR_END},
+#line 40 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
+      {"self",         {keyword_self,        keyword_self},        EXPR_END},
+#line 24 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
+      {"elsif",        {keyword_elsif,       keyword_elsif},       EXPR_VALUE},
+#line 37 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
+      {"rescue",       {keyword_rescue,      modifier_rescue},     EXPR_MID},
+#line 43 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
+      {"true",         {keyword_true,        keyword_true},        EXPR_END},
+#line 46 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
+      {"until",        {keyword_until,       modifier_until},      EXPR_VALUE},
+#line 45 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
+      {"unless",       {keyword_unless,      modifier_unless},     EXPR_VALUE},
+#line 39 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
+      {"return",       {keyword_return,      keyword_return},      EXPR_MID},
+#line 21 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
+      {"def",          {keyword_def,         keyword_def},         EXPR_FNAME},
+#line 16 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
+      {"and",          {keyword_and,         keyword_and},         EXPR_VALUE},
+#line 22 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
+      {"do",           {keyword_do,          keyword_do},          EXPR_BEG},
+#line 49 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
+      {"yield",        {keyword_yield,       keyword_yield},       EXPR_ARG},
+      {"redo",         {keyword_redo,        keyword_redo},        EXPR_END},
+#line 29 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
+      {"next",         {keyword_next,        keyword_next},        EXPR_MID},
+#line 38 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
+      {"super",        {keyword_super,       keyword_super},       EXPR_ARG},
 #line 28 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
-      {"for",          {keyword_for,         keyword_for},         EXPR_VALUE},
-#line 44 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
-      {"undef",        {keyword_undef,       keyword_undef},       EXPR_FNAME},
-#line 35 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
-      {"or",           {keyword_or,          keyword_or},          EXPR_VALUE},
-#line 30 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
-      {"in",           {keyword_in,          keyword_in},          EXPR_VALUE},
-#line 47 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
-      {"when",         {keyword_when,        keyword_when},        EXPR_VALUE},
-#line 38 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
-      {"retry",        {keyword_retry,       keyword_retry},       EXPR_END},
-#line 29 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
-      {"if",           {keyword_if,          modifier_if},         EXPR_VALUE},
-#line 19 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
-      {"case",         {keyword_case,        keyword_case},        EXPR_VALUE},
-#line 36 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
-      {"redo",         {keyword_redo,        keyword_redo},        EXPR_END},
-#line 32 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
-      {"next",         {keyword_next,        keyword_next},        EXPR_MID},
-#line 41 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
-      {"super",        {keyword_super,       keyword_super},       EXPR_ARG},
-#line 31 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
       {"module",       {keyword_module,      keyword_module},      EXPR_VALUE},
 #line 17 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
+#line 14 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
       {"begin",        {keyword_begin,       keyword_begin},       EXPR_BEG},
+#line 9 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
+      {"__LINE__",     {keyword__LINE__,     keyword__LINE__},     EXPR_END},
+#line 8 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
+      {"__FILE__",     {keyword__FILE__,     keyword__FILE__},     EXPR_END},
+#line 7 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
+      {"__ENCODING__", {keyword__ENCODING__, keyword__ENCODING__}, EXPR_END},
+#line 11 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
+      {"END",          {keyword_END,         keyword_END},         EXPR_END},
 #line 12 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
+      {"__LINE__",     {keyword__LINE__,     keyword__LINE__},     EXPR_END},
+#line 11 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
+      {"__FILE__",     {keyword__FILE__,     keyword__FILE__},     EXPR_END},
+      {"alias",        {keyword_alias,       keyword_alias},       EXPR_FNAME},
 #line 10 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
-      {"__ENCODING__", {keyword__ENCODING__, keyword__ENCODING__}, EXPR_END},
-#line 14 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
-      {"END",          {keyword_END,         keyword_END},         EXPR_END},
-#line 15 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
-      {"alias",        {keyword_alias,       keyword_alias},       EXPR_FNAME},
-#line 13 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
       {"BEGIN",        {keyword_BEGIN,       keyword_BEGIN},       EXPR_END},
       {""},
 #line 20 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
+#line 17 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
       {"class",        {keyword_class,       keyword_class},       EXPR_CLASS},
       {""}, {""},
 #line 48 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
+#line 45 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
       {"while",        {keyword_while,       modifier_while},      EXPR_VALUE}
     };
 …
   if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)
+    {
       register int key = hash (str, len);
       if (key <= MAX_HASH_VALUE && key >= 0)
+      register unsigned int key = hash (str, len);
+      if (key <= MAX_HASH_VALUE)
+        {
           register const char *s = wordlist[key].name;
 …
   return 0;
+}
 #line 50 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"
+#line 47 "/home/matz/work/mruby/mrbgems/mruby-compiler/core/keywords"

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-compiler/core/node.h

-              r331
+              r439
 enum node_type {
   NODE_METHOD,
-  NODE_FBODY,
-  NODE_CFUNC,
   NODE_SCOPE,
   NODE_BLOCK,
 …
   NODE_CASE,
   NODE_WHEN,
-  NODE_OPT_N,
   NODE_WHILE,
   NODE_UNTIL,
 …
   NODE_SCALL,
   NODE_FCALL,
-  NODE_VCALL,
   NODE_SUPER,
   NODE_ZSUPER,
 …
   NODE_ZARRAY,
   NODE_HASH,
+  NODE_KW_HASH,
   NODE_RETURN,
   NODE_YIELD,
 …
   NODE_CONST,
   NODE_CVAR,
+  NODE_NVAR,
   NODE_NTH_REF,
   NODE_BACK_REF,
   NODE_MATCH,
-  NODE_MATCH2,
-  NODE_MATCH3,
   NODE_INT,
   NODE_FLOAT,
 …
   NODE_DREGX,
   NODE_DREGX_ONCE,
-  NODE_LIST,
   NODE_ARG,
+  NODE_ARGSCAT,
+  NODE_ARGSPUSH,
+  NODE_ARGS_TAIL,
+  NODE_KW_ARG,
+  NODE_KW_REST_ARGS,
   NODE_SPLAT,
   NODE_TO_ARY,
 …
   NODE_COLON2,
   NODE_COLON3,
-  NODE_CREF,
   NODE_DOT2,
   NODE_DOT3,
-  NODE_FLIP2,
-  NODE_FLIP3,
-  NODE_ATTRSET,
   NODE_SELF,
   NODE_NIL,
 …
   NODE_FALSE,
   NODE_DEFINED,
-  NODE_NEWLINE,
   NODE_POSTEXE,
-  NODE_ALLOCA,
-  NODE_DMETHOD,
-  NODE_BMETHOD,
-  NODE_MEMO,
-  NODE_IFUNC,
   NODE_DSYM,
-  NODE_ATTRASGN,
   NODE_HEREDOC,
   NODE_LITERAL_DELIM,

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-compiler/core/parse.y

-              r331
+              r439
 #endif
 #define YYERROR_VERBOSE 1
+/*
+ * Force yacc to use our memory management.  This is a little evil because
+ * the macros assume that "parser_state *p" is in scope
+ */
+#define YYMALLOC(n)    mrb_malloc(p->mrb, (n))
+#define YYFREE(o)      mrb_free(p->mrb, (o))
+#define YYSTACK_USE_ALLOCA 0
+#define YYSTACK_USE_ALLOCA 1
 #include <ctype.h>
 …
 #include <mruby/error.h>
 #include <mruby/throw.h>
+#include <mruby/string.h>
 #include "node.h"
 …
 #define intn(x) ((int)(intptr_t)(x))
+#define NUM_SUFFIX_R   (1<<0)
+#define NUM_SUFFIX_I   (1<<1)
 static inline mrb_sym
 intern_cstr_gen(parser_state *p, const char *s)
 …
 #define intern(s,len) intern_gen(p,(s),(len))
+static inline mrb_sym
+intern_gen_c(parser_state *p, const char c)
+{
+  return mrb_intern(p->mrb, &c, 1);
+}
+#define intern_c(c) intern_gen_c(p,(c))
+#define intern_lit(s) mrb_intern_lit(p->mrb, s)
 static void
 …
   c->lineno = p->lineno;
   c->filename_index = p->current_filename_index;
+  /* beginning of next partial file; need to point the previous file */
+  if (p->lineno == 0 && p->current_filename_index > 0) {
+    c->filename_index-- ;
+  }
   return c;
+}
 …
   if (!a) return b;
+  if (!b) return a;
   while (c->cdr) {
     c = c->cdr;
+  }
+  if (b) {
+    c->cdr = b;
+  }
+  c->cdr = b;
   return a;
+}
 …
 #undef strdup
 #define strdup(s) parser_strdup(p, s)
+static void
+dump_int(uint16_t i, char *s)
+{
+  char *p = s;
+  char *t = s;
+  while (i > 0) {
+    *p++ = (i % 10)+'0';
+    i /= 10;
+  }
+  if (p == s) *p++ = '0';
+  *p = 0;
+  p--;  /* point the last char */
+  while (t < p) {
+    char c = *t;
+    *t++ = *p;
+    *p-- = c;
+  }
+}
 /* xxx ----------------------------- */
 …
+}
+static void
+local_add_blk(parser_state *p, mrb_sym blk)
+{
+  /* allocate register for block */
+  local_add_f(p, blk ? blk : mrb_intern_lit(p->mrb, "&"));
+}
+static void
+local_add_kw(parser_state *p, mrb_sym kwd)
+{
+  /* allocate register for keywords hash */
+  local_add_f(p, kwd ? kwd : mrb_intern_lit(p->mrb, "**"));
+}
 static node*
 locals_node(parser_state *p)
+{
   return p->locals ? p->locals->car : NULL;
+}
+static void
+nvars_nest(parser_state *p)
+{
+  p->nvars = cons(nint(0), p->nvars);
+}
+static void
+nvars_block(parser_state *p)
+{
+  p->nvars = cons(nint(-2), p->nvars);
+}
+static void
+nvars_unnest(parser_state *p)
+{
+  p->nvars = p->nvars->cdr;
+}
 …
+}
+/* (:kw_hash (k . v) (k . v)...) */
+static node*
+new_kw_hash(parser_state *p, node *a)
+{
+  return cons((node*)NODE_KW_HASH, a);
+}
 /* (:sym . a) */
 static node*
 …
+}
+/* (:nvar . a) */
+static node*
+new_nvar(parser_state *p, int num)
+{
+  int nvars = intn(p->nvars->car);
+  p->nvars->car = nint(nvars > num ? nvars : num);
+  return cons((node*)NODE_NVAR, nint(num));
+}
 /* (:const . a) */
 static node*
 …
+}
+/* (m o r m2 b) */
+static void
+local_add_margs(parser_state *p, node *n)
+{
+  while (n) {
+    if (n->car->car == (node*)NODE_MASGN) {
+      node *t = n->car->cdr->cdr;
+      n->car->cdr->cdr = NULL;
+      while (t) {
+        local_add_f(p, sym(t->car));
+        t = t->cdr;
+      }
+      local_add_margs(p, n->car->cdr->car->car);
+      local_add_margs(p, n->car->cdr->car->cdr->cdr->car);
+    }
+    n = n->cdr;
+  }
+}
+static void
+local_add_lv(parser_state *p, node *lv)
+{
+  while (lv) {
+    local_add_f(p, sym(lv->car));
+    lv = lv->cdr;
+  }
+}
+/* (m o r m2 tail) */
 /* m: (a b c) */
 /* o: ((a . e1) (b . e2)) */
 …
 /* b: a */
 static node*
 new_args(parser_state *p, node *m, node *opt, mrb_sym rest, node *m2, mrb_sym blk)
+new_args(parser_state *p, node *m, node *opt, mrb_sym rest, node *m2, node *tail)
+{
   node *n;
+  n = cons(m2, nsym(blk));
+  local_add_margs(p, m);
+  local_add_margs(p, m2);
+  n = cons(m2, tail);
   n = cons(nsym(rest), n);
   n = cons(opt, n);
+  while (opt) {
+    /* opt: (sym . (opt . lv)) -> (sym . opt) */
+    local_add_lv(p, opt->car->cdr->cdr);
+    opt->car->cdr = opt->car->cdr->car;
+    opt = opt->cdr;
+  }
   return cons(m, n);
+}
+/* (:args_tail keywords rest_keywords_sym block_sym) */
+static node*
+new_args_tail(parser_state *p, node *kws, node *kwrest, mrb_sym blk)
+{
+  node *k;
+  if (kws || kwrest) {
+    local_add_kw(p, (kwrest && kwrest->cdr)? sym(kwrest->cdr) : 0);
+  }
+  local_add_blk(p, blk);
+  /* allocate register for keywords arguments */
+  /* order is for Proc#parameters */
+  for (k = kws; k; k = k->cdr) {
+    if (!k->car->cdr->cdr->car) { /* allocate required keywords */
+      local_add_f(p, sym(k->car->cdr->car));
+    }
+  }
+  for (k = kws; k; k = k->cdr) {
+    if (k->car->cdr->cdr->car) { /* allocate keywords with default */
+      local_add_lv(p, k->car->cdr->cdr->car->cdr);
+      k->car->cdr->cdr->car = k->car->cdr->cdr->car->car;
+      local_add_f(p, sym(k->car->cdr->car));
+    }
+  }
+  return list4((node*)NODE_ARGS_TAIL, kws, kwrest, nsym(blk));
+}
+/* (:kw_arg kw_sym def_arg) */
+static node*
+new_kw_arg(parser_state *p, mrb_sym kw, node *def_arg)
+{
+  mrb_assert(kw);
+  return list3((node*)NODE_KW_ARG, nsym(kw), def_arg);
+}
 /* (:block_arg . a) */
 static node*
 …
+}
+static node*
+setup_numparams(parser_state *p, node *a)
+{
+  int nvars = intn(p->nvars->car);
+  if (nvars > 0) {
+    int i;
+    mrb_sym sym;
+    // m || opt || rest || tail
+    if (a && (a->car || (a->cdr && a->cdr->car) || (a->cdr->cdr && a->cdr->cdr->car) || (a->cdr->cdr->cdr->cdr && a->cdr->cdr->cdr->cdr->car))) {
+      yyerror(p, "ordinary parameter is defined");
+    }
+    else if (p->locals) {
+      /* p->locals should not be NULL unless error happens before the point */
+      node* args = 0;
+      for (i = nvars; i > 0; i--) {
+        char buf[3];
+        buf[0] = '_';
+        buf[1] = i+'0';
+        buf[2] = '\0';
+        sym = intern_cstr(buf);
+        args = cons(new_arg(p, sym), args);
+        p->locals->car = cons(nsym(sym), p->locals->car);
+      }
+      a = new_args(p, args, 0, 0, 0, 0);
+    }
+  }
+  return a;
+}
 /* (:block arg body) */
 static node*
 new_block(parser_state *p, node *a, node *b)
+{
+  a = setup_numparams(p, a);
   return list4((node*)NODE_BLOCK, locals_node(p), a, b);
+}
 …
+}
+/* (:masgn mlhs mrhs) no check */
+static node*
+new_masgn_param(parser_state *p, node *a, node *b)
+{
+  return cons((node*)NODE_MASGN, cons(a, b));
+}
 /* (:asgn lhs rhs) */
 static node*
 …
+}
+static node*
+new_imaginary(parser_state *p, node *imaginary)
+{
+  return new_call(p, new_const(p, intern_lit("Kernel")), intern_lit("Complex"), list1(list2(list3((node*)NODE_INT, (node*)strdup("0"), nint(10)), imaginary)), 1);
+}
+static node*
+new_rational(parser_state *p, node *rational)
+{
+  return new_call(p, new_const(p, intern_lit("Kernel")), intern_lit("Rational"), list1(list1(rational)), 1);
+}
 /* (:int . i) */
 static node*
+new_int(parser_state *p, const char *s, int base)
+{
+  return list3((node*)NODE_INT, (node*)strdup(s), nint(base));
+}
+new_int(parser_state *p, const char *s, int base, int suffix)
+{
+  node* result = list3((node*)NODE_INT, (node*)strdup(s), nint(base));
+  if (suffix & NUM_SUFFIX_R) {
+    result = new_rational(p, result);
+  }
+  if (suffix & NUM_SUFFIX_I) {
+    result = new_imaginary(p, result);
+  }
+  return result;
+}
+#ifndef MRB_WITHOUT_FLOAT
 /* (:float . i) */
 static node*
+new_float(parser_state *p, const char *s)
+{
+  return cons((node*)NODE_FLOAT, (node*)strdup(s));
+}
+new_float(parser_state *p, const char *s, int suffix)
+{
+  node* result = cons((node*)NODE_FLOAT, (node*)strdup(s));
+  if (suffix & NUM_SUFFIX_R) {
+    result = new_rational(p, result);
+  }
+  if (suffix & NUM_SUFFIX_I) {
+    result = new_imaginary(p, result);
+  }
+  return result;
+}
+#endif
 /* (:str . (s . len)) */
 static node*
 new_str(parser_state *p, const char *s, int len)
+new_str(parser_state *p, const char *s, size_t len)
+{
   return cons((node*)NODE_STR, cons((node*)strndup(s, len), nint(len)));
 …
+}
+static int
+string_node_p(node *n)
+{
+  return (int)((enum node_type)(intptr_t)n->car == NODE_STR);
+}
+static node*
+composite_string_node(parser_state *p, node *a, node *b)
+{
+  size_t newlen = (size_t)a->cdr + (size_t)b->cdr;
+  char *str = (char*)mrb_pool_realloc(p->pool, a->car, (size_t)a->cdr + 1, newlen + 1);
+  memcpy(str + (size_t)a->cdr, b->car, (size_t)b->cdr);
+  str[newlen] = '\0';
+  a->car = (node*)str;
+  a->cdr = (node*)newlen;
+  cons_free(b);
+  return a;
+}
+static node*
+concat_string(parser_state *p, node *a, node *b)
+{
+  if (string_node_p(a)) {
+    if (string_node_p(b)) {
+      /* a == NODE_STR && b == NODE_STR */
+      composite_string_node(p, a->cdr, b->cdr);
+      cons_free(b);
+      return a;
+    }
+    else {
+      /* a == NODE_STR && b == NODE_DSTR */
+      if (string_node_p(b->cdr->car)) {
+        /* a == NODE_STR && b->[NODE_STR, ...] */
+        composite_string_node(p, a->cdr, b->cdr->car->cdr);
+        cons_free(b->cdr->car);
+        b->cdr->car = a;
+        return b;
+      }
+    }
+  }
+  else {
+    node *c; /* last node of a */
+    for (c = a; c->cdr != NULL; c = c->cdr) ;
+    if (string_node_p(b)) {
+      /* a == NODE_DSTR && b == NODE_STR */
+      if (string_node_p(c->car)) {
+        /* a->[..., NODE_STR] && b == NODE_STR */
+        composite_string_node(p, c->car->cdr, b->cdr);
+        cons_free(b);
+        return a;
+      }
+      push(a, b);
+      return a;
+    }
+    else {
+      /* a == NODE_DSTR && b == NODE_DSTR */
+      if (string_node_p(c->car) && string_node_p(b->cdr->car)) {
+        /* a->[..., NODE_STR] && b->[NODE_STR, ...] */
+        node *d = b->cdr;
+        cons_free(b);
+        composite_string_node(p, c->car->cdr, d->car->cdr);
+        cons_free(d->car);
+        c->cdr = d->cdr;
+        cons_free(d);
+        return a;
+      }
+      else {
+        c->cdr = b->cdr;
+        cons_free(b);
+        return a;
+      }
+    }
+  }
+  return new_dstr(p, list2(a, b));
+}
 /* (:str . (s . len)) */
 static node*
 …
 new_dsym(parser_state *p, node *a)
+{
   return cons((node*)NODE_DSYM, new_dstr(p, a));
+  return cons((node*)NODE_DSYM, a);
+}
 …
   if (p->parsing_heredoc == NULL) {
     p->lstate = EXPR_BEG;
-    p->cmd_start = TRUE;
     end_strterm(p);
     p->lex_strterm = p->lex_strterm_before_heredoc;
     p->lex_strterm_before_heredoc = NULL;
-    p->heredoc_end_now = TRUE;
+  }
   else {
 …
         keyword__ENCODING__
 %token <id>  tIDENTIFIER tFID tGVAR tIVAR tCONSTANT tCVAR tLABEL
+%token <id>  tIDENTIFIER tFID tGVAR tIVAR tCONSTANT tCVAR tLABEL_TAG
 %token <nd>  tINTEGER tFLOAT tCHAR tXSTRING tREGEXP
 %token <nd>  tSTRING tSTRING_PART tSTRING_MID tLABEL_END
+%token <nd>  tSTRING tSTRING_PART tSTRING_MID
 %token <nd>  tNTH_REF tBACK_REF
 %token <num> tREGEXP_END
+%type <nd> singleton string string_rep string_interp xstring regexp
+%token <num> tNUMPARAM
+%type <nd> singleton string string_fragment string_rep string_interp xstring regexp
 %type <nd> literal numeric cpath symbol
 %type <nd> top_compstmt top_stmts top_stmt
 …
 %type <nd> command_asgn command_rhs mrhs superclass block_call block_command
 %type <nd> f_block_optarg f_block_opt
 %type <nd> f_arglist f_args f_arg f_arg_item f_optarg f_marg f_marg_list f_margs
+%type <nd> f_arglist f_args f_arg f_arg_item f_optarg f_margs
 %type <nd> assoc_list assocs assoc undef_list backref for_var
 %type <nd> block_param opt_block_param block_param_def f_opt
 …
 %type <nd> heredoc words symbols
 %type <num> call_op call_op2     /* 0:'&.', 1:'.', 2:'::' */
+%type <nd> args_tail opt_args_tail f_kwarg f_kw f_kwrest
+%type <nd> f_block_kwarg f_block_kw block_args_tail opt_block_args_tail
+%type <id> f_label
 %token tUPLUS             /* unary+ */
 …
 %token tLBRACE_ARG        /* { */
 %token tSTAR              /* * */
+%token tDSTAR             /* ** */
 %token tAMPER             /* & */
 %token tLAMBDA            /* -> */
 …
 %right '=' tOP_ASGN
 %left modifier_rescue
 %right '?' ':'
+%right '?' ':' tLABEL_TAG
 %nonassoc tDOT2 tDOT3
 %left  tOROP
 …
+                    {
                       $<nd>$ = local_switch(p);
+                      nvars_block(p);
+                    }
                   '{' top_compstmt '}'
 …
                       yyerror(p, "BEGIN not supported");
                       local_resume(p, $<nd>2);
+                      nvars_unnest(p);
                       $$ = 0;
+                    }
 …
                       $$ = new_op_asgn(p, $1, $2, $3);
+                    }
                 | primary_value '[' opt_call_args rbracket tOP_ASGN command_rhs
+                    {
                       $$ = new_op_asgn(p, new_call(p, $1, intern("[]",2), $3, '.'), $5, $6);
+                | primary_value '[' opt_call_args ']' tOP_ASGN command_rhs
+                    {
+                      $$ = new_op_asgn(p, new_call(p, $1, intern_lit("[]"), $3, '.'), $5, $6);
+                    }
                 | primary_value call_op tIDENTIFIER tOP_ASGN command_rhs
 …
                       $$ = new_begin(p, 0);
+                    }
+                ;
+                ;
 command_rhs     : command_call   %prec tOP_ASGN
 …
+                    {
                       local_nest(p);
+                      nvars_nest(p);
+                    }
                   opt_block_param
 …
                       $$ = new_block(p, $3, $4);
                       local_unnest(p);
+                      nvars_unnest(p);
+                    }
+                ;
 …
                       assignable(p, $1);
+                    }
                 | primary_value '[' opt_call_args rbracket
+                    {
                       $$ = new_call(p, $1, intern("[]",2), $3, '.');
+                | primary_value '[' opt_call_args ']'
+                    {
+                      $$ = new_call(p, $1, intern_lit("[]"), $3, '.');
+                    }
                 | primary_value call_op tIDENTIFIER
 …
                       assignable(p, $1);
+                    }
                 | primary_value '[' opt_call_args rbracket
+                    {
                       $$ = new_call(p, $1, intern("[]",2), $3, '.');
+                | primary_value '[' opt_call_args ']'
+                    {
+                      $$ = new_call(p, $1, intern_lit("[]"), $3, '.');
+                    }
                 | primary_value call_op tIDENTIFIER
 …
                       backref_error(p, $1);
                       $$ = 0;
+                    }
+                | tNUMPARAM
+                    {
+                      yyerror(p, "can't assign to numbered parameter");
+                    }
+                ;
 …
+                ;
+op              : '|'           { $$ = intern_c('|');   }
+                | '^'           { $$ = intern_c('^');   }
+                | '&'           { $$ = intern_c('&');   }
+                | tCMP          { $$ = intern("<=>",3); }
+                | tEQ           { $$ = intern("==",2);  }
+                | tEQQ          { $$ = intern("===",3); }
+                | tMATCH        { $$ = intern("=~",2);  }
+                | tNMATCH       { $$ = intern("!~",2);  }
+                | '>'           { $$ = intern_c('>');   }
+                | tGEQ          { $$ = intern(">=",2);  }
+                | '<'           { $$ = intern_c('<');   }
+                | tLEQ          { $$ = intern("<=",2);  }
+                | tNEQ          { $$ = intern("!=",2);  }
+                | tLSHFT        { $$ = intern("<<",2);  }
+                | tRSHFT        { $$ = intern(">>",2);  }
+                | '+'           { $$ = intern_c('+');   }
+                | '-'           { $$ = intern_c('-');   }
+                | '*'           { $$ = intern_c('*');   }
+                | tSTAR         { $$ = intern_c('*');   }
+                | '/'           { $$ = intern_c('/');   }
+                | '%'           { $$ = intern_c('%');   }
+                | tPOW          { $$ = intern("**",2);  }
+                | '!'           { $$ = intern_c('!');   }
+                | '~'           { $$ = intern_c('~');   }
+                | tUPLUS        { $$ = intern("+@",2);  }
+                | tUMINUS       { $$ = intern("-@",2);  }
+                | tAREF         { $$ = intern("[]",2);  }
+                | tASET         { $$ = intern("[]=",3); }
+                | '`'           { $$ = intern_c('`');   }
+op              : '|'           { $$ = intern_lit("|");   }
+                | '^'           { $$ = intern_lit("^");   }
+                | '&'           { $$ = intern_lit("&");   }
+                | tCMP          { $$ = intern_lit("<=>"); }
+                | tEQ           { $$ = intern_lit("==");  }
+                | tEQQ          { $$ = intern_lit("==="); }
+                | tMATCH        { $$ = intern_lit("=~");  }
+                | tNMATCH       { $$ = intern_lit("!~");  }
+                | '>'           { $$ = intern_lit(">");   }
+                | tGEQ          { $$ = intern_lit(">=");  }
+                | '<'           { $$ = intern_lit("<");   }
+                | tLEQ          { $$ = intern_lit("<=");  }
+                | tNEQ          { $$ = intern_lit("!=");  }
+                | tLSHFT        { $$ = intern_lit("<<");  }
+                | tRSHFT        { $$ = intern_lit(">>");  }
+                | '+'           { $$ = intern_lit("+");   }
+                | '-'           { $$ = intern_lit("-");   }
+                | '*'           { $$ = intern_lit("*");   }
+                | tSTAR         { $$ = intern_lit("*");   }
+                | '/'           { $$ = intern_lit("/");   }
+                | '%'           { $$ = intern_lit("%");   }
+                | tPOW          { $$ = intern_lit("**");  }
+                | tDSTAR        { $$ = intern_lit("**");  }
+                | '!'           { $$ = intern_lit("!");   }
+                | '~'           { $$ = intern_lit("~");   }
+                | tUPLUS        { $$ = intern_lit("+@");  }
+                | tUMINUS       { $$ = intern_lit("-@");  }
+                | tAREF         { $$ = intern_lit("[]");  }
+                | tASET         { $$ = intern_lit("[]="); }
+                | '`'           { $$ = intern_lit("`");   }
+                ;
 …
                       $$ = new_op_asgn(p, $1, $2, $3);
+                    }
                 | primary_value '[' opt_call_args rbracket tOP_ASGN arg_rhs
+                    {
                       $$ = new_op_asgn(p, new_call(p, $1, intern("[]",2), $3, '.'), $5, $6);
+                | primary_value '[' opt_call_args ']' tOP_ASGN arg_rhs
+                    {
+                      $$ = new_op_asgn(p, new_call(p, $1, intern_lit("[]"), $3, '.'), $5, $6);
+                    }
                 | primary_value call_op tIDENTIFIER tOP_ASGN arg_rhs
 …
                       $$ = new_if(p, cond($1), $3, $6);
+                    }
+                | arg '?' arg opt_nl tLABEL_TAG arg
+                    {
+                      $$ = new_if(p, cond($1), $3, $6);
+                    }
                 | primary
+                    {
 …
                 | args comma assocs trailer
+                    {
                       $$ = push($1, new_hash(p, $3));
+                      $$ = push($1, new_kw_hash(p, $3));
+                    }
                 | assocs trailer
+                    {
                       $$ = cons(new_hash(p, $1), 0);
+                      $$ = cons(new_kw_hash(p, $1), 0);
                       NODE_LINENO($$, $1);
+                    }
 …
+                ;
 paren_args      : '(' opt_call_args rparen
+paren_args      : '(' opt_call_args ')'
+                    {
                       $$ = $2;
 …
 opt_call_args   : none
                 | call_args
                 | args ','
+                | call_args opt_terms
+                | args comma
+                    {
                       $$ = cons($1,0);
                       NODE_LINENO($$, $1);
+                    }
                 | args comma assocs ','
+                    {
                       $$ = cons(push($1, new_hash(p, $3)), 0);
+                | args comma assocs comma
+                    {
+                      $$ = cons(push($1, new_kw_hash(p, $3)), 0);
                       NODE_LINENO($$, $1);
+                    }
                 | assocs ','
+                    {
                       $$ = cons(list1(new_hash(p, $1)), 0);
+                | assocs comma
+                    {
+                      $$ = cons(list1(new_kw_hash(p, $1)), 0);
                       NODE_LINENO($$, $1);
+                    }
 …
                 | assocs opt_block_arg
+                    {
                       $$ = cons(list1(new_hash(p, $1)), $2);
+                      $$ = cons(list1(new_kw_hash(p, $1)), $2);
                       NODE_LINENO($$, $1);
+                    }
                 | args comma assocs opt_block_arg
+                    {
                       $$ = cons(push($1, new_hash(p, $3)), $4);
+                      $$ = cons(push($1, new_kw_hash(p, $3)), $4);
                       NODE_LINENO($$, $1);
+                    }
 …
 comma           : ','
                 | ','  heredoc_bodies
+                | ','  opt_nl heredoc_bodies
+                ;
 …
                 | var_ref
                 | backref
+                | tNUMPARAM
+                    {
+                      $$ = new_nvar(p, $1);
+                    }
                 | tFID
+                    {
 …
                         yyerror(p, "class definition in method body");
                       $<nd>$ = local_switch(p);
+                      nvars_block(p);
+                    }
                   bodystmt
 …
                       SET_LINENO($$, $1);
                       local_resume(p, $<nd>4);
+                      nvars_unnest(p);
+                    }
                 | keyword_class
 …
+                    {
                       $<nd>$ = cons(local_switch(p), nint(p->in_single));
+                      nvars_block(p);
                       p->in_single = 0;
+                    }
 …
                       SET_LINENO($$, $1);
                       local_resume(p, $<nd>6->car);
+                      nvars_unnest(p);
                       p->in_def = $<num>4;
                       p->in_single = intn($<nd>6->cdr);
 …
                         yyerror(p, "module definition in method body");
                       $<nd>$ = local_switch(p);
+                      nvars_block(p);
+                    }
                   bodystmt
 …
                       SET_LINENO($$, $1);
                       local_resume(p, $<nd>3);
+                      nvars_unnest(p);
+                    }
                 | keyword_def fname
 …
                       p->in_def++;
                       $<nd>$ = local_switch(p);
+                      nvars_block(p);
+                    }
                   f_arglist
 …
                       SET_LINENO($$, $1);
                       local_resume(p, $<nd>4);
+                      nvars_unnest(p);
                       p->in_def--;
                       p->cmdarg_stack = $<stack>3;
 …
                       p->lstate = EXPR_ENDFN; /* force for args */
                       $<nd>$ = local_switch(p);
+                      nvars_block(p);
+                    }
                   f_arglist
 …
                       SET_LINENO($$, $1);
                       local_resume(p, $<nd>6);
+                      nvars_unnest(p);
                       p->in_single--;
                       p->cmdarg_stack = $<stack>4;
 …
+                ;
+f_marg          : f_norm_arg
+                    {
+                      $$ = new_arg(p, $1);
+                    }
+                | tLPAREN f_margs rparen
+                    {
+                      $$ = new_masgn(p, $2, 0);
+                    }
+                ;
+f_marg_list     : f_marg
+                    {
+                      $$ = list1($1);
+                    }
+                | f_marg_list ',' f_marg
+                    {
+                      $$ = push($1, $3);
+                    }
+                ;
+f_margs         : f_marg_list
+f_margs         : f_arg
+                    {
                       $$ = list3($1,0,0);
+                    }
                 | f_marg_list ',' tSTAR f_norm_arg
+                | f_arg ',' tSTAR f_norm_arg
+                    {
                       $$ = list3($1, new_arg(p, $4), 0);
+                    }
                 | f_marg_list ',' tSTAR f_norm_arg ',' f_marg_list
+                | f_arg ',' tSTAR f_norm_arg ',' f_arg
+                    {
                       $$ = list3($1, new_arg(p, $4), $6);
+                    }
+                | f_marg_list ',' tSTAR
+                    {
+                | f_arg ',' tSTAR
+                    {
+                      local_add_f(p, 0);
                       $$ = list3($1, (node*)-1, 0);
+                    }
                 | f_marg_list ',' tSTAR ',' f_marg_list
+                | f_arg ',' tSTAR ',' f_arg
+                    {
                       $$ = list3($1, (node*)-1, $5);
 …
                       $$ = list3(0, new_arg(p, $2), 0);
+                    }
                 | tSTAR f_norm_arg ',' f_marg_list
+                | tSTAR f_norm_arg ',' f_arg
+                    {
                       $$ = list3(0, new_arg(p, $2), $4);
 …
                 | tSTAR
+                    {
+                      local_add_f(p, 0);
                       $$ = list3(0, (node*)-1, 0);
+                    }
+                | tSTAR ',' f_marg_list
+                    {
+                      $$ = list3(0, (node*)-1, $3);
+                    }
+                ;
+block_param     : f_arg ',' f_block_optarg ',' f_rest_arg opt_f_block_arg
+                | tSTAR ','
+                    {
+                      local_add_f(p, 0);
+                    }
+                  f_arg
+                    {
+                      $$ = list3(0, (node*)-1, $4);
+                    }
+                ;
+block_args_tail : f_block_kwarg ',' f_kwrest opt_f_block_arg
+                    {
+                      $$ = new_args_tail(p, $1, $3, $4);
+                    }
+                | f_block_kwarg opt_f_block_arg
+                    {
+                      $$ = new_args_tail(p, $1, 0, $2);
+                    }
+                | f_kwrest opt_f_block_arg
+                    {
+                      $$ = new_args_tail(p, 0, $1, $2);
+                    }
+                | f_block_arg
+                    {
+                      $$ = new_args_tail(p, 0, 0, $1);
+                    }
+                ;
+opt_block_args_tail : ',' block_args_tail
+                    {
+                      $$ = $2;
+                    }
+                | /* none */
+                    {
+                      $$ = new_args_tail(p, 0, 0, 0);
+                    }
+                ;
+block_param     : f_arg ',' f_block_optarg ',' f_rest_arg opt_block_args_tail
+                    {
                       $$ = new_args(p, $1, $3, $5, 0, $6);
+                    }
                 | f_arg ',' f_block_optarg ',' f_rest_arg ',' f_arg opt_f_block_arg
+                | f_arg ',' f_block_optarg ',' f_rest_arg ',' f_arg opt_block_args_tail
+                    {
                       $$ = new_args(p, $1, $3, $5, $7, $8);
+                    }
                 | f_arg ',' f_block_optarg opt_f_block_arg
+                | f_arg ',' f_block_optarg opt_block_args_tail
+                    {
                       $$ = new_args(p, $1, $3, 0, 0, $4);
+                    }
                 | f_arg ',' f_block_optarg ',' f_arg opt_f_block_arg
+                | f_arg ',' f_block_optarg ',' f_arg opt_block_args_tail
+                    {
                       $$ = new_args(p, $1, $3, 0, $5, $6);
+                    }
                 | f_arg ',' f_rest_arg opt_f_block_arg
+                | f_arg ',' f_rest_arg opt_block_args_tail
+                    {
                       $$ = new_args(p, $1, 0, $3, 0, $4);
+                    }
                 | f_arg ','
+                    {
                       $$ = new_args(p, $1, 0, 0, 0, 0);
+                    }
                 | f_arg ',' f_rest_arg ',' f_arg opt_f_block_arg
+                | f_arg ',' opt_block_args_tail
+                    {
+                      $$ = new_args(p, $1, 0, 0, 0, $3);
+                    }
+                | f_arg ',' f_rest_arg ',' f_arg opt_block_args_tail
+                    {
                       $$ = new_args(p, $1, 0, $3, $5, $6);
+                    }
                 | f_arg opt_f_block_arg
+                | f_arg opt_block_args_tail
+                    {
                       $$ = new_args(p, $1, 0, 0, 0, $2);
+                    }
                 | f_block_optarg ',' f_rest_arg opt_f_block_arg
+                | f_block_optarg ',' f_rest_arg opt_block_args_tail
+                    {
                       $$ = new_args(p, 0, $1, $3, 0, $4);
+                    }
                 | f_block_optarg ',' f_rest_arg ',' f_arg opt_f_block_arg
+                | f_block_optarg ',' f_rest_arg ',' f_arg opt_block_args_tail
+                    {
                       $$ = new_args(p, 0, $1, $3, $5, $6);
+                    }
                 | f_block_optarg opt_f_block_arg
+                | f_block_optarg opt_block_args_tail
+                    {
                       $$ = new_args(p, 0, $1, 0, 0, $2);
+                    }
                 | f_block_optarg ',' f_arg opt_f_block_arg
+                | f_block_optarg ',' f_arg opt_block_args_tail
+                    {
                       $$ = new_args(p, 0, $1, 0, $3, $4);
+                    }
                 | f_rest_arg opt_f_block_arg
+                | f_rest_arg opt_block_args_tail
+                    {
                       $$ = new_args(p, 0, 0, $1, 0, $2);
+                    }
                 | f_rest_arg ',' f_arg opt_f_block_arg
+                | f_rest_arg ',' f_arg opt_block_args_tail
+                    {
                       $$ = new_args(p, 0, 0, $1, $3, $4);
+                    }
                 | f_block_arg
+                | block_args_tail
+                    {
                       $$ = new_args(p, 0, 0, 0, 0, $1);
 …
 opt_block_param : none
+                    {
+                      local_add_blk(p, 0);
+                      $$ = 0;
+                    }
                 | block_param_def
+                    {
+                   {
                       p->cmd_start = TRUE;
                       $$ = $1;
 …
+                ;
 block_param_def : '|' opt_bv_decl '|'
+block_param_def : '|' {local_add_blk(p, 0);} opt_bv_decl '|'
+                    {
                       $$ = 0;
 …
                 | tOROP
+                    {
+                      local_add_blk(p, 0);
                       $$ = 0;
+                    }
 …
                       $$ = $2;
+                    }
                 | keyword_do_LAMBDA compstmt keyword_end
+                | keyword_do_LAMBDA bodystmt keyword_end
+                    {
                       $$ = $2;
 …
+                    {
                       local_nest(p);
+                      nvars_nest(p);
+                    }
                   opt_block_param
                   compstmt
+                  bodystmt
                   keyword_end
+                    {
                       $$ = new_block(p,$3,$4);
                       local_unnest(p);
+                      nvars_unnest(p);
+                    }
+                ;
 …
                 | primary_value call_op paren_args
+                    {
                       $$ = new_call(p, $1, intern("call",4), $3, $2);
+                      $$ = new_call(p, $1, intern_lit("call"), $3, $2);
+                    }
                 | primary_value tCOLON2 paren_args
+                    {
                       $$ = new_call(p, $1, intern("call",4), $3, tCOLON2);
+                      $$ = new_call(p, $1, intern_lit("call"), $3, tCOLON2);
+                    }
                 | keyword_super paren_args
 …
                       $$ = new_zsuper(p);
+                    }
                 | primary_value '[' opt_call_args rbracket
+                    {
                       $$ = new_call(p, $1, intern("[]",2), $3, '.');
+                | primary_value '[' opt_call_args ']'
+                    {
+                      $$ = new_call(p, $1, intern_lit("[]"), $3, '.');
+                    }
+                ;
 …
+                    {
                       local_nest(p);
+                      nvars_nest(p);
                       $<num>$ = p->lineno;
+                    }
 …
                       SET_LINENO($$, $<num>2);
                       local_unnest(p);
+                      nvars_unnest(p);
+                    }
                 | keyword_do
+                    {
                       local_nest(p);
+                      nvars_nest(p);
                       $<num>$ = p->lineno;
+                    }
                   opt_block_param
                   compstmt keyword_end
+                  bodystmt keyword_end
+                    {
                       $$ = new_block(p,$3,$4);
                       SET_LINENO($$, $<num>2);
                       local_unnest(p);
+                      nvars_unnest(p);
+                    }
+                ;
 …
+                ;
+string          : tCHAR
+string          : string_fragment
+                | string string_fragment
+                    {
+                      $$ = concat_string(p, $1, $2);
+                    }
+                ;
+string_fragment : tCHAR
                 | tSTRING
                 | tSTRING_BEG tSTRING
 …
 symbol          : basic_symbol
+                    {
+                      p->lstate = EXPR_ENDARG;
                       $$ = new_sym(p, $1);
+                    }
                 | tSYMBEG tSTRING_BEG string_rep tSTRING
+                    {
                       p->lstate = EXPR_END;
                       $$ = new_dsym(p, push($3, $4));
+                      p->lstate = EXPR_ENDARG;
+                      $$ = new_dsym(p, new_dstr(p, push($3, $4)));
+                    }
+                ;
 …
 basic_symbol    : tSYMBEG sym
+                    {
-                      p->lstate = EXPR_END;
                       $$ = $2;
+                    }
 …
                       assignable(p, $1);
+                    }
+                | tNUMPARAM
+                    {
+                      yyerror(p, "can't assign to numbered parameter");
+                    }
+                ;
 …
                 | keyword__FILE__
+                    {
                       const char *fn = p->filename;
+                      const char *fn = mrb_sym_name_len(p->mrb, p->filename_sym, NULL);
                       if (!fn) {
                         fn = "(null)";
 …
                       char buf[16];
+                      snprintf(buf, sizeof(buf), "%d", p->lineno);
+                      $$ = new_int(p, buf, 10);
+                      dump_int(p->lineno, buf);
+                      $$ = new_int(p, buf, 10, 0);
+                    }
+                | keyword__ENCODING__
+                    {
+#ifdef MRB_UTF8_STRING
+                      const char *enc = "UTF-8";
+#else
+                      const char *enc = "ASCII-8BIT";
+#endif
+                      $$ = new_str(p, enc, strlen(enc));
+                    }
+                ;
 …
+                ;
+f_args          : f_arg ',' f_optarg ',' f_rest_arg opt_f_block_arg
+f_label         : tIDENTIFIER tLABEL_TAG
+                    {
+                      local_nest(p);
+                    }
+                ;
+f_kw            : f_label arg
+                    {
+                      void_expr_error(p, $2);
+                      $$ = new_kw_arg(p, $1, cons($2, locals_node(p)));
+                      local_unnest(p);
+                    }
+                | f_label
+                    {
+                      $$ = new_kw_arg(p, $1, 0);
+                      local_unnest(p);
+                    }
+                ;
+f_block_kw      : f_label primary_value
+                    {
+                      $$ = new_kw_arg(p, $1, cons($2, locals_node(p)));
+                      local_unnest(p);
+                    }
+                | f_label
+                    {
+                      $$ = new_kw_arg(p, $1, 0);
+                      local_unnest(p);
+                    }
+                ;
+f_block_kwarg   : f_block_kw
+                    {
+                      $$ = list1($1);
+                    }
+                | f_block_kwarg ',' f_block_kw
+                    {
+                      $$ = push($1, $3);
+                    }
+                ;
+f_kwarg         : f_kw
+                    {
+                      $$ = list1($1);
+                    }
+                | f_kwarg ',' f_kw
+                    {
+                      $$ = push($1, $3);
+                    }
+                ;
+kwrest_mark     : tPOW
+                | tDSTAR
+                ;
+f_kwrest        : kwrest_mark tIDENTIFIER
+                    {
+                      $$ = cons((node*)NODE_KW_REST_ARGS, nsym($2));
+                    }
+                | kwrest_mark
+                    {
+                      $$ = cons((node*)NODE_KW_REST_ARGS, 0);
+                    }
+                ;
+args_tail       : f_kwarg ',' f_kwrest opt_f_block_arg
+                    {
+                      $$ = new_args_tail(p, $1, $3, $4);
+                    }
+                | f_kwarg opt_f_block_arg
+                    {
+                      $$ = new_args_tail(p, $1, 0, $2);
+                    }
+                | f_kwrest opt_f_block_arg
+                    {
+                      $$ = new_args_tail(p, 0, $1, $2);
+                    }
+                | f_block_arg
+                    {
+                      $$ = new_args_tail(p, 0, 0, $1);
+                    }
+                ;
+opt_args_tail   : ',' args_tail
+                    {
+                      $$ = $2;
+                    }
+                | /* none */
+                    {
+                      $$ = new_args_tail(p, 0, 0, 0);
+                    }
+                ;
+f_args          : f_arg ',' f_optarg ',' f_rest_arg opt_args_tail
+                    {
                       $$ = new_args(p, $1, $3, $5, 0, $6);
+                    }
                 | f_arg ',' f_optarg ',' f_rest_arg ',' f_arg opt_f_block_arg
+                | f_arg ',' f_optarg ',' f_rest_arg ',' f_arg opt_args_tail
+                    {
                       $$ = new_args(p, $1, $3, $5, $7, $8);
+                    }
                 | f_arg ',' f_optarg opt_f_block_arg
+                | f_arg ',' f_optarg opt_args_tail
+                    {
                       $$ = new_args(p, $1, $3, 0, 0, $4);
+                    }
                 | f_arg ',' f_optarg ',' f_arg opt_f_block_arg
+                | f_arg ',' f_optarg ',' f_arg opt_args_tail
+                    {
                       $$ = new_args(p, $1, $3, 0, $5, $6);
+                    }
                 | f_arg ',' f_rest_arg opt_f_block_arg
+                | f_arg ',' f_rest_arg opt_args_tail
+                    {
                       $$ = new_args(p, $1, 0, $3, 0, $4);
+                    }
                 | f_arg ',' f_rest_arg ',' f_arg opt_f_block_arg
+                | f_arg ',' f_rest_arg ',' f_arg opt_args_tail
+                    {
                       $$ = new_args(p, $1, 0, $3, $5, $6);
+                    }
                 | f_arg opt_f_block_arg
+                | f_arg opt_args_tail
+                    {
                       $$ = new_args(p, $1, 0, 0, 0, $2);
+                    }
                 | f_optarg ',' f_rest_arg opt_f_block_arg
+                | f_optarg ',' f_rest_arg opt_args_tail
+                    {
                       $$ = new_args(p, 0, $1, $3, 0, $4);
+                    }
                 | f_optarg ',' f_rest_arg ',' f_arg opt_f_block_arg
+                | f_optarg ',' f_rest_arg ',' f_arg opt_args_tail
+                    {
                       $$ = new_args(p, 0, $1, $3, $5, $6);
+                    }
                 | f_optarg opt_f_block_arg
+                | f_optarg opt_args_tail
+                    {
                       $$ = new_args(p, 0, $1, 0, 0, $2);
+                    }
                 | f_optarg ',' f_arg opt_f_block_arg
+                | f_optarg ',' f_arg opt_args_tail
+                    {
                       $$ = new_args(p, 0, $1, 0, $3, $4);
+                    }
                 | f_rest_arg opt_f_block_arg
+                | f_rest_arg opt_args_tail
+                    {
                       $$ = new_args(p, 0, 0, $1, 0, $2);
+                    }
                 | f_rest_arg ',' f_arg opt_f_block_arg
+                | f_rest_arg ',' f_arg opt_args_tail
+                    {
                       $$ = new_args(p, 0, 0, $1, $3, $4);
+                    }
                 | f_block_arg
+                | args_tail
+                    {
                       $$ = new_args(p, 0, 0, 0, 0, $1);
 …
                 | /* none */
+                    {
                       local_add_f(p, 0);
+                      local_add_f(p, mrb_intern_lit(p->mrb, "&"));
                       $$ = new_args(p, 0, 0, 0, 0, 0);
+                    }
 …
                       $$ = 0;
+                    }
+                | tNUMPARAM
+                    {
+                      yyerror(p, "formal argument cannot be a numbered parameter");
+                      $$ = 0;
+                    }
+                ;
 …
                       $$ = new_arg(p, $1);
+                    }
+                | tLPAREN f_margs rparen
+                    {
+                      $$ = new_masgn(p, $2, 0);
+                | tLPAREN
+                    {
+                      $<nd>$ = local_switch(p);
+                    }
+                  f_margs rparen
+                    {
+                      $$ = new_masgn_param(p, $3, p->locals->car);
+                      local_resume(p, $<nd>2);
+                      local_add_f(p, 0);
+                    }
+                ;
 …
+                    {
                       local_add_f(p, $1);
+                      local_nest(p);
                       $$ = $1;
+                    }
 …
+                    {
                       void_expr_error(p, $2);
+                      $$ = cons(nsym($1), $2);
+                      $$ = cons(nsym($1), cons($2, locals_node(p)));
+                      local_unnest(p);
+                    }
+                ;
 …
+                    {
                       void_expr_error(p, $2);
+                      $$ = cons(nsym($1), $2);
+                      $$ = cons(nsym($1), cons($2, locals_node(p)));
+                      local_unnest(p);
+                    }
+                ;
 …
                 | restarg_mark
+                    {
                       local_add_f(p, 0);
+                      local_add_f(p, mrb_intern_lit(p->mrb, "*"));
                       $$ = -1;
+                    }
 …
 f_block_arg     : blkarg_mark tIDENTIFIER
+                    {
-                      local_add_f(p, $2);
                       $$ = $2;
+                    }
 …
                 | none
+                    {
-                      local_add_f(p, 0);
                       $$ = 0;
+                    }
 …
                       NODE_LINENO($$, $1);
+                    }
                 | assocs ',' assoc
+                | assocs comma assoc
+                    {
                       $$ = push($1, $3);
+                    }
+                ;
+label_tag       : tLABEL_TAG
+                | tLABEL_TAG heredoc_bodies
+                ;
 …
                       $$ = cons($1, $3);
+                    }
+                | tLABEL arg
+                | tIDENTIFIER label_tag arg
+                    {
+                      void_expr_error(p, $3);
+                      $$ = cons(new_sym(p, $1), $3);
+                    }
+                | string_fragment label_tag arg
+                    {
+                      void_expr_error(p, $3);
+                      if ($1->car == (node*)NODE_DSTR) {
+                        $$ = cons(new_dsym(p, $1), $3);
+                      }
+                      else {
+                        $$ = cons(new_sym(p, new_strsym(p, $1)), $3);
+                      }
+                    }
+                | tDSTAR arg
+                    {
                       void_expr_error(p, $2);
+                      $$ = cons(new_sym(p, $1), $2);
+                    }
+                | tLABEL_END arg
+                    {
+                      void_expr_error(p, $2);
+                      $$ = cons(new_sym(p, new_strsym(p, $1)), $2);
+                    }
+                | tSTRING_BEG tLABEL_END arg
+                    {
+                      void_expr_error(p, $3);
+                      $$ = cons(new_sym(p, new_strsym(p, $2)), $3);
+                    }
+                | tSTRING_BEG string_rep tLABEL_END arg
+                    {
+                      void_expr_error(p, $4);
+                      $$ = cons(new_dsym(p, push($2, $3)), $4);
+                      $$ = cons(cons((node*)NODE_KW_REST_ARGS, 0), $2);
+                    }
+                ;
 …
+                ;
+rparen          : opt_nl ')'
+                ;
+rbracket        : opt_nl ']'
+rparen          : opt_terms ')'
+                ;
 trailer         : /* none */
                 | nl
+                | terms
                 | comma
+                ;
 …
+{
   char* c;
   int n;
+  size_t n;
   if (! p->capture_errors) {
 #ifndef MRB_DISABLE_STDIO
+    if (p->filename) {
+      fprintf(stderr, "%s:%d:%d: %s\n", p->filename, p->lineno, p->column, s);
+    if (p->filename_sym) {
+      const char *filename = mrb_sym_name_len(p->mrb, p->filename_sym, NULL);
+      fprintf(stderr, "%s:%d:%d: %s\n", filename, p->lineno, p->column, s);
+    }
     else {
 …
 static void
 yyerror_i(parser_state *p, const char *fmt, int i)
+yyerror_c(parser_state *p, const char *msg, char c)
+{
   char buf[256];
+  snprintf(buf, sizeof(buf), fmt, i);
+  strncpy(buf, msg, sizeof(buf) - 2);
+  buf[sizeof(buf) - 2] = '\0';
+  strncat(buf, &c, 1);
   yyerror(p, buf);
+}
 …
+{
   char* c;
   int n;
+  size_t n;
   if (! p->capture_errors) {
 #ifndef MRB_DISABLE_STDIO
+    if (p->filename) {
+      fprintf(stderr, "%s:%d:%d: %s\n", p->filename, p->lineno, p->column, s);
+    if (p->filename_sym) {
+      const char *filename = mrb_sym_name_len(p->mrb, p->filename_sym, NULL);
+      fprintf(stderr, "%s:%d:%d: warning: %s\n", filename, p->lineno, p->column, s);
+    }
     else {
       fprintf(stderr, "line %d:%d: %s\n", p->lineno, p->column, s);
+      fprintf(stderr, "line %d:%d: warning: %s\n", p->lineno, p->column, s);
+    }
 #endif
 …
 static void
 yywarning_s(parser_state *p, const char *fmt, const char *s)
+yywarning_s(parser_state *p, const char *msg, const char *s)
+{
   char buf[256];
+  snprintf(buf, sizeof(buf), fmt, s);
+  strncpy(buf, msg, sizeof(buf) - 1);
+  buf[sizeof(buf) - 1] = '\0';
+  strncat(buf, ": ", sizeof(buf) - strlen(buf) - 1);
+  strncat(buf, s, sizeof(buf) - strlen(buf) - 1);
   yywarning(p, buf);
+}
 …
   int c;
   c = (int)(intptr_t)n->car;
+  c = intn(n->car);
   if (c == NODE_NTH_REF) {
     yyerror_i(p, "can't set variable $%" MRB_PRId, (mrb_int)(intptr_t)n->cdr);
+    yyerror_c(p, "can't set variable $", (char)intn(n->cdr)+'0');
+  }
   else if (c == NODE_BACK_REF) {
     yyerror_i(p, "can't set variable $%c", (int)(intptr_t)n->cdr);
+    yyerror_c(p, "can't set variable $", (char)intn(n->cdr));
+  }
   else {
     mrb_bug(p->mrb, "Internal error in backref_error() : n=>car == %S", mrb_fixnum_value(c));
+    mrb_bug(p->mrb, "Internal error in backref_error() : n=>car == %d", c);
+  }
+}
 …
   if (n == NULL) return;
   c = (int)(intptr_t)n->car;
+  c = intn(n->car);
   switch (c) {
   case NODE_BREAK:
 …
   case NODE_AND:
   case NODE_OR:
+    void_expr_error(p, n->cdr->car);
+    void_expr_error(p, n->cdr->cdr);
+    if (n->cdr) {
+      void_expr_error(p, n->cdr->car);
+      void_expr_error(p, n->cdr->cdr);
+    }
     break;
   case NODE_BEGIN:
 …
 static inline int
+nextc0(parser_state *p)
+{
+  int c;
+#ifndef MRB_DISABLE_STDIO
+  if (p->f) {
+    if (feof(p->f)) return -1;
+    c = fgetc(p->f);
+    if (c == EOF) return -1;
+  }
+  else
+#endif
+    if (!p->s || p->s >= p->send) {
+      return -1;
+    }
+    else {
+      c = (unsigned char)*p->s++;
+    }
+  return c;
+}
+static inline int
 nextc(parser_state *p)
+{
 …
     node *tmp;
     c = (int)(intptr_t)p->pb->car;
+    c = intn(p->pb->car);
     tmp = p->pb;
     p->pb = p->pb->cdr;
 …
+  }
   else {
+#ifndef MRB_DISABLE_STDIO
+    if (p->f) {
+      if (feof(p->f)) goto eof;
+      c = fgetc(p->f);
+      if (c == EOF) goto eof;
+    }
+    else
+#endif
+      if (!p->s || p->s >= p->send) {
+        goto eof;
+      }
+      else {
+        c = (unsigned char)*p->s++;
+      }
+    c = nextc0(p);
+    if (c < 0) goto eof;
+  }
   if (c >= 0) {
 …
+  }
   if (c == '\r') {
+    c = nextc(p);
+    if (c != '\n') {
+      pushback(p, c);
+      return '\r';
+    }
+    return c;
+    const int lf = nextc0(p);
+    if (lf == '\n') {
+      return '\n';
+    }
+    if (lf > 0) pushback(p, lf);
+  }
   return c;
 …
     p->column--;
+  }
   p->pb = cons((node*)(intptr_t)c, p->pb);
+  p->pb = cons(nint(c), p->pb);
+}
 …
     if (c0 == -1) return c0;    /* do not skip partial EOF */
     if (c0 >= 0) --p->column;
     list = push(list, (node*)(intptr_t)c0);
+    list = push(list, nint(c0));
   } while(n--);
   if (p->pb) {
 …
 peeks(parser_state *p, const char *s)
+{
   int len = strlen(s);
+  size_t len = strlen(s);
 #ifndef MRB_DISABLE_STDIO
 …
     s++;
     if (peeks(p, s)) {
       int len = strlen(s);
+      size_t len = strlen(s);
       while (len--) {
 …
 #define IS_LABEL_SUFFIX(n) (peek_n(p, ':',(n)) && !peek_n(p, ':', (n)+1))
 static int
+static int32_t
 scan_oct(const int *start, int len, int *retlen)
+{
   const int *s = start;
   int retval = 0;
+  int32_t retval = 0;
   /* mrb_assert(len <= 3) */
 …
     retval |= *s++ - '0';
+  }
   *retlen = s - start;
+  *retlen = (int)(s - start);
   return retval;
 …
 static int32_t
 scan_hex(const int *start, int len, int *retlen)
+scan_hex(parser_state *p, const int *start, int len, int *retlen)
+{
   static const char hexdigit[] = "0123456789abcdef0123456789ABCDEF";
   const int *s = start;
   int32_t retval = 0;
+  uint32_t retval = 0;
   char *tmp;
 …
     s++;
+  }
   *retlen = s - start;
   return retval;
+  *retlen = (int)(s - start);
+  return (int32_t)retval;
+}
 …
 read_escape_unicode(parser_state *p, int limit)
+{
-  int32_t c;
   int buf[9];
   int i;
+  int32_t hex;
   /* Look for opening brace */
   i = 0;
   buf[0] = nextc(p);
+  if (buf[0] < 0) goto eof;
+  if (buf[0] < 0) {
+  eof:
+    yyerror(p, "invalid escape character syntax");
+    return -1;
+  }
   if (ISXDIGIT(buf[0])) {
     /* \uxxxx form */
 …
     pushback(p, buf[0]);
+  }
+  c = scan_hex(buf, i, &i);
+  if (i == 0) {
+  eof:
+    yyerror(p, "Invalid escape character syntax");
+  hex = scan_hex(p, buf, i, &i);
+  if (i == 0 || hex > 0x10FFFF || (hex & 0xFFFFF800) == 0xD800) {
+    yyerror(p, "invalid Unicode code point");
     return -1;
+  }
+  if (c < 0 || c > 0x10FFFF || (c & 0xFFFFF800) == 0xD800) {
+    yyerror(p, "Invalid Unicode code point");
+    return -1;
+  }
+  return c;
+  return hex;
+}
 …
+      }
+    }
-    c = scan_hex(buf, i, &i);
     if (i == 0) {
       yyerror(p, "Invalid escape character syntax");
       return 0;
+    }
+  }
   return c;
+      yyerror(p, "invalid hex escape");
+      return -1;
+    }
+    return scan_hex(p, buf, i, &i);
+  }
   case 'u':     /* Unicode */
 …
   int c;
   string_type type = (string_type)(intptr_t)p->lex_strterm->car;
   int nest_level = (intptr_t)p->lex_strterm->cdr->car;
   int beg = (intptr_t)p->lex_strterm->cdr->cdr->car;
   int end = (intptr_t)p->lex_strterm->cdr->cdr->cdr;
+  int nest_level = intn(p->lex_strterm->cdr->car);
+  int beg = intn(p->lex_strterm->cdr->cdr->car);
+  int end = intn(p->lex_strterm->cdr->cdr->cdr);
   parser_heredoc_info *hinf = (type & STR_FUNC_HEREDOC) ? parsing_heredoc_inf(p) : NULL;
-  int cmd_state = p->cmd_start;
   if (beg == 0) beg = -3;       /* should never happen */
 …
+        }
         if ((len-1 == hinf->term_len) && (strncmp(s, hinf->term, len-1) == 0)) {
+          if (c < 0) {
+            p->parsing_heredoc = NULL;
+          }
+          else {
+            return tHEREDOC_END;
+          }
+          return tHEREDOC_END;
+        }
+      }
       if (c < 0) {
         char buf[256];
+        snprintf(buf, sizeof(buf), "can't find heredoc delimiter \"%s\" anywhere before EOF", hinf->term);
+        yyerror(p, buf);
+        const char s1[] = "can't find heredoc delimiter \"";
+        const char s2[] = "\" anywhere before EOF";
+        if (sizeof(s1)+sizeof(s2)+strlen(hinf->term)+1 >= sizeof(buf)) {
+          yyerror(p, "can't find heredoc delimiter anywhere before EOF");
+        } else {
+          strcpy(buf, s1);
+          strcat(buf, hinf->term);
+          strcat(buf, s2);
+          yyerror(p, buf);
+        }
         return 0;
+      }
 …
     else if (c == beg) {
       nest_level++;
       p->lex_strterm->cdr->car = (node*)(intptr_t)nest_level;
+      p->lex_strterm->cdr->car = nint(nest_level);
+    }
     else if (c == end) {
       nest_level--;
       p->lex_strterm->cdr->car = (node*)(intptr_t)nest_level;
+      p->lex_strterm->cdr->car = nint(nest_level);
+    }
     else if (c == '\\') {
 …
   tokfix(p);
   p->lstate = EXPR_END;
+  p->lstate = EXPR_ENDARG;
   end_strterm(p);
 …
       case 'u': f |= 16; break;
       case 'n': f |= 32; break;
+      case 'o': break;
       default: tokadd(p, re_opt); break;
+      }
 …
     if (toklen(p)) {
       char msg[128];
+      strcpy(msg, "unknown regexp option");
       tokfix(p);
+      snprintf(msg, sizeof(msg), "unknown regexp option%s - %s",
+          toklen(p) > 1 ? "s" : "", tok(p));
+      if (toklen(p) > 1) {
+        strcat(msg, "s");
+      }
+      strcat(msg, " - ");
+      strncat(msg, tok(p), sizeof(msg) - strlen(msg) - 1);
       yyerror(p, msg);
+    }
 …
+  }
   pylval.nd = new_str(p, tok(p), toklen(p));
-  if (IS_LABEL_POSSIBLE()) {
-    if (IS_LABEL_SUFFIX(0)) {
-      p->lstate = EXPR_BEG;
-      nextc(p);
-      return tLABEL_END;
+    }
+  }
   return tSTRING;
+}
+static int
+number_literal_suffix(parser_state *p)
+{
+  int c, result = 0;
+  node *list = 0;
+  int column = p->column;
+  int mask = NUM_SUFFIX_R|NUM_SUFFIX_I;
+  while ((c = nextc(p)) != -1) {
+    list = push(list, (node*)(intptr_t)c);
+    if ((mask & NUM_SUFFIX_I) && c == 'i') {
+      result |= (mask & NUM_SUFFIX_I);
+      mask &= ~NUM_SUFFIX_I;
+      /* r after i, rational of complex is disallowed */
+      mask &= ~NUM_SUFFIX_R;
+      continue;
+    }
+    if ((mask & NUM_SUFFIX_R) && c == 'r') {
+      result |= (mask & NUM_SUFFIX_R);
+      mask &= ~NUM_SUFFIX_R;
+      continue;
+    }
+    if (!ISASCII(c) || ISALPHA(c) || c == '_') {
+      p->column = column;
+      if (p->pb) {
+        p->pb = append((node*)list, p->pb);
+      }
+      else {
+        p->pb = list;
+      }
+      return 0;
+    }
+    pushback(p, c);
+    break;
+  }
+  return result;
+}
 static int
 …
   case -2:      /* end of a file */
   case '\n':
     maybe_heredoc:
+  maybe_heredoc:
     heredoc_treat_nextline(p);
-  switch (p->lstate) {
-  case EXPR_BEG:
-  case EXPR_FNAME:
-  case EXPR_DOT:
-  case EXPR_CLASS:
-  case EXPR_VALUE:
-    p->lineno++;
     p->column = 0;
+    switch (p->lstate) {
+    case EXPR_BEG:
+    case EXPR_FNAME:
+    case EXPR_DOT:
+    case EXPR_CLASS:
+    case EXPR_VALUE:
+      p->lineno++;
+      if (p->parsing_heredoc != NULL) {
+        if (p->lex_strterm) {
+          return parse_string(p);
+        }
+      }
+      goto retry;
+    default:
+      break;
+    }
     if (p->parsing_heredoc != NULL) {
+      if (p->lex_strterm) {
+        return parse_string(p);
+      }
+    }
+    goto retry;
+  default:
+    break;
+  }
+  if (p->parsing_heredoc != NULL) {
+      return '\n';
+    }
+    while ((c = nextc(p))) {
+      switch (c) {
+      case ' ': case '\t': case '\f': case '\r':
+      case '\13': /* '\v' */
+        space_seen = 1;
+        break;
+      case '#': /* comment as a whitespace */
+        pushback(p, '#');
+        p->lineno++;
+        goto retry;
+      case '.':
+        if (!peek(p, '.')) {
+          pushback(p, '.');
+          p->lineno++;
+          goto retry;
+        }
+        pushback(p, c);
+        goto normal_newline;
+      case '&':
+        if (peek(p, '.')) {
+          pushback(p, '&');
+          p->lineno++;
+          goto retry;
+        }
+        pushback(p, c);
+        goto normal_newline;
+      case -1:                  /* EOF */
+      case -2:                  /* end of a file */
+        goto normal_newline;
+      default:
+        pushback(p, c);
+        goto normal_newline;
+      }
+    }
+  normal_newline:
+    p->cmd_start = TRUE;
+    p->lstate = EXPR_BEG;
     return '\n';
+  }
-  while ((c = nextc(p))) {
-    switch (c) {
-    case ' ': case '\t': case '\f': case '\r':
-    case '\13': /* '\v' */
-      space_seen = 1;
-      break;
-    case '.':
-      if ((c = nextc(p)) != '.') {
-        pushback(p, c);
-        pushback(p, '.');
-        goto retry;
+      }
-    case -1:                  /* EOF */
-    case -2:                  /* end of a file */
-      goto normal_newline;
-    default:
-      pushback(p, c);
-      goto normal_newline;
+    }
+  }
-  normal_newline:
-  p->cmd_start = TRUE;
-  p->lstate = EXPR_BEG;
-  return '\n';
   case '*':
     if ((c = nextc(p)) == '*') {
       if ((c = nextc(p)) == '=') {
         pylval.id = intern("**",2);
+        pylval.id = intern_lit("**");
         p->lstate = EXPR_BEG;
         return tOP_ASGN;
+      }
       pushback(p, c);
+      c = tPOW;
+      if (IS_SPCARG(c)) {
+        yywarning(p, "'**' interpreted as argument prefix");
+        c = tDSTAR;
+      }
+      else if (IS_BEG()) {
+        c = tDSTAR;
+      }
+      else {
+        c = tPOW; /* "**", "argument prefix" */
+      }
+    }
     else {
       if (c == '=') {
         pylval.id = intern_c('*');
+        pylval.id = intern_lit("*");
         p->lstate = EXPR_BEG;
         return tOP_ASGN;
 …
     if (c == '<') {
       if ((c = nextc(p)) == '=') {
         pylval.id = intern("<<",2);
+        pylval.id = intern_lit("<<");
         p->lstate = EXPR_BEG;
         return tOP_ASGN;
 …
     if (c == '>') {
       if ((c = nextc(p)) == '=') {
         pylval.id = intern(">>",2);
+        pylval.id = intern_lit(">>");
         p->lstate = EXPR_BEG;
         return tOP_ASGN;
 …
         if (c2) {
           char buf[256];
+          snprintf(buf, sizeof(buf), "invalid character syntax; use ?\\%c", c2);
+          char cc[] = { (char)c2, '\0' };
+          strcpy(buf, "invalid character syntax; use ?\\");
+          strncat(buf, cc, 2);
           yyerror(p, buf);
+        }
 …
     newtok(p);
     /* need support UTF-8 if configured */
     if ((isalnum(c) || c == '_')) {
+    if ((ISALNUM(c) || c == '_')) {
       int c2 = nextc(p);
       pushback(p, c2);
       if ((isalnum(c2) || c2 == '_')) {
+      if ((ISALNUM(c2) || c2 == '_')) {
         goto ternary;
+      }
 …
     tokfix(p);
     pylval.nd = new_str(p, tok(p), toklen(p));
     p->lstate = EXPR_END;
+    p->lstate = EXPR_ENDARG;
     return tCHAR;
 …
       p->lstate = EXPR_BEG;
       if ((c = nextc(p)) == '=') {
         pylval.id = intern("&&",2);
+        pylval.id = intern_lit("&&");
         p->lstate = EXPR_BEG;
         return tOP_ASGN;
 …
+    }
     else if (c == '=') {
       pylval.id = intern_c('&');
+      pylval.id = intern_lit("&");
       p->lstate = EXPR_BEG;
       return tOP_ASGN;
 …
       p->lstate = EXPR_BEG;
       if ((c = nextc(p)) == '=') {
         pylval.id = intern("||",2);
+        pylval.id = intern_lit("||");
         p->lstate = EXPR_BEG;
         return tOP_ASGN;
 …
+    }
     if (c == '=') {
       pylval.id = intern_c('|');
+      pylval.id = intern_lit("|");
       p->lstate = EXPR_BEG;
       return tOP_ASGN;
 …
+    }
     if (c == '=') {
       pylval.id = intern_c('+');
+      pylval.id = intern_lit("+");
       p->lstate = EXPR_BEG;
       return tOP_ASGN;
 …
+    }
     if (c == '=') {
       pylval.id = intern_c('-');
+      pylval.id = intern_lit("-");
       p->lstate = EXPR_BEG;
       return tOP_ASGN;
 …
+  {
     int is_float, seen_point, seen_e, nondigit;
+    int suffix = 0;
     is_float = seen_point = seen_e = nondigit = 0;
     p->lstate = EXPR_END;
+    p->lstate = EXPR_ENDARG;
     newtok(p);
     if (c == '-' || c == '+') {
 …
+        }
         else if (nondigit) goto trailing_uc;
+        pylval.nd = new_int(p, tok(p), 16);
+        suffix = number_literal_suffix(p);
+        pylval.nd = new_int(p, tok(p), 16, suffix);
         return tINTEGER;
+      }
 …
+        }
         else if (nondigit) goto trailing_uc;
+        pylval.nd = new_int(p, tok(p), 2);
+        suffix = number_literal_suffix(p);
+        pylval.nd = new_int(p, tok(p), 2, suffix);
         return tINTEGER;
+      }
 …
+        }
         else if (nondigit) goto trailing_uc;
+        pylval.nd = new_int(p, tok(p), 10);
+        suffix = number_literal_suffix(p);
+        pylval.nd = new_int(p, tok(p), 10, suffix);
         return tINTEGER;
+      }
 …
           tokfix(p);
           if (nondigit) goto trailing_uc;
+          pylval.nd = new_int(p, tok(p), 8);
+          suffix = number_literal_suffix(p);
+          pylval.nd = new_int(p, tok(p), 8, suffix);
           return tINTEGER;
+        }
 …
       else {
         pushback(p, c);
+        pylval.nd = new_int(p, "0", 10);
+        suffix = number_literal_suffix(p);
+        pylval.nd = new_int(p, "0", 10, suffix);
         return tINTEGER;
+      }
 …
     if (nondigit) {
       trailing_uc:
       yyerror_i(p, "trailing '%c' in number", nondigit);
+      yyerror_c(p, "trailing non digit in number: ", (char)nondigit);
+    }
     tokfix(p);
     if (is_float) {
+#ifdef MRB_WITHOUT_FLOAT
+      yywarning_s(p, "floating point numbers are not supported", tok(p));
+      pylval.nd = new_int(p, "0", 10, 0);
+      return tINTEGER;
+#else
       double d;
       char *endp;
 …
       d = mrb_float_read(tok(p), &endp);
       if (d == 0 && endp == tok(p)) {
         yywarning_s(p, "corrupted float value %s", tok(p));
+        yywarning_s(p, "corrupted float value", tok(p));
+      }
       else if (errno == ERANGE) {
         yywarning_s(p, "float %s out of range", tok(p));
+        yywarning_s(p, "float out of range", tok(p));
         errno = 0;
+      }
+      pylval.nd = new_float(p, tok(p));
+      suffix = number_literal_suffix(p);
+      pylval.nd = new_float(p, tok(p), suffix);
       return tFLOAT;
+    }
+    pylval.nd = new_int(p, tok(p), 10);
+#endif
+    }
+    suffix = number_literal_suffix(p);
+    pylval.nd = new_int(p, tok(p), 10, suffix);
     return tINTEGER;
+  }
 …
       p->lstate = EXPR_ENDFN;
     else
       p->lstate = EXPR_ENDARG;
+      p->lstate = EXPR_END;
     return c;
 …
       return tCOLON2;
+    }
     if (IS_END() || ISSPACE(c)) {
+    if (!space_seen && IS_END()) {
       pushback(p, c);
       p->lstate = EXPR_BEG;
+      return ':';
+      return tLABEL_TAG;
+    }
+    if (!ISSPACE(c) || IS_BEG()) {
+      pushback(p, c);
+      p->lstate = EXPR_FNAME;
+      return tSYMBEG;
+    }
     pushback(p, c);
     p->lstate = EXPR_FNAME;
     return tSYMBEG;
+    p->lstate = EXPR_BEG;
+    return ':';
   case '/':
 …
+    }
     if ((c = nextc(p)) == '=') {
       pylval.id = intern_c('/');
+      pylval.id = intern_lit("/");
       p->lstate = EXPR_BEG;
       return tOP_ASGN;
 …
   case '^':
     if ((c = nextc(p)) == '=') {
       pylval.id = intern_c('^');
+      pylval.id = intern_lit("^");
       p->lstate = EXPR_BEG;
       return tOP_ASGN;
 …
+    }
     else if (IS_SPCARG(-1)) {
+      c = tLPAREN_ARG;
+    }
+    else if (p->lstate == EXPR_END && space_seen) {
       c = tLPAREN_ARG;
+    }
 …
       else {
         term = nextc(p);
         if (isalnum(term)) {
+        if (ISALNUM(term)) {
           yyerror(p, "unknown type of %string");
           return 0;
 …
+    }
     if ((c = nextc(p)) == '=') {
       pylval.id = intern_c('%');
+      pylval.id = intern_lit("%");
       p->lstate = EXPR_BEG;
       return tOP_ASGN;
 …
       tokadd(p, c);
       tokfix(p);
       pylval.id = intern_cstr(tok(p));
+      pylval.id = intern(tok(p), toklen(p));
       return tGVAR;
 …
       gvar:
       tokfix(p);
       pylval.id = intern_cstr(tok(p));
+      pylval.id = intern(tok(p), toklen(p));
       return tGVAR;
 …
         tokadd(p, c);
         c = nextc(p);
       } while (c >= 0 && isdigit(c));
+      } while (c >= 0 && ISDIGIT(c));
       pushback(p, c);
       if (last_state == EXPR_FNAME) goto gvar;
 …
         unsigned long n = strtoul(tok(p), NULL, 10);
         if (n > INT_MAX) {
           yyerror_i(p, "capture group index must be <= %d", INT_MAX);
+          yyerror(p, "capture group index must be <= " MRB_STRINGIZE(INT_MAX));
           return 0;
+        }
 …
         return 0;
+      }
       else if (isdigit(c)) {
+      else if (ISDIGIT(c)) {
         if (p->tidx == 1) {
           yyerror_i(p, "'@%c' is not allowed as an instance variable name", c);
+          yyerror_c(p, "wrong instance variable name: @", c);
+        }
         else {
           yyerror_i(p, "'@@%c' is not allowed as a class variable name", c);
+          yyerror_c(p, "wrong class variable name: @@", c);
+        }
         return 0;
 …
     default:
       if (!identchar(c)) {
+        yyerror_i(p,  "Invalid char '\\x%02X' in expression", c);
+        char buf[36];
+        const char s[] = "Invalid char in expression: 0x";
+        const char hexdigits[] = "0123456789ABCDEF";
+        strcpy(buf, s);
+        buf[sizeof(s)-1] = hexdigits[(c & 0xf0) >> 4];
+        buf[sizeof(s)]   = hexdigits[(c & 0x0f)];
+        buf[sizeof(s)+1] = 0;
+        yyerror(p, buf);
         goto retry;
+      }
 …
       break;
+    case '_':
+      if (toklen(p) == 2 && ISDIGIT(tok(p)[1]) && p->nvars) {
+        int n = tok(p)[1] - '0';
+        int nvar;
+        if (n > 0) {
+          node *nvars = p->nvars->cdr;
+          while (nvars) {
+            nvar = intn(nvars->car);
+            if (nvar == -2) break; /* top of the scope */
+            if (nvar > 0) {
+              yywarning(p, "numbered parameter used in outer block");
+              break;
+            }
+            nvars->car = nint(-1);
+            nvars = nvars->cdr;
+          }
+          nvar = intn(p->nvars->car);
+          if (nvar == -1) {
+            yywarning(p, "numbered parameter used in inner block");
+          }
+          if (nvar >= -1) {
+            pylval.num = n;
+            p->lstate = EXPR_END;
+            return tNUMPARAM;
+          }
+          else {
+            yywarning(p, "identifier for numbered parameter; consider another name");
+          }
+        }
+      }
+      /* fall through */
     default:
       if (toklast(p) == '!' || toklast(p) == '?') {
 …
       else {
         if (p->lstate == EXPR_FNAME) {
+          if ((c = nextc(p)) == '=' && !peek(p, '~') && !peek(p, '>') &&
+              (!peek(p, '=') || (peek_n(p, '>', 1)))) {
+            result = tIDENTIFIER;
+            tokadd(p, c);
+            tokfix(p);
+          }
+          else {
+            pushback(p, c);
+          }
           if ((c = nextc(p)) == '=' && !peek(p, '~') && !peek(p, '>') &&
               (!peek(p, '=') || (peek_n(p, '>', 1)))) {
 …
       if (IS_LABEL_POSSIBLE()) {
         if (IS_LABEL_SUFFIX(0)) {
+          p->lstate = EXPR_BEG;
+          nextc(p);
+          p->lstate = EXPR_END;
           tokfix(p);
           pylval.id = intern_cstr(tok(p));
           return tLABEL;
+          pylval.id = intern(tok(p), toklen(p));
+          return tIDENTIFIER;
+        }
+      }
 …
+    }
+    {
       mrb_sym ident = intern_cstr(tok(p));
+      mrb_sym ident = intern(tok(p), toklen(p));
       pylval.id = ident;
+#if 0
+      if (last_state != EXPR_DOT && islower(tok(p)[0]) && lvar_defined(ident)) {
+      if (last_state != EXPR_DOT && ISLOWER(tok(p)[0]) && local_var_p(p, ident)) {
         p->lstate = EXPR_END;
+      }
-#endif
+    }
     return result;
 …
   p->capture_errors = cxt->capture_errors;
   p->no_optimize = cxt->no_optimize;
+  p->on_eval = cxt->on_eval;
   if (cxt->partial_hook) {
     p->cxt = cxt;
 …
   if (!cxt) return;
   if ((int)(intptr_t)p->tree->car != NODE_SCOPE) return;
+  if (intn(p->tree->car) != NODE_SCOPE) return;
   n0 = n = p->tree->cdr->car;
   while (n) {
 …
   MRB_TRY(p->jmp) {
     int n;
+    int n = 1;
     p->cmd_start = TRUE;
 …
+{
   if (s) {
     int len = strlen(s);
+    size_t len = strlen(s);
     char *p = (char *)mrb_malloc(mrb, len + 1);
 …
   sym = mrb_intern_cstr(p->mrb, f);
   p->filename = mrb_sym2name_len(p->mrb, sym, NULL);
+  p->filename_sym = sym;
   p->lineno = (p->filename_table_length > 0)? 0 : 1;
   for (i = 0; i < p->filename_table_length; ++i) {
     if (p->filename_table[i] == sym) {
       p->current_filename_index = i;
+      p->current_filename_index = (int)i;
       return;
+    }
+  }
+  if (p->filename_table_length == UINT16_MAX) {
+    yyerror(p, "too many files to compile");
+    return;
+  }
   p->current_filename_index = p->filename_table_length++;
   new_table = (mrb_sym*)parser_palloc(p, sizeof(mrb_sym) * p->filename_table_length);
   if (p->filename_table) {
     memmove(new_table, p->filename_table, sizeof(mrb_sym) * p->filename_table_length);
+    memmove(new_table, p->filename_table, sizeof(mrb_sym) * p->current_filename_index);
+  }
   p->filename_table = new_table;
 …
+}
 MRB_API char const*
+MRB_API mrb_sym
 mrb_parser_get_filename(struct mrb_parser_state* p, uint16_t idx) {
   if (idx >= p->filename_table_length) { return NULL; }
+  if (idx >= p->filename_table_length) return 0;
   else {
     return mrb_sym2name_len(p->mrb, p->filename_table[idx], NULL);
+    return p->filename_table[idx];
+  }
+}
 …
 MRB_API parser_state*
 mrb_parse_nstring(mrb_state *mrb, const char *s, int len, mrbc_context *c)
+mrb_parse_nstring(mrb_state *mrb, const char *s, size_t len, mrbc_context *c)
+{
   parser_state *p;
 …
+  }
   if (!p->tree || p->nerr) {
+    if (c) c->parser_nerr = p->nerr;
     if (p->capture_errors) {
       char buf[256];
+      int n;
+      n = snprintf(buf, sizeof(buf), "line %d: %s\n",
+          p->error_buffer[0].lineno, p->error_buffer[0].message);
+      mrb->exc = mrb_obj_ptr(mrb_exc_new(mrb, E_SYNTAX_ERROR, buf, n));
+      strcpy(buf, "line ");
+      dump_int(p->error_buffer[0].lineno, buf+5);
+      strcat(buf, ": ");
+      strncat(buf, p->error_buffer[0].message, sizeof(buf) - strlen(buf) - 1);
+      mrb->exc = mrb_obj_ptr(mrb_exc_new(mrb, E_SYNTAX_ERROR, buf, strlen(buf)));
       mrb_parser_free(p);
       return mrb_undef_value();
 …
+    }
+  }
   proc->target_class = target;
+  MRB_PROC_SET_TARGET_CLASS(proc, target);
   if (mrb->c->ci) {
     mrb->c->ci->target_class = target;
 …
 MRB_API mrb_value
 mrb_load_nstring_cxt(mrb_state *mrb, const char *s, int len, mrbc_context *c)
+mrb_load_nstring_cxt(mrb_state *mrb, const char *s, size_t len, mrbc_context *c)
+{
   return mrb_load_exec(mrb, mrb_parse_nstring(mrb, s, len, c), c);
 …
 MRB_API mrb_value
 mrb_load_nstring(mrb_state *mrb, const char *s, int len)
+mrb_load_nstring(mrb_state *mrb, const char *s, size_t len)
+{
   return mrb_load_nstring_cxt(mrb, s, len, NULL);
 …
+}
+static void
+dump_args(mrb_state *mrb, node *n, int offset)
+{
+  if (n->car) {
+    dump_prefix(n, offset+1);
+    printf("mandatory args:\n");
+    dump_recur(mrb, n->car, offset+2);
+  }
+  n = n->cdr;
+  if (n->car) {
+    dump_prefix(n, offset+1);
+    printf("optional args:\n");
+    {
+      node *n2 = n->car;
+      while (n2) {
+        dump_prefix(n2, offset+2);
+        printf("%s=\n", mrb_sym_name(mrb, sym(n2->car->car)));
+        mrb_parser_dump(mrb, n2->car->cdr, offset+3);
+        n2 = n2->cdr;
+      }
+    }
+  }
+  n = n->cdr;
+  if (n->car) {
+    dump_prefix(n, offset+1);
+    printf("rest=*%s\n", mrb_sym_name(mrb, sym(n->car)));
+  }
+  n = n->cdr;
+  if (n->car) {
+    dump_prefix(n, offset+1);
+    printf("post mandatory args:\n");
+    dump_recur(mrb, n->car, offset+2);
+  }
+  n = n->cdr;
+  if (n) {
+    mrb_assert(intn(n->car) == NODE_ARGS_TAIL);
+    mrb_parser_dump(mrb, n, offset);
+  }
+}
+/*
+ * This function restores the GC arena on return.
+ * For this reason, if a process that further generates an object is
+ * performed at the caller, the string pointer returned as the return
+ * value may become invalid.
+ */
+static const char*
+str_dump(mrb_state *mrb, const char *str, int len)
+{
+  mrb_int ai = mrb_gc_arena_save(mrb);
+  mrb_value s;
+# if INT_MAX > MRB_INT_MAX / 4
+  /* check maximum length with "\xNN" charactor */
+  if (len > MRB_INT_MAX / 4) {
+    len = MRB_INT_MAX / 4;
+  }
+# endif
+  s = mrb_str_new(mrb, str, (mrb_int)len);
+  s = mrb_str_dump(mrb, s);
+  mrb_gc_arena_restore(mrb, ai);
+  return RSTRING_PTR(s);
+}
 #endif
 …
   again:
   dump_prefix(tree, offset);
   nodetype = (int)(intptr_t)tree->car;
+  nodetype = intn(tree->car);
   tree = tree->cdr;
   switch (nodetype) {
 …
   case NODE_LAMBDA:
+    printf("NODE_BLOCK:\n");
+    printf("NODE_LAMBDA:\n");
+    dump_prefix(tree, offset);
     goto block;
 …
     tree = tree->cdr;
     if (tree->car) {
+      node *n = tree->car;
+      if (n->car) {
+        dump_prefix(n, offset+1);
+        printf("mandatory args:\n");
+        dump_recur(mrb, n->car, offset+2);
+      }
+      n = n->cdr;
+      if (n->car) {
+        dump_prefix(n, offset+1);
+        printf("optional args:\n");
+        {
+          node *n2 = n->car;
+          while (n2) {
+            dump_prefix(n2, offset+2);
+            printf("%s=", mrb_sym2name(mrb, sym(n2->car->car)));
+            mrb_parser_dump(mrb, n2->car->cdr, 0);
+            n2 = n2->cdr;
+          }
+        }
+      }
+      n = n->cdr;
+      if (n->car) {
+        dump_prefix(n, offset+1);
+        printf("rest=*%s\n", mrb_sym2name(mrb, sym(n->car)));
+      }
+      n = n->cdr;
+      if (n->car) {
+        dump_prefix(n, offset+1);
+        printf("post mandatory args:\n");
+        dump_recur(mrb, n->car, offset+2);
+      }
+      if (n->cdr) {
+        dump_prefix(n, offset+1);
+        printf("blk=&%s\n", mrb_sym2name(mrb, sym(n->cdr)));
+      }
+      dump_args(mrb, tree->car, offset+1);
+    }
     dump_prefix(tree, offset+1);
 …
           if (n2->car) {
             if (!first_lval) printf(", ");
             printf("%s", mrb_sym2name(mrb, sym(n2->car)));
+            printf("%s", mrb_sym_name(mrb, sym(n2->car)));
             first_lval = FALSE;
+          }
 …
     dump_prefix(tree, offset+1);
     printf("method='%s' (%d)\n",
         mrb_sym2name(mrb, sym(tree->cdr->car)),
         (int)(intptr_t)tree->cdr->car);
+        mrb_sym_dump(mrb, sym(tree->cdr->car)),
+        intn(tree->cdr->car));
     tree = tree->cdr->cdr->car;
     if (tree) {
 …
     mrb_parser_dump(mrb, tree->car, offset+1);
     dump_prefix(tree, offset+1);
     printf("::%s\n", mrb_sym2name(mrb, sym(tree->cdr)));
+    printf("::%s\n", mrb_sym_name(mrb, sym(tree->cdr)));
     break;
   case NODE_COLON3:
     printf("NODE_COLON3: ::%s\n", mrb_sym2name(mrb, sym(tree)));
+    printf("NODE_COLON3: ::%s\n", mrb_sym_name(mrb, sym(tree)));
     break;
 …
   case NODE_HASH:
     printf("NODE_HASH:\n");
+    while (tree) {
+      dump_prefix(tree, offset+1);
+      printf("key:\n");
+      mrb_parser_dump(mrb, tree->car->car, offset+2);
+      dump_prefix(tree, offset+1);
+      printf("value:\n");
+      mrb_parser_dump(mrb, tree->car->cdr, offset+2);
+      tree = tree->cdr;
+    }
+    break;
+  case NODE_KW_HASH:
+    printf("NODE_KW_HASH:\n");
     while (tree) {
       dump_prefix(tree, offset+1);
 …
     tree = tree->cdr;
     dump_prefix(tree, offset+1);
     printf("op='%s' (%d)\n", mrb_sym2name(mrb, sym(tree->car)), (int)(intptr_t)tree->car);
+    printf("op='%s' (%d)\n", mrb_sym_name(mrb, sym(tree->car)), intn(tree->car));
     tree = tree->cdr;
     mrb_parser_dump(mrb, tree->car, offset+1);
 …
   case NODE_LVAR:
     printf("NODE_LVAR %s\n", mrb_sym2name(mrb, sym(tree)));
+    printf("NODE_LVAR %s\n", mrb_sym_name(mrb, sym(tree)));
     break;
   case NODE_GVAR:
     printf("NODE_GVAR %s\n", mrb_sym2name(mrb, sym(tree)));
+    printf("NODE_GVAR %s\n", mrb_sym_name(mrb, sym(tree)));
     break;
   case NODE_IVAR:
     printf("NODE_IVAR %s\n", mrb_sym2name(mrb, sym(tree)));
+    printf("NODE_IVAR %s\n", mrb_sym_name(mrb, sym(tree)));
     break;
   case NODE_CVAR:
+    printf("NODE_CVAR %s\n", mrb_sym2name(mrb, sym(tree)));
+    printf("NODE_CVAR %s\n", mrb_sym_name(mrb, sym(tree)));
+    break;
+  case NODE_NVAR:
+    printf("NODE_NVAR %d\n", intn(tree));
     break;
   case NODE_CONST:
     printf("NODE_CONST %s\n", mrb_sym2name(mrb, sym(tree)));
+    printf("NODE_CONST %s\n", mrb_sym_name(mrb, sym(tree)));
     break;
 …
   case NODE_BACK_REF:
     printf("NODE_BACK_REF: $%c\n", (int)(intptr_t)tree);
+    printf("NODE_BACK_REF: $%c\n", intn(tree));
     break;
   case NODE_NTH_REF:
     printf("NODE_NTH_REF: $%" MRB_PRId "\n", (mrb_int)(intptr_t)tree);
+    printf("NODE_NTH_REF: $%d\n", intn(tree));
     break;
   case NODE_ARG:
     printf("NODE_ARG %s\n", mrb_sym2name(mrb, sym(tree)));
+    printf("NODE_ARG %s\n", mrb_sym_name(mrb, sym(tree)));
     break;
 …
   case NODE_INT:
     printf("NODE_INT %s base %d\n", (char*)tree->car, (int)(intptr_t)tree->cdr->car);
+    printf("NODE_INT %s base %d\n", (char*)tree->car, intn(tree->cdr->car));
     break;
 …
   case NODE_NEGATE:
     printf("NODE_NEGATE\n");
+    printf("NODE_NEGATE:\n");
     mrb_parser_dump(mrb, tree, offset+1);
     break;
   case NODE_STR:
     printf("NODE_STR \"%s\" len %d\n", (char*)tree->car, (int)(intptr_t)tree->cdr);
+    printf("NODE_STR %s len %d\n", str_dump(mrb, (char*)tree->car, intn(tree->cdr)), intn(tree->cdr));
     break;
   case NODE_DSTR:
     printf("NODE_DSTR\n");
+    printf("NODE_DSTR:\n");
     dump_recur(mrb, tree, offset+1);
     break;
   case NODE_XSTR:
     printf("NODE_XSTR \"%s\" len %d\n", (char*)tree->car, (int)(intptr_t)tree->cdr);
+    printf("NODE_XSTR %s len %d\n", str_dump(mrb, (char*)tree->car, intn(tree->cdr)), intn(tree->cdr));
     break;
   case NODE_DXSTR:
     printf("NODE_DXSTR\n");
+    printf("NODE_DXSTR:\n");
     dump_recur(mrb, tree, offset+1);
     break;
 …
   case NODE_DREGX:
     printf("NODE_DREGX\n");
+    printf("NODE_DREGX:\n");
     dump_recur(mrb, tree->car, offset+1);
     dump_prefix(tree, offset);
 …
   case NODE_SYM:
+    printf("NODE_SYM :%s (%d)\n", mrb_sym2name(mrb, sym(tree)),
+           (int)(intptr_t)tree);
+    printf("NODE_SYM :%s (%d)\n", mrb_sym_dump(mrb, sym(tree)),
+           intn(tree));
+    break;
+  case NODE_DSYM:
+    printf("NODE_DSYM:\n");
+    mrb_parser_dump(mrb, tree, offset+1);
+    break;
+  case NODE_WORDS:
+    printf("NODE_WORDS:\n");
+    dump_recur(mrb, tree, offset+1);
+    break;
+  case NODE_SYMBOLS:
+    printf("NODE_SYMBOLS:\n");
+    dump_recur(mrb, tree, offset+1);
+    break;
+  case NODE_LITERAL_DELIM:
+    printf("NODE_LITERAL_DELIM\n");
     break;
 …
   case NODE_ALIAS:
     printf("NODE_ALIAS %s %s:\n",
         mrb_sym2name(mrb, sym(tree->car)),
         mrb_sym2name(mrb, sym(tree->cdr)));
+        mrb_sym_dump(mrb, sym(tree->car)),
+        mrb_sym_dump(mrb, sym(tree->cdr)));
     break;
 …
       node *t = tree;
       while (t) {
         printf(" %s", mrb_sym2name(mrb, sym(t->car)));
+        printf(" %s", mrb_sym_dump(mrb, sym(t->car)));
         t = t->cdr;
+      }
 …
     if (tree->car->car == (node*)0) {
       dump_prefix(tree, offset+1);
       printf(":%s\n", mrb_sym2name(mrb, sym(tree->car->cdr)));
+      printf(":%s\n", mrb_sym_name(mrb, sym(tree->car->cdr)));
+    }
     else if (tree->car->car == (node*)1) {
       dump_prefix(tree, offset+1);
       printf("::%s\n", mrb_sym2name(mrb, sym(tree->car->cdr)));
+      printf("::%s\n", mrb_sym_name(mrb, sym(tree->car->cdr)));
+    }
     else {
       mrb_parser_dump(mrb, tree->car->car, offset+1);
       dump_prefix(tree, offset+1);
       printf("::%s\n", mrb_sym2name(mrb, sym(tree->car->cdr)));
+      printf("::%s\n", mrb_sym_name(mrb, sym(tree->car->cdr)));
+    }
     if (tree->cdr->car) {
 …
     if (tree->car->car == (node*)0) {
       dump_prefix(tree, offset+1);
       printf(":%s\n", mrb_sym2name(mrb, sym(tree->car->cdr)));
+      printf(":%s\n", mrb_sym_name(mrb, sym(tree->car->cdr)));
+    }
     else if (tree->car->car == (node*)1) {
       dump_prefix(tree, offset+1);
       printf("::%s\n", mrb_sym2name(mrb, sym(tree->car->cdr)));
+      printf("::%s\n", mrb_sym_name(mrb, sym(tree->car->cdr)));
+    }
     else {
       mrb_parser_dump(mrb, tree->car->car, offset+1);
       dump_prefix(tree, offset+1);
       printf("::%s\n", mrb_sym2name(mrb, sym(tree->car->cdr)));
+      printf("::%s\n", mrb_sym_name(mrb, sym(tree->car->cdr)));
+    }
     dump_prefix(tree, offset+1);
 …
     printf("NODE_DEF:\n");
     dump_prefix(tree, offset+1);
     printf("%s\n", mrb_sym2name(mrb, sym(tree->car)));
+    printf("%s\n", mrb_sym_dump(mrb, sym(tree->car)));
     tree = tree->cdr;
+    {
 …
           if (n2->car) {
             if (!first_lval) printf(", ");
             printf("%s", mrb_sym2name(mrb, sym(n2->car)));
+            printf("%s", mrb_sym_name(mrb, sym(n2->car)));
             first_lval = FALSE;
+          }
 …
     tree = tree->cdr;
     if (tree->car) {
+      node *n = tree->car;
+      if (n->car) {
+        dump_prefix(n, offset+1);
+        printf("mandatory args:\n");
+        dump_recur(mrb, n->car, offset+2);
+      }
+      n = n->cdr;
+      if (n->car) {
+        dump_prefix(n, offset+1);
+        printf("optional args:\n");
+        {
+          node *n2 = n->car;
+          while (n2) {
+            dump_prefix(n2, offset+2);
+            printf("%s=", mrb_sym2name(mrb, sym(n2->car->car)));
+            mrb_parser_dump(mrb, n2->car->cdr, 0);
+            n2 = n2->cdr;
+          }
+        }
+      }
+      n = n->cdr;
+      if (n->car) {
+        dump_prefix(n, offset+1);
+        printf("rest=*%s\n", mrb_sym2name(mrb, sym(n->car)));
+      }
+      n = n->cdr;
+      if (n->car) {
+        dump_prefix(n, offset+1);
+        printf("post mandatory args:\n");
+        dump_recur(mrb, n->car, offset+2);
+      }
+      if (n->cdr) {
+        dump_prefix(n, offset+1);
+        printf("blk=&%s\n", mrb_sym2name(mrb, sym(n->cdr)));
+      }
+      dump_args(mrb, tree->car, offset);
+    }
     mrb_parser_dump(mrb, tree->cdr->car, offset+1);
 …
     tree = tree->cdr;
     dump_prefix(tree, offset+1);
     printf(":%s\n", mrb_sym2name(mrb, sym(tree->car)));
+    printf(":%s\n", mrb_sym_dump(mrb, sym(tree->car)));
     tree = tree->cdr->cdr;
     if (tree->car) {
+      node *n = tree->car;
+      if (n->car) {
+        dump_prefix(n, offset+1);
+        printf("mandatory args:\n");
+        dump_recur(mrb, n->car, offset+2);
+      }
+      n = n->cdr;
+      if (n->car) {
+        dump_prefix(n, offset+1);
+        printf("optional args:\n");
+        {
+          node *n2 = n->car;
+          while (n2) {
+            dump_prefix(n2, offset+2);
+            printf("%s=", mrb_sym2name(mrb, sym(n2->car->car)));
+            mrb_parser_dump(mrb, n2->car->cdr, 0);
+            n2 = n2->cdr;
+          }
+        }
+      }
+      n = n->cdr;
+      if (n->car) {
+        dump_prefix(n, offset+1);
+        printf("rest=*%s\n", mrb_sym2name(mrb, sym(n->car)));
+      }
+      n = n->cdr;
+      if (n->car) {
+        dump_prefix(n, offset+1);
+        printf("post mandatory args:\n");
+        dump_recur(mrb, n->car, offset+2);
+      }
+      n = n->cdr;
+      if (n) {
+        dump_prefix(n, offset+1);
+        printf("blk=&%s\n", mrb_sym2name(mrb, sym(n)));
+      }
+      dump_args(mrb, tree->car, offset+1);
+    }
     tree = tree->cdr;
 …
     break;
+  case NODE_ARGS_TAIL:
+    printf("NODE_ARGS_TAIL:\n");
+    {
+      node *kws = tree->car;
+      while (kws) {
+        mrb_parser_dump(mrb, kws->car, offset+1);
+        kws = kws->cdr;
+      }
+    }
+    tree = tree->cdr;
+    if (tree->car) {
+      mrb_assert(intn(tree->car->car) == NODE_KW_REST_ARGS);
+      mrb_parser_dump(mrb, tree->car, offset+1);
+    }
+    tree = tree->cdr;
+    if (tree->car) {
+      dump_prefix(tree, offset+1);
+      printf("block='%s'\n", mrb_sym_name(mrb, sym(tree->car)));
+    }
+    break;
+  case NODE_KW_ARG:
+    printf("NODE_KW_ARG %s:\n", mrb_sym_name(mrb, sym(tree->car)));
+    mrb_parser_dump(mrb, tree->cdr->car, offset + 1);
+    break;
+  case NODE_KW_REST_ARGS:
+    printf("NODE_KW_REST_ARGS %s\n", mrb_sym_name(mrb, sym(tree)));
+    break;
   default:
     printf("node type: %d (0x%x)\n", nodetype, (unsigned)nodetype);

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-compiler/mrbgem.rake

-              r331
+              r439
     end
   end
-  file objfile("#{current_build_dir}/core/y.tab") => lex_def
   # Parser
+  file "#{current_build_dir}/core/y.tab.c" => ["#{current_dir}/core/parse.y"] do |t|
+  file "#{current_build_dir}/core/y.tab.c" => ["#{current_dir}/core/parse.y", lex_def] do |t|
+    mkdir_p File.dirname t.name
     yacc.run t.name, t.prerequisites.first
   end
 …
   end
   file libfile("#{build.build_dir}/lib/libmruby_core") => core_objs
+  file build.libmruby_core_static => core_objs
   build.libmruby << core_objs
 end

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-enum-ext/mrblib/enum.rb

-              r331
+              r439
   def drop(n)
     raise TypeError, "no implicit conversion of #{n.class} into Integer" unless n.respond_to?(:to_int)
+    n = n.__to_int
     raise ArgumentError, "attempt to drop negative size" if n < 0
-    n = n.to_int
     ary = []
     self.each {|*val| n == 0 ? ary << val.__svalue : n -= 1 }
 …
   def take(n)
     raise TypeError, "no implicit conversion of #{n.class} into Integer" unless n.respond_to?(:to_int)
     i = n.to_int
+    n = n.__to_int
+    i = n.to_i
     raise ArgumentError, "attempt to take negative size" if i < 0
     ary = []
 …
   def each_cons(n, &block)
     raise TypeError, "no implicit conversion of #{n.class} into Integer" unless n.respond_to?(:to_int)
+    n = n.__to_int
     raise ArgumentError, "invalid size" if n <= 0
     return to_enum(:each_cons,n) unless block
     ary = []
     n = n.to_int
+    n = n.to_i
     self.each do |*val|
       ary.shift if ary.size == n
 …
   def each_slice(n, &block)
     raise TypeError, "no implicit conversion of #{n.class} into Integer" unless n.respond_to?(:to_int)
+    n = n.__to_int
     raise ArgumentError, "invalid slice size" if n <= 0
     return to_enum(:each_slice,n) unless block
     ary = []
     n = n.to_int
+    n = n.to_i
     self.each do |*val|
       ary << val.__svalue
 …
+    }
     if ary.size > 1
+      __sort_sub__(ary, ::Array.new(ary.size), 0, 0, ary.size - 1) do |a,b|
+        a <=> b
+      end
+      ary.sort!
     end
     ary.collect{|e,i| orig[i]}
   end
-  NONE = Object.new
   ##
   # call-seq:
 …
       return nil
     when 1
+      n = args[0]
+      raise TypeError, "no implicit conversion of #{n.class} into Integer" unless n.respond_to?(:to_int)
+      i = n.to_int
+      i = args[0].__to_int
       raise ArgumentError, "attempt to take negative size" if i < 0
       ary = []
 …
   #  call-seq:
   #     enum.none? [{ |obj| block }]   -> true or false
+  #     enum.none?(pattern)            -> true or false
+  #
   #  Passes each element of the collection to the given block. The method
 …
   #  <code>true</code> only if none of the collection members is true.
+  #
+  #  If a pattern is supplied instead, the method returns whether
+  #  <code>pattern === element</code> for none of the collection members.
+  #
   #     %w(ant bear cat).none? { |word| word.length == 5 } #=> true
   #     %w(ant bear cat).none? { |word| word.length >= 4 } #=> false
+  #     %w{ant bear cat}.none?(/d/)                        #=> true
+  #     [1, 3.14, 42].none?(Float)                         #=> false
   #     [].none?                                           #=> true
   #     [nil, false].none?                                 #=> true
   #     [nil, true].none?                                  #=> false
+  def none?(&block)
+    if block
+  def none?(pat=NONE, &block)
+    if pat != NONE
+      self.each do |*val|
+        return false if pat === val.__svalue
+      end
+    elsif block
       self.each do |*val|
         return false if block.call(*val)
 …
   #  call-seq:
   #    enum.one? [{ |obj| block }]   -> true or false
+  #    enum.one?(pattern)            -> true or false
+  #
   # Passes each element of the collection to the given block. The method
 …
   # true.
+  #
+  # If a pattern is supplied instead, the method returns whether
+  # <code>pattern === element</code> for exactly one collection member.
+  #
   #    %w(ant bear cat).one? { |word| word.length == 4 }  #=> true
   #    %w(ant bear cat).one? { |word| word.length > 4 }   #=> false
   #    %w(ant bear cat).one? { |word| word.length < 4 }   #=> false
+  #    %w{ant bear cat}.one?(/t/)                         #=> false
   #    [nil, true, 99].one?                               #=> false
   #    [nil, true, false].one?                            #=> true
+  #
+  def one?(&block)
+  #    [ nil, true, 99 ].one?(Integer)                    #=> true
+  #    [].one?                                            #=> false
+  def one?(pat=NONE, &block)
     count = 0
+    if block
+    if pat!=NONE
+      self.each do |*val|
+        count += 1 if pat === val.__svalue
+        return false if count > 1
+      end
+    elsif block
       self.each do |*val|
         count += 1 if block.call(*val)
 …
   end
+  # ISO 15.3.2.2.1
+  #  call-seq:
+  #     enum.all? [{ |obj| block } ]   -> true or false
+  #     enum.all?(pattern)             -> true or false
+  #
+  #  Passes each element of the collection to the given block. The method
+  #  returns <code>true</code> if the block never returns
+  #  <code>false</code> or <code>nil</code>. If the block is not given,
+  #  Ruby adds an implicit block of <code>{ |obj| obj }</code> which will
+  #  cause #all? to return +true+ when none of the collection members are
+  #  +false+ or +nil+.
+  #
+  #  If a pattern is supplied instead, the method returns whether
+  #  <code>pattern === element</code> for every collection member.
+  #
+  #     %w[ant bear cat].all? { |word| word.length >= 3 } #=> true
+  #     %w[ant bear cat].all? { |word| word.length >= 4 } #=> false
+  #     %w[ant bear cat].all?(/t/)                        #=> false
+  #     [1, 2i, 3.14].all?(Numeric)                       #=> true
+  #     [nil, true, 99].all?                              #=> false
+  #
+  def all?(pat=NONE, &block)
+    if pat != NONE
+      self.each{|*val| return false unless pat === val.__svalue}
+    elsif block
+      self.each{|*val| return false unless block.call(*val)}
+    else
+      self.each{|*val| return false unless val.__svalue}
+    end
+    true
+  end
+  # ISO 15.3.2.2.2
+  #  call-seq:
+  #     enum.any? [{ |obj| block }]   -> true or false
+  #     enum.any?(pattern)            -> true or false
+  #
+  #  Passes each element of the collection to the given block. The method
+  #  returns <code>true</code> if the block ever returns a value other
+  #  than <code>false</code> or <code>nil</code>. If the block is not
+  #  given, Ruby adds an implicit block of <code>{ |obj| obj }</code> that
+  #  will cause #any? to return +true+ if at least one of the collection
+  #  members is not +false+ or +nil+.
+  #
+  #  If a pattern is supplied instead, the method returns whether
+  #  <code>pattern === element</code> for any collection member.
+  #
+  #     %w[ant bear cat].any? { |word| word.length >= 3 } #=> true
+  #     %w[ant bear cat].any? { |word| word.length >= 4 } #=> true
+  #     %w[ant bear cat].any?(/d/)                        #=> false
+  #     [nil, true, 99].any?(Integer)                     #=> true
+  #     [nil, true, 99].any?                              #=> true
+  #     [].any?                                           #=> false
+  #
+  def any?(pat=NONE, &block)
+    if pat != NONE
+      self.each{|*val| return true if pat === val.__svalue}
+    elsif block
+      self.each{|*val| return true if block.call(*val)}
+    else
+      self.each{|*val| return true if val.__svalue}
+    end
+    false
+  end
   ##
   #  call-seq:
 …
+  #
+  def each_with_object(obj=nil, &block)
+    raise ArgumentError, "wrong number of arguments (0 for 1)" if obj.nil?
+  def each_with_object(obj, &block)
     return to_enum(:each_with_object, obj) unless block
 …
       n = -1
     else
+      unless nv.respond_to?(:to_int)
+        raise TypeError, "no implicit conversion of #{nv.class} into Integer"
+      end
+      n = nv.to_int
+      unless n.kind_of?(Integer)
+        raise TypeError, "no implicit conversion of #{nv.class} into Integer"
+      end
+      n = nv.__to_int
       return nil if n <= 0
     end
 …
   #  call-seq:
   #     enum.zip(arg, ...)                  -> an_array_of_array
+  #     enum.zip(arg, ...) { |arr| block }  -> nil
+  #
   #  Takes one element from <i>enum</i> and merges corresponding
 …
   #  count of arguments.  The length of the resulting sequence will be
   #  <code>enum#size</code>.  If the size of any argument is less than
+  #  <code>enum#size</code>, <code>nil</code> values are supplied.
+  #
+  def zip(*arg)
+    ary = []
+    arg = arg.map{|a|a.to_a}
+  #  <code>enum#size</code>, <code>nil</code> values are supplied. If
+  #  a block is given, it is invoked for each output array, otherwise
+  #  an array of arrays is returned.
+  #
+  #     a = [ 4, 5, 6 ]
+  #     b = [ 7, 8, 9 ]
+  #
+  #     a.zip(b)                 #=> [[4, 7], [5, 8], [6, 9]]
+  #     [1, 2, 3].zip(a, b)      #=> [[1, 4, 7], [2, 5, 8], [3, 6, 9]]
+  #     [1, 2].zip(a, b)         #=> [[1, 4, 7], [2, 5, 8]]
+  #     a.zip([1, 2], [8])       #=> [[4, 1, 8], [5, 2, nil], [6, nil, nil]]
+  #
+  #     c = []
+  #     a.zip(b) { |x, y| c << x + y }  #=> nil
+  #     c                               #=> [11, 13, 15]
+  #
+  def zip(*arg, &block)
+    result = block ? nil : []
+    arg = arg.map do |a|
+      unless a.respond_to?(:to_a)
+        raise TypeError, "wrong argument type #{a.class} (must respond to :to_a)"
+      end
+      a.to_a
+    end
     i = 0
     self.each do |*val|
 …
         idx += 1
       end
-      ary.push(a)
       i += 1
+    end
+    ary
+      if result.nil?
+        block.call(a)
+      else
+        result.push(a)
+      end
+    end
+    result
   end
 …
+  #
   def to_h
+  def to_h(&blk)
     h = {}
+    self.each do |*v|
+      v = v.__svalue
+      raise TypeError, "wrong element type #{v.class} (expected Array)" unless v.is_a? Array
+      raise ArgumentError, "element has wrong array length (expected 2, was #{v.size})" if v.size != 2
+      h[v[0]] = v[1]
+    if blk
+      self.each do |v|
+        v = blk.call(v)
+        raise TypeError, "wrong element type #{v.class} (expected Array)" unless v.is_a? Array
+        raise ArgumentError, "element has wrong array length (expected 2, was #{v.size})" if v.size != 2
+        h[v[0]] = v[1]
+      end
+    else
+      self.each do |*v|
+        v = v.__svalue
+        raise TypeError, "wrong element type #{v.class} (expected Array)" unless v.is_a? Array
+        raise ArgumentError, "element has wrong array length (expected 2, was #{v.size})" if v.size != 2
+        h[v[0]] = v[1]
+      end
     end
+    h
   end
+  def nil.to_h
+    {}
+  def uniq(&block)
+    hash = {}
+    if block
+      self.each do|*v|
+        v = v.__svalue
+        hash[block.call(v)] ||= v
+      end
+    else
+      self.each do|*v|
+        v = v.__svalue
+        hash[v] ||= v
+      end
+    end
+    hash.values
+  end
+  def filter_map(&blk)
+    return to_enum(:filter_map) unless blk
+    ary = []
+    self.each do |x|
+      x = blk.call(x)
+      ary.push x if x
+    end
+    ary
+  end
+  alias filter select
+  ##
+  # call-seq:
+  #   enum.tally -> a_hash
+  #
+  # Tallys the collection.  Returns a hash where the keys are the
+  # elements and the values are numbers of elements in the collection
+  # that correspond to the key.
+  #
+  #    ["a", "b", "c", "b"].tally #=> {"a"=>1, "b"=>2, "c"=>1}
+  def tally
+    hash = {}
+    self.each do |x|
+      hash[x] = (hash[x]||0)+1
+    end
+    hash
   end
 end

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-enum-ext/test/enum.rb

-              r331
+              r439
   assert_true %w(ant bear cat).none? { |word| word.length == 5 }
   assert_false %w(ant bear cat).none? { |word| word.length >= 4 }
+  assert_false [1, 3.14, 42].none?(Float)
   assert_true [].none?
   assert_true [nil, false].none?
 …
   assert_false %w(ant bear cat).one? { |word| word.length > 4 }
   assert_false %w(ant bear cat).one? { |word| word.length < 4 }
+  assert_true [1, 3.14, 42].one?(Float)
   assert_false [nil, true, 99].one?
   assert_true [nil, true, false].one?
+  assert_true [ nil, true, 99 ].one?(Integer)
+  assert_false [].one?
+end
+assert("Enumerable#all? (enhancement)") do
+  assert_false [1, 2, 3.14].all?(Integer)
+  assert_true [1, 2, 3.14].all?(Numeric)
+end
+assert("Enumerable#any? (enhancement)") do
+  assert_false [1, 2, 3].all?(Float)
+  assert_true [nil, true, 99].any?(Integer)
 end
 assert("Enumerable#each_with_object") do
   assert_true [2, 4, 6, 8, 10, 12, 14, 16, 18, 20], (1..10).each_with_object([]) { |i, a| a << i*2 }
+  assert_equal [2, 4, 6, 8, 10, 12, 14, 16, 18, 20], (1..10).each_with_object([]) { |i, a| a << i*2 }
   assert_raise(ArgumentError) { (1..10).each_with_object() { |i, a| a << i*2 } }
 end
 …
   r = (1..3)
   a = []
   assert_equal (1..3), r.reverse_each { |v| a << v }
+  assert_same r, r.reverse_each { |v| a << v }
   assert_equal [3, 2, 1], a
 end
 …
   assert_equal [[1, 4, 7], [2, 5, 8]], [1, 2].zip(a, b)
   assert_equal [[4, 1, 8], [5, 2, nil], [6, nil, nil]], a.zip([1, 2], [8])
+  ret = []
+  assert_equal nil, a.zip([1, 2], [8]) { |i| ret << i }
+  assert_equal [[4, 1, 8], [5, 2, nil], [6, nil, nil]], ret
+  assert_raise(TypeError) { [1].zip(1) }
 end
 …
   assert_equal Hash, h.class
   assert_equal h0, h
+  # mruby-enum-ext also provides nil.to_h
+  assert_equal Hash.new, nil.to_h
+  assert_equal({1=>4,3=>8}, c.new.to_h{|k,v|[k,v*2]})
 end
+assert("Enumerable#filter_map") do
+  assert_equal [4, 8, 12, 16, 20], (1..10).filter_map{|i| i * 2 if i%2==0}
+end
+assert("Enumerable#tally") do
+  assert_equal({"a"=>1, "b"=>2, "c"=>1}, ["a", "b", "c", "b"].tally)
+end

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-enum-lazy/mrblib/lazy.rb

-              r331
+              r439
     def to_enum(meth=:each, *args, &block)
+      unless self.respond_to?(meth)
+        raise ArgumentError, "undefined method #{meth}"
+      end
       lz = Lazy.new(self, &block)
       lz.obj = self
 …
     def reject(&block)
       Lazy.new(self){|yielder, val|
         if not block.call(val)
+        unless block.call(val)
           yielder << val
         end
 …
     end
+    def uniq(&block)
+      hash = {}
+      Lazy.new(self){|yielder, val|
+        if block
+          v = block.call(val)
+        else
+          v = val
+        end
+        unless hash.include?(v)
+          yielder << val
+          hash[v] = val
+        end
+      }
+    end
     alias force to_a
   end

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-enum-lazy/test/lazy.rb

r331	r439
41	41	end
42	42
43		assert("Enumrator::Lazy#to_enum") do
	43	assert("Enumerator::Lazy#to_enum") do
44	44	lazy_enum = (0..Float::INFINITY).lazy.to_enum(:each_slice, 2)
45	45	assert_kind_of Enumerator::Lazy, lazy_enum

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-enumerator/mrbgem.rake

r321	r439
3	3	spec.author = 'mruby developers'
4	4	spec.add_dependency('mruby-fiber', :core => 'mruby-fiber')
5		~~spec.add_dependency 'mruby-enum-ext', :core => 'mruby-enum-ext'~~
6	5	spec.summary = 'Enumerator class'
7	6	end

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-enumerator/mrblib/enumerator.rb

-              r331
+              r439
   ##
-  # @overload initialize(size = nil, &block)
   # @overload initialize(obj, method = :each, *args)
+  #
 …
   #     p fib.take(10) # => [1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
+  #
+  def initialize(obj=nil, meth=:each, *args, &block)
+    if block_given?
+  # In the second, deprecated, form, a generated Enumerator iterates over the
+  # given object using the given method with the given arguments passed. This
+  # form is left only for internal use.
+  #
+  # Use of this form is discouraged.  Use Kernel#enum_for or Kernel#to_enum
+  # instead.
+  def initialize(obj=NONE, meth=:each, *args, &block)
+    if block
       obj = Generator.new(&block)
     else
       raise ArgumentError unless obj
+    elsif obj == NONE
+      raise ArgumentError, "wrong number of arguments (given 0, expected 1+)"
     end
     @obj = obj
     @meth = meth
     @args = args.dup
+    @args = args
     @fib = nil
     @dst = nil
 …
     @stop_exc = false
   end
   attr_accessor :obj, :meth, :args, :fib
   private :obj, :meth, :args, :fib
+  attr_accessor :obj, :meth, :args
+  attr_reader :fib
   def initialize_copy(obj)
 …
   # +offset+:: the starting index to use
+  #
+  def with_index(offset=0)
+    return to_enum :with_index, offset unless block_given?
+    offset = if offset.nil?
+    elsif offset.respond_to?(:to_int)
+      offset.to_int
+  def with_index(offset=0, &block)
+    return to_enum :with_index, offset unless block
+    if offset.nil?
+      offset = 0
     else
       raise TypeError, "no implicit conversion of #{offset.class} into Integer"
+      offset = offset.__to_int
     end
 …
     enumerator_block_call do |*i|
       n += 1
       yield i.__svalue, n
+      block.call i.__svalue, n
     end
   end
 …
   #   # => foo:2
+  #
   def with_object(object)
     return to_enum(:with_object, object) unless block_given?
+  def with_object(object, &block)
+    return to_enum(:with_object, object) unless block
     enumerator_block_call do |i|
       yield [i,object]
+      block.call [i,object]
     end
     object
 …
   def inspect
-    return "#<#{self.class}: uninitialized>" unless @obj
     if @args && @args.size > 0
       args = @args.join(", ")
       "#<#{self.class}: #{@obj}:#{@meth}(#{args})>"
+      "#<#{self.class}: #{@obj.inspect}:#{@meth}(#{args})>"
     else
       "#<#{self.class}: #{@obj}:#{@meth}>"
+      "#<#{self.class}: #{@obj.inspect}:#{@meth}>"
     end
   end
 …
   # === Examples
+  #
+  #   "Hello, world!".scan(/\w+/)                     #=> ["Hello", "world"]
+  #   "Hello, world!".to_enum(:scan, /\w+/).to_a      #=> ["Hello", "world"]
+  #   "Hello, world!".to_enum(:scan).each(/\w+/).to_a #=> ["Hello", "world"]
+  #   Array.new(3)                     #=> [nil, nil, nil]
+  #   Array.new(3) { |i| i }           #=> [0, 1, 2]
+  #   Array.to_enum(:new, 3).to_a      #=> [0, 1, 2]
+  #   Array.to_enum(:new).each(3).to_a #=> [0, 1, 2]
+  #
   #   obj = Object.new
 …
       obj.args = args
     end
     return obj unless block_given?
+    return obj unless block
     enumerator_block_call(&block)
   end
 …
   class Yielder
     def initialize(&block)
       raise LocalJumpError, "no block given" unless block_given?
+      raise LocalJumpError, "no block given" unless block
       @proc = block
 …
     end
   end
+  ##
+  # call-seq:
+  #    Enumerator.produce(initial = nil) { |val| } -> enumerator
+  #
+  # Creates an infinite enumerator from any block, just called over and
+  # over.  Result of the previous iteration is passed to the next one.
+  # If +initial+ is provided, it is passed to the first iteration, and
+  # becomes the first element of the enumerator; if it is not provided,
+  # first iteration receives +nil+, and its result becomes first
+  # element of the iterator.
+  #
+  # Raising StopIteration from the block stops an iteration.
+  #
+  # Examples of usage:
+  #
+  #   Enumerator.produce(1, &:succ)   # => enumerator of 1, 2, 3, 4, ....
+  #
+  #   Enumerator.produce { rand(10) } # => infinite random number sequence
+  #
+  #   ancestors = Enumerator.produce(node) { |prev| node = prev.parent or raise StopIteration }
+  #   enclosing_section = ancestors.find { |n| n.type == :section }
+  def Enumerator.produce(init=NONE, &block)
+    raise ArgumentError, "no block given" if block.nil?
+    Enumerator.new do |y|
+      if init == NONE
+        val = nil
+      else
+        val = init
+        y.yield(val)
+      end
+      begin
+        while true
+          y.yield(val = block.call(val))
+        end
+      rescue StopIteration
+        # do nothing
+      end
+    end
+  end
 end
 …
   #   obj.to_enum(method = :each, *args)                 -> enum
   #   obj.enum_for(method = :each, *args)                -> enum
-  #   obj.to_enum(method = :each, *args) {|*args| block} -> enum
-  #   obj.enum_for(method = :each, *args){|*args| block} -> enum
+  #
   # Creates a new Enumerator which will enumerate by calling +method+ on
   # +obj+, passing +args+ if any.
+  #
-  # If a block is given, it will be used to calculate the size of
-  # the enumerator without the need to iterate it (see Enumerator#size).
+  #
   # === Examples
 …
   # a generic Enumerable, in case no block is passed.
+  #
   # Here is such an example, with parameter passing and a sizing block:
+  # Here is such an example with parameter passing:
+  #
   #     module Enumerable
 …
   #         raise ArgumentError, "#{n} is negative!" if n < 0
   #         unless block_given?
+  #           return to_enum(__method__, n) do # __method__ is :repeat here
+  #             sz = size     # Call size and multiply by n...
+  #             sz * n if sz  # but return nil if size itself is nil
+  #           end
+  #           return to_enum(__method__, n) # __method__ is :repeat here
   #         end
   #         each do |*val|
 …
     Enumerator.new self, meth, *args
   end
   alias :enum_for :to_enum
+  alias enum_for to_enum
 end
 module Enumerable
   # use Enumerator to use infinite sequence
+  def zip(*arg)
+    ary = []
+    arg = arg.map{|a|a.each}
+    i = 0
+    self.each do |*val|
+      a = []
+      a.push(val.__svalue)
+      idx = 0
+      while idx < arg.size
+        begin
+          a.push(arg[idx].next)
+        rescue StopIteration
+          a.push(nil)
+  def zip(*args, &block)
+    args = args.map do |a|
+      if a.respond_to?(:each)
+        a.to_enum(:each)
+      else
+        raise TypeError, "wrong argument type #{a.class} (must respond to :each)"
+      end
+    end
+    result = block ? nil : []
+    each do |*val|
+      tmp = [val.__svalue]
+      args.each do |arg|
+        v = if arg.nil?
+          nil
+        else
+          begin
+            arg.next
+          rescue StopIteration
+            nil
+          end
         end
         idx += 1
+        tmp.push(v)
       end
+      ary.push(a)
+      i += 1
+    end
+    ary
+      if result.nil?
+        block.call(tmp)
+      else
+        result.push(tmp)
+      end
+    end
+    result
   end
 end

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-enumerator/test/enumerator.rb

-              r331
+              r439
 end
+assert 'Enumerator' do
+def assert_take(exp, enumerator)
+  result = []
+  n = exp.size
+  enumerator.each do |v|
+    result << v
+    n -= 1
+    break if n == 0
+  end if n > 0
+  assert_equal exp, result
+end
+assert 'Enumerator.class' do
   assert_equal Class, Enumerator.class
 end
 assert 'Enumerator' do
+assert 'Enumerator.superclass' do
   assert_equal Object, Enumerator.superclass
 end
 …
   assert_equal [[:x,1],[:y,2]], {x:1, y:2}.each.map{|i| i}.sort
   assert_equal [1,2,3], @obj.to_enum(:foo, 1,2,3).to_a
+  assert_equal [1,2,3], Enumerator.new(@obj, :foo, 1,2,3).to_a
+  assert_equal [1,2,3], Enumerator.new { |y| i = 0; loop { y << (i += 1) } }.take(3)
+  assert_take [1,2,3], Enumerator.new { |y| i = 0; loop { y << (i += 1) } }
   assert_raise(ArgumentError) { Enumerator.new }
-  enum = @obj.to_enum
-  assert_raise(NoMethodError) { enum.each {} }
   # examples
 …
     end
   end
   assert_equal fib.take(10), [1,1,2,3,5,8,13,21,34,55]
+  assert_take [1,1,2,3,5,8,13,21,34,55], fib
 end
 …
   @obj.to_enum(:foo, 1, 2, 3).with_index(10).with_index(20) { |*i| a << i }
   assert_equal [[[1, 10], 20], [[2, 11], 21], [[3, 12], 22]], a
-end
-assert 'Enumerator#with_index nonnum offset' do
-  s = Object.new
-  def s.to_int; 1 end
-  assert_equal([[1,1],[2,2],[3,3]], @obj.to_enum(:foo, 1, 2, 3).with_index(s).to_a)
 end
 …
 assert 'Enumerator#inspect' do
   e = (0..10).each
+  assert_equal("#<Enumerator: 0..10:each>", e.inspect)
+  e = Enumerator.new("FooObject", :foo, 1)
+  assert_equal("#<Enumerator: FooObject:foo(1)>", e.inspect)
+  e = Enumerator.new("FooObject", :foo, 1, 2, 3)
+  assert_equal("#<Enumerator: FooObject:foo(1, 2, 3)>", e.inspect)
+  assert_equal('#<Enumerator: 0..10:each>', e.inspect)
+  e = 'FooObject'.enum_for(:foo, 1)
+  assert_equal('#<Enumerator: "FooObject":foo(1)>', e.inspect)
+  e = 'FooObject'.enum_for(:foo, 1, 2, 3)
+  assert_equal('#<Enumerator: "FooObject":foo(1, 2, 3)>', e.inspect)
+  e = nil.enum_for(:to_s)
+  assert_equal('#<Enumerator: nil:to_s>', e.inspect)
 end
 …
 assert 'Kernel#to_enum' do
+  e = nil
   assert_equal Enumerator, [].to_enum.class
+  assert_raise(ArgumentError){ nil.to_enum }
+  assert_nothing_raised { e = [].to_enum(:_not_implemented_) }
+  assert_raise(NoMethodError) { e.first }
 end
 …
 assert 'Hash#select' do
   h = {1=>2,3=>4,5=>6}
   hret = h.select.with_index {|a,b| a[1] == 4}
+  hret = h.select.with_index {|a,_b| a[1] == 4}
   assert_equal({3=>4}, hret)
   assert_equal({1=>2,3=>4,5=>6}, h)
 …
 assert 'Hash#select!' do
   h = {1=>2,3=>4,5=>6}
   hret = h.select!.with_index {|a,b| a[1] == 4}
+  hret = h.select!.with_index {|a,_b| a[1] == 4}
   assert_equal h, hret
   assert_equal({3=>4}, h)
 …
 assert 'Hash#reject' do
   h = {1=>2,3=>4,5=>6}
   hret = h.reject.with_index {|a,b| a[1] == 4}
+  hret = h.reject.with_index {|a,_b| a[1] == 4}
   assert_equal({1=>2,5=>6}, hret)
   assert_equal({1=>2,3=>4,5=>6}, h)
 …
 assert 'Hash#reject!' do
   h = {1=>2,3=>4,5=>6}
   hret = h.reject!.with_index {|a,b| a[1] == 4}
+  hret = h.reject!.with_index {|a,_b| a[1] == 4}
   assert_equal h, hret
   assert_equal({1=>2,5=>6}, h)
 …
   assert_equal [1,2,3,4,5], c
 end
+assert 'Enumerable#zip' do
+  assert_equal [[1, 10], [2, 11], [3, 12]], [1,2,3].zip(10..Float::INFINITY)
+  ret = []
+  assert_equal nil, [1,2,3].zip(10..Float::INFINITY) { |i| ret << i }
+  assert_equal [[1, 10], [2, 11], [3, 12]], ret
+  assert_raise(TypeError) { [1].zip(1) }
+end
+assert 'Enumerator.produce' do
+  assert_raise(ArgumentError) { Enumerator.produce }
+  # Without initial object
+  passed_args = []
+  enum = Enumerator.produce {|obj| passed_args << obj; (obj || 0).succ }
+  assert_equal Enumerator, enum.class
+  assert_take [1, 2, 3], enum
+  assert_equal [nil, 1, 2], passed_args
+  # With initial object
+  passed_args = []
+  enum = Enumerator.produce(1) {|obj| passed_args << obj; obj.succ }
+  assert_take [1, 2, 3], enum
+  assert_equal [1, 2], passed_args
+  # Raising StopIteration
+  words = %w[The quick brown fox jumps over the lazy dog]
+  enum = Enumerator.produce { words.shift or raise StopIteration }
+  assert_equal %w[The quick brown fox jumps over the lazy dog], enum.to_a
+  # Raising StopIteration
+  object = [[[["abc", "def"], "ghi", "jkl"], "mno", "pqr"], "stuv", "wxyz"]
+  enum = Enumerator.produce(object) {|obj|
+    obj.respond_to?(:first) or raise StopIteration
+    obj.first
+  }
+  assert_nothing_raised {
+    assert_equal [
+      [[[["abc", "def"], "ghi", "jkl"], "mno", "pqr"], "stuv", "wxyz"],
+      [[["abc", "def"], "ghi", "jkl"], "mno", "pqr"],
+      [["abc", "def"], "ghi", "jkl"],
+      ["abc", "def"],
+      "abc",
+    ], enum.to_a
+  }
+end

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-error/src/exception.c

-              r331
+              r439
   struct mrb_jmpbuf c_jmp;
   mrb_value result = mrb_nil_value();
+  int ai = mrb_gc_arena_save(mrb);
   if (state) { *state = FALSE; }
 …
   } MRB_END_EXC(&c_jmp);
+  mrb_gc_arena_restore(mrb, ai);
   mrb_gc_protect(mrb, result);
   return result;
 …
   struct mrb_jmpbuf c_jmp;
   mrb_value result;
+  int ai = mrb_gc_arena_save(mrb);
   MRB_TRY(&c_jmp) {
 …
   } MRB_CATCH(&c_jmp) {
     mrb->jmp = prev_jmp;
+    mrb_gc_arena_restore(mrb, ai);
     ensure(mrb, e_data);
     MRB_THROW(mrb->jmp); /* rethrow catched exceptions */
   } MRB_END_EXC(&c_jmp);
+  mrb_gc_arena_restore(mrb, ai);
+  mrb_gc_protect(mrb, result);
   ensure(mrb, e_data);
+  mrb_gc_arena_restore(mrb, ai);
   mrb_gc_protect(mrb, result);
   return result;
 …
   mrb_bool error_matched = FALSE;
   mrb_int i;
+  int ai = mrb_gc_arena_save(mrb);
   MRB_TRY(&c_jmp) {
 …
     mrb->exc = NULL;
+    mrb_gc_arena_restore(mrb, ai);
     result = rescue(mrb, r_data);
   } MRB_END_EXC(&c_jmp);
+  mrb_gc_arena_restore(mrb, ai);
   mrb_gc_protect(mrb, result);
   return result;

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-eval/src/eval.c

-              r331
+              r439
 get_closure_irep(mrb_state *mrb, int level)
+{
+  struct mrb_context *c = mrb->c;
+  struct REnv *e = c->ci[-1].proc->env;
+  struct RProc *proc;
+  if (level == 0) {
+    proc = c->ci[-1].proc;
+    if (MRB_PROC_CFUNC_P(proc)) {
+      return NULL;
+    }
+    return proc->body.irep;
+  }
+  while (--level) {
+    e = (struct REnv*)e->c;
+    if (!e) return NULL;
+  }
+  if (!e) return NULL;
+  if (!MRB_ENV_STACK_SHARED_P(e)) return NULL;
+  c = e->cxt.c;
+  proc = c->cibase[e->cioff].proc;
+  if (!proc || MRB_PROC_CFUNC_P(proc)) {
+  struct RProc *proc = mrb->c->ci[-1].proc;
+  while (level--) {
+    if (!proc) return NULL;
+    proc = proc->upper;
+  }
+  if (!proc) return NULL;
+  if (MRB_PROC_CFUNC_P(proc)) {
     return NULL;
+  }
 …
+}
+static inline mrb_code
+/* search for irep lev above the bottom */
+static mrb_irep*
+search_irep(mrb_irep *top, int bnest, int lev, mrb_irep *bottom)
+{
+  int i;
+  for (i=0; i<top->rlen; i++) {
+    mrb_irep* tmp = top->reps[i];
+    if (tmp == bottom) return top;
+    tmp = search_irep(tmp, bnest-1, lev, bottom);
+    if (tmp) {
+      if (bnest == lev) return top;
+      return tmp;
+    }
+  }
+  return NULL;
+}
+static uint16_t
 search_variable(mrb_state *mrb, mrb_sym vsym, int bnest)
+{
 …
   for (level = 0; (virep = get_closure_irep(mrb, level)); level++) {
     if (!virep || virep->lv == NULL) {
+    if (virep->lv == NULL) {
       continue;
+    }
     for (pos = 0; pos < virep->nlocals - 1; pos++) {
       if (vsym == virep->lv[pos].name) {
+        return (MKARG_B(pos + 1) | MKARG_C(level + bnest));
+      }
+    }
+  }
+        return (pos+1)<<8 | (level+bnest);
+      }
+    }
+  }
+  return 0;
+}
+static int
+irep_argc(mrb_irep *irep)
+{
+  mrb_code c;
+  c = irep->iseq[0];
+  if (c == OP_ENTER) {
+    mrb_aspec ax = PEEK_W(irep->iseq+1);
+    /* extra 1 means a slot for block */
+    return MRB_ASPEC_REQ(ax)+MRB_ASPEC_OPT(ax)+MRB_ASPEC_REST(ax)+MRB_ASPEC_POST(ax)+1;
+  }
   return 0;
+}
 …
+}
+extern uint8_t mrb_insn_size[];
+extern uint8_t mrb_insn_size1[];
+extern uint8_t mrb_insn_size2[];
+extern uint8_t mrb_insn_size3[];
 static void
+patch_irep(mrb_state *mrb, mrb_irep *irep, int bnest)
+{
+  size_t i;
+  mrb_code c;
+  int argc = 0;
+  for (i = 0; i < irep->ilen; i++) {
+    c = irep->iseq[i];
+    switch(GET_OPCODE(c)){
+    case OP_ENTER:
+      {
+        mrb_aspec ax = GETARG_Ax(c);
+        /* extra 1 means a slot for block */
+        argc = MRB_ASPEC_REQ(ax)+MRB_ASPEC_OPT(ax)+MRB_ASPEC_REST(ax)+MRB_ASPEC_POST(ax)+1;
+      }
+      break;
+patch_irep(mrb_state *mrb, mrb_irep *irep, int bnest, mrb_irep *top)
+{
+  int i;
+  uint32_t a;
+  uint16_t b;
+  uint8_t c;
+  mrb_code insn;
+  int argc = irep_argc(irep);
+  mrb_code *iseq = (mrb_code *)irep->iseq;
+  mrb_assert((irep->flags & MRB_ISEQ_NO_FREE) == 0);
+  for (i = 0; i < irep->ilen; ) {
+    insn = iseq[i];
+    switch(insn){
     case OP_EPUSH:
+      patch_irep(mrb, irep->reps[GETARG_Bx(c)], bnest + 1);
+      a = PEEK_B(iseq+i+1);
+      patch_irep(mrb, irep->reps[a], bnest + 1, top);
       break;
     case OP_LAMBDA:
+      {
+        int arg_c = GETARG_c(c);
+        if (arg_c & OP_L_CAPTURE) {
+          patch_irep(mrb, irep->reps[GETARG_b(c)], bnest + 1);
+        }
+      }
+    case OP_BLOCK:
+      a = PEEK_B(iseq+i+1);
+      b = PEEK_B(iseq+i+2);
+      patch_irep(mrb, irep->reps[b], bnest + 1, top);
       break;
     case OP_SEND:
+      if (GETARG_C(c) != 0) {
+      b = PEEK_B(iseq+i+2);
+      c = PEEK_B(iseq+i+3);
+      if (c != 0) {
         break;
+      }
+      {
         mrb_code arg = search_variable(mrb, irep->syms[GETARG_B(c)], bnest);
+      else {
+        uint16_t arg = search_variable(mrb, irep->syms[b], bnest);
         if (arg != 0) {
           /* must replace */
+          irep->iseq[i] = MKOPCODE(OP_GETUPVAR) | MKARG_A(GETARG_A(c)) | arg;
+          iseq[i] = OP_GETUPVAR;
+          iseq[i+2] = arg >> 8;
+          iseq[i+3] = arg & 0xff;
+        }
+      }
 …
     case OP_MOVE:
+      a = PEEK_B(iseq+i+1);
+      b = PEEK_B(iseq+i+2);
       /* src part */
       if (potential_upvar_p(irep->lv, GETARG_B(c), argc, irep->nlocals)) {
         mrb_code arg = search_variable(mrb, irep->lv[GETARG_B(c) - 1].name, bnest);
+      if (potential_upvar_p(irep->lv, b, argc, irep->nlocals)) {
+        uint16_t arg = search_variable(mrb, irep->lv[b - 1].name, bnest);
         if (arg != 0) {
           /* must replace */
+          irep->iseq[i] = MKOPCODE(OP_GETUPVAR) | MKARG_A(GETARG_A(c)) | arg;
+          iseq[i] = insn = OP_GETUPVAR;
+          iseq[i+2] = arg >> 8;
+          iseq[i+3] = arg & 0xff;
+        }
+      }
       /* dst part */
       if (potential_upvar_p(irep->lv, GETARG_A(c), argc, irep->nlocals)) {
         mrb_code arg = search_variable(mrb, irep->lv[GETARG_A(c) - 1].name, bnest);
+      if (potential_upvar_p(irep->lv, a, argc, irep->nlocals)) {
+        uint16_t arg = search_variable(mrb, irep->lv[a - 1].name, bnest);
         if (arg != 0) {
           /* must replace */
+          irep->iseq[i] = MKOPCODE(OP_SETUPVAR) | MKARG_A(GETARG_B(c)) | arg;
+        }
+      }
+      break;
+    case OP_STOP:
+      if (mrb->c->ci->acc >= 0) {
+        irep->iseq[i] = MKOP_AB(OP_RETURN, irep->nlocals, OP_R_NORMAL);
+      }
+      break;
+    }
+          iseq[i] = insn = OP_SETUPVAR;
+          iseq[i+1] = (mrb_code)b;
+          iseq[i+2] = arg >> 8;
+          iseq[i+3] = arg & 0xff;
+        }
+      }
+      break;
+    case OP_GETUPVAR:
+      a = PEEK_B(iseq+i+1);
+      b = PEEK_B(iseq+i+2);
+      c = PEEK_B(iseq+i+3);
+      {
+        int lev = c+1;
+        mrb_irep *tmp = search_irep(top, bnest, lev, irep);
+        if (potential_upvar_p(tmp->lv, b, irep_argc(tmp), tmp->nlocals)) {
+          uint16_t arg = search_variable(mrb, tmp->lv[b-1].name, bnest);
+          if (arg != 0) {
+            /* must replace */
+            iseq[i] = OP_GETUPVAR;
+            iseq[i+2] = arg >> 8;
+            iseq[i+3] = arg & 0xff;
+          }
+        }
+      }
+      break;
+    case OP_SETUPVAR:
+      a = PEEK_B(iseq+i+1);
+      b = PEEK_B(iseq+i+2);
+      c = PEEK_B(iseq+i+3);
+      {
+        int lev = c+1;
+        mrb_irep *tmp = search_irep(top, bnest, lev, irep);
+        if (potential_upvar_p(tmp->lv, b, irep_argc(tmp), tmp->nlocals)) {
+          uint16_t arg = search_variable(mrb, tmp->lv[b-1].name, bnest);
+          if (arg != 0) {
+            /* must replace */
+            iseq[i] = OP_SETUPVAR;
+            iseq[i+1] = a;
+            iseq[i+2] = arg >> 8;
+            iseq[i+3] = arg & 0xff;
+          }
+        }
+      }
+      break;
+    case OP_EXT1:
+      insn = PEEK_B(iseq+i+1);
+      i += mrb_insn_size1[insn]+1;
+      continue;
+    case OP_EXT2:
+      insn = PEEK_B(iseq+i+1);
+      i += mrb_insn_size2[insn]+1;
+      continue;
+    case OP_EXT3:
+      insn = PEEK_B(iseq+i+1);
+      i += mrb_insn_size3[insn]+1;
+      continue;
+    }
+    i+=mrb_insn_size[insn];
+  }
+}
 …
 static struct RProc*
 create_proc_from_string(mrb_state *mrb, char *s, int len, mrb_value binding, const char *file, mrb_int line)
+create_proc_from_string(mrb_state *mrb, char *s, mrb_int len, mrb_value binding, const char *file, mrb_int line)
+{
   mrbc_context *cxt;
 …
   struct RProc *proc;
   struct REnv *e;
+  struct mrb_context *c = mrb->c;
+  mrb_callinfo *ci; /* callinfo of eval caller */
+  struct RClass *target_class = NULL;
+  int bidx;
   if (!mrb_nil_p(binding)) {
 …
   cxt = mrbc_context_new(mrb);
   cxt->lineno = line;
+  cxt->lineno = (uint16_t)line;
   mrbc_filename(mrb, cxt, file ? file : "(eval)");
   cxt->capture_errors = TRUE;
   cxt->no_optimize = TRUE;
+  cxt->on_eval = TRUE;
   p = mrb_parse_nstring(mrb, s, len, cxt);
 …
     if (file) {
       str = mrb_format(mrb, " file %S line %S: %S",
                        mrb_str_new_cstr(mrb, file),
                        mrb_fixnum_value(p->error_buffer[0].lineno),
                        mrb_str_new_cstr(mrb, p->error_buffer[0].message));
+      str = mrb_format(mrb, "file %s line %d: %s",
+                       file,
+                       p->error_buffer[0].lineno,
+                       p->error_buffer[0].message);
+    }
     else {
       str = mrb_format(mrb, " line %S: %S",
                        mrb_fixnum_value(p->error_buffer[0].lineno),
                        mrb_str_new_cstr(mrb, p->error_buffer[0].message));
+      str = mrb_format(mrb, "line %d: %s",
+                       p->error_buffer[0].lineno,
+                       p->error_buffer[0].message);
+    }
     mrb_parser_free(p);
 …
     mrb_raise(mrb, E_SCRIPT_ERROR, "codegen error");
+  }
+  if (c->ci[-1].proc->target_class) {
+    proc->target_class = c->ci[-1].proc->target_class;
+  }
+  e = c->ci[-1].proc->env;
+  if (!e) e = c->ci[-1].env;
+  e = (struct REnv*)mrb_obj_alloc(mrb, MRB_TT_ENV, (struct RClass*)e);
+  e->cxt.c = c;
+  e->cioff = c->ci - c->cibase;
+  e->stack = c->ci->stackent;
+  MRB_SET_ENV_STACK_LEN(e, c->ci->proc->body.irep->nlocals);
+  c->ci->target_class = proc->target_class;
+  c->ci->env = 0;
+  proc->env = e;
+  patch_irep(mrb, proc->body.irep, 0);
+  if (mrb->c->ci > mrb->c->cibase) {
+    ci = &mrb->c->ci[-1];
+  }
+  else {
+    ci = mrb->c->cibase;
+  }
+  if (ci->proc) {
+    target_class = MRB_PROC_TARGET_CLASS(ci->proc);
+  }
+  if (ci->proc && !MRB_PROC_CFUNC_P(ci->proc)) {
+    if (ci->env) {
+      e = ci->env;
+    }
+    else {
+      e = (struct REnv*)mrb_obj_alloc(mrb, MRB_TT_ENV,
+                                      (struct RClass*)target_class);
+      e->mid = ci->mid;
+      e->stack = ci[1].stackent;
+      e->cxt = mrb->c;
+      MRB_ENV_SET_STACK_LEN(e, ci->proc->body.irep->nlocals);
+      bidx = ci->argc;
+      if (ci->argc < 0) bidx = 2;
+      else bidx += 1;
+      MRB_ENV_SET_BIDX(e, bidx);
+      ci->env = e;
+    }
+    proc->e.env = e;
+    proc->flags |= MRB_PROC_ENVSET;
+    mrb_field_write_barrier(mrb, (struct RBasic*)proc, (struct RBasic*)e);
+  }
+  proc->upper = ci->proc;
+  mrb->c->ci->target_class = target_class;
+  patch_irep(mrb, proc->body.irep, 0, proc->body.irep);
+  /* mrb_codedump_all(mrb, proc); */
   mrb_parser_free(p);
 …
 exec_irep(mrb_state *mrb, mrb_value self, struct RProc *proc)
+{
+  /* no argument passed from eval() */
+  mrb->c->ci->argc = 0;
   if (mrb->c->ci->acc < 0) {
+    mrb_value ret = mrb_top_run(mrb, proc, mrb->c->stack[0], 0);
+    ptrdiff_t cioff = mrb->c->ci - mrb->c->cibase;
+    mrb_value ret = mrb_top_run(mrb, proc, self, 0);
     if (mrb->exc) {
       mrb_exc_raise(mrb, mrb_obj_value(mrb->exc));
+    }
+    mrb->c->ci = mrb->c->cibase + cioff;
     return ret;
+  }
+  /* clear block */
+  mrb->c->stack[1] = mrb_nil_value();
   return mrb_exec_irep(mrb, self, proc);
+}
 …
   mrb_int argc; mrb_value *argv;
   mrb_get_args(mrb, "*&", &argv, &argc, &b);
+  mrb_get_args(mrb, "*!&", &argv, &argc, &b);
   if (mrb_nil_p(b)) {
 …
     cv = mrb_singleton_class(mrb, self);
     proc = create_proc_from_string(mrb, s, len, mrb_nil_value(), file, line);
+    proc->target_class = mrb_class_ptr(cv);
+    mrb->c->ci->env = NULL;
+    MRB_PROC_SET_TARGET_CLASS(proc, mrb_class_ptr(cv));
     mrb_assert(!MRB_PROC_CFUNC_P(proc));
+    mrb->c->ci->target_class = mrb_class_ptr(cv);
     return exec_irep(mrb, self, proc);
+  }
 …
+{
   mrb_define_module_function(mrb, mrb->kernel_module, "eval", f_eval, MRB_ARGS_ARG(1, 3));
   mrb_define_method(mrb, mrb->kernel_module, "instance_eval", f_instance_eval, MRB_ARGS_ARG(1, 2));
+  mrb_define_method(mrb, mrb_class_get(mrb, "BasicObject"), "instance_eval", f_instance_eval, MRB_ARGS_OPT(3)|MRB_ARGS_BLOCK());
+}

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-eval/test/eval.rb

-              r331
+              r439
   assert_equal(2) {
     a = 10
     Kernel.eval 'def f(a); b=a.send(:+, 1); end'
+    Kernel.eval 'def f(a); b=a+1; end'
     f(1)
+  }
 …
 assert('String instance_eval') do
   obj = Object.new
   obj.instance_variable_set :@test, 'test'
+  obj.instance_eval{ @test = 'test' }
   assert_raise(ArgumentError) { obj.instance_eval(0) { } }
   assert_raise(ArgumentError) { obj.instance_eval('0', 'test', 0, 'test') }
 …
 end
 assert('Object#instance_eval with begin-rescue-ensure execution order') do
+assert('BasicObject#instance_eval with begin-rescue-ensure execution order') do
   class HellRaiser
     def raise_hell
 …
   assert_equal([:enter_raise_hell, :begin, :rescue, :ensure], hell_raiser.raise_hell)
 end
+assert('BasicObject#instance_eval to define singleton methods Issue #3141') do
+  foo_class = Class.new do
+    def bar(x)
+      instance_eval "def baz; #{x}; end"
+    end
+  end
+  f1 = foo_class.new
+  f2 = foo_class.new
+  f1.bar 1
+  f2.bar 2
+  assert_equal(1){f1.baz}
+  assert_equal(2){f2.baz}
+end
+assert('Kernel.#eval(string) Issue #4021') do
+  assert_equal('FOO') { (eval <<'EOS').call }
+foo = "FOO"
+Proc.new { foo }
+EOS
+  assert_equal('FOO') {
+    def do_eval(code)
+      eval(code)
+    end
+    do_eval(<<'EOS').call
+foo = "FOO"
+Proc.new { foo }
+EOS
+  }
+end

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-exit/src/mruby-exit.c

-              r331
+              r439
 f_exit(mrb_state *mrb, mrb_value self)
+{
+  mrb_int i = EXIT_SUCCESS;
+  mrb_value status = mrb_true_value();
+  int istatus;
+  mrb_get_args(mrb, "|i", &i);
+  exit(i);
+  mrb_get_args(mrb, "|o", &status);
+  istatus = mrb_true_p(status) ? EXIT_SUCCESS :
+            mrb_false_p(status) ? EXIT_FAILURE :
+            (int)mrb_int(mrb, status);
+  exit(istatus);
   /* not reached */
   return mrb_nil_value();
+  return status;
+}

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-fiber/src/fiber.c

-              r331
+              r439
   size_t slen;
   mrb_get_args(mrb, "&", &blk);
+  mrb_get_args(mrb, "&!", &blk);
   if (f->cxt) {
     mrb_raise(mrb, E_RUNTIME_ERROR, "cannot initialize twice");
+  }
-  if (mrb_nil_p(blk)) {
-    mrb_raise(mrb, E_ARGUMENT_ERROR, "tried to create Fiber object without a block");
+  }
   p = mrb_proc_ptr(blk);
 …
   /* adjust return callinfo */
   ci = c->ci;
   ci->target_class = p->target_class;
+  ci->target_class = MRB_PROC_TARGET_CLASS(p);
   ci->proc = p;
+  mrb_field_write_barrier(mrb, (struct RBasic*)mrb_obj_ptr(self), (struct RBasic*)p);
   ci->pc = p->body.irep->iseq;
-  ci->nregs = p->body.irep->nregs;
   ci[1] = ci[0];
   c->ci++;                      /* push dummy callinfo */
 …
   struct mrb_context *c = fiber_check(mrb, self);
   struct mrb_context *old_c = mrb->c;
+  enum mrb_fiber_state status;
   mrb_value value;
   fiber_check_cfunc(mrb, c);
+  if (resume && c->status == MRB_FIBER_TRANSFERRED) {
+    mrb_raise(mrb, E_FIBER_ERROR, "resuming transferred fiber");
+  }
+  if (c->status == MRB_FIBER_RUNNING || c->status == MRB_FIBER_RESUMED) {
+    mrb_raise(mrb, E_FIBER_ERROR, "double resume (fib)");
+  }
+  if (c->status == MRB_FIBER_TERMINATED) {
+  status = c->status;
+  switch (status) {
+  case MRB_FIBER_TRANSFERRED:
+    if (resume) {
+      mrb_raise(mrb, E_FIBER_ERROR, "resuming transferred fiber");
+    }
+    break;
+  case MRB_FIBER_RUNNING:
+  case MRB_FIBER_RESUMED:
+    mrb_raise(mrb, E_FIBER_ERROR, "double resume");
+    break;
+  case MRB_FIBER_TERMINATED:
     mrb_raise(mrb, E_FIBER_ERROR, "resuming dead fiber");
+  }
+  mrb->c->status = resume ? MRB_FIBER_RESUMED : MRB_FIBER_TRANSFERRED;
+    break;
+  default:
+    break;
+  }
+  old_c->status = resume ? MRB_FIBER_RESUMED : MRB_FIBER_TRANSFERRED;
   c->prev = resume ? mrb->c : (c->prev ? c->prev : mrb->root_c);
+  if (c->status == MRB_FIBER_CREATED) {
+  fiber_switch_context(mrb, c);
+  if (status == MRB_FIBER_CREATED) {
     mrb_value *b, *e;
     if (len >= c->stend - c->stack) {
       mrb_raise(mrb, E_FIBER_ERROR, "too many arguments to fiber");
+    if (!c->ci->proc) {
+      mrb_raise(mrb, E_FIBER_ERROR, "double resume (current)");
+    }
+    mrb_stack_extend(mrb, len+2); /* for receiver and (optional) block */
     b = c->stack+1;
     e = b + len;
 …
       *b++ = *a++;
+    }
     c->cibase->argc = len;
     value = c->stack[0] = c->ci->proc->env->stack[0];
+    c->cibase->argc = (int)len;
+    value = c->stack[0] = MRB_PROC_ENV(c->ci->proc)->stack[0];
+  }
   else {
     value = fiber_result(mrb, a, len);
+  }
-  fiber_switch_context(mrb, c);
   if (vmexec) {
 …
   mrb_bool vmexec = FALSE;
   mrb_get_args(mrb, "*", &a, &len);
+  mrb_get_args(mrb, "*!", &a, &len);
   if (mrb->c->ci->acc < 0) {
     vmexec = TRUE;
 …
  *  execution of the fiber block this method will always return false.
  */
 static mrb_value
 fiber_alive_p(mrb_state *mrb, mrb_value self)
+MRB_API mrb_value
+mrb_fiber_alive_p(mrb_state *mrb, mrb_value self)
+{
   struct mrb_context *c = fiber_check(mrb, self);
   return mrb_bool_value(c->status != MRB_FIBER_TERMINATED);
+}
+#define fiber_alive_p mrb_fiber_alive_p
 static mrb_value
 …
   mrb_get_args(mrb, "o", &other);
   if (mrb_type(other) != MRB_TT_FIBER) {
+  if (!mrb_fiber_p(other)) {
     return mrb_false_value();
+  }
 …
   fiber_check_cfunc(mrb, mrb->c);
   mrb_get_args(mrb, "*", &a, &len);
+  mrb_get_args(mrb, "*!", &a, &len);
   if (c == mrb->root_c) {
 …
   mrb_int len;
   mrb_get_args(mrb, "*", &a, &len);
+  mrb_get_args(mrb, "*!", &a, &len);
   return mrb_fiber_yield(mrb, len, a);
+}
 …
   MRB_SET_INSTANCE_TT(c, MRB_TT_FIBER);
   mrb_define_method(mrb, c, "initialize", fiber_init,    MRB_ARGS_NONE());
+  mrb_define_method(mrb, c, "initialize", fiber_init,    MRB_ARGS_NONE()|MRB_ARGS_BLOCK());
   mrb_define_method(mrb, c, "resume",     fiber_resume,  MRB_ARGS_ANY());
   mrb_define_method(mrb, c, "transfer",   fiber_transfer, MRB_ARGS_ANY());

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-fiber/test/fiber.rb

r321	r439
77	77
78	78	assert('Fiber with splat in the block argument list') {
79		~~Fiber.new{\|*x\|x}.resume(1) == [1]~~
	79	assert_equal([1], Fiber.new{\|*x\|x}.resume(1))
80	80	}
81	81

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-hash-ext/mrbgem.rake

r321	r439
3	3	spec.author = 'mruby developers'
4	4	spec.summary = 'Hash class extension'
5		spec.add_dependency 'mruby-enum-ext', :core => 'mruby-enum-ext'
6		spec.add_dependency 'mruby-array-ext', :core => 'mruby-array-ext'
	5	spec.add_dependency 'mruby-array-ext', core: 'mruby-array-ext'
7	6	end

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-hash-ext/mrblib/hash.rb

-              r331
+              r439
     if length == 1
       o = object[0]
       if o.respond_to?(:to_hash)
+      if Hash === o
         h = self.new
         object[0].to_hash.each { |k, v| h[k] = v }
+        o.each { |k, v| h[k] = v }
         return h
       elsif o.respond_to?(:to_a)
 …
   ##
   # call-seq:
-  #     Hash.try_convert(obj) -> hash or nil
+  #
-  # Try to convert <i>obj</i> into a hash, using to_hash method.
-  # Returns converted hash or nil if <i>obj</i> cannot be converted
-  # for any reason.
+  #
-  #     Hash.try_convert({1=>2})   # => {1=>2}
-  #     Hash.try_convert("1=>2")   # => nil
+  #
-  def self.try_convert(obj)
-    if obj.respond_to?(:to_hash)
-      obj.to_hash
-    else
-      nil
-    end
-  end
-  ##
-  # call-seq:
   #     hsh.merge!(other_hash)                                 -> hsh
   #     hsh.merge!(other_hash){|key, oldval, newval| block}    -> hsh
 …
   def merge!(other, &block)
     raise TypeError, "can't convert argument into Hash" unless other.respond_to?(:to_hash)
+    raise TypeError, "Hash required (#{other.class} given)" unless Hash === other
     if block
       other.each_key{|k|
 …
   alias update merge!
+  ##
+  # call-seq:
+  #   hsh.compact!    -> hsh
+  #
+  # Removes all nil values from the hash. Returns the hash.
+  # Returns nil if the hash does not contain nil values.
+  #
+  #   h = { a: 1, b: false, c: nil }
+  #   h.compact!     #=> { a: 1, b: false }
+  #
+  def compact!
+    keys = self.keys
+    nk = keys.select{|k|
+      self[k] != nil
+    }
+    return nil if (keys.size == nk.size)
+    h = {}
+    nk.each {|k|
+      h[k] = self[k]
+    }
+    h
+    self.replace(h)
+  end
+  ##
+  # call-seq:
+  #    hsh.compact     -> new_hsh
+  #
+  # Returns a new hash with the nil values/key pairs removed
+  #
+  #    h = { a: 1, b: false, c: nil }
+  #    h.compact     #=> { a: 1, b: false }
+  #    h             #=> { a: 1, b: false, c: nil }
+  #
+  def compact
+    h = {}
+    self.keys.select{|k|
+      self[k] != nil
+    }.each {|k|
+      h[k] = self[k]
+    }
+    h
+  end
   ##
 …
         none
       else
         raise KeyError, "Key not found: #{key}"
+        raise KeyError, "Key not found: #{key.inspect}"
       end
     else
 …
   def delete_if(&block)
     return to_enum :delete_if unless block_given?
+    return to_enum :delete_if unless block
     self.each do |k, v|
 …
   def keep_if(&block)
     return to_enum :keep_if unless block_given?
+    return to_enum :keep_if unless block
     keys = []
 …
+  #
   def <(hash)
+    begin
+      hash = hash.to_hash
+    rescue NoMethodError
+      raise TypeError, "can't convert #{hash.class} to Hash"
+    end
+    raise TypeError, "can't convert #{hash.class} to Hash" unless Hash === hash
     size < hash.size and all? {|key, val|
       hash.key?(key) and hash[key] == val
 …
+  #
   def <=(hash)
+    begin
+      hash = hash.to_hash
+    rescue NoMethodError
+      raise TypeError, "can't convert #{hash.class} to Hash"
+    end
+    raise TypeError, "can't convert #{hash.class} to Hash" unless Hash === hash
     size <= hash.size and all? {|key, val|
       hash.key?(key) and hash[key] == val
 …
+  #
   def >(hash)
+    begin
+      hash = hash.to_hash
+    rescue NoMethodError
+      raise TypeError, "can't convert #{hash.class} to Hash"
+    end
+    raise TypeError, "can't convert #{hash.class} to Hash" unless Hash === hash
     size > hash.size and hash.all? {|key, val|
       key?(key) and self[key] == val
 …
+  #
   def >=(hash)
+    begin
+      hash = hash.to_hash
+    rescue NoMethodError
+      raise TypeError, "can't convert #{hash.class} to Hash"
+    end
+    raise TypeError, "can't convert #{hash.class} to Hash" unless Hash === hash
     size >= hash.size and hash.all? {|key, val|
       key?(key) and self[key] == val
 …
     end
   end
+  ##
+  # call-seq:
+  #    hsh.transform_keys {|key| block } -> new_hash
+  #    hsh.transform_keys                -> an_enumerator
+  #
+  # Returns a new hash, with the keys computed from running the block
+  # once for each key in the hash, and the values unchanged.
+  #
+  # If no block is given, an enumerator is returned instead.
+  #
+  def transform_keys(&block)
+    return to_enum :transform_keys unless block
+    hash = {}
+    self.keys.each do |k|
+      new_key = block.call(k)
+      hash[new_key] = self[k]
+    end
+    hash
+  end
+  ##
+  # call-seq:
+  #    hsh.transform_keys! {|key| block } -> hsh
+  #    hsh.transform_keys!                -> an_enumerator
+  #
+  # Invokes the given block once for each key in <i>hsh</i>, replacing it
+  # with the new key returned by the block, and then returns <i>hsh</i>.
+  #
+  # If no block is given, an enumerator is returned instead.
+  #
+  def transform_keys!(&block)
+    return to_enum :transform_keys! unless block
+    self.keys.each do |k|
+      value = self[k]
+      self.__delete(k)
+      k = block.call(k) if block
+      self[k] = value
+    end
+    self
+  end
+  ##
+  # call-seq:
+  #    hsh.transform_values {|value| block } -> new_hash
+  #    hsh.transform_values                  -> an_enumerator
+  #
+  # Returns a new hash with the results of running the block once for
+  # every value.
+  # This method does not change the keys.
+  #
+  # If no block is given, an enumerator is returned instead.
+  #
+  def transform_values(&b)
+    return to_enum :transform_values unless block_given?
+    hash = {}
+    self.keys.each do |k|
+      hash[k] = yield(self[k])
+    end
+    hash
+  end
+  ##
+  # call-seq:
+  #    hsh.transform_values! {|key| block } -> hsh
+  #    hsh.transform_values!                -> an_enumerator
+  #
+  # Invokes the given block once for each value in the hash, replacing
+  # with the new value returned by the block, and then returns <i>hsh</i>.
+  #
+  # If no block is given, an enumerator is returned instead.
+  #
+  def transform_values!(&b)
+    return to_enum :transform_values! unless block_given?
+    self.keys.each do |k|
+      self[k] = yield(self[k])
+    end
+    self
+  end
+  def to_proc
+    ->x{self[x]}
+  end
+  ##
+  # call-seq:
+  #   hsh.fetch_values(key, ...)                 -> array
+  #   hsh.fetch_values(key, ...) { |key| block } -> array
+  #
+  # Returns an array containing the values associated with the given keys
+  # but also raises <code>KeyError</code> when one of keys can't be found.
+  # Also see <code>Hash#values_at</code> and <code>Hash#fetch</code>.
+  #
+  #   h = { "cat" => "feline", "dog" => "canine", "cow" => "bovine" }
+  #
+  #   h.fetch_values("cow", "cat")                   #=> ["bovine", "feline"]
+  #   h.fetch_values("cow", "bird")                  # raises KeyError
+  #   h.fetch_values("cow", "bird") { |k| k.upcase } #=> ["bovine", "BIRD"]
+  #
+  def fetch_values(*keys, &block)
+    keys.map do |k|
+      self.fetch(k, &block)
+    end
+  end
+  alias filter select
+  alias filter! select!
 end

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-hash-ext/src/hash-ext.c

-              r331
+              r439
+}
+/*
+ *  call-seq:
+ *     hsh.slice(*keys) -> a_hash
+ *
+ *  Returns a hash containing only the given keys and their values.
+ *
+ *     h = { a: 100, b: 200, c: 300 }
+ *     h.slice(:a)           #=> {:a=>100}
+ *     h.slice(:b, :c, :d)   #=> {:b=>200, :c=>300}
+ */
+static mrb_value
+hash_slice(mrb_state *mrb, mrb_value hash)
+{
+  mrb_value *argv, result;
+  mrb_int argc, i;
+  mrb_get_args(mrb, "*", &argv, &argc);
+  result = mrb_hash_new_capa(mrb, argc);
+  if (argc == 0) return result; /* empty hash */
+  for (i = 0; i < argc; i++) {
+    mrb_value key = argv[i];
+    mrb_value val;
+    val = mrb_hash_fetch(mrb, hash, key, mrb_undef_value());
+    if (!mrb_undef_p(val)) {
+      mrb_hash_set(mrb, result, key, val);
+    }
+  }
+  return result;
+}
 void
 mrb_mruby_hash_ext_gem_init(mrb_state *mrb)
 …
   h = mrb->hash_class;
   mrb_define_method(mrb, h, "values_at", hash_values_at, MRB_ARGS_ANY());
+  mrb_define_method(mrb, h, "slice",     hash_slice, MRB_ARGS_ANY());
+}

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-hash-ext/test/hash.rb

-              r331
+              r439
 end
-assert('Hash.try_convert') do
-  assert_nil Hash.try_convert(nil)
-  assert_nil Hash.try_convert("{1=>2}")
-  assert_equal({1=>2}, Hash.try_convert({1=>2}))
-end
 assert('Hash#merge!') do
   a = { 'abc_key' => 'abc_value', 'cba_key' => 'cba_value' }
 …
   h = Hash.new { |hash,k| hash[k] = k }
   assert_equal keys, h.values_at(*keys)
+end
+assert('Hash#compact') do
+  h = { "cat" => "feline", "dog" => nil, "cow" => false }
+  assert_equal({ "cat" => "feline", "cow" => false }, h.compact)
+  assert_equal({ "cat" => "feline", "dog" => nil, "cow" => false }, h)
+end
+assert('Hash#compact!') do
+  h = { "cat" => "feline", "dog" => nil, "cow" => false }
+  h.compact!
+  assert_equal({ "cat" => "feline", "cow" => false }, h)
 end
 …
   assert_nil(h.dig(:d))
 end
+assert("Hash#transform_keys") do
+  h = {"1" => 100, "2" => 200}
+  assert_equal({"1!" => 100, "2!" => 200},
+               h.transform_keys{|k| k+"!"})
+  assert_equal({1 => 100, 2 => 200},
+               h.transform_keys{|k|k.to_i})
+  assert_same(h, h.transform_keys!{|k|k.to_i})
+  assert_equal({1 => 100, 2 => 200}, h)
+end
+assert("Hash#transform_values") do
+  h = {a: 1, b: 2, c: 3}
+  assert_equal({a: 2, b: 5, c: 10},
+               h.transform_values{|v| v * v + 1})
+  assert_equal({a: "1", b: "2", c: "3"},
+               h.transform_values{|v|v.to_s})
+  assert_same(h, h.transform_values!{|v|v.to_s})
+  assert_equal({a: "1", b: "2", c: "3"}, h)
+end
+assert("Hash#slice") do
+  h = { a: 100, b: 200, c: 300 }
+  assert_equal({:a=>100}, h.slice(:a))
+  assert_equal({:b=>200, :c=>300}, h.slice(:b, :c, :d))
+end

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-inline-struct/test/inline.c

-              r331
+              r439
   mrb_get_args(mrb, "o", &object);
+  if (mrb_float_p(object))
+  {
+    snprintf(string, size, "float(%.3f)", mrb_float(object));
+  if (mrb_fixnum_p(object)) {
+    strncpy(string, "fixnum", size-1);
+  }
+  else if (mrb_fixnum_p(object))
+  {
     snprintf(string, size, "fixnum(%" MRB_PRId ")", mrb_fixnum(object));
+#ifndef MRB_WITHOUT_FLOAT
+  else if (mrb_float_p(object)) {
+    strncpy(string, "float", size-1);
+  }
+  else if (mrb_string_p(object))
+  {
+    snprintf(string, size, "string(%s)", mrb_string_value_cstr(mrb, &object));
+#endif
+  else if (mrb_string_p(object)) {
+    strncpy(string, "string", size-1);
+  }
+  else {
+    strncpy(string, "anything", size-1);
+  }
 …
   if (mrb_obj_class(mrb, object) != mrb_class_get(mrb, "InlineStructTest"))
+  {
     mrb_raisef(mrb, E_TYPE_ERROR, "Expected InlineStructTest");
+    mrb_raise(mrb, E_TYPE_ERROR, "Expected InlineStructTest");
+  }
   return mrb_bool_value(((char*)mrb_istruct_ptr(object))[0] == 's');

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-inline-struct/test/inline.rb

-              r331
+              r439
 assert('InlineStructTest#dup') do
   obj = InlineStructTest.new(1)
   assert_equal obj.to_s, 'fixnum(1)'
   assert_equal obj.dup.to_s, 'fixnum(1)'
+  assert_equal obj.to_s, 'fixnum'
+  assert_equal obj.dup.to_s, 'fixnum'
 end
 assert('InlineStructTest#clone') do
   obj = InlineStructTest.new(1)
   assert_equal obj.to_s, 'fixnum(1)'
   assert_equal obj.clone.to_s, 'fixnum(1)'
+  assert_equal obj.to_s, 'fixnum'
+  assert_equal obj.clone.to_s, 'fixnum'
 end
 …
 assert('InlineStructTest#mutate (dup)') do
   obj1 = InlineStructTest.new("foo")
   assert_equal obj1.to_s, "string(foo)"
+  assert_equal obj1.to_s, "string"
   obj2 = obj1.dup
   assert_equal obj2.to_s, "string(foo)"
+  assert_equal obj2.to_s, "string"
   obj1.mutate
   assert_equal obj1.to_s, "mutate(foo)"
   assert_equal obj2.to_s, "string(foo)"
+  assert_equal obj1.to_s, "mutate"
+  assert_equal obj2.to_s, "string"
 end
 assert('InlineStructTest#mutate (clone)') do
   obj1 = InlineStructTest.new("foo")
   assert_equal obj1.to_s, "string(foo)"
+  assert_equal obj1.to_s, "string"
   obj2 = obj1.clone
   assert_equal obj2.to_s, "string(foo)"
+  assert_equal obj2.to_s, "string"
   obj1.mutate
   assert_equal obj1.to_s, "mutate(foo)"
   assert_equal obj2.to_s, "string(foo)"
+  assert_equal obj1.to_s, "mutate"
+  assert_equal obj2.to_s, "string"
 end
 …
     assert_equal InlineStructTest.length, 3 * 8
   end
-  assert('InlineStructTest w/float [64 bit]') do
-    obj = InlineStructTest.new(1.25)
-    assert_equal obj.to_s, "float(1.250)"
-  end
-  assert('InlineStructTest w/fixnum [64 bit]') do
-    obj = InlineStructTest.new(42)
-    assert_equal obj.to_s, "fixnum(42)"
-  end
-  assert('InlineStructTest w/string [64 bit]') do
-    obj = InlineStructTest.new("hello")
-    assert_equal obj.to_s, "string(hello)"
-  end
-  assert('InlineStructTest w/long string [64 bit]') do
-    obj = InlineStructTest.new("this won't fit in 3 * 8 bytes available for the structure")
-    assert_equal obj.to_s, "string(this won't fit i"
-  end
 end
 …
     assert_equal InlineStructTest.length, 3 * 4
   end
+end
+  assert('InlineStructTest w/float [32 bit]') do
+    obj = InlineStructTest.new(1.25)
+    assert_equal obj.to_s, "float(1.250"
+  end
+  assert('InlineStructTest w/fixnum [32 bit]') do
+    obj = InlineStructTest.new(42)
+    assert_equal obj.to_s, "fixnum(42)"
+  end
+  assert('InlineStructTest w/string [32 bit]') do
+    obj = InlineStructTest.new("hello")
+    assert_equal obj.to_s, "string(hell"
+  end
+  assert('InlineStructTest w/long string [32 bit]') do
+    obj = InlineStructTest.new("this won't fit in 3 * 4 bytes available for the structure")
+    assert_equal obj.to_s, "string(this"
+# 16-bit mode
+if InlineStructTest.length == 6
+  assert('InlineStructTest length [16 bit]') do
+    assert_equal InlineStructTest.length, 3 * 2
   end
 end

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-kernel-ext/mrbgem.rake

r321	r439
2	2	spec.license = 'MIT'
3	3	spec.author = 'mruby developers'
4		spec.summary = '~~Kernel module extension~~'
	4	spec.summary = 'extensional function-like methods'
5	5	end

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-kernel-ext/src/kernel.c

-              r331
+              r439
       break;
     case 1:
       if (mrb_type(v) == MRB_TT_RANGE) {
+      if (mrb_range_p(v)) {
         mrb_int beg, len;
         if (mrb_range_beg_len(mrb, v, &beg, &len, bt_len, TRUE) == 1) {
+        if (mrb_range_beg_len(mrb, v, &beg, &len, bt_len, TRUE) == MRB_RANGE_OK) {
           lev = beg;
           n = len;
 …
+      }
       else {
+        v = mrb_to_int(mrb, v);
+        lev = mrb_fixnum(v);
+        lev = mrb_int(mrb, v);
         if (lev < 0) {
           mrb_raisef(mrb, E_ARGUMENT_ERROR, "negative level (%S)", v);
+          mrb_raisef(mrb, E_ARGUMENT_ERROR, "negative level (%v)", v);
+        }
         n = bt_len - lev;
 …
       break;
     case 2:
       lev = mrb_fixnum(mrb_to_int(mrb, v));
       n = mrb_fixnum(mrb_to_int(mrb, length));
+      lev = mrb_int(mrb, v);
+      n = mrb_int(mrb, length);
       if (lev < 0) {
         mrb_raisef(mrb, E_ARGUMENT_ERROR, "negative level (%S)", v);
+        mrb_raisef(mrb, E_ARGUMENT_ERROR, "negative level (%v)", v);
+      }
       if (n < 0) {
         mrb_raisef(mrb, E_ARGUMENT_ERROR, "negative size (%S)", length);
+        mrb_raisef(mrb, E_ARGUMENT_ERROR, "negative size (%v)", length);
+      }
       break;
 …
  *  In any case, strings should be strictly conformed to numeric
  *  representation. This behavior is different from that of
+ *  <code>String#to_i</code>.  Non string values will be converted using
+ *  <code>to_int</code>, and <code>to_i</code>. Passing <code>nil</code>
+ *  raises a TypeError.
+ *  <code>String#to_i</code>.  Non string values will be treated as integers.
+ *  Passing <code>nil</code> raises a TypeError.
+ *
  *     Integer(123.999)    #=> 123
 …
+}
+#ifndef MRB_WITHOUT_FLOAT
 /*
  *  call-seq:
 …
   return mrb_Float(mrb, arg);
+}
+#endif
 /*
 …
+ *
  *  Returns <i>arg</i> as an <code>String</code>.
+ *
+ *  First tries to call its <code>to_str</code> method, then its to_s method.
+ *  converted using <code>to_s</code> method.
+ *
  *     String(self)        #=> "main"
 …
   mrb_get_args(mrb, "o", &arg);
+  tmp = mrb_check_convert_type(mrb, arg, MRB_TT_STRING, "String", "to_str");
+  if (mrb_nil_p(tmp)) {
+    tmp = mrb_check_convert_type(mrb, arg, MRB_TT_STRING, "String", "to_s");
+  }
+  tmp = mrb_convert_type(mrb, arg, MRB_TT_STRING, "String", "to_s");
   return tmp;
+}
 …
  *     Array(arg)    -> array
+ *
+ *  Returns +arg+ as an Array.
+ *
+ *  First tries to call Array#to_ary on +arg+, then Array#to_a.
+ *  Returns +arg+ as an Array using to_a method.
+ *
  *     Array(1..5)   #=> [1, 2, 3, 4, 5]
 …
   mrb_get_args(mrb, "o", &arg);
+  tmp = mrb_check_convert_type(mrb, arg, MRB_TT_ARRAY, "Array", "to_ary");
+  if (mrb_nil_p(tmp)) {
+    tmp = mrb_check_convert_type(mrb, arg, MRB_TT_ARRAY, "Array", "to_a");
+  }
+  tmp = mrb_check_convert_type(mrb, arg, MRB_TT_ARRAY, "Array", "to_a");
   if (mrb_nil_p(tmp)) {
     return mrb_ary_new_from_values(mrb, 1, &arg);
 …
  *     Hash(arg)    -> hash
+ *
  *  Converts <i>arg</i> to a <code>Hash</code> by calling
  *  <i>arg</i><code>.to_hash</code>. Returns an empty <code>Hash</code> when
  *  <i>arg</i> is <tt>nil</tt> or <tt>[]</tt>.
+ *  Returns a <code>Hash</code> if <i>arg</i> is a <code>Hash</code>.
+ *  Returns an empty <code>Hash</code> when <i>arg</i> is <tt>nil</tt>
+ *  or <tt>[]</tt>.
+ *
  *      Hash([])          #=> {}
 …
 mrb_f_hash(mrb_state *mrb, mrb_value self)
+{
   mrb_value arg, tmp;
   mrb_get_args(mrb, "o", &arg);
   if (mrb_nil_p(arg)) {
+  mrb_value arg;
+  mrb_get_args(mrb, "o", &arg);
+  if (mrb_nil_p(arg) || (mrb_array_p(arg) && RARRAY_LEN(arg) == 0)) {
     return mrb_hash_new(mrb);
+  }
+  tmp = mrb_check_convert_type(mrb, arg, MRB_TT_HASH, "Hash", "to_hash");
+  if (mrb_nil_p(tmp)) {
+    if (mrb_array_p(arg) && RARRAY_LEN(arg) == 0) {
+      return mrb_hash_new(mrb);
+    }
+    mrb_raisef(mrb, E_TYPE_ERROR, "can't convert %S into Hash",
+      mrb_str_new_cstr(mrb, mrb_obj_classname(mrb, arg)));
+  }
+  return tmp;
+  return mrb_ensure_hash_type(mrb, arg);
+}
 …
   mrb_define_module_function(mrb, krn, "caller", mrb_f_caller, MRB_ARGS_OPT(2));
   mrb_define_method(mrb, krn, "__method__", mrb_f_method, MRB_ARGS_NONE());
+  mrb_define_module_function(mrb, krn, "Integer", mrb_f_integer, MRB_ARGS_ANY());
+  mrb_define_module_function(mrb, krn, "Integer", mrb_f_integer, MRB_ARGS_ARG(1,1));
+#ifndef MRB_WITHOUT_FLOAT
   mrb_define_module_function(mrb, krn, "Float", mrb_f_float, MRB_ARGS_REQ(1));
+#endif
   mrb_define_module_function(mrb, krn, "String", mrb_f_string, MRB_ARGS_REQ(1));
   mrb_define_module_function(mrb, krn, "Array", mrb_f_array, MRB_ARGS_REQ(1));

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-kernel-ext/test/kernel.rb

-              r331
+              r439
 assert('Kernel#Integer') do
+  assert_equal(123, Integer(123.999))
+  assert_equal(26, Integer("0x1a"))
+  assert_equal(930, Integer("0930", 10))
+  assert_equal(7, Integer("111", 2))
+  assert_equal(0, Integer("0"))
+  assert_equal(0, Integer("00000"))
+  assert_operator(26, :eql?, Integer("0x1a"))
+  assert_operator(930, :eql?, Integer("0930", 10))
+  assert_operator(7, :eql?, Integer("111", 2))
+  assert_operator(0, :eql?, Integer("0"))
+  assert_operator(0, :eql?, Integer("00000"))
+  assert_operator(123, :eql?, Integer('1_2_3'))
+  assert_operator(123, :eql?, Integer("\t\r\n\f\v 123 \t\r\n\f\v"))
   assert_raise(TypeError) { Integer(nil) }
+  assert_raise(ArgumentError) { Integer('a') }
+  assert_raise(ArgumentError) { Integer('4a5') }
+  assert_raise(ArgumentError) { Integer('1_2__3') }
+  assert_raise(ArgumentError) { Integer('68_') }
+  assert_raise(ArgumentError) { Integer('68_ ') }
+  assert_raise(ArgumentError) { Integer('_68') }
+  assert_raise(ArgumentError) { Integer(' _68') }
+  assert_raise(ArgumentError) { Integer('6 8') }
+  assert_raise(ArgumentError) { Integer("15\0") }
+  assert_raise(ArgumentError) { Integer("15.0") }
+  skip unless Object.const_defined?(:Float)
+  assert_operator(123, :eql?, Integer(123.999))
 end
 assert('Kernel#Float') do
+  assert_equal(1.0, Float(1))
+  assert_equal(123.456, Float(123.456))
+  assert_equal(123.456, Float("123.456"))
+  skip unless Object.const_defined?(:Float)
+  assert_operator(1.0, :eql?, Float(1))
+  assert_operator(123.456, :eql?, Float(123.456))
+  assert_operator(123.456, :eql?, Float("123.456"))
+  assert_operator(123.0, :eql?, Float('1_2_3'))
+  assert_operator(12.34, :eql?, Float('1_2.3_4'))
+  assert_operator(0.9, :eql?, Float('.9'))
+  assert_operator(0.9, :eql?, Float(" \t\r\n\f\v.9 \t\r\n\f\v"))
+  assert_operator(16.0, :eql?, Float("0x10"))
   assert_raise(TypeError) { Float(nil) }
+  assert_raise(ArgumentError) { Float("1. 5") }
+  assert_raise(ArgumentError) { Float("1.5a") }
+  assert_raise(ArgumentError) { Float("1.5\0") }
+  assert_raise(ArgumentError) { Float('a') }
+  assert_raise(ArgumentError) { Float('4a5') }
+  assert_raise(ArgumentError) { Float('1_2__3') }
+  assert_raise(ArgumentError) { Float('68_') }
+  assert_raise(ArgumentError) { Float('68._7') }
+  assert_raise(ArgumentError) { Float('68.7_') }
+  assert_raise(ArgumentError) { Float('68.7_ ') }
+  assert_raise(ArgumentError) { Float('_68') }
+  assert_raise(ArgumentError) { Float(' _68') }
+  assert_raise(ArgumentError) { Float('1_2.3__4') }
 end

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-math/src/math.c

-              r331
+              r439
 */
+#ifdef MRB_WITHOUT_FLOAT
+# error Math conflicts 'MRB_WITHOUT_FLOAT' configuration in your 'build_config.rb'
+#endif
 #include <mruby.h>
 #include <mruby/array.h>
 …
   struct RClass *math = mrb_module_get(mrb, "Math");
   struct RClass *domainerror = mrb_class_get_under(mrb, math, "DomainError");
+  mrb_value str = mrb_str_new_cstr(mrb, func);
+  mrb_raisef(mrb, domainerror, "Numerical argument is out of domain - %S", str);
+  mrb_raisef(mrb, domainerror, "Numerical argument is out of domain - %s", func);
+}
 …
 #include <float.h>
-#define MATH_TOLERANCE 1E-12
 double
 …
     sum  += term/(2*j+1);
     ++j;
+  } while (fabs(term/sum) > MATH_TOLERANCE);
+    if (sum == 0) break;
+  } while (fabs(term/sum) > DBL_EPSILON);
   return two_sqrtpi*sum;
+}
 …
     q1 = q2;
     q2 = b/d;
   } while (fabs(q1-q2)/q2 > MATH_TOLERANCE);
+  } while (fabs(q1-q2)/q2 > DBL_EPSILON);
   return one_sqrtpi*exp(-x*x)*q2;
+}
+#endif
+#if defined __FreeBSD__ && !defined __FreeBSD_version
+#include <osreldate.h> /* for __FreeBSD_version */
 #endif
 …
+{
   mrb_float x, base;
   int argc;
+  mrb_int argc;
   argc = mrb_get_args(mrb, "f|f", &x, &base);
 …
   mrb_get_args(mrb, "fi", &x, &i);
   x = ldexp(x, i);
+  x = ldexp(x, (int)i);
   return mrb_float_value(mrb, x);
 …
 #else
   mrb_define_const(mrb, mrb_math, "E", mrb_float_value(mrb, exp(1.0)));
-#endif
-#ifdef MRB_USE_FLOAT
-  mrb_define_const(mrb, mrb_math, "TOLERANCE", mrb_float_value(mrb, 1e-5));
-#else
-  mrb_define_const(mrb, mrb_math, "TOLERANCE", mrb_float_value(mrb, 1e-12));
 #endif

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-math/test/math.rb

-              r321
+              r439
 # Math Test
+##
+# Performs fuzzy check for equality on methods returning floats
+# on the basis of the Math::TOLERANCE constant.
+def check_float(a, b)
+  tolerance = Math::TOLERANCE
+  a = a.to_f
+  b = b.to_f
+  if a.finite? and b.finite?
+    (a-b).abs < tolerance
+  else
+    true
+def assert_float_and_int(exp_ary, act_ary)
+  assert('assert_float_and_int') do
+    flo_exp, int_exp, flo_act, int_act = *exp_ary, *act_ary
+    assert_float(flo_exp, flo_act)
+    assert_operator(int_exp, :eql?, int_act)
   end
 end
 assert('Math.sin 0') do
   check_float(Math.sin(0), 0)
+  assert_float(0, Math.sin(0))
 end
 assert('Math.sin PI/2') do
   check_float(Math.sin(Math::PI / 2), 1)
+  assert_float(1, Math.sin(Math::PI / 2))
 end
 assert('Math.cos 0') do
   check_float(Math.cos(0), 1)
+  assert_float(1, Math.cos(0))
 end
 assert('Math.cos PI/2') do
   check_float(Math.cos(Math::PI / 2), 0)
+  assert_float(0, Math.cos(Math::PI / 2))
 end
 assert('Math.tan 0') do
   check_float(Math.tan(0), 0)
+  assert_float(0, Math.tan(0))
 end
 assert('Math.tan PI/4') do
   check_float(Math.tan(Math::PI / 4), 1)
+  assert_float(1, Math.tan(Math::PI / 4))
 end
 assert('Fundamental trig identities') do
-  result = true
   N = 13
   N.times do |i|
 …
     c  = Math.cos(a)
     t  = Math.tan(a)
+    result &= check_float(s, Math.cos(ca))
+    result &= check_float(t, 1 / Math.tan(ca))
+    result &= check_float(s ** 2 + c ** 2, 1)
+    result &= check_float(t ** 2 + 1, (1/c) ** 2)
+    result &= check_float((1/t) ** 2 + 1, (1/s) ** 2)
+  end
+  result
+    assert_float(Math.cos(ca), s)
+    assert_float(1 / Math.tan(ca), t)
+    assert_float(1, s ** 2 + c ** 2)
+    assert_float((1/c) ** 2, t ** 2 + 1)
+    assert_float((1/s) ** 2, (1/t) ** 2 + 1)
+  end
 end
 assert('Math.erf 0') do
   check_float(Math.erf(0), 0)
+  assert_float(0, Math.erf(0))
 end
 assert('Math.exp 0') do
   check_float(Math.exp(0), 1.0)
+  assert_float(1.0, Math.exp(0))
 end
 assert('Math.exp 1') do
   check_float(Math.exp(1), 2.718281828459045)
+  assert_float(2.718281828459045, Math.exp(1))
 end
 assert('Math.exp 1.5') do
   check_float(Math.exp(1.5), 4.4816890703380645)
+  assert_float(4.4816890703380645, Math.exp(1.5))
 end
 assert('Math.log 1') do
   check_float(Math.log(1), 0)
+  assert_float(0, Math.log(1))
 end
 assert('Math.log E') do
   check_float(Math.log(Math::E), 1.0)
+  assert_float(1.0, Math.log(Math::E))
 end
 assert('Math.log E**3') do
   check_float(Math.log(Math::E**3), 3.0)
+  assert_float(3.0, Math.log(Math::E**3))
 end
 assert('Math.log2 1') do
   check_float(Math.log2(1), 0.0)
+  assert_float(0.0, Math.log2(1))
 end
 assert('Math.log2 2') do
   check_float(Math.log2(2), 1.0)
+  assert_float(1.0, Math.log2(2))
 end
 assert('Math.log10 1') do
   check_float(Math.log10(1), 0.0)
+  assert_float(0.0, Math.log10(1))
 end
 assert('Math.log10 10') do
   check_float(Math.log10(10), 1.0)
+  assert_float(1.0, Math.log10(10))
 end
 assert('Math.log10 10**100') do
   check_float(Math.log10(10**100), 100.0)
+  assert_float(100.0, Math.log10(10**100))
 end
 …
   num = [0.0, 1.0, 2.0, 3.0, 4.0]
   sqr = [0, 1, 4, 9, 16]
-  result = true
   sqr.each_with_index do |v,i|
+    result &= check_float(Math.sqrt(v), num[i])
+  end
+  result
+    assert_float(num[i], Math.sqrt(v))
+  end
 end
 …
   num = [-2.0, -1.0, 0.0, 1.0, 2.0]
   cub = [-8, -1, 0, 1, 8]
-  result = true
   cub.each_with_index do |v,i|
+    result &= check_float(Math.cbrt(v), num[i])
+  end
+  result
+    assert_float(num[i], Math.cbrt(v))
+  end
 end
 assert('Math.hypot') do
+  check_float(Math.hypot(3, 4), 5.0)
+end
+assert('Math.frexp 1234') do
+  n = 1234
+  fraction, exponent = Math.frexp(n)
+  check_float(Math.ldexp(fraction, exponent), n)
+  assert_float(5.0, Math.hypot(3, 4))
 end
 assert('Math.erf 1') do
   check_float(Math.erf(1), 0.842700792949715)
+  assert_float(0.842700792949715, Math.erf(1))
 end
 assert('Math.erfc 1') do
   check_float(Math.erfc(1), 0.157299207050285)
+  assert_float(0.157299207050285, Math.erfc(1))
 end
 assert('Math.erf -1') do
   check_float(Math.erf(-1), -0.8427007929497148)
+  assert_float(-0.8427007929497148, Math.erf(-1))
 end
 assert('Math.erfc -1') do
+  check_float(Math.erfc(-1), 1.8427007929497148)
+end
+  assert_float(1.8427007929497148, Math.erfc(-1))
+end
+assert('Math.acos') do
+  assert_float(0 * Math::PI / 4, Math.acos( 1.0))
+  assert_float(1 * Math::PI / 4, Math.acos( 1.0 / Math.sqrt(2)))
+  assert_float(2 * Math::PI / 4, Math.acos( 0.0))
+  assert_float(4 * Math::PI / 4, Math.acos(-1.0))
+  assert_raise(Math::DomainError) { Math.acos(+1.1) }
+  assert_raise(Math::DomainError) { Math.acos(-1.1) }
+end
+assert('Math.asin') do
+  assert_float( 0 * Math::PI / 4, Math.asin( 0.0))
+  assert_float( 1 * Math::PI / 4, Math.asin( 1.0 / Math.sqrt(2)))
+  assert_float( 2 * Math::PI / 4, Math.asin( 1.0))
+  assert_float(-2 * Math::PI / 4, Math.asin(-1.0))
+  assert_raise(Math::DomainError) { Math.asin(+1.1) }
+  assert_raise(Math::DomainError) { Math.asin(-1.1) }
+  assert_raise(Math::DomainError) { Math.asin(2.0) }
+end
+assert('Math.atan') do
+  assert_float( 0 * Math::PI / 4, Math.atan( 0.0))
+  assert_float( 1 * Math::PI / 4, Math.atan( 1.0))
+  assert_float( 2 * Math::PI / 4, Math.atan(1.0 / 0.0))
+  assert_float(-1 * Math::PI / 4, Math.atan(-1.0))
+end
+assert('Math.cosh') do
+  assert_float(1, Math.cosh(0))
+  assert_float((Math::E ** 1 + Math::E ** -1) / 2, Math.cosh(1))
+  assert_float((Math::E ** 2 + Math::E ** -2) / 2, Math.cosh(2))
+end
+assert('Math.sinh') do
+  assert_float(0, Math.sinh(0))
+  assert_float((Math::E ** 1 - Math::E ** -1) / 2, Math.sinh(1))
+  assert_float((Math::E ** 2 - Math::E ** -2) / 2, Math.sinh(2))
+end
+assert('Math.tanh') do
+  assert_float(Math.sinh(0) / Math.cosh(0), Math.tanh(0))
+  assert_float(Math.sinh(1) / Math.cosh(1), Math.tanh(1))
+  assert_float(Math.sinh(2) / Math.cosh(2), Math.tanh(2))
+  assert_float(+1.0, Math.tanh(+1000.0))
+  assert_float(-1.0, Math.tanh(-1000.0))
+end
+assert('Math.acosh') do
+  assert_float(0, Math.acosh(1))
+  assert_float(1, Math.acosh((Math::E ** 1 + Math::E ** -1) / 2))
+  assert_float(2, Math.acosh((Math::E ** 2 + Math::E ** -2) / 2))
+  assert_raise(Math::DomainError) { Math.acosh(0.9) }
+  assert_raise(Math::DomainError) { Math.acosh(0) }
+end
+assert('Math.asinh') do
+  assert_float(0, Math.asinh(0))
+  assert_float(1, Math.asinh((Math::E ** 1 - Math::E ** -1) / 2))
+  assert_float(2, Math.asinh((Math::E ** 2 - Math::E ** -2) / 2))
+end
+assert('Math.atanh') do
+  assert_float(0, Math.atanh(Math.sinh(0) / Math.cosh(0)))
+  assert_float(1, Math.atanh(Math.sinh(1) / Math.cosh(1)))
+  assert_float(2, Math.atanh(Math.sinh(2) / Math.cosh(2)))
+  assert_float(Float::INFINITY, Math.atanh(1))
+  assert_float(-Float::INFINITY, Math.atanh(-1))
+  assert_raise(Math::DomainError) { Math.atanh(+1.1) }
+  assert_raise(Math::DomainError) { Math.atanh(-1.1) }
+end
+assert('Math.atan2') do
+  assert_float(+0.0, Math.atan2(+0.0, +0.0))
+  assert_float(-0.0, Math.atan2(-0.0, +0.0))
+  assert_float(+Math::PI, Math.atan2(+0.0, -0.0))
+  assert_float(-Math::PI, Math.atan2(-0.0, -0.0))
+  inf = Float::INFINITY
+  expected = 3.0 * Math::PI / 4.0
+  assert_float(+expected, Math.atan2(+inf, -inf))
+  assert_float(-expected, Math.atan2(-inf, -inf))
+  expected = Math::PI / 4.0
+  assert_float(+expected, Math.atan2(+inf, +inf))
+  assert_float(-expected, Math.atan2(-inf, +inf))
+  assert_float(0, Math.atan2(0, 1))
+  assert_float(Math::PI / 4, Math.atan2(1, 1))
+  assert_float(Math::PI / 2, Math.atan2(1, 0))
+end
+assert('Math.ldexp') do
+  assert_float(0.0, Math.ldexp(0.0, 0.0))
+  assert_float(0.5, Math.ldexp(0.5, 0.0))
+  assert_float(1.0, Math.ldexp(0.5, 1.0))
+  assert_float(2.0, Math.ldexp(0.5, 2.0))
+  assert_float(3.0, Math.ldexp(0.75, 2.0))
+end
+assert('Math.frexp') do
+  assert_float_and_int([0.0,  0], Math.frexp(0.0))
+  assert_float_and_int([0.5,  0], Math.frexp(0.5))
+  assert_float_and_int([0.5,  1], Math.frexp(1.0))
+  assert_float_and_int([0.5,  2], Math.frexp(2.0))
+  assert_float_and_int([0.75, 2], Math.frexp(3.0))
+end

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-numeric-ext/mrblib/numeric_ext.rb

-              r331
+              r439
+module Integral
+  def div(other)
+    self.divmod(other)[0]
+  end
+class Numeric
   def zero?
     self == 0
 …
     end
   end
+  def positive?
+    self > 0
+  end
+  def negative?
+    self < 0
+  end
 end

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-numeric-ext/src/numeric_ext.c

-              r331
+              r439
 #include <limits.h>
 #include <mruby.h>
+#include <mruby/numeric.h>
+/*
+ *  call-seq:
+ *     int.allbits?(mask)  ->  true or false
+ *
+ *  Returns +true+ if all bits of <code>+int+ & +mask+</code> are 1.
+ */
 static mrb_value
 mrb_int_chr(mrb_state *mrb, mrb_value x)
+mrb_int_allbits(mrb_state *mrb, mrb_value self)
+{
+  mrb_int chr;
+  char c;
+  mrb_int n, m;
+  chr = mrb_fixnum(x);
+  if (chr >= (1 << CHAR_BIT)) {
+    mrb_raisef(mrb, E_RANGE_ERROR, "%S out of char range", x);
+  }
+  c = (char)chr;
+  mrb_get_args(mrb, "i", &m);
+  n = mrb_int(mrb, self);
+  return mrb_bool_value((n & m) == m);
+}
+  return mrb_str_new(mrb, &c, 1);
+/*
+ *  call-seq:
+ *     int.anybits?(mask)  ->  true or false
+ *
+ *  Returns +true+ if any bits of <code>+int+ & +mask+</code> are 1.
+ */
+static mrb_value
+mrb_int_anybits(mrb_state *mrb, mrb_value self)
+{
+  mrb_int n, m;
+  mrb_get_args(mrb, "i", &m);
+  n = mrb_int(mrb, self);
+  return mrb_bool_value((n & m) != 0);
+}
+/*
+ *  call-seq:
+ *     int.nobits?(mask)  ->  true or false
+ *
+ *  Returns +true+ if no bits of <code>+int+ & +mask+</code> are 1.
+ */
+static mrb_value
+mrb_int_nobits(mrb_state *mrb, mrb_value self)
+{
+  mrb_int n, m;
+  mrb_get_args(mrb, "i", &m);
+  n = mrb_int(mrb, self);
+  return mrb_bool_value((n & m) == 0);
+}
 …
 mrb_mruby_numeric_ext_gem_init(mrb_state* mrb)
+{
   struct RClass *i = mrb_class_get(mrb, "Integer");
+  struct RClass *i = mrb_module_get(mrb, "Integral");
+  mrb_define_method(mrb, i, "chr", mrb_int_chr, MRB_ARGS_NONE());
+  mrb_define_method(mrb, i, "allbits?", mrb_int_allbits, MRB_ARGS_REQ(1));
+  mrb_define_method(mrb, i, "anybits?", mrb_int_anybits, MRB_ARGS_REQ(1));
+  mrb_define_method(mrb, i, "nobits?", mrb_int_nobits, MRB_ARGS_REQ(1));
+#ifndef MRB_WITHOUT_FLOAT
+  mrb_define_const(mrb, mrb->float_class, "RADIX",        mrb_fixnum_value(MRB_FLT_RADIX));
+  mrb_define_const(mrb, mrb->float_class, "MANT_DIG",     mrb_fixnum_value(MRB_FLT_MANT_DIG));
+  mrb_define_const(mrb, mrb->float_class, "EPSILON",      mrb_float_value(mrb, MRB_FLT_EPSILON));
+  mrb_define_const(mrb, mrb->float_class, "DIG",          mrb_fixnum_value(MRB_FLT_DIG));
+  mrb_define_const(mrb, mrb->float_class, "MIN_EXP",      mrb_fixnum_value(MRB_FLT_MIN_EXP));
+  mrb_define_const(mrb, mrb->float_class, "MIN",          mrb_float_value(mrb, MRB_FLT_MIN));
+  mrb_define_const(mrb, mrb->float_class, "MIN_10_EXP",   mrb_fixnum_value(MRB_FLT_MIN_10_EXP));
+  mrb_define_const(mrb, mrb->float_class, "MAX_EXP",      mrb_fixnum_value(MRB_FLT_MAX_EXP));
+  mrb_define_const(mrb, mrb->float_class, "MAX",          mrb_float_value(mrb, MRB_FLT_MAX));
+  mrb_define_const(mrb, mrb->float_class, "MAX_10_EXP",   mrb_fixnum_value(MRB_FLT_MAX_10_EXP));
+#endif /* MRB_WITHOUT_FLOAT */
+}

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-numeric-ext/test/numeric.rb

-              r331
+              r439
 ##
 # Numeric(Ext) Test
-assert('Integer#chr') do
-  assert_equal("A", 65.chr)
-  assert_equal("B", 0x42.chr)
-  # multibyte encoding (not support yet)
-  assert_raise(RangeError) { 256.chr }
-end
 assert('Integer#div') do
 …
 assert('Float#div') do
+  skip unless Object.const_defined?(:Float)
   assert_float 52, 365.2425.div(7)
 end

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-object-ext/mrbgem.rake

r321	r439
2	2	spec.license = 'MIT'
3	3	spec.author = 'mruby developers'
4		spec.summary = '~~Object class extension~~'
	4	spec.summary = 'extensional methods shared by all objects'
5	5	end

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-object-ext/mrblib/object.rb

-              r321
+              r439
+class Object
+module Kernel
+  # call-seq:
+  #   obj.yield_self {|_obj|...} -> an_object
+  #   obj.then {|_obj|...}       -> an_object
+  #
+  # Yields <i>obj</i> and returns the result.
+  #
+  #   'my string'.yield_self {|s|s.upcase} #=> "MY STRING"
+  #
+  def yield_self(&block)
+    return to_enum :yield_self unless block
+    block.call(self)
+  end
+  alias then yield_self
   ##
   #  call-seq:

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-object-ext/src/object.c

-              r331
+              r439
 #include <mruby/array.h>
 #include <mruby/class.h>
+#include <mruby/hash.h>
 #include <mruby/proc.h>
 …
+}
+#ifndef MRB_WITHOUT_FLOAT
 /*
  *  call-seq:
 …
+{
   return mrb_float_value(mrb, 0.0);
+}
+#endif
+/*
+ *  call-seq:
+ *     nil.to_h    -> {}
+ *
+ *  Always returns an empty hash.
+ */
+static mrb_value
+nil_to_h(mrb_state *mrb, mrb_value obj)
+{
+  return mrb_hash_new(mrb);
+}
 …
+{
   return mrb_fixnum_value(0);
+}
+/*
+ *  call-seq:
+ *     obj.itself -> an_object
+ *
+ *  Returns <i>obj</i>.
+ *
+ *      string = 'my string' #=> "my string"
+ *      string.itself.object_id == string.object_id #=> true
+ *
+ */
+static mrb_value
+mrb_f_itself(mrb_state *mrb, mrb_value self)
+{
+  return self;
+}
 …
   mrb_value blk;
   struct RClass *c;
-  mrb_value args;
+  mrb_get_args(mrb, "*&", &argv, &argc, &blk);
+  if (mrb_nil_p(blk)) {
+    mrb_raise(mrb, E_ARGUMENT_ERROR, "no block given");
+  }
+  mrb_get_args(mrb, "*&!", &argv, &argc, &blk);
   switch (mrb_type(self)) {
   case MRB_TT_SYMBOL:
   case MRB_TT_FIXNUM:
+#ifndef MRB_WITHOUT_FLOAT
   case MRB_TT_FLOAT:
+#endif
     c = NULL;
     break;
 …
     break;
+  }
-  args = mrb_ary_new_from_values(mrb, argc, argv);
-  argv = RARRAY_PTR(args);
   mrb->c->ci->target_class = c;
   return mrb_yield_cont(mrb, blk, self, argc, argv);
 …
   mrb_define_method(mrb, n, "to_a", nil_to_a,       MRB_ARGS_NONE());
+#ifndef MRB_WITHOUT_FLOAT
   mrb_define_method(mrb, n, "to_f", nil_to_f,       MRB_ARGS_NONE());
+#endif
+  mrb_define_method(mrb, n, "to_h", nil_to_h,       MRB_ARGS_NONE());
   mrb_define_method(mrb, n, "to_i", nil_to_i,       MRB_ARGS_NONE());
+  mrb_define_method(mrb, mrb->kernel_module, "instance_exec", mrb_obj_instance_exec, MRB_ARGS_ANY() | MRB_ARGS_BLOCK());
+  mrb_define_method(mrb, mrb->kernel_module, "itself", mrb_f_itself, MRB_ARGS_NONE());
+  mrb_define_method(mrb, mrb_class_get(mrb, "BasicObject"), "instance_exec", mrb_obj_instance_exec, MRB_ARGS_ANY() | MRB_ARGS_BLOCK());
+}

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-object-ext/test/nil.rb

-              r321
+              r439
 assert('NilClass#to_f') do
+  skip unless Object.const_defined?(:Float)
   assert_equal 0.0, nil.to_f
+end
+assert('NilClass#to_h') do
+  assert_equal Hash.new, nil.to_h
 end

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-objectspace/src/mruby_objectspace.c

-              r331
+              r439
+  }
   if (!mrb_test(mrb_hash_empty_p(mrb, hash))) {
+  if (!mrb_hash_empty_p(mrb, hash)) {
     mrb_hash_clear(mrb, hash);
+  }
 …
   mrb_value cls = mrb_nil_value();
   struct os_each_object_data d;
+  mrb_get_args(mrb, "&|C", &d.block, &cls);
+  if (mrb_nil_p(d.block)) {
+    mrb_raise(mrb, E_ARGUMENT_ERROR, "Expected block in ObjectSpace.each_object.");
+  }
+  mrb_get_args(mrb, "&!|C", &d.block, &cls);
   d.target_module = mrb_nil_p(cls) ? NULL : mrb_class_ptr(cls);

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-objectspace/test/objectspace.rb

-              r321
+              r439
 assert('ObjectSpace.count_objects') do
   h = {}
   f = Fiber.new {} if Object.const_defined? :Fiber
+  f = Fiber.new {} if Object.const_defined?(:Fiber)
   ObjectSpace.count_objects(h)
   assert_kind_of(Hash, h)
 …
     objs << {}
   end
+  ObjectSpace.count_objects(h)
   objs = nil
-  ObjectSpace.count_objects(h)
   GC.start
   ObjectSpace.count_objects(h_after)
 …
 assert 'Check class pointer of ObjectSpace.each_object.' do
   ObjectSpace.each_object { |obj| !obj }
+  assert_nothing_raised { ObjectSpace.each_object { |obj| !obj } }
 end

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-print/mrblib/print.rb

-              r321
+              r439
       i += 1
     end
     args[0]
+    args.__svalue
   end
+  unless Kernel.respond_to?(:sprintf)
+    def printf(*args)
+      raise NotImplementedError.new('printf not available')
+    end
+    def sprintf(*args)
+      raise NotImplementedError.new('sprintf not available')
+    end
+  else
+    def printf(*args)
+      __printstr__(sprintf(*args))
+      nil
+    end
+  def printf(*args)
+    __printstr__(sprintf(*args))
+    nil
   end
 end

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-print/src/print.c

-              r331
+              r439
 #include <mruby.h>
+#ifdef MRB_DISABLE_STDIO
+# error print conflicts 'MRB_DISABLE_STDIO' configuration in your 'build_config.rb'
+#endif
 #include <mruby/string.h>
-#include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 …
     if (isatty(fileno(stdout))) {
       DWORD written;
       int mlen = RSTRING_LEN(obj);
+      int mlen = (int)RSTRING_LEN(obj);
       char* utf8 = RSTRING_PTR(obj);
       int wlen = MultiByteToWideChar(CP_UTF8, 0, utf8, mlen, NULL, 0);
       wchar_t* utf16 = (wchar_t*)mrb_malloc(mrb, (wlen+1) * sizeof(wchar_t));
-      if (utf16 == NULL) return;
       if (MultiByteToWideChar(CP_UTF8, 0, utf8, mlen, utf16, wlen) > 0) {
         utf16[wlen] = 0;
 …
 #endif
       fwrite(RSTRING_PTR(obj), RSTRING_LEN(obj), 1, stdout);
+    fflush(stdout);
+  }
+}

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-proc-ext/mrblib/proc.rb

-              r321
+              r439
     pproc = self
     make_curry = proc do |given_args=[]|
       send(type) do |*args|
+      __send__(type) do |*args|
         new_args = given_args + args
         if new_args.size >= arity
 …
   end
+  def <<(other)
+    ->(*args, &block) { call(other.call(*args, &block)) }
+  end
+  def >>(other)
+    ->(*args, &block) { other.call(call(*args, &block)) }
+  end
 end

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-proc-ext/src/proc.c

-              r331
+              r439
     const char *filename;
     filename = mrb_debug_get_filename(irep, 0);
     line = mrb_debug_get_line(irep, 0);
+    filename = mrb_debug_get_filename(mrb, irep, 0);
+    line = mrb_debug_get_line(mrb, irep, 0);
     return (!filename && line == -1)? mrb_nil_value()
 …
   struct RProc *p = mrb_proc_ptr(self);
   mrb_value str = mrb_str_new_lit(mrb, "#<Proc:");
   mrb_str_concat(mrb, str, mrb_ptr_to_str(mrb, mrb_cptr(self)));
+  mrb_str_cat_str(mrb, str, mrb_ptr_to_str(mrb, mrb_cptr(self)));
   if (!MRB_PROC_CFUNC_P(p)) {
 …
     mrb_str_cat_lit(mrb, str, "@");
     filename = mrb_debug_get_filename(irep, 0);
+    filename = mrb_debug_get_filename(mrb, irep, 0);
     mrb_str_cat_cstr(mrb, str, filename ? filename : "-");
     mrb_str_cat_lit(mrb, str, ":");
     line = mrb_debug_get_line(irep, 0);
+    line = mrb_debug_get_line(mrb, irep, 0);
     if (line != -1) {
       str = mrb_format(mrb, "%S:%S", str, mrb_fixnum_value(line));
+      mrb_str_concat(mrb, str, mrb_fixnum_value(line));
+    }
     else {
 …
   mrb_value blk;
+  mrb_get_args(mrb, "&", &blk);
+  if (mrb_nil_p(blk)) {
+    mrb_raise(mrb, E_ARGUMENT_ERROR, "tried to create Proc object without a block");
+  }
+  mrb_get_args(mrb, "&!", &blk);
   return blk;
 …
+{
   struct parameters_type {
+    size_t len;
+    const char *name;
     int size;
-    const char *name;
   } *p, parameters_list [] = {
     {0, "req"},
     {0, "opt"},
     {0, "rest"},
     {0, "req"},
     {0, "block"},
     {0, NULL}
+    {sizeof("req")   - 1, "req",   0},
+    {sizeof("opt")   - 1, "opt",   0},
+    {sizeof("rest")  - 1, "rest",  0},
+    {sizeof("req")   - 1, "req",   0},
+    {sizeof("block") - 1, "block", 0},
+    {0, NULL, 0}
   };
   const struct RProc *proc = mrb_proc_ptr(self);
   const struct mrb_irep *irep = proc->body.irep;
   mrb_aspec aspec;
   mrb_value sname, parameters;
+  mrb_value parameters;
   int i, j;
+  int max = -1;
   if (MRB_PROC_CFUNC_P(proc)) {
 …
     return mrb_ary_new(mrb);
+  }
   if (GET_OPCODE(*irep->iseq) != OP_ENTER) {
+  if (*irep->iseq != OP_ENTER) {
     return mrb_ary_new(mrb);
+  }
   if (!MRB_PROC_STRICT_P(proc)) {
+    parameters_list[0].len = sizeof("opt") - 1;
     parameters_list[0].name = "opt";
+    parameters_list[3].len = sizeof("opt") - 1;
     parameters_list[3].name = "opt";
+  }
   aspec = GETARG_Ax(*irep->iseq);
+  aspec = PEEK_W(irep->iseq+1);
   parameters_list[0].size = MRB_ASPEC_REQ(aspec);
   parameters_list[1].size = MRB_ASPEC_OPT(aspec);
 …
   parameters = mrb_ary_new_capa(mrb, irep->nlocals-1);
+  max = irep->nlocals-1;
   for (i = 0, p = parameters_list; p->name; p++) {
     if (p->size <= 0) continue;
+    sname = mrb_symbol_value(mrb_intern_cstr(mrb, p->name));
+    mrb_value sname = mrb_symbol_value(mrb_intern_static(mrb, p->name, p->len));
     for (j = 0; j < p->size; i++, j++) {
+      mrb_value a = mrb_ary_new(mrb);
+      mrb_value a;
+      a = mrb_ary_new(mrb);
       mrb_ary_push(mrb, a, sname);
+      if (irep->lv[i].name) {
+        mrb_ary_push(mrb, a, mrb_symbol_value(irep->lv[i].name));
+      if (i < max && irep->lv[i].name) {
+        mrb_sym sym = irep->lv[i].name;
+        const char *name = mrb_sym_name(mrb, sym);
+        switch (name[0]) {
+        case '*': case '&':
+          break;
+        default:
+          mrb_ary_push(mrb, a, mrb_symbol_value(sym));
+          break;
+        }
+      }
       mrb_ary_push(mrb, parameters, a);
 …
   mrb_define_method(mrb, p, "parameters",      mrb_proc_parameters,      MRB_ARGS_NONE());
   mrb_define_class_method(mrb, mrb->kernel_module, "proc", mrb_kernel_proc, MRB_ARGS_NONE());
   mrb_define_method(mrb, mrb->kernel_module,       "proc", mrb_kernel_proc, MRB_ARGS_NONE());
+  mrb_define_class_method(mrb, mrb->kernel_module, "proc", mrb_kernel_proc, MRB_ARGS_NONE()|MRB_ARGS_BLOCK());
+  mrb_define_method(mrb, mrb->kernel_module,       "proc", mrb_kernel_proc, MRB_ARGS_NONE()|MRB_ARGS_BLOCK());
+}

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-proc-ext/test/proc.c

-              r331
+              r439
   mrb_sym n;
   mrb_value n_val;
+  mrb_method_t m;
+  struct RProc *p;
   mrb_get_args(mrb, "n", &n);
   n_val = mrb_symbol_value(n);
+  mrb_define_method_raw(mrb, mrb_class_ptr(self), n,
+                        mrb_proc_new_cfunc_with_env(mrb, return_func_name, 1, &n_val));
+  p = mrb_proc_new_cfunc_with_env(mrb, return_func_name, 1, &n_val);
+  MRB_METHOD_FROM_PROC(m, p);
+  mrb_define_method_raw(mrb, mrb_class_ptr(self), n, m);
   return self;
+}
 …
   mrb_sym n;
   mrb_value *argv; mrb_int argc;
+  mrb_method_t m;
+  struct RProc *p;
   mrb_get_args(mrb, "na", &n, &argv, &argc);
+  mrb_define_method_raw(mrb, mrb_class_ptr(self), n,
+                        mrb_proc_new_cfunc_with_env(mrb, return_env, argc, argv));
+  p = mrb_proc_new_cfunc_with_env(mrb, return_env, argc, argv);
+  MRB_METHOD_FROM_PROC(m, p);
+  mrb_define_method_raw(mrb, mrb_class_ptr(self), n, m);
   return self;
+}

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-proc-ext/test/proc.rb

-              r331
+              r439
 # Proc(Ext) Test
+def enable_debug_info?
+  return @enable_debug_info unless @enable_debug_info == nil
+  begin
+    raise
+  rescue => e
+    @enable_debug_info = !e.backtrace.empty?
+  end
+end
 assert('Proc#source_location') do
   loc = Proc.new {}.source_location
   next true if loc.nil?
   assert_equal loc[0][-7, 7], 'proc.rb'
   assert_equal loc[1], 5
+  skip unless enable_debug_info?
+  file, line = Proc.new{}.source_location
+  assert_equal __FILE__, file
+  assert_equal __LINE__ - 2, line
 end
 assert('Proc#inspect') do
   ins = Proc.new{}.inspect
+  assert_kind_of String, ins
+  if enable_debug_info?
+    metas = %w(\\ * ? [ ] { })
+    file = __FILE__.split("").map{|c| metas.include?(c) ? "\\#{c}" : c}.join
+    line = __LINE__ - 4
+  else
+    file = line = "-"
+  end
+  assert_match "#<Proc:0x*@#{file}:#{line}>", ins
+end
+assert('Proc#parameters') do
+  parameters = Proc.new{|x,y=42,*other|}.parameters
+  assert_equal [[:opt, :x], [:opt, :y], [:rest, :other]], parameters
 end
 …
 assert('Kernel#proc') do
   assert_true !proc{|a|}.lambda?
+  assert_raise LocalJumpError do
+    proc{ break }.call
+  end
+end
+assert "Proc#<< and Proc#>>" do
+  add3 = ->(n) { n + 3 }
+  mul2 = ->(n) { n * 2 }
+  f1 = mul2 << add3
+  assert_kind_of Proc, f1
+  assert_equal 16, f1.call(5)
+  f2 = mul2 >> add3
+  assert_kind_of Proc, f2
+  assert_equal 13, f2.call(5)
 end

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-random/src/random.c

-              r331
+              r439
 #include <mruby/data.h>
 #include <mruby/array.h>
+#include "mt19937ar.h"
+#include <mruby/istruct.h>
+#if INT32_MAX <= INTPTR_MAX
+# define XORSHIFT96
+# define NSEEDS 3
+#else
+# define NSEEDS 4
+#endif
+#define LASTSEED (NSEEDS-1)
 #include <time.h>
+static char const MT_STATE_KEY[] = "$mrb_i_mt_state";
+static const struct mrb_data_type mt_state_type = {
+  MT_STATE_KEY, mrb_free,
+};
+static mrb_value mrb_random_rand(mrb_state *mrb, mrb_value self);
+static mrb_value mrb_random_srand(mrb_state *mrb, mrb_value self);
+typedef struct rand_state {
+  uint32_t seed[NSEEDS];
+} rand_state;
 static void
+mt_srand(mt_state *t, unsigned long seed)
+{
+  mrb_random_init_genrand(t, seed);
+}
+static unsigned long
+mt_rand(mt_state *t)
+{
+  return mrb_random_genrand_int32(t);
+}
+rand_init(rand_state *t)
+{
+  t->seed[0] = 123456789;
+  t->seed[1] = 362436069;
+  t->seed[2] = 521288629;
+#ifndef XORSHIFT96
+  t->seed[3] = 88675123;
+#endif
+}
+static uint32_t
+rand_seed(rand_state *t, uint32_t seed)
+{
+  uint32_t old_seed = t->seed[LASTSEED];
+  rand_init(t);
+  t->seed[LASTSEED] = seed;
+  return old_seed;
+}
+#ifdef XORSHIFT96
+static uint32_t
+rand_uint32(rand_state *state)
+{
+  uint32_t *seed = state->seed;
+  uint32_t x = seed[0];
+  uint32_t y = seed[1];
+  uint32_t z = seed[2];
+  uint32_t t;
+  t = (x ^ (x << 3)) ^ (y ^ (y >> 19)) ^ (z ^ (z << 6));
+  x = y; y = z; z = t;
+  seed[0] = x;
+  seed[1] = y;
+  seed[2] = z;
+  return z;
+}
+#else  /* XORSHIFT96 */
+static uint32_t
+rand_uint32(rand_state *state)
+{
+  uint32_t *seed = state->seed;
+  uint32_t x = seed[0];
+  uint32_t y = seed[1];
+  uint32_t z = seed[2];
+  uint32_t w = seed[3];
+  uint32_t t;
+  t = x ^ (x << 11);
+  x = y; y = z; z = w;
+  w = (w ^ (w >> 19)) ^ (t ^ (t >> 8));
+  seed[0] = x;
+  seed[1] = y;
+  seed[2] = z;
+  seed[3] = w;
+  return w;
+}
+#endif  /* XORSHIFT96 */
+#ifndef MRB_WITHOUT_FLOAT
 static double
+mt_rand_real(mt_state *t)
+{
+  return mrb_random_genrand_real1(t);
+}
+static mrb_value
+mrb_random_mt_srand(mrb_state *mrb, mt_state *t, mrb_value seed)
+{
+  if (mrb_nil_p(seed)) {
+    seed = mrb_fixnum_value((mrb_int)(time(NULL) + mt_rand(t)));
+    if (mrb_fixnum(seed) < 0) {
+      seed = mrb_fixnum_value(0 - mrb_fixnum(seed));
+    }
+  }
+  mt_srand(t, (unsigned) mrb_fixnum(seed));
+  return seed;
+}
+static mrb_value
+mrb_random_mt_rand(mrb_state *mrb, mt_state *t, mrb_value max)
+rand_real(rand_state *t)
+{
+  uint32_t x = rand_uint32(t);
+  return x*(1.0/4294967295.0);
+}
+#endif
+static mrb_value
+random_rand(mrb_state *mrb, rand_state *t, mrb_value max)
+{
   mrb_value value;
   if (mrb_fixnum(max) == 0) {
+    value = mrb_float_value(mrb, mt_rand_real(t));
+  }
+  else {
+    value = mrb_fixnum_value(mt_rand(t) % mrb_fixnum(max));
+#ifndef MRB_WITHOUT_FLOAT
+    value = mrb_float_value(mrb, rand_real(t));
+#else
+    mrb_raise(mrb, E_ARGUMENT_ERROR, "Float not supported");
+#endif
+  }
+  else {
+    value = mrb_fixnum_value(rand_uint32(t) % mrb_fixnum(max));
+  }
 …
   if (!mrb_nil_p(arg)) {
     arg = mrb_check_convert_type(mrb, arg, MRB_TT_FIXNUM, "Fixnum", "to_int");
+    if (mrb_nil_p(arg)) {
       mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid argument type");
+    }
     if (mrb_fixnum(arg) < 0) {
       arg = mrb_fixnum_value(0 - mrb_fixnum(arg));
+    mrb_int i;
+    arg = mrb_to_int(mrb, arg);
+    i = mrb_fixnum(arg);
+    if (i < 0) {
+      arg = mrb_fixnum_value(0 - i);
+    }
+  }
 …
+}
+static mrb_value
+get_random(mrb_state *mrb) {
+  return mrb_const_get(mrb,
+             mrb_obj_value(mrb_class_get(mrb, "Random")),
+             mrb_intern_lit(mrb, "DEFAULT"));
+}
+static mt_state *
+get_random_state(mrb_state *mrb)
+{
+  mrb_value random_val = get_random(mrb);
+  return DATA_GET_PTR(mrb, random_val, &mt_state_type, mt_state);
+}
+static mrb_value
+mrb_random_g_rand(mrb_state *mrb, mrb_value self)
+{
+  mrb_value random = get_random(mrb);
+  return mrb_random_rand(mrb, random);
+}
+static mrb_value
+mrb_random_g_srand(mrb_state *mrb, mrb_value self)
+{
+  mrb_value random = get_random(mrb);
+  return mrb_random_srand(mrb, random);
+}
+static mrb_value
+mrb_random_init(mrb_state *mrb, mrb_value self)
+static void
+random_check(mrb_state *mrb, mrb_value random) {
+  struct RClass *c = mrb_class_get(mrb, "Random");
+  if (!mrb_obj_is_kind_of(mrb, random, c) || !mrb_istruct_p(random)) {
+    mrb_raise(mrb, E_TYPE_ERROR, "Random instance required");
+  }
+}
+static mrb_value
+random_default(mrb_state *mrb) {
+  struct RClass *c = mrb_class_get(mrb, "Random");
+  mrb_value d = mrb_const_get(mrb, mrb_obj_value(c), mrb_intern_lit(mrb, "DEFAULT"));
+  if (!mrb_obj_is_kind_of(mrb, d, c)) {
+    mrb_raise(mrb, E_TYPE_ERROR, "Random::DEFAULT replaced");
+  }
+  return d;
+}
+#define random_ptr(v) (rand_state*)mrb_istruct_ptr(v)
+#define random_default_state(mrb) random_ptr(random_default(mrb))
+static mrb_value
+random_m_init(mrb_state *mrb, mrb_value self)
+{
   mrb_value seed;
   mt_state *t;
+  rand_state *t;
   seed = get_opt(mrb);
   /* avoid memory leaks */
+  t = (mt_state*)DATA_PTR(self);
+  if (t) {
+    mrb_free(mrb, t);
+  }
+  mrb_data_init(self, NULL, &mt_state_type);
+  t = (mt_state *)mrb_malloc(mrb, sizeof(mt_state));
+  t->mti = N + 1;
+  seed = mrb_random_mt_srand(mrb, t, seed);
+  t = random_ptr(self);
   if (mrb_nil_p(seed)) {
+    t->has_seed = FALSE;
+  }
+  else {
+    mrb_assert(mrb_fixnum_p(seed));
+    t->has_seed = TRUE;
+    t->seed = mrb_fixnum(seed);
+  }
+  mrb_data_init(self, t, &mt_state_type);
+    rand_init(t);
+  }
+  else {
+    rand_seed(t, (uint32_t)mrb_fixnum(seed));
+  }
   return self;
+}
+static void
+mrb_random_rand_seed(mrb_state *mrb, mt_state *t)
+{
+  if (!t->has_seed) {
+    mrb_random_mt_srand(mrb, t, mrb_nil_value());
+  }
+}
+static mrb_value
+mrb_random_rand(mrb_state *mrb, mrb_value self)
+static mrb_value
+random_m_rand(mrb_state *mrb, mrb_value self)
+{
   mrb_value max;
   mt_state *t = DATA_GET_PTR(mrb, self, &mt_state_type, mt_state);
+  rand_state *t = random_ptr(self);
   max = get_opt(mrb);
+  mrb_random_rand_seed(mrb, t);
+  return mrb_random_mt_rand(mrb, t, max);
+}
+static mrb_value
+mrb_random_srand(mrb_state *mrb, mrb_value self)
+{
+  mrb_value seed;
+  mrb_value old_seed;
+  mt_state *t = DATA_GET_PTR(mrb, self, &mt_state_type, mt_state);
+  seed = get_opt(mrb);
+  seed = mrb_random_mt_srand(mrb, t, seed);
+  old_seed = t->has_seed? mrb_fixnum_value(t->seed) : mrb_nil_value();
+  if (mrb_nil_p(seed)) {
+    t->has_seed = FALSE;
+  }
+  else {
+    mrb_assert(mrb_fixnum_p(seed));
+    t->has_seed = TRUE;
+    t->seed = mrb_fixnum(seed);
+  }
+  return old_seed;
+  return random_rand(mrb, t, max);
+}
+static mrb_value
+random_m_srand(mrb_state *mrb, mrb_value self)
+{
+  uint32_t seed;
+  uint32_t old_seed;
+  mrb_value sv;
+  rand_state *t = random_ptr(self);
+  sv = get_opt(mrb);
+  if (mrb_nil_p(sv)) {
+    seed = (uint32_t)time(NULL) + rand_uint32(t);
+  }
+  else {
+    seed = (uint32_t)mrb_fixnum(sv);
+  }
+  old_seed = rand_seed(t, seed);
+  return mrb_fixnum_value((mrb_int)old_seed);
+}
 …
+{
   mrb_int i;
+  mt_state *random = NULL;
+  mrb_value max;
+  mrb_value r = mrb_nil_value();
+  rand_state *random;
   if (RARRAY_LEN(ary) > 1) {
+    mrb_get_args(mrb, "|d", &random, &mt_state_type);
+    if (random == NULL) {
+      random = get_random_state(mrb);
+    }
+    mrb_random_rand_seed(mrb, random);
+    mrb_get_args(mrb, "|o", &r);
+    if (mrb_nil_p(r)) {
+      random = random_default_state(mrb);
+    }
+    else {
+      random_check(mrb, r);
+      random = random_ptr(r);
+    }
     mrb_ary_modify(mrb, mrb_ary_ptr(ary));
+    max = mrb_fixnum_value(RARRAY_LEN(ary));
     for (i = RARRAY_LEN(ary) - 1; i > 0; i--)  {
       mrb_int j;
+      mrb_value *ptr = RARRAY_PTR(ary);
       mrb_value tmp;
       j = mrb_fixnum(mrb_random_mt_rand(mrb, random, mrb_fixnum_value(RARRAY_LEN(ary))));
       tmp = RARRAY_PTR(ary)[i];
       mrb_ary_ptr(ary)->ptr[i] = RARRAY_PTR(ary)[j];
       mrb_ary_ptr(ary)->ptr[j] = tmp;
+      j = mrb_fixnum(random_rand(mrb, random, max));
+      tmp = ptr[i];
+      ptr[i] = ptr[j];
+      ptr[j] = tmp;
+    }
+  }
 …
   mrb_int n = 0;
   mrb_bool given;
+  mt_state *random = NULL;
+  mrb_value r = mrb_nil_value();
+  rand_state *random;
   mrb_int len;
+  mrb_get_args(mrb, "|i?d", &n, &given, &random, &mt_state_type);
+  if (random == NULL) {
+    random = get_random_state(mrb);
+  }
+  mrb_random_rand_seed(mrb, random);
+  mt_rand(random);
+  mrb_get_args(mrb, "|i?o", &n, &given, &r);
+  if (mrb_nil_p(r)) {
+    random = random_default_state(mrb);
+  }
+  else {
+    random_check(mrb, r);
+    random = random_ptr(r);
+  }
   len = RARRAY_LEN(ary);
   if (!given) {                 /* pick one element */
 …
       return RARRAY_PTR(ary)[0];
     default:
       return RARRAY_PTR(ary)[mt_rand(random) % len];
+      return RARRAY_PTR(ary)[rand_uint32(random) % len];
+    }
+  }
 …
       for (;;) {
       retry:
         r = mt_rand(random) % len;
+        r = (mrb_int)(rand_uint32(random) % len);
         for (j=0; j<i; j++) {
 …
+}
+static mrb_value
+random_f_rand(mrb_state *mrb, mrb_value self)
+{
+  rand_state *t = random_default_state(mrb);
+  return random_rand(mrb, t, get_opt(mrb));
+}
+static mrb_value
+random_f_srand(mrb_state *mrb, mrb_value self)
+{
+  mrb_value random = random_default(mrb);
+  return random_m_srand(mrb, random);
+}
 void mrb_mruby_random_gem_init(mrb_state *mrb)
 …
   struct RClass *array = mrb->array_class;
+  mrb_define_method(mrb, mrb->kernel_module, "rand", mrb_random_g_rand, MRB_ARGS_OPT(1));
+  mrb_define_method(mrb, mrb->kernel_module, "srand", mrb_random_g_srand, MRB_ARGS_OPT(1));
+  mrb_assert(sizeof(rand_state) <= ISTRUCT_DATA_SIZE);
+  mrb_define_method(mrb, mrb->kernel_module, "rand", random_f_rand, MRB_ARGS_OPT(1));
+  mrb_define_method(mrb, mrb->kernel_module, "srand", random_f_srand, MRB_ARGS_OPT(1));
   random = mrb_define_class(mrb, "Random", mrb->object_class);
   MRB_SET_INSTANCE_TT(random, MRB_TT_DATA);
   mrb_define_class_method(mrb, random, "rand", mrb_random_g_rand, MRB_ARGS_OPT(1));
   mrb_define_class_method(mrb, random, "srand", mrb_random_g_srand, MRB_ARGS_OPT(1));
   mrb_define_method(mrb, random, "initialize", mrb_random_init, MRB_ARGS_OPT(1));
   mrb_define_method(mrb, random, "rand", mrb_random_rand, MRB_ARGS_OPT(1));
   mrb_define_method(mrb, random, "srand", mrb_random_srand, MRB_ARGS_OPT(1));
+  MRB_SET_INSTANCE_TT(random, MRB_TT_ISTRUCT);
+  mrb_define_class_method(mrb, random, "rand", random_f_rand, MRB_ARGS_OPT(1));
+  mrb_define_class_method(mrb, random, "srand", random_f_srand, MRB_ARGS_OPT(1));
+  mrb_define_method(mrb, random, "initialize", random_m_init, MRB_ARGS_OPT(1));
+  mrb_define_method(mrb, random, "rand", random_m_rand, MRB_ARGS_OPT(1));
+  mrb_define_method(mrb, random, "srand", random_m_srand, MRB_ARGS_OPT(1));
   mrb_define_method(mrb, array, "shuffle", mrb_ary_shuffle, MRB_ARGS_OPT(1));

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-random/test/random.rb

-              r331
+              r439
 # Random Test
 assert("Random#srand") do
+assert("Random.new") do
   r1 = Random.new(123)
   r2 = Random.new(123)
+  r1.rand == r2.rand
+  r3 = Random.new(124)
+  assert_equal(r1.rand, r2.rand)
+  assert_not_equal(r1.rand, r3.rand)
 end
 assert("Kernel::srand") do
+assert("Kernel.srand") do
   srand(234)
   r1 = rand
   srand(234)
   r2 = rand
+  r1 == r2
+  srand(235)
+  r3 = rand
+  assert_equal(r1, r2)
+  assert_not_equal(r1, r3)
 end
 assert("Random::srand") do
+assert("Random.srand") do
   Random.srand(345)
   r1 = rand
   srand(345)
   r2 = Random.rand
+  r1 == r2
+  Random.srand(346)
+  r3 = rand
+  assert_equal(r1, r2)
+  assert_not_equal(r1, r3)
 end
+assert("fixnum") do
+  rand(3).class == Fixnum
+end
+assert("float") do
+  rand.class == Float
+assert("return class of Kernel.rand") do
+  assert_kind_of(Fixnum, rand(3))
+  assert_kind_of(Fixnum, rand(1.5))
+  assert_kind_of(Float, rand)
+  assert_kind_of(Float, rand(0.5))
 end
 assert("Array#shuffle") do
+  ary = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+  orig = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+  ary = orig.dup
   shuffled = ary.shuffle
+  ary == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] and shuffled != ary and 10.times { |x| ary.include? x }
+  assert_equal(orig, ary)
+  assert_not_equal(ary, shuffled)
+  assert_equal(orig, shuffled.sort)
 end
 assert('Array#shuffle!') do
+  ary = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+  ary.shuffle!
+  ary != [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] and 10.times { |x| ary.include? x }
+  orig = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+  ary = orig.dup
+  assert_same(ary, ary.shuffle!)
+  assert_not_equal(orig, ary)
+  assert_equal(orig, ary.sort)
 end
 …
   # verify that the same seed causes the same results
   ary1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
   shuffle1 = ary1.shuffle Random.new 345
   ary2 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
   shuffle2 = ary2.shuffle Random.new 345
   ary1 != shuffle1 and 10.times { |x| shuffle1.include? x } and shuffle1 == shuffle2
+  ary = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+  shuffled1 = ary.shuffle Random.new 345
+  shuffled2 = ary.shuffle Random.new 345
+  shuffled3 = ary.shuffle Random.new 346
+  assert_equal(shuffled1, shuffled2)
+  assert_not_equal(shuffled1, shuffled3)
 end
 …
   ary2 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
   ary2.shuffle! Random.new 345
+  ary1 != [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] and 10.times { |x| ary1.include? x } and ary1 == ary2
+  ary3 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+  ary3.shuffle! Random.new 346
+  assert_equal(ary1, ary2)
+  assert_not_equal(ary1, ary3)
 end
+assert('Array#sample checks input length after reading arguments') do
+  $ary = [1, 2, 3]
+  class ArrayChange
+    def to_i
+      $ary << 4
+assert('Array#sample') do
+.times do
+    assert_include([0, 1, 2], [2, 1, 0].sample)
+    [2, 1, 0].sample(2).each { |sample| assert_include([0, 1, 2], sample) }
+    h = {}
+    (1..10).to_a.sample(7).each do |sample|
+      assert_not_include(h, sample)
+      h[sample] = true
     end
   end
+  assert_equal [1, 2, 3, 4], $ary.sample(ArrayChange.new).sort
+  assert_nil([].sample)
+  assert_equal([], [].sample(1))
+  assert_equal([], [2, 1].sample(0))
+  assert_raise(TypeError) { [2, 1].sample(true) }
+  assert_raise(ArgumentError) { [2, 1].sample(-1) }
 end
+assert('Array#sample(random)') do
+  assert_raise(TypeError) do
+    # this will cause an exception due to the wrong argument
+    [1, 2].sample(2, "Not a Random instance")
+  end
+  # verify that the same seed causes the same results
+  ary = (1..10).to_a
+  srand(15)
+  samples1 = ary.sample(4)
+  samples2 = ary.sample(4, Random.new(15))
+  samples3 = ary.sample(4, Random.new(16))
+  assert_equal(samples1, samples2)
+  assert_not_equal(samples1, samples3)
+end

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-range-ext/mrblib/range.rb

-              r331
+              r439
     raise ArgumentError, "wrong number of arguments (given #{args.length}, expected 1)" unless args.length == 1
     nv = args[0]
+    raise TypeError, "no implicit conversion from nil to integer" if nv.nil?
+    raise TypeError, "no implicit conversion of #{nv.class} into Integer" unless nv.respond_to?(:to_int)
+    n = nv.to_int
+    raise TypeError, "no implicit conversion of #{nv.class} into Integer" unless n.kind_of?(Integer)
+    n = nv.__to_int
     raise ArgumentError, "negative array size (or size too big)" unless 0 <= n
     ary = []
 …
     ary
   end
+  def max(&block)
+    val = self.first
+    last = self.last
+    return super if block
+    # fast path for numerics
+    if val.kind_of?(Numeric) && last.kind_of?(Numeric)
+      raise TypeError if exclude_end? && !last.kind_of?(Fixnum)
+      return nil if val > last
+      return nil if val == last && exclude_end?
+      max = last
+      max -= 1 if exclude_end?
+      return max
+    end
+    # delegate to Enumerable
+    super
+  end
+  def min(&block)
+    val = self.first
+    last = self.last
+    return super if block
+    # fast path for numerics
+    if val.kind_of?(Numeric) && last.kind_of?(Numeric)
+      return nil if val > last
+      return nil if val == last && exclude_end?
+      min = val
+      return min
+    end
+    # delegate to Enumerable
+    super
+  end
 end

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-range-ext/src/range.c

-              r331
+              r439
 #include <mruby/range.h>
 #include <math.h>
-#include <float.h>
 static mrb_bool
 r_le(mrb_state *mrb, mrb_value a, mrb_value b)
+{
+  mrb_value r = mrb_funcall(mrb, a, "<=>", 1, b); /* compare result */
+  /* output :a < b => -1, a = b =>  0, a > b => +1 */
+  mrb_int n = mrb_cmp(mrb, a, b);
+  if (mrb_fixnum_p(r)) {
+    mrb_int c = mrb_fixnum(r);
+    if (c == 0 || c == -1) return TRUE;
+  }
+  if (n == 0 || n == -1) return TRUE;
   return FALSE;
+}
 …
 r_lt(mrb_state *mrb, mrb_value a, mrb_value b)
+{
+  mrb_value r = mrb_funcall(mrb, a, "<=>", 1, b);
+  /* output :a < b => -1, a = b =>  0, a > b => +1 */
+  return mrb_fixnum_p(r) && mrb_fixnum(r) == -1;
+  return mrb_cmp(mrb, a, b) == -1;
+}
 …
  */
 static mrb_value
 mrb_range_cover(mrb_state *mrb, mrb_value range)
+range_cover(mrb_state *mrb, mrb_value range)
+{
   mrb_value val;
 …
   mrb_get_args(mrb, "o", &val);
   beg = r->edges->beg;
   end = r->edges->end;
+  beg = RANGE_BEG(r);
+  end = RANGE_END(r);
   if (r_le(mrb, beg, val)) {
     if (r->excl) {
+    if (RANGE_EXCL(r)) {
       if (r_lt(mrb, val, end))
         return mrb_true_value();
 …
  */
 static mrb_value
 mrb_range_last(mrb_state *mrb, mrb_value range)
+range_last(mrb_state *mrb, mrb_value range)
+{
   mrb_value num;
   mrb_value array;
-  struct RRange *r = mrb_range_ptr(mrb, range);
   if (mrb_get_args(mrb, "|o", &num) == 0) {
     return r->edges->end;
+    return mrb_range_end(mrb, range);
+  }
 …
  */
+#ifndef MRB_WITHOUT_FLOAT
 static mrb_value
 mrb_range_size(mrb_state *mrb, mrb_value range)
+range_size(mrb_state *mrb, mrb_value range)
+{
   struct RRange *r = mrb_range_ptr(mrb, range);
 …
   mrb_bool excl;
   beg = r->edges->beg;
   end = r->edges->end;
   excl = r->excl;
+  beg = RANGE_BEG(r);
+  end = RANGE_END(r);
+  excl = RANGE_EXCL(r);
   if (mrb_fixnum_p(beg)) {
     beg_f = (mrb_float)mrb_fixnum(beg);
 …
   return mrb_nil_value();
+}
+#else
+static mrb_value
+range_size(mrb_state *mrb, mrb_value range)
+{
+  struct RRange *r = mrb_range_ptr(mrb, range);
+  mrb_value beg, end;
+  mrb_int excl;
+  beg = RANGE_BEG(r);
+  end = RANGE_END(r);
+  excl = RANGE_EXCL(r) ? 0 : 1;
+  if (mrb_fixnum_p(beg) && mrb_fixnum_p(end)) {
+    mrb_int a = mrb_fixnum(beg);
+    mrb_int b = mrb_fixnum(end);
+    mrb_int c = b - a + excl;
+    return mrb_fixnum_value(c);
+  }
+  return mrb_nil_value();
+}
+#endif /* MRB_WITHOUT_FLOAT */
 void
 …
   struct RClass * s = mrb_class_get(mrb, "Range");
   mrb_define_method(mrb, s, "cover?", mrb_range_cover, MRB_ARGS_REQ(1));
   mrb_define_method(mrb, s, "last",   mrb_range_last,  MRB_ARGS_OPT(1));
   mrb_define_method(mrb, s, "size",   mrb_range_size,  MRB_ARGS_NONE());
+  mrb_define_method(mrb, s, "cover?", range_cover, MRB_ARGS_REQ(1));
+  mrb_define_method(mrb, s, "last",   range_last,  MRB_ARGS_OPT(1));
+  mrb_define_method(mrb, s, "size",   range_size,  MRB_ARGS_NONE());
+}

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-range-ext/test/range.rb

-              r331
+              r439
   assert_equal 10, (10..20).first
   assert_equal [10, 11, 12], (10..20).first(3)
+  skip unless Object.const_defined?(:Float)
   assert_equal [0, 1, 2], (0..Float::INFINITY).first(3)
 end
 …
   assert_equal 42, (1..42).size
   assert_equal 41, (1...42).size
+  assert_nil ('a'..'z').size
+  skip unless Object.const_defined?(:Float)
   assert_equal 6, (1...6.3).size
   assert_equal 5, (1...6.0).size
 …
   assert_equal 15, (1.0..15.9).size
   assert_equal Float::INFINITY, (0..Float::INFINITY).size
-  assert_nil ('a'..'z').size
 end
+assert('Range#max') do
+  # returns the maximum value in the range when called with no arguments
+  assert_equal 10, (1..10).max
+  assert_equal 9, (1...10).max
+  assert_equal 536870911, (0...2**29).max
+  # returns nil when the endpoint is less than the start point
+  assert_equal nil, (100..10).max
+  # returns nil when the endpoint equals the start point and the range is exclusive
+  assert_equal nil, (5...5).max
+  # returns the endpoint when the endpoint equals the start point and the range is inclusive
+  assert_equal 5, (5..5).max
+  skip unless Object.const_defined?(:Float)
+  # returns the maximum value in the Float range when called with no arguments
+  assert_equal 908.1111, (303.20..908.1111).max
+  # raises TypeError when called on an exclusive range and a non Integer value
+  assert_raise(TypeError) { (303.20...908.1111).max }
+  # returns nil when the endpoint is less than the start point in a Float range
+  assert_equal nil, (3003.20..908.1111).max
+end
+assert('Range#max given a block') do
+  # passes each pair of values in the range to the block
+  acc = []
+  (1..10).max do |a, b|
+    acc << a
+    acc << b
+    a
+  end
+  (1..10).each do |value|
+    assert_true acc.include?(value)
+  end
+  # passes each pair of elements to the block in reversed order
+  acc = []
+  (1..5).max do |a, b|
+    acc << [a, b]
+    a
+  end
+  assert_equal [[2, 1], [3, 2], [4, 3], [5, 4]], acc
+  # returns the element the block determines to be the maximum
+  assert_equal 1, ((1..3).max { |_a, _b| -3 })
+  # returns nil when the endpoint is less than the start point
+  assert_equal nil, ((100..10).max { |x, y| x <=> y })
+  assert_equal nil, ((5...5).max { |x, y| x <=> y })
+end
+assert('Range#min') do
+  # returns the minimum value in the range when called with no arguments
+  assert_equal 1, (1..10).min
+  assert_equal 1, (1...10).min
+  # returns nil when the start point is greater than the endpoint
+  assert_equal nil, (100..10).min
+  # returns nil when the endpoint equals the start point and the range is exclusive
+  assert_equal nil, (5...5).max
+  # returns the endpoint when the endpoint equals the start point and the range is inclusive
+  assert_equal 5, (5..5).max
+  skip unless Object.const_defined?(:Float)
+  # returns the minimum value in the Float range when called with no arguments
+  assert_equal 303.20, (303.20..908.1111).min
+  # returns nil when the start point is greater than the endpoint in a Float range
+  assert_equal nil, (3003.20..908.1111).max
+end
+assert('Range#min given a block') do
+  # passes each pair of values in the range to the block
+  acc = []
+  (1..10).min do |a, b|
+    acc << a
+    acc << b
+    a
+  end
+  (1..10).each do |value|
+    assert_true acc.include?(value)
+  end
+  # passes each pair of elements to the block in reversed order
+  acc = []
+  (1..5).min do |a, b|
+    acc << [a, b]
+    a
+  end
+  assert_equal [[2, 1], [3, 1], [4, 1], [5, 1]], acc
+  # returns the element the block determines to be the minimum
+  assert_equal 3, ((1..3).min { |_a, _b| -3 })
+  # returns nil when the start point is greater than the endpoint
+  assert_equal nil, ((100..10).min { |x, y| x <=> y })
+  assert_equal nil, ((5...5).min { |x, y| x <=> y })
+end

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-sprintf/src/kernel.c

-              r331
+              r439
   krn = mrb->kernel_module;
   mrb_define_method(mrb, krn, "sprintf", mrb_f_sprintf, MRB_ARGS_ANY());
   mrb_define_method(mrb, krn, "format",  mrb_f_sprintf, MRB_ARGS_ANY());
+  mrb_define_method(mrb, krn, "sprintf", mrb_f_sprintf, MRB_ARGS_REQ(1)|MRB_ARGS_REST());
+  mrb_define_method(mrb, krn, "format",  mrb_f_sprintf, MRB_ARGS_REQ(1)|MRB_ARGS_REST());
+}

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-sprintf/src/sprintf.c

-              r331
+              r439
 #include <mruby.h>
+#ifdef MRB_DISABLE_STDIO
+# error sprintf conflicts 'MRB_DISABLE_STDIO' configuration in your 'build_config.rb'
+#endif
 #include <limits.h>
-#include <stdio.h>
 #include <string.h>
 #include <mruby/string.h>
 #include <mruby/hash.h>
 #include <mruby/numeric.h>
+#ifndef MRB_WITHOUT_FLOAT
 #include <math.h>
+#endif
 #include <ctype.h>
 …
 #define EXTENDSIGN(n, l) (((~0U << (n)) >> (((n)*(l)) % BITSPERDIG)) & ~(~0U << (n)))
+mrb_value mrb_str_format(mrb_state *, int, const mrb_value *, mrb_value);
+mrb_value mrb_str_format(mrb_state *, mrb_int, const mrb_value *, mrb_value);
+#ifndef MRB_WITHOUT_FLOAT
 static void fmt_setup(char*,size_t,int,int,mrb_int,mrb_int);
+#endif
 static char*
 …
   if (base != 2) {
     mrb_raisef(mrb, E_ARGUMENT_ERROR, "invalid radix %S", mrb_fixnum_value(base));
+    mrb_raisef(mrb, E_ARGUMENT_ERROR, "invalid radix %d", base);
+  }
   if (val == 0) {
 …
 #define CHECK(l) do {\
-/*  int cr = ENC_CODERANGE(result);*/\
   while ((l) >= bsiz - blen) {\
+    if (bsiz > MRB_INT_MAX/2) mrb_raise(mrb, E_ARGUMENT_ERROR, "too big specifier"); \
     bsiz*=2;\
-    if (bsiz < 0) mrb_raise(mrb, E_ARGUMENT_ERROR, "too big specifier"); \
   }\
   mrb_str_resize(mrb, result, bsiz);\
-/*  ENC_CODERANGE_SET(result, cr);*/\
   buf = RSTRING_PTR(result);\
 } while (0)
 …
   CHECK(l);\
   memcpy(&buf[blen], s, l);\
   blen += (l);\
+  blen += (mrb_int)(l);\
 } while (0)
 …
   switch (posarg) {
   case -1:
     mrb_raisef(mrb, E_ARGUMENT_ERROR, "unnumbered(%S) mixed with numbered", mrb_fixnum_value(nextarg));
+    mrb_raisef(mrb, E_ARGUMENT_ERROR, "unnumbered(%d) mixed with numbered", nextarg);
     break;
   case -2:
     mrb_raisef(mrb, E_ARGUMENT_ERROR, "unnumbered(%S) mixed with named", mrb_fixnum_value(nextarg));
+    mrb_raisef(mrb, E_ARGUMENT_ERROR, "unnumbered(%d) mixed with named", nextarg);
     break;
   default:
 …
 static void
 check_pos_arg(mrb_state *mrb, int posarg, int n)
+check_pos_arg(mrb_state *mrb, int posarg, mrb_int n)
+{
   if (posarg > 0) {
     mrb_raisef(mrb, E_ARGUMENT_ERROR, "numbered(%S) after unnumbered(%S)",
                mrb_fixnum_value(n), mrb_fixnum_value(posarg));
+    mrb_raisef(mrb, E_ARGUMENT_ERROR, "numbered(%i) after unnumbered(%d)",
+               n, posarg);
+  }
   if (posarg == -2) {
     mrb_raisef(mrb, E_ARGUMENT_ERROR, "numbered(%S) after named", mrb_fixnum_value(n));
+    mrb_raisef(mrb, E_ARGUMENT_ERROR, "numbered(%i) after named", n);
+  }
   if (n < 1) {
     mrb_raisef(mrb, E_ARGUMENT_ERROR, "invalid index - %S$", mrb_fixnum_value(n));
+    mrb_raisef(mrb, E_ARGUMENT_ERROR, "invalid index - %i$", n);
+  }
+}
 static void
 check_name_arg(mrb_state *mrb, int posarg, const char *name, int len)
+check_name_arg(mrb_state *mrb, int posarg, const char *name, size_t len)
+{
   if (posarg > 0) {
     mrb_raisef(mrb, E_ARGUMENT_ERROR, "named%S after unnumbered(%S)",
                mrb_str_new(mrb, (name), (len)), mrb_fixnum_value(posarg));
+    mrb_raisef(mrb, E_ARGUMENT_ERROR, "named%l after unnumbered(%d)",
+               name, len, posarg);
+  }
   if (posarg == -1) {
     mrb_raisef(mrb, E_ARGUMENT_ERROR, "named%S after numbered", mrb_str_new(mrb, (name), (len)));
+    mrb_raisef(mrb, E_ARGUMENT_ERROR, "named%l after numbered", name, len);
+  }
+}
 …
 #define GETNUM(n, val) \
   for (; p < end && ISDIGIT(*p); p++) {\
+    int next_n = 10 * n + (*p - '0'); \
+    if (next_n / 10 != n) {\
+    if (n > (MRB_INT_MAX - (*p - '0'))/10) {\
       mrb_raise(mrb, E_ARGUMENT_ERROR, #val " too big"); \
     } \
     n = next_n; \
+    n = 10 * n + (*p - '0'); \
   } \
   if (p >= end) { \
 …
 static mrb_value
 get_hash(mrb_state *mrb, mrb_value *hash, int argc, const mrb_value *argv)
+get_hash(mrb_state *mrb, mrb_value *hash, mrb_int argc, const mrb_value *argv)
+{
   mrb_value tmp;
 …
     mrb_raise(mrb, E_ARGUMENT_ERROR, "one hash required");
+  }
   tmp = mrb_check_convert_type(mrb, argv[1], MRB_TT_HASH, "Hash", "to_hash");
+  tmp = mrb_check_hash_type(mrb, argv[1]);
   if (mrb_nil_p(tmp)) {
     mrb_raise(mrb, E_ARGUMENT_ERROR, "one hash required");
 …
 mrb_value
 mrb_str_format(mrb_state *mrb, int argc, const mrb_value *argv, mrb_value fmt)
+mrb_str_format(mrb_state *mrb, mrb_int argc, const mrb_value *argv, mrb_value fmt)
+{
   const char *p, *end;
 …
   mrb_int width;
   mrb_int prec;
-  int flags = FNONE;
   int nextarg = 1;
   int posarg = 0;
 …
   ++argc;
   --argv;
   fmt = mrb_str_to_str(mrb, fmt);
+  mrb_to_str(mrb, fmt);
   p = RSTRING_PTR(fmt);
   end = p + RSTRING_LEN(fmt);
   blen = 0;
   bsiz = 120;
   result = mrb_str_buf_new(mrb, bsiz);
+  result = mrb_str_new_capa(mrb, bsiz);
   buf = RSTRING_PTR(result);
   memset(buf, 0, bsiz);
 …
     const char *t;
     mrb_sym id = 0;
+    int flags = FNONE;
     for (t = p; t < end && *t != '%'; t++) ;
 …
     switch (*p) {
       default:
         mrb_raisef(mrb, E_ARGUMENT_ERROR, "malformed format string - \\%%S", mrb_str_new(mrb, p, 1));
+        mrb_raisef(mrb, E_ARGUMENT_ERROR, "malformed format string - %%%c", *p);
         break;
 …
         if (*p == '$') {
           if (!mrb_undef_p(nextvalue)) {
             mrb_raisef(mrb, E_ARGUMENT_ERROR, "value given twice - %S$", mrb_fixnum_value(n));
+            mrb_raisef(mrb, E_ARGUMENT_ERROR, "value given twice - %i$", n);
+          }
           nextvalue = GETPOSARG(n);
 …
           p++;
         if (id) {
           mrb_raisef(mrb, E_ARGUMENT_ERROR, "name%S after <%S>",
                      mrb_str_new(mrb, start, p - start + 1), mrb_sym2str(mrb, id));
+          mrb_raisef(mrb, E_ARGUMENT_ERROR, "name%l after <%n>",
+                     start, p - start + 1, id);
+        }
         symname = mrb_str_new(mrb, start + 1, p - start - 1);
         id = mrb_intern_str(mrb, symname);
         nextvalue = GETNAMEARG(mrb_symbol_value(id), start, (int)(p - start + 1));
+        nextvalue = GETNAMEARG(mrb_symbol_value(id), start, p - start + 1);
         if (mrb_undef_p(nextvalue)) {
           mrb_raisef(mrb, E_KEY_ERROR, "key%S not found", mrb_str_new(mrb, start, p - start + 1));
+          mrb_raisef(mrb, E_KEY_ERROR, "key%l not found", start, p - start + 1);
+        }
         if (term == '}') goto format_s;
 …
         tmp = mrb_check_string_type(mrb, val);
         if (!mrb_nil_p(tmp)) {
           if (mrb_fixnum(mrb_funcall(mrb, tmp, "size", 0)) != 1 ) {
+          if (RSTRING_LEN(tmp) != 1) {
             mrb_raise(mrb, E_ARGUMENT_ERROR, "%c requires a character");
+          }
+        }
         else if (mrb_fixnum_p(val)) {
+          tmp = mrb_funcall(mrb, val, "chr", 0);
+          mrb_int n = mrb_fixnum(val);
+          if (n < 0x80) {
+            char buf[1];
+            buf[0] = (char)n;
+            tmp = mrb_str_new(mrb, buf, 1);
+          }
+          else {
+            tmp = mrb_funcall(mrb, val, "chr", 0);
+            mrb_check_type(mrb, tmp, MRB_TT_STRING);
+          }
+        }
         else {
           mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid character");
+        }
-        mrb_check_type(mrb, tmp, MRB_TT_STRING);
         c = RSTRING_PTR(tmp);
         n = RSTRING_LEN(tmp);
 …
             char *p = RSTRING_PTR(str) + prec;
             slen = prec;
             len = p - RSTRING_PTR(str);
+            len = (mrb_int)(p - RSTRING_PTR(str));
+          }
           /* need to adjust multi-byte string pos */
 …
         mrb_int len;
-        switch (*p) {
-          case 'd':
-          case 'i':
-            sign = 1; break;
-          default:
-            break;
+        }
         if (flags & FSHARP) {
           switch (*p) {
 …
   bin_retry:
         switch (mrb_type(val)) {
+#ifndef MRB_WITHOUT_FLOAT
           case MRB_TT_FLOAT:
             val = mrb_flo_to_fixnum(mrb, val);
             if (mrb_fixnum_p(val)) goto bin_retry;
             break;
+#endif
           case MRB_TT_STRING:
             val = mrb_str_to_inum(mrb, val, 0, TRUE);
 …
           case 'd':
           case 'i':
+            sign = 1;
+            /* fall through */
           default:
             base = 10; break;
+        }
-        if (base == 2) {
-          if (v < 0 && !sign) {
-            val = mrb_fix2binstr(mrb, mrb_fixnum_value(v), base);
-            dots = 1;
+          }
-          else {
-            val = mrb_fixnum_to_str(mrb, mrb_fixnum_value(v), base);
+          }
+        }
         if (sign) {
           if (v > 0) {
+          if (v >= 0) {
             if (flags & FPLUS) {
               sc = '+';
 …
+            }
+          }
+          else {
+            sc = '-';
+            width--;
+          }
+          mrb_assert(base == 10);
+          snprintf(nbuf, sizeof(nbuf), "%" MRB_PRId, v);
+          s = nbuf;
+          if (v < 0) s++;       /* skip minus sign */
+        }
+        else {
+          s = nbuf;
+          if (v < 0) {
+            dots = 1;
+          }
           switch (base) {
           case 2:
+            strncpy(nbuf, RSTRING_PTR(val), sizeof(nbuf));
+            break;
+          case 8:
+            snprintf(nbuf, sizeof(nbuf), "%" MRB_PRIo, v);
+            break;
+          case 10:
+            snprintf(nbuf, sizeof(nbuf), "%" MRB_PRId, v);
+            break;
+          case 16:
+            snprintf(nbuf, sizeof(nbuf), "%" MRB_PRIx, v);
+            break;
+          }
+          s = nbuf;
+        }
+        else {
+          s = nbuf;
+          if (base != 10 && v < 0) {
+            dots = 1;
+          }
+          switch (base) {
+          case 2:
+            if (v < 0) {
+              val = mrb_fix2binstr(mrb, mrb_fixnum_value(v), base);
+            }
+            else {
+              val = mrb_fixnum_to_str(mrb, mrb_fixnum_value(v), base);
+            }
             strncpy(++s, RSTRING_PTR(val), sizeof(nbuf)-1);
             break;
           case 8:
             snprintf(++s, sizeof(nbuf)-1, "%" MRB_PRIo, v);
-            break;
-          case 10:
-            snprintf(++s, sizeof(nbuf)-1, "%" MRB_PRId, v);
             break;
           case 16:
 …
+        }
-        if (dots) {
-          prec -= 2;
-          width -= 2;
+        }
         if (*p == 'X') {
           char *pp = s;
 …
         if (!(flags&FMINUS) && width > 0) {
           FILL(' ', width);
+          width = 0;
+        }
 …
           PUSH(prefix, plen);
+        }
+        if (dots) PUSH("..", 2);
+        if (dots) {
+          prec -= 2;
+          width -= 2;
+          PUSH("..", 2);
+        }
         if (prec > len) {
           CHECK(prec - len);
+          if (v < 0) {
+          if ((flags & (FMINUS|FPREC)) != FMINUS) {
+            char c = '0';
+            FILL(c, prec - len);
+          } else if (v < 0) {
             char c = sign_bits(base, p);
-            FILL(c, prec - len);
+          }
-          else if ((flags & (FMINUS|FPREC)) != FMINUS) {
-            char c = '0';
             FILL(c, prec - len);
+          }
 …
       break;
+#ifndef MRB_WITHOUT_FLOAT
       case 'f':
       case 'g':
 …
         mrb_value val = GETARG();
         double fval;
         int i, need = 6;
+        mrb_int need = 6;
         char fbuf[32];
 …
         if (!isfinite(fval)) {
           const char *expr;
           const int elen = 3;
+          const mrb_int elen = 3;
           char sign = '\0';
 …
             sign = (flags & FPLUS) ? '+' : ' ';
           if (sign)
             ++need;
+            ++need;
           if ((flags & FWIDTH) && need < width)
             need = width;
 …
         need = 0;
         if (*p != 'e' && *p != 'E') {
           i = INT_MIN;
+          int i;
           frexp(fval, &i);
           if (i > 0)
             need = BIT_DIGITS(i);
+        }
+        if (need > MRB_INT_MAX - ((flags&FPREC) ? prec : 6)) {
+        too_big_width:
+          mrb_raise(mrb, E_ARGUMENT_ERROR,
+                    (width > prec ? "width too big" : "prec too big"));
+        }
         need += (flags&FPREC) ? prec : 6;
         if ((flags&FWIDTH) && need < width)
           need = width;
+        if (need > MRB_INT_MAX - 20) {
+          goto too_big_width;
+        }
         need += 20;
-        if (need <= 0) {
-          mrb_raise(mrb, E_ARGUMENT_ERROR,
-                    (width > prec ? "width too big" : "prec too big"));
+        }
         CHECK(need);
         n = snprintf(&buf[blen], need, fbuf, fval);
         if (n < 0) {
+        if (n < 0 || n >= need) {
           mrb_raise(mrb, E_RUNTIME_ERROR, "formatting error");
+        }
 …
+      }
       break;
+#endif
+    }
     flags = FNONE;
 …
     const char *mesg = "too many arguments for format string";
     if (mrb_test(ruby_debug)) mrb_raise(mrb, E_ARGUMENT_ERROR, mesg);
     if (mrb_test(ruby_verbose)) mrb_warn(mrb, "%S", mrb_str_new_cstr(mrb, mesg));
+    if (mrb_test(ruby_verbose)) mrb_warn(mrb, "%s", mesg);
+  }
 #endif
 …
+}
+#ifndef MRB_WITHOUT_FLOAT
 static void
 fmt_setup(char *buf, size_t size, int c, int flags, mrb_int width, mrb_int prec)
 …
   *buf = '\0';
+}
+#endif

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-sprintf/test/sprintf.rb

-              r331
+              r439
 assert('String#%') do
   assert_equal "one=1", "one=%d" % 1
   assert_equal "1 one 1.0", "%d %s %3.1f" % [ 1, "one", 1.01 ]
+  assert_equal "1 one", "%d %s" % [ 1, "one" ]
   assert_equal "123 < 456", "%{num} < %<str>s" % { num: 123, str: "456" }
   assert_equal 15, ("%b" % (1<<14)).size
+  skip unless Object.const_defined?(:Float)
+  assert_equal "1.0", "%3.1f" % 1.01
 end
 assert('String#% with inf') do
+  skip unless Object.const_defined?(:Float)
   inf = Float::INFINITY
 …
 assert('String#% with nan') do
+  skip unless Object.const_defined?(:Float)
   nan = Float::NAN
 …
     assert_raise TypeError do
       "%c" % 0
+      "%c" % 0x80
     end
   ensure
 …
 end
+assert("String#% %d") do
+  assert_equal("  10",   "%4d" % 10)
+  assert_equal("1000",   "%4d" % 1000)
+  assert_equal("10000",  "%4d" % 10000)
+end
 assert("String#% invalid format") do
   assert_raise ArgumentError do

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-string-ext/mrbgem.rake

r331	r439
3	3	spec.author = 'mruby developers'
4	4	spec.summary = 'String class extension'
5		~~spec.add_test_dependency 'mruby-enumerator', core: 'mruby-enumerator'~~
6	5	end

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-string-ext/mrblib/string.rb

-              r331
+              r439
 class String
-  ##
-  #  call-seq:
-  #     String.try_convert(obj) -> string or nil
+  #
-  # Try to convert <i>obj</i> into a String, using to_str method.
-  # Returns converted string or nil if <i>obj</i> cannot be converted
-  # for any reason.
+  #
-  #     String.try_convert("str")     #=> "str"
-  #     String.try_convert(/re/)      #=> nil
+  #
-  def self.try_convert(obj)
-    if obj.respond_to?(:to_str)
-      obj.to_str
-    else
-      nil
-    end
-  end
   ##
 …
+  #
   def lstrip!
     raise RuntimeError, "can't modify frozen String" if frozen?
+    raise FrozenError, "can't modify frozen String" if frozen?
     s = self.lstrip
     (s == self) ? nil : self.replace(s)
 …
+  #
   def rstrip!
     raise RuntimeError, "can't modify frozen String" if frozen?
+    raise FrozenError, "can't modify frozen String" if frozen?
     s = self.rstrip
     (s == self) ? nil : self.replace(s)
 …
+  #
   def strip!
     raise RuntimeError, "can't modify frozen String" if frozen?
+    raise FrozenError, "can't modify frozen String" if frozen?
     s = self.strip
     (s == self) ? nil : self.replace(s)
 …
+  #
   def casecmp(str)
     self.downcase <=> str.to_str.downcase
+    self.downcase <=> str.__to_str.downcase
   rescue NoMethodError
+    raise TypeError, "no implicit conversion of #{str.class} into String"
+    nil
+  end
+  ##
+  # call-seq:
+  #   str.casecmp?(other)  -> true, false, or nil
+  #
+  # Returns true if str and other_str are equal after case folding,
+  # false if they are not equal, and nil if other_str is not a string.
+  def casecmp?(str)
+    c = self.casecmp(str)
+    return nil if c.nil?
+    return c == 0
   end
 …
+  #
   def slice!(arg1, arg2=nil)
     raise RuntimeError, "can't modify frozen String" if frozen?
+    raise FrozenError, "can't modify frozen String" if frozen?
     raise "wrong number of arguments (for 1..2)" if arg1.nil? && arg2.nil?
 …
   end
+  ##
+  # Call the given block for each character of
+  # +self+.
   def each_char(&block)
     return to_enum :each_char unless block
+    split('').each do |i|
+      block.call(i)
+    pos = 0
+    while pos < self.size
+      block.call(self[pos])
+      pos += 1
     end
     self
 …
     self
   end
+  ##
+  #  call-seq:
+  #    string.lines                ->  array of string
+  #    string.lines {|s| block}    ->  array of string
+  #
+  #  Returns strings per line;
+  #
+  #    a = "abc\ndef"
+  #    a.lines    #=> ["abc\n", "def"]
+  #
+  #  If a block is given, it works the same as <code>each_line</code>.
+  def lines(&blk)
+    lines = self.__lines
+    if blk
+      lines.each do |line|
+        blk.call(line)
+      end
+    end
+    lines
+  end
+  ##
+  #  call-seq:
+  #     str.upto(other_str, exclusive=false) {|s| block }   -> str
+  #     str.upto(other_str, exclusive=false)                -> an_enumerator
+  #
+  #  Iterates through successive values, starting at <i>str</i> and
+  #  ending at <i>other_str</i> inclusive, passing each value in turn to
+  #  the block. The <code>String#succ</code> method is used to generate
+  #  each value.  If optional second argument exclusive is omitted or is false,
+  #  the last value will be included; otherwise it will be excluded.
+  #
+  #  If no block is given, an enumerator is returned instead.
+  #
+  #     "a8".upto("b6") {|s| print s, ' ' }
+  #     for s in "a8".."b6"
+  #       print s, ' '
+  #     end
+  #
+  #  <em>produces:</em>
+  #
+  #     a8 a9 b0 b1 b2 b3 b4 b5 b6
+  #     a8 a9 b0 b1 b2 b3 b4 b5 b6
+  #
+  #  If <i>str</i> and <i>other_str</i> contains only ascii numeric characters,
+  #  both are recognized as decimal numbers. In addition, the width of
+  #  string (e.g. leading zeros) is handled appropriately.
+  #
+  #     "9".upto("11").to_a   #=> ["9", "10", "11"]
+  #     "25".upto("5").to_a   #=> []
+  #     "07".upto("11").to_a  #=> ["07", "08", "09", "10", "11"]
+  def upto(max, exclusive=false, &block)
+    return to_enum(:upto, max, exclusive) unless block
+    raise TypeError, "no implicit conversion of #{max.class} into String" unless max.kind_of? String
+    len = self.length
+    maxlen = max.length
+    # single character
+    if len == 1 and maxlen == 1
+      c = self.ord
+      e = max.ord
+      while c <= e
+        break if exclusive and c == e
+        yield c.chr(__ENCODING__)
+        c += 1
+      end
+      return self
+    end
+    # both edges are all digits
+    bi = self.to_i(10)
+    ei = max.to_i(10)
+    len = self.length
+    if (bi > 0 or bi == "0"*len) and (ei > 0 or ei == "0"*maxlen)
+      while bi <= ei
+        break if exclusive and bi == ei
+        s = bi.to_s
+        s = s.rjust(len, "0") if s.length < len
+        yield s
+        bi += 1
+      end
+      return self
+    end
+    bs = self
+    while true
+      n = (bs <=> max)
+      break if n > 0
+      break if exclusive and n == 0
+      yield bs
+      break if n == 0
+      bs = bs.succ
+    end
+    self
+  end
 end

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-string-ext/src/string.c

-              r331
+              r439
 #include <mruby/range.h>
+static mrb_value
+mrb_str_getbyte(mrb_state *mrb, mrb_value str)
+{
+  mrb_int pos;
+  mrb_get_args(mrb, "i", &pos);
+  if (pos < 0)
+    pos += RSTRING_LEN(str);
+  if (pos < 0 ||  RSTRING_LEN(str) <= pos)
+    return mrb_nil_value();
+  return mrb_fixnum_value((unsigned char)RSTRING_PTR(str)[pos]);
+}
+static mrb_value
+mrb_str_setbyte(mrb_state *mrb, mrb_value str)
+{
+  mrb_int pos, byte;
+  long len;
+  mrb_get_args(mrb, "ii", &pos, &byte);
+  len = RSTRING_LEN(str);
+  if (pos < -len || len <= pos)
+    mrb_raisef(mrb, E_INDEX_ERROR, "index %S is out of array", mrb_fixnum_value(pos));
+  if (pos < 0)
+    pos += len;
+  mrb_str_modify(mrb, mrb_str_ptr(str));
+  byte &= 0xff;
+  RSTRING_PTR(str)[pos] = byte;
+  return mrb_fixnum_value((unsigned char)byte);
+}
+static mrb_value
+mrb_str_byteslice(mrb_state *mrb, mrb_value str)
+{
+  mrb_value a1;
+#define ENC_ASCII_8BIT "ASCII-8BIT"
+#define ENC_BINARY     "BINARY"
+#define ENC_UTF8       "UTF-8"
+#define ENC_COMP_P(enc, enc_lit) \
+  str_casecmp_p(RSTRING_PTR(enc), RSTRING_LEN(enc), enc_lit, sizeof(enc_lit"")-1)
+#ifdef MRB_WITHOUT_FLOAT
+# define mrb_float_p(o) FALSE
+#endif
+static mrb_bool
+str_casecmp_p(const char *s1, mrb_int len1, const char *s2, mrb_int len2)
+{
+  const char *e1, *e2;
+  if (len1 != len2) return FALSE;
+  e1 = s1 + len1;
+  e2 = s2 + len2;
+  while (s1 < e1 && s2 < e2) {
+    if (*s1 != *s2 && TOUPPER(*s1) != TOUPPER(*s2)) return FALSE;
+    ++s1;
+    ++s2;
+  }
+  return TRUE;
+}
+static mrb_value
+int_chr_binary(mrb_state *mrb, mrb_value num)
+{
+  mrb_int cp = mrb_int(mrb, num);
+  char c;
+  mrb_value str;
+  if (cp < 0 || 0xff < cp) {
+    mrb_raisef(mrb, E_RANGE_ERROR, "%v out of char range", num);
+  }
+  c = (char)cp;
+  str = mrb_str_new(mrb, &c, 1);
+  RSTR_SET_ASCII_FLAG(mrb_str_ptr(str));
+  return str;
+}
+#ifdef MRB_UTF8_STRING
+static mrb_value
+int_chr_utf8(mrb_state *mrb, mrb_value num)
+{
+  mrb_int cp = mrb_int(mrb, num);
+  char utf8[4];
   mrb_int len;
   int argc;
+  argc = mrb_get_args(mrb, "o|i", &a1, &len);
   if (argc == 2) {
     return mrb_str_substr(mrb, str, mrb_fixnum(a1), len);
+  }
   switch (mrb_type(a1)) {
   case MRB_TT_RANGE:
+    {
       mrb_int beg;
       len = RSTRING_LEN(str);
       switch (mrb_range_beg_len(mrb, a1, &beg, &len, len, TRUE)) {
       case 0:                   /* not range */
         break;
       case 1:                   /* range */
         return mrb_str_substr(mrb, str, beg, len);
       case 2:                   /* out of range */
         mrb_raisef(mrb, E_RANGE_ERROR, "%S out of range", a1);
         break;
+      }
       return mrb_nil_value();
+    }
   case MRB_TT_FLOAT:
     a1 = mrb_fixnum_value((mrb_int)mrb_float(a1));
     /* fall through */
   case MRB_TT_FIXNUM:
     return mrb_str_substr(mrb, str, mrb_fixnum(a1), 1);
   default:
     mrb_raise(mrb, E_TYPE_ERROR, "wrong type of argument");
+  }
   /* not reached */
+  return mrb_nil_value();
+}
+  mrb_value str;
+  uint32_t ascii_flag = 0;
+  if (cp < 0 || 0x10FFFF < cp) {
+    mrb_raisef(mrb, E_RANGE_ERROR, "%v out of char range", num);
+  }
+  if (cp < 0x80) {
+    utf8[0] = (char)cp;
+    len = 1;
+    ascii_flag = MRB_STR_ASCII;
+  }
+  else if (cp < 0x800) {
+    utf8[0] = (char)(0xC0 | (cp >> 6));
+    utf8[1] = (char)(0x80 | (cp & 0x3F));
+    len = 2;
+  }
+  else if (cp < 0x10000) {
+    utf8[0] = (char)(0xE0 |  (cp >> 12));
+    utf8[1] = (char)(0x80 | ((cp >>  6) & 0x3F));
+    utf8[2] = (char)(0x80 | ( cp        & 0x3F));
+    len = 3;
+  }
+  else {
+    utf8[0] = (char)(0xF0 |  (cp >> 18));
+    utf8[1] = (char)(0x80 | ((cp >> 12) & 0x3F));
+    utf8[2] = (char)(0x80 | ((cp >>  6) & 0x3F));
+    utf8[3] = (char)(0x80 | ( cp        & 0x3F));
+    len = 4;
+  }
+  str = mrb_str_new(mrb, utf8, len);
+  mrb_str_ptr(str)->flags |= ascii_flag;
+  return str;
+}
+#endif
 /*
 …
+}
-static mrb_value mrb_fixnum_chr(mrb_state *mrb, mrb_value num);
 /*
  *  call-seq:
 …
  *  Append---Concatenates the given object to <i>str</i>. If the object is a
  *  <code>Integer</code>, it is considered as a codepoint, and is converted
+ *  to a character before concatenation.
+ *  to a character before concatenation
+ *  (equivalent to <code>str.concat(integer.chr(__ENCODING__))</code>).
+ *
  *     a = "hello "
 …
  */
 static mrb_value
 mrb_str_concat2(mrb_state *mrb, mrb_value self)
+mrb_str_concat_m(mrb_state *mrb, mrb_value self)
+{
   mrb_value str;
   mrb_get_args(mrb, "o", &str);
+  if (mrb_fixnum_p(str))
+    str = mrb_fixnum_chr(mrb, str);
+  if (mrb_fixnum_p(str) || mrb_float_p(str))
+#ifdef MRB_UTF8_STRING
+    str = int_chr_utf8(mrb, str);
+#else
+    str = int_chr_binary(mrb, str);
+#endif
   else
     str = mrb_string_type(mrb, str);
   mrb_str_concat(mrb, self, str);
+    mrb_ensure_string_type(mrb, str);
+  mrb_str_cat_str(mrb, self, str);
   return self;
+}
 …
     size_t len_l, len_r;
     int ai = mrb_gc_arena_save(mrb);
     sub = mrb_string_type(mrb, argv[i]);
+    sub = mrb_ensure_string_type(mrb, argv[i]);
     mrb_gc_arena_restore(mrb, ai);
     len_l = RSTRING_LEN(self);
 …
     size_t len_l, len_r;
     int ai = mrb_gc_arena_save(mrb);
     sub = mrb_string_type(mrb, argv[i]);
+    sub = mrb_ensure_string_type(mrb, argv[i]);
     mrb_gc_arena_restore(mrb, ai);
     len_l = RSTRING_LEN(self);
 …
+}
+enum tr_pattern_type {
+  TR_UNINITIALIZED = 0,
+  TR_IN_ORDER  = 1,
+  TR_RANGE = 2,
+};
+/*
+  #tr Pattern syntax
+  <syntax> ::= (<pattern>)* | '^' (<pattern>)*
+  <pattern> ::= <in order> | <range>
+  <in order> ::= (<ch>)+
+  <range> ::= <ch> '-' <ch>
+*/
+struct tr_pattern {
+  uint8_t type;         // 1:in-order, 2:range
+  mrb_bool flag_reverse : 1;
+  mrb_bool flag_on_heap : 1;
+  uint16_t n;
+  union {
+    uint16_t start_pos;
+    char ch[2];
+  } val;
+  struct tr_pattern *next;
+};
+#define STATIC_TR_PATTERN { 0 }
+static inline void
+tr_free_pattern(mrb_state *mrb, struct tr_pattern *pat)
+{
+  while (pat) {
+    struct tr_pattern *p = pat->next;
+    if (pat->flag_on_heap) {
+      mrb_free(mrb, pat);
+    }
+    pat = p;
+  }
+}
+static struct tr_pattern*
+tr_parse_pattern(mrb_state *mrb, struct tr_pattern *ret, const mrb_value v_pattern, mrb_bool flag_reverse_enable)
+{
+  const char *pattern = RSTRING_PTR(v_pattern);
+  mrb_int pattern_length = RSTRING_LEN(v_pattern);
+  mrb_bool flag_reverse = FALSE;
+  struct tr_pattern *pat1;
+  mrb_int i = 0;
+  if(flag_reverse_enable && pattern_length >= 2 && pattern[0] == '^') {
+    flag_reverse = TRUE;
+    i++;
+  }
+  while (i < pattern_length) {
+    /* is range pattern ? */
+    mrb_bool const ret_uninit = (ret->type == TR_UNINITIALIZED);
+    pat1 = ret_uninit
+           ? ret
+           : (struct tr_pattern*)mrb_malloc_simple(mrb, sizeof(struct tr_pattern));
+    if ((i+2) < pattern_length && pattern[i] != '\\' && pattern[i+1] == '-') {
+      if (pat1 == NULL && ret) {
+      nomem:
+        tr_free_pattern(mrb, ret);
+        mrb_exc_raise(mrb, mrb_obj_value(mrb->nomem_err));
+        return NULL;            /* not reached */
+      }
+      pat1->type = TR_RANGE;
+      pat1->flag_reverse = flag_reverse;
+      pat1->flag_on_heap = !ret_uninit;
+      pat1->n = pattern[i+2] - pattern[i] + 1;
+      pat1->next = NULL;
+      pat1->val.ch[0] = pattern[i];
+      pat1->val.ch[1] = pattern[i+2];
+      i += 3;
+    }
+    else {
+      /* in order pattern. */
+      mrb_int start_pos = i++;
+      mrb_int len;
+      while (i < pattern_length) {
+        if ((i+2) < pattern_length && pattern[i] != '\\' && pattern[i+1] == '-')
+          break;
+        i++;
+      }
+      len = i - start_pos;
+      if (len > UINT16_MAX) {
+        mrb_raise(mrb, E_ARGUMENT_ERROR, "tr pattern too long (max 65536)");
+      }
+      if (pat1 == NULL && ret) {
+        goto nomem;
+      }
+      pat1->type = TR_IN_ORDER;
+      pat1->flag_reverse = flag_reverse;
+      pat1->flag_on_heap = !ret_uninit;
+      pat1->n = len;
+      pat1->next = NULL;
+      pat1->val.start_pos = start_pos;
+    }
+    if (ret == NULL || ret_uninit) {
+      ret = pat1;
+    }
+    else {
+      struct tr_pattern *p = ret;
+      while (p->next != NULL) {
+        p = p->next;
+      }
+      p->next = pat1;
+    }
+  }
+  return ret;
+}
+static inline mrb_int
+tr_find_character(const struct tr_pattern *pat, const char *pat_str, int ch)
+{
+  mrb_int ret = -1;
+  mrb_int n_sum = 0;
+  mrb_int flag_reverse = pat ? pat->flag_reverse : 0;
+  while (pat != NULL) {
+    if (pat->type == TR_IN_ORDER) {
+      int i;
+      for (i = 0; i < pat->n; i++) {
+        if (pat_str[pat->val.start_pos + i] == ch) ret = n_sum + i;
+      }
+    }
+    else if (pat->type == TR_RANGE) {
+      if (pat->val.ch[0] <= ch && ch <= pat->val.ch[1])
+        ret = n_sum + ch - pat->val.ch[0];
+    }
+    else {
+      mrb_assert(pat->type == TR_UNINITIALIZED);
+    }
+    n_sum += pat->n;
+    pat = pat->next;
+  }
+  if (flag_reverse) {
+    return (ret < 0) ? MRB_INT_MAX : -1;
+  }
+  return ret;
+}
+static inline mrb_int
+tr_get_character(const struct tr_pattern *pat, const char *pat_str, mrb_int n_th)
+{
+  mrb_int n_sum = 0;
+  while (pat != NULL) {
+    if (n_th < (n_sum + pat->n)) {
+      mrb_int i = (n_th - n_sum);
+      switch (pat->type) {
+      case TR_IN_ORDER:
+        return pat_str[pat->val.start_pos + i];
+      case TR_RANGE:
+        return pat->val.ch[0]+i;
+      case TR_UNINITIALIZED:
+        return -1;
+      }
+    }
+    if (pat->next == NULL) {
+      switch (pat->type) {
+      case TR_IN_ORDER:
+        return pat_str[pat->val.start_pos + pat->n - 1];
+      case TR_RANGE:
+        return pat->val.ch[1];
+      case TR_UNINITIALIZED:
+        return -1;
+      }
+    }
+    n_sum += pat->n;
+    pat = pat->next;
+  }
+  return -1;
+}
+static inline void
+tr_bitmap_set(uint8_t bitmap[32], uint8_t ch)
+{
+  uint8_t idx1 = ch / 8;
+  uint8_t idx2 = ch % 8;
+  bitmap[idx1] |= (1<<idx2);
+}
+static inline mrb_bool
+tr_bitmap_detect(uint8_t bitmap[32], uint8_t ch)
+{
+  uint8_t idx1 = ch / 8;
+  uint8_t idx2 = ch % 8;
+  if (bitmap[idx1] & (1<<idx2))
+    return TRUE;
+  return FALSE;
+}
+/* compile patter to bitmap */
+static void
+tr_compile_pattern(const struct tr_pattern *pat, mrb_value pstr, uint8_t bitmap[32])
+{
+  const char *pattern = RSTRING_PTR(pstr);
+  mrb_int flag_reverse = pat ? pat->flag_reverse : 0;
+  int i;
+  for (i=0; i<32; i++) {
+    bitmap[i] = 0;
+  }
+  while (pat != NULL) {
+    if (pat->type == TR_IN_ORDER) {
+      for (i = 0; i < pat->n; i++) {
+        tr_bitmap_set(bitmap, pattern[pat->val.start_pos + i]);
+      }
+    }
+    else if (pat->type == TR_RANGE) {
+      for (i = pat->val.ch[0]; i < pat->val.ch[1]; i++) {
+        tr_bitmap_set(bitmap, i);
+      }
+    }
+    else {
+      mrb_assert(pat->type == TR_UNINITIALIZED);
+    }
+    pat = pat->next;
+  }
+  if (flag_reverse) {
+    for (i=0; i<32; i++) {
+      bitmap[i] ^= 0xff;
+    }
+  }
+}
+static mrb_bool
+str_tr(mrb_state *mrb, mrb_value str, mrb_value p1, mrb_value p2, mrb_bool squeeze)
+{
+  struct tr_pattern pat = STATIC_TR_PATTERN;
+  struct tr_pattern rep_storage = STATIC_TR_PATTERN;
+  char *s;
+  mrb_int len;
+  mrb_int i;
+  mrb_int j;
+  mrb_bool flag_changed = FALSE;
+  mrb_int lastch = -1;
+  struct tr_pattern *rep;
+  mrb_str_modify(mrb, mrb_str_ptr(str));
+  tr_parse_pattern(mrb, &pat, p1, TRUE);
+  rep = tr_parse_pattern(mrb, &rep_storage, p2, FALSE);
+  s = RSTRING_PTR(str);
+  len = RSTRING_LEN(str);
+  for (i=j=0; i<len; i++,j++) {
+    mrb_int n = tr_find_character(&pat, RSTRING_PTR(p1), s[i]);
+    if (i>j) s[j] = s[i];
+    if (n >= 0) {
+      flag_changed = TRUE;
+      if (rep == NULL) {
+        j--;
+      }
+      else {
+        mrb_int c = tr_get_character(rep, RSTRING_PTR(p2), n);
+        if (c < 0 || (squeeze && c == lastch)) {
+          j--;
+          continue;
+        }
+        if (c > 0x80) {
+          mrb_raisef(mrb, E_ARGUMENT_ERROR, "character (%i) out of range", c);
+        }
+        lastch = c;
+        s[i] = (char)c;
+      }
+    }
+  }
+  tr_free_pattern(mrb, &pat);
+  tr_free_pattern(mrb, rep);
+  if (flag_changed) {
+    RSTR_SET_LEN(RSTRING(str), j);
+    RSTRING_PTR(str)[j] = 0;
+  }
+  return flag_changed;
+}
+/*
+ * call-seq:
+ *   str.tr(from_str, to_str)   => new_str
+ *
+ * Returns a copy of str with the characters in from_str replaced by the
+ * corresponding characters in to_str.  If to_str is shorter than from_str,
+ * it is padded with its last character in order to maintain the
+ * correspondence.
+ *
+ *  "hello".tr('el', 'ip')      #=> "hippo"
+ *  "hello".tr('aeiou', '*')    #=> "h*ll*"
+ *  "hello".tr('aeiou', 'AA*')  #=> "hAll*"
+ *
+ * Both strings may use the c1-c2 notation to denote ranges of characters,
+ * and from_str may start with a ^, which denotes all characters except
+ * those listed.
+ *
+ *  "hello".tr('a-y', 'b-z')    #=> "ifmmp"
+ *  "hello".tr('^aeiou', '*')   #=> "*e**o"
+ *
+ * The backslash character \ can be used to escape ^ or - and is otherwise
+ * ignored unless it appears at the end of a range or the end of the
+ * from_str or to_str:
+ *
+ *
+ *  "hello^world".tr("\\^aeiou", "*") #=> "h*ll**w*rld"
+ *  "hello-world".tr("a\\-eo", "*")   #=> "h*ll**w*rld"
+ *
+ *  "hello\r\nworld".tr("\r", "")   #=> "hello\nworld"
+ *  "hello\r\nworld".tr("\\r", "")  #=> "hello\r\nwold"
+ *  "hello\r\nworld".tr("\\\r", "") #=> "hello\nworld"
+ *
+ *  "X['\\b']".tr("X\\", "")   #=> "['b']"
+ *  "X['\\b']".tr("X-\\]", "") #=> "'b'"
+ *
+ *  Note: conversion is effective only in ASCII region.
+ */
+static mrb_value
+mrb_str_tr(mrb_state *mrb, mrb_value str)
+{
+  mrb_value dup;
+  mrb_value p1, p2;
+  mrb_get_args(mrb, "SS", &p1, &p2);
+  dup = mrb_str_dup(mrb, str);
+  str_tr(mrb, dup, p1, p2, FALSE);
+  return dup;
+}
+/*
+ * call-seq:
+ *   str.tr!(from_str, to_str)   -> str or nil
+ *
+ * Translates str in place, using the same rules as String#tr.
+ * Returns str, or nil if no changes were made.
+ */
+static mrb_value
+mrb_str_tr_bang(mrb_state *mrb, mrb_value str)
+{
+  mrb_value p1, p2;
+  mrb_get_args(mrb, "SS", &p1, &p2);
+  if (str_tr(mrb, str, p1, p2, FALSE)) {
+    return str;
+  }
+  return mrb_nil_value();
+}
+/*
+ * call-seq:
+ *   str.tr_s(from_str, to_str)   -> new_str
+ *
+ * Processes a copy of str as described under String#tr, then removes
+ * duplicate characters in regions that were affected by the translation.
+ *
+ *  "hello".tr_s('l', 'r')     #=> "hero"
+ *  "hello".tr_s('el', '*')    #=> "h*o"
+ *  "hello".tr_s('el', 'hx')   #=> "hhxo"
+ */
+static mrb_value
+mrb_str_tr_s(mrb_state *mrb, mrb_value str)
+{
+  mrb_value dup;
+  mrb_value p1, p2;
+  mrb_get_args(mrb, "SS", &p1, &p2);
+  dup = mrb_str_dup(mrb, str);
+  str_tr(mrb, dup, p1, p2, TRUE);
+  return dup;
+}
+/*
+ * call-seq:
+ *   str.tr_s!(from_str, to_str)   -> str or nil
+ *
+ * Performs String#tr_s processing on str in place, returning
+ * str, or nil if no changes were made.
+ */
+static mrb_value
+mrb_str_tr_s_bang(mrb_state *mrb, mrb_value str)
+{
+  mrb_value p1, p2;
+  mrb_get_args(mrb, "SS", &p1, &p2);
+  if (str_tr(mrb, str, p1, p2, TRUE)) {
+    return str;
+  }
+  return mrb_nil_value();
+}
+static mrb_bool
+str_squeeze(mrb_state *mrb, mrb_value str, mrb_value v_pat)
+{
+  struct tr_pattern pat_storage = STATIC_TR_PATTERN;
+  struct tr_pattern *pat = NULL;
+  mrb_int i, j;
+  char *s;
+  mrb_int len;
+  mrb_bool flag_changed = FALSE;
+  mrb_int lastch = -1;
+  uint8_t bitmap[32];
+  mrb_str_modify(mrb, mrb_str_ptr(str));
+  if (!mrb_nil_p(v_pat)) {
+    pat = tr_parse_pattern(mrb, &pat_storage, v_pat, TRUE);
+    tr_compile_pattern(pat, v_pat, bitmap);
+    tr_free_pattern(mrb, pat);
+  }
+  s = RSTRING_PTR(str);
+  len = RSTRING_LEN(str);
+  if (pat) {
+    for (i=j=0; i<len; i++,j++) {
+      if (i>j) s[j] = s[i];
+      if (tr_bitmap_detect(bitmap, s[i]) && s[i] == lastch) {
+        flag_changed = TRUE;
+        j--;
+      }
+      lastch = s[i];
+    }
+  }
+  else {
+    for (i=j=0; i<len; i++,j++) {
+      if (i>j) s[j] = s[i];
+      if (s[i] >= 0 && s[i] == lastch) {
+        flag_changed = TRUE;
+        j--;
+      }
+      lastch = s[i];
+    }
+  }
+  if (flag_changed) {
+    RSTR_SET_LEN(RSTRING(str), j);
+    RSTRING_PTR(str)[j] = 0;
+  }
+  return flag_changed;
+}
+/*
+ * call-seq:
+ *   str.squeeze([other_str])    -> new_str
+ *
+ * Builds a set of characters from the other_str
+ * parameter(s) using the procedure described for String#count. Returns a
+ * new string where runs of the same character that occur in this set are
+ * replaced by a single character. If no arguments are given, all runs of
+ * identical characters are replaced by a single character.
+ *
+ *  "yellow moon".squeeze                  #=> "yelow mon"
+ *  "  now   is  the".squeeze(" ")         #=> " now is the"
+ *  "putters shoot balls".squeeze("m-z")   #=> "puters shot balls"
+ */
+static mrb_value
+mrb_str_squeeze(mrb_state *mrb, mrb_value str)
+{
+  mrb_value pat = mrb_nil_value();
+  mrb_value dup;
+  mrb_get_args(mrb, "|S", &pat);
+  dup = mrb_str_dup(mrb, str);
+  str_squeeze(mrb, dup, pat);
+  return dup;
+}
+/*
+ * call-seq:
+ *   str.squeeze!([other_str])   -> str or nil
+ *
+ * Squeezes str in place, returning either str, or nil if no
+ * changes were made.
+ */
+static mrb_value
+mrb_str_squeeze_bang(mrb_state *mrb, mrb_value str)
+{
+  mrb_value pat = mrb_nil_value();
+  mrb_get_args(mrb, "|S", &pat);
+  if (str_squeeze(mrb, str, pat)) {
+    return str;
+  }
+  return mrb_nil_value();
+}
+static mrb_bool
+str_delete(mrb_state *mrb, mrb_value str, mrb_value v_pat)
+{
+  struct tr_pattern pat = STATIC_TR_PATTERN;
+  mrb_int i, j;
+  char *s;
+  mrb_int len;
+  mrb_bool flag_changed = FALSE;
+  uint8_t bitmap[32];
+  mrb_str_modify(mrb, mrb_str_ptr(str));
+  tr_parse_pattern(mrb, &pat, v_pat, TRUE);
+  tr_compile_pattern(&pat, v_pat, bitmap);
+  tr_free_pattern(mrb, &pat);
+  s = RSTRING_PTR(str);
+  len = RSTRING_LEN(str);
+  for (i=j=0; i<len; i++,j++) {
+    if (i>j) s[j] = s[i];
+    if (tr_bitmap_detect(bitmap, s[i])) {
+      flag_changed = TRUE;
+      j--;
+    }
+  }
+  if (flag_changed) {
+    RSTR_SET_LEN(RSTRING(str), j);
+    RSTRING_PTR(str)[j] = 0;
+  }
+  return flag_changed;
+}
+static mrb_value
+mrb_str_delete(mrb_state *mrb, mrb_value str)
+{
+  mrb_value pat;
+  mrb_value dup;
+  mrb_get_args(mrb, "S", &pat);
+  dup = mrb_str_dup(mrb, str);
+  str_delete(mrb, dup, pat);
+  return dup;
+}
+static mrb_value
+mrb_str_delete_bang(mrb_state *mrb, mrb_value str)
+{
+  mrb_value pat;
+  mrb_get_args(mrb, "S", &pat);
+  if (str_delete(mrb, str, pat)) {
+    return str;
+  }
+  return mrb_nil_value();
+}
+/*
+ * call_seq:
+ *   str.count([other_str])   -> integer
+ *
+ * Each other_str parameter defines a set of characters to count.  The
+ * intersection of these sets defines the characters to count in str.  Any
+ * other_str that starts with a caret ^ is negated.  The sequence c1-c2
+ * means all characters between c1 and c2.  The backslash character \ can
+ * be used to escape ^ or - and is otherwise ignored unless it appears at
+ * the end of a sequence or the end of a other_str.
+ */
+static mrb_value
+mrb_str_count(mrb_state *mrb, mrb_value str)
+{
+  mrb_value v_pat = mrb_nil_value();
+  mrb_int i;
+  char *s;
+  mrb_int len;
+  mrb_int count = 0;
+  struct tr_pattern pat = STATIC_TR_PATTERN;
+  uint8_t bitmap[32];
+  mrb_get_args(mrb, "S", &v_pat);
+  tr_parse_pattern(mrb, &pat, v_pat, TRUE);
+  tr_compile_pattern(&pat, v_pat, bitmap);
+  tr_free_pattern(mrb, &pat);
+  s = RSTRING_PTR(str);
+  len = RSTRING_LEN(str);
+  for (i = 0; i < len; i++) {
+    if (tr_bitmap_detect(bitmap, s[i])) count++;
+  }
+  return mrb_fixnum_value(count);
+}
 static mrb_value
 mrb_str_hex(mrb_state *mrb, mrb_value self)
 …
+}
+static mrb_value
+mrb_fixnum_chr(mrb_state *mrb, mrb_value num)
+{
+  mrb_int cp = mrb_fixnum(num);
+/*
+ *  call-seq:
+ *     int.chr([encoding])  ->  string
+ *
+ *  Returns a string containing the character represented by the +int+'s value
+ *  according to +encoding+. +"ASCII-8BIT"+ (+"BINARY"+) and +"UTF-8"+ (only
+ *  with +MRB_UTF8_STRING+) can be specified as +encoding+ (default is
+ *  +"ASCII-8BIT"+).
+ *
+ *     65.chr                  #=> "A"
+ *     230.chr                 #=> "\xE6"
+ *     230.chr("ASCII-8BIT")   #=> "\xE6"
+ *     230.chr("UTF-8")        #=> "\u00E6"
+ */
+static mrb_value
+mrb_int_chr(mrb_state *mrb, mrb_value num)
+{
+  mrb_value enc;
+  mrb_bool enc_given;
+  mrb_get_args(mrb, "|S?", &enc, &enc_given);
+  if (!enc_given ||
+      ENC_COMP_P(enc, ENC_ASCII_8BIT) ||
+      ENC_COMP_P(enc, ENC_BINARY)) {
+    return int_chr_binary(mrb, num);
+  }
 #ifdef MRB_UTF8_STRING
+  char utf8[4];
+  mrb_int len;
+  if (cp < 0 || 0x10FFFF < cp) {
+    mrb_raisef(mrb, E_RANGE_ERROR, "%S out of char range", num);
+  }
+  if (cp < 0x80) {
+    utf8[0] = (char)cp;
+    len = 1;
+  }
+  else if (cp < 0x800) {
+    utf8[0] = (char)(0xC0 | (cp >> 6));
+    utf8[1] = (char)(0x80 | (cp & 0x3F));
+    len = 2;
+  }
+  else if (cp < 0x10000) {
+    utf8[0] = (char)(0xE0 |  (cp >> 12));
+    utf8[1] = (char)(0x80 | ((cp >>  6) & 0x3F));
+    utf8[2] = (char)(0x80 | ( cp        & 0x3F));
+    len = 3;
+  }
+  else if (ENC_COMP_P(enc, ENC_UTF8)) {
+    return int_chr_utf8(mrb, num);
+  }
+#endif
   else {
+    utf8[0] = (char)(0xF0 |  (cp >> 18));
+    utf8[1] = (char)(0x80 | ((cp >> 12) & 0x3F));
+    utf8[2] = (char)(0x80 | ((cp >>  6) & 0x3F));
+    utf8[3] = (char)(0x80 | ( cp        & 0x3F));
+    len = 4;
+  }
+  return mrb_str_new(mrb, utf8, len);
+#else
+  char c;
+  if (cp < 0 || 0xff < cp) {
+    mrb_raisef(mrb, E_RANGE_ERROR, "%S out of char range", num);
+  }
+  c = (char)cp;
+  return mrb_str_new(mrb, &c, 1);
+#endif
+}
+/*
+ *  call-seq:
+ *     string.lines    ->  array of string
+ *
+ *  Returns strings per line;
+ *
+ *     a = "abc\ndef"
+ *     a.lines    #=> ["abc\n", "def"]
+ */
+static mrb_value
+mrb_str_lines(mrb_state *mrb, mrb_value self)
+{
+  mrb_value result;
+  mrb_value blk;
+  int ai;
+  mrb_int len;
+  mrb_value arg;
+  char *b = RSTRING_PTR(self);
+  char *p = b, *t;
+  char *e = b + RSTRING_LEN(self);
+  mrb_get_args(mrb, "&", &blk);
+  result = mrb_ary_new(mrb);
+  ai = mrb_gc_arena_save(mrb);
+  if (!mrb_nil_p(blk)) {
+    while (p < e) {
+      t = p;
+      while (p < e && *p != '\n') p++;
+      if (*p == '\n') p++;
+      len = (mrb_int) (p - t);
+      arg = mrb_str_new(mrb, t, len);
+      mrb_yield_argv(mrb, blk, 1, &arg);
+      mrb_gc_arena_restore(mrb, ai);
+      if (b != RSTRING_PTR(self)) {
+        ptrdiff_t diff = p - b;
+        b = RSTRING_PTR(self);
+        p = b + diff;
+      }
+      e = b + RSTRING_LEN(self);
+    }
+    return self;
+  }
+  while (p < e) {
+    t = p;
+    while (p < e && *p != '\n') p++;
+    if (*p == '\n') p++;
+    len = (mrb_int) (p - t);
+    mrb_ary_push(mrb, result, mrb_str_new(mrb, t, len));
+    mrb_gc_arena_restore(mrb, ai);
+  }
+  return result;
+    mrb_raisef(mrb, E_ARGUMENT_ERROR, "unknown encoding name - %v", enc);
+  }
+  /* not reached */
+  return mrb_nil_value();
+}
 …
 #endif
-static mrb_bool
-all_digits_p(const char *s, mrb_int len)
+{
-  while (len-- > 0) {
-    if (!ISDIGIT(*s)) return FALSE;
-    s++;
+  }
-  return TRUE;
+}
 /*
  *  call-seq:
+ *     str.upto(other_str, exclusive=false) {|s| block }   -> str
+ *     str.upto(other_str, exclusive=false)                -> an_enumerator
+ *
+ *  Iterates through successive values, starting at <i>str</i> and
+ *  ending at <i>other_str</i> inclusive, passing each value in turn to
+ *  the block. The <code>String#succ</code> method is used to generate
+ *  each value.  If optional second argument exclusive is omitted or is false,
+ *  the last value will be included; otherwise it will be excluded.
+ *
+ *  If no block is given, an enumerator is returned instead.
+ *
+ *     "a8".upto("b6") {|s| print s, ' ' }
+ *     for s in "a8".."b6"
+ *       print s, ' '
+ *     end
+ *
+ *  <em>produces:</em>
+ *
+ *     a8 a9 b0 b1 b2 b3 b4 b5 b6
+ *     a8 a9 b0 b1 b2 b3 b4 b5 b6
+ *
+ *  If <i>str</i> and <i>other_str</i> contains only ascii numeric characters,
+ *  both are recognized as decimal numbers. In addition, the width of
+ *  string (e.g. leading zeros) is handled appropriately.
+ *
+ *     "9".upto("11").to_a   #=> ["9", "10", "11"]
+ *     "25".upto("5").to_a   #=> []
+ *     "07".upto("11").to_a  #=> ["07", "08", "09", "10", "11"]
+ */
+static mrb_value
+mrb_str_upto(mrb_state *mrb, mrb_value beg)
+{
+  mrb_value end;
+  mrb_value exclusive = mrb_false_value();
+  mrb_value block = mrb_nil_value();
+  mrb_value current, after_end;
+  mrb_int n;
+  mrb_bool excl;
+  mrb_get_args(mrb, "o|o&", &end, &exclusive, &block);
+  if (mrb_nil_p(block)) {
+    return mrb_funcall(mrb, beg, "to_enum", 3, mrb_symbol_value(mrb_intern_lit(mrb, "upto")), end, exclusive);
+  }
+  end = mrb_string_type(mrb, end);
+  excl = mrb_test(exclusive);
+  /* single character */
+  if (RSTRING_LEN(beg) == 1 && RSTRING_LEN(end) == 1 &&
+  ISASCII(RSTRING_PTR(beg)[0]) && ISASCII(RSTRING_PTR(end)[0])) {
+    char c = RSTRING_PTR(beg)[0];
+    char e = RSTRING_PTR(end)[0];
+    int ai = mrb_gc_arena_save(mrb);
+    if (c > e || (excl && c == e)) return beg;
+    for (;;) {
+      mrb_yield(mrb, block, mrb_str_new(mrb, &c, 1));
+      mrb_gc_arena_restore(mrb, ai);
+      if (!excl && c == e) break;
+      c++;
+      if (excl && c == e) break;
+    }
+    return beg;
+  }
+  /* both edges are all digits */
+  if (ISDIGIT(RSTRING_PTR(beg)[0]) && ISDIGIT(RSTRING_PTR(end)[0]) &&
+      all_digits_p(RSTRING_PTR(beg), RSTRING_LEN(beg)) &&
+      all_digits_p(RSTRING_PTR(end), RSTRING_LEN(end))) {
+    int ai = mrb_gc_arena_save(mrb);
+    mrb_int min_width = RSTRING_LEN(beg);
+    mrb_int max_width = RSTRING_LEN(end);
+    mrb_int bi = mrb_int(mrb, mrb_str_to_inum(mrb, beg, 10, FALSE));
+    mrb_int ei = mrb_int(mrb, mrb_str_to_inum(mrb, end, 10, FALSE));
+    mrb_value str = mrb_str_new(mrb, NULL, max_width);
+    char *buf = RSTRING_PTR(str);
+    while (bi <= ei) {
+      if (excl && bi == ei) break;
+      snprintf(buf, max_width+1, "%.*" MRB_PRId, (int)min_width, bi);
+      mrb_yield(mrb, block, mrb_str_new(mrb, buf, strlen(buf)));
+      mrb_gc_arena_restore(mrb, ai);
+      bi++;
+    }
+    return beg;
+  }
+  /* normal case */
+  n = mrb_int(mrb, mrb_funcall(mrb, beg, "<=>", 1, end));
+  if (n > 0 || (excl && n == 0)) return beg;
+  after_end = mrb_funcall(mrb, end, "succ", 0);
+  current = mrb_str_dup(mrb, beg);
+  while (!mrb_str_equal(mrb, current, after_end)) {
+    int ai = mrb_gc_arena_save(mrb);
+    mrb_value next = mrb_nil_value();
+    if (excl || !mrb_str_equal(mrb, current, end))
+      next = mrb_funcall(mrb, current, "succ", 0);
+    mrb_yield(mrb, block, current);
+    if (mrb_nil_p(next)) break;
+    current = mrb_str_to_str(mrb, next);
+    if (excl && mrb_str_equal(mrb, current, end)) break;
+    if (RSTRING_LEN(current) > RSTRING_LEN(end) || RSTRING_LEN(current) == 0)
+      break;
+ *     str.delete_prefix!(prefix) -> self or nil
+ *
+ *  Deletes leading <code>prefix</code> from <i>str</i>, returning
+ *  <code>nil</code> if no change was made.
+ *
+ *     "hello".delete_prefix!("hel") #=> "lo"
+ *     "hello".delete_prefix!("llo") #=> nil
+ */
+static mrb_value
+mrb_str_del_prefix_bang(mrb_state *mrb, mrb_value self)
+{
+  mrb_int plen, slen;
+  char *ptr, *s;
+  struct RString *str = RSTRING(self);
+  mrb_get_args(mrb, "s", &ptr, &plen);
+  slen = RSTR_LEN(str);
+  if (plen > slen) return mrb_nil_value();
+  s = RSTR_PTR(str);
+  if (memcmp(s, ptr, plen) != 0) return mrb_nil_value();
+  if (!mrb_frozen_p(str) && (RSTR_SHARED_P(str) || RSTR_FSHARED_P(str))) {
+    str->as.heap.ptr += plen;
+  }
+  else {
+    mrb_str_modify(mrb, str);
+    s = RSTR_PTR(str);
+    memmove(s, s+plen, slen-plen);
+  }
+  RSTR_SET_LEN(str, slen-plen);
+  return self;
+}
+/*
+ *  call-seq:
+ *     str.delete_prefix(prefix) -> new_str
+ *
+ *  Returns a copy of <i>str</i> with leading <code>prefix</code> deleted.
+ *
+ *     "hello".delete_prefix("hel") #=> "lo"
+ *     "hello".delete_prefix("llo") #=> "hello"
+ */
+static mrb_value
+mrb_str_del_prefix(mrb_state *mrb, mrb_value self)
+{
+  mrb_int plen, slen;
+  char *ptr;
+  mrb_get_args(mrb, "s", &ptr, &plen);
+  slen = RSTRING_LEN(self);
+  if (plen > slen) return mrb_str_dup(mrb, self);
+  if (memcmp(RSTRING_PTR(self), ptr, plen) != 0)
+    return mrb_str_dup(mrb, self);
+  return mrb_str_substr(mrb, self, plen, slen-plen);
+}
+/*
+ *  call-seq:
+ *     str.delete_suffix!(suffix) -> self or nil
+ *
+ *  Deletes trailing <code>suffix</code> from <i>str</i>, returning
+ *  <code>nil</code> if no change was made.
+ *
+ *     "hello".delete_suffix!("llo") #=> "he"
+ *     "hello".delete_suffix!("hel") #=> nil
+ */
+static mrb_value
+mrb_str_del_suffix_bang(mrb_state *mrb, mrb_value self)
+{
+  mrb_int plen, slen;
+  char *ptr, *s;
+  struct RString *str = RSTRING(self);
+  mrb_get_args(mrb, "s", &ptr, &plen);
+  slen = RSTR_LEN(str);
+  if (plen > slen) return mrb_nil_value();
+  s = RSTR_PTR(str);
+  if (memcmp(s+slen-plen, ptr, plen) != 0) return mrb_nil_value();
+  if (!mrb_frozen_p(str) && (RSTR_SHARED_P(str) || RSTR_FSHARED_P(str))) {
+    /* no need to modify string */
+  }
+  else {
+    mrb_str_modify(mrb, str);
+  }
+  RSTR_SET_LEN(str, slen-plen);
+  return self;
+}
+/*
+ *  call-seq:
+ *     str.delete_suffix(suffix) -> new_str
+ *
+ *  Returns a copy of <i>str</i> with leading <code>suffix</code> deleted.
+ *
+ *     "hello".delete_suffix("hel") #=> "lo"
+ *     "hello".delete_suffix("llo") #=> "hello"
+ */
+static mrb_value
+mrb_str_del_suffix(mrb_state *mrb, mrb_value self)
+{
+  mrb_int plen, slen;
+  char *ptr;
+  mrb_get_args(mrb, "s", &ptr, &plen);
+  slen = RSTRING_LEN(self);
+  if (plen > slen) return mrb_str_dup(mrb, self);
+  if (memcmp(RSTRING_PTR(self)+slen-plen, ptr, plen) != 0)
+    return mrb_str_dup(mrb, self);
+  return mrb_str_substr(mrb, self, 0, slen-plen);
+}
+static mrb_value
+mrb_str_lines(mrb_state *mrb, mrb_value self)
+{
+  mrb_value result;
+  int ai;
+  mrb_int len;
+  char *b = RSTRING_PTR(self);
+  char *p = b, *t;
+  char *e = b + RSTRING_LEN(self);
+  result = mrb_ary_new(mrb);
+  ai = mrb_gc_arena_save(mrb);
+  while (p < e) {
+    t = p;
+    while (p < e && *p != '\n') p++;
+    if (*p == '\n') p++;
+    len = (mrb_int) (p - t);
+    mrb_ary_push(mrb, result, mrb_str_new(mrb, t, len));
     mrb_gc_arena_restore(mrb, ai);
+  }
+  return beg;
+  return result;
+}
 …
   mrb_define_method(mrb, s, "dump",            mrb_str_dump,            MRB_ARGS_NONE());
-  mrb_define_method(mrb, s, "getbyte",         mrb_str_getbyte,         MRB_ARGS_REQ(1));
-  mrb_define_method(mrb, s, "setbyte",         mrb_str_setbyte,         MRB_ARGS_REQ(2));
-  mrb_define_method(mrb, s, "byteslice",       mrb_str_byteslice,       MRB_ARGS_REQ(1)|MRB_ARGS_OPT(1));
   mrb_define_method(mrb, s, "swapcase!",       mrb_str_swapcase_bang,   MRB_ARGS_NONE());
   mrb_define_method(mrb, s, "swapcase",        mrb_str_swapcase,        MRB_ARGS_NONE());
+  mrb_define_method(mrb, s, "concat",          mrb_str_concat2,         MRB_ARGS_REQ(1));
+  mrb_define_method(mrb, s, "<<",              mrb_str_concat2,         MRB_ARGS_REQ(1));
+  mrb_define_method(mrb, s, "concat",          mrb_str_concat_m,        MRB_ARGS_REQ(1));
+  mrb_define_method(mrb, s, "<<",              mrb_str_concat_m,        MRB_ARGS_REQ(1));
+  mrb_define_method(mrb, s, "count",           mrb_str_count,           MRB_ARGS_REQ(1));
+  mrb_define_method(mrb, s, "tr",              mrb_str_tr,              MRB_ARGS_REQ(2));
+  mrb_define_method(mrb, s, "tr!",             mrb_str_tr_bang,         MRB_ARGS_REQ(2));
+  mrb_define_method(mrb, s, "tr_s",            mrb_str_tr_s,            MRB_ARGS_REQ(2));
+  mrb_define_method(mrb, s, "tr_s!",           mrb_str_tr_s_bang,       MRB_ARGS_REQ(2));
+  mrb_define_method(mrb, s, "squeeze",         mrb_str_squeeze,         MRB_ARGS_OPT(1));
+  mrb_define_method(mrb, s, "squeeze!",        mrb_str_squeeze_bang,    MRB_ARGS_OPT(1));
+  mrb_define_method(mrb, s, "delete",          mrb_str_delete,          MRB_ARGS_REQ(1));
+  mrb_define_method(mrb, s, "delete!",         mrb_str_delete_bang,     MRB_ARGS_REQ(1));
   mrb_define_method(mrb, s, "start_with?",     mrb_str_start_with,      MRB_ARGS_REST());
   mrb_define_method(mrb, s, "end_with?",       mrb_str_end_with,        MRB_ARGS_REST());
 …
   mrb_define_method(mrb, s, "oct",             mrb_str_oct,             MRB_ARGS_NONE());
   mrb_define_method(mrb, s, "chr",             mrb_str_chr,             MRB_ARGS_NONE());
-  mrb_define_method(mrb, s, "lines",           mrb_str_lines,           MRB_ARGS_NONE());
   mrb_define_method(mrb, s, "succ",            mrb_str_succ,            MRB_ARGS_NONE());
   mrb_define_method(mrb, s, "succ!",           mrb_str_succ_bang,       MRB_ARGS_NONE());
+  mrb_alias_method(mrb, s, mrb_intern_lit(mrb, "next"), mrb_intern_lit(mrb, "succ"));
+  mrb_alias_method(mrb, s, mrb_intern_lit(mrb, "next!"), mrb_intern_lit(mrb, "succ!"));
+  mrb_define_method(mrb, s, "ord", mrb_str_ord, MRB_ARGS_NONE());
+  mrb_define_method(mrb, s, "upto", mrb_str_upto, MRB_ARGS_ANY());
+  mrb_define_method(mrb, mrb->fixnum_class, "chr", mrb_fixnum_chr, MRB_ARGS_NONE());
+  mrb_define_method(mrb, s, "next",            mrb_str_succ,            MRB_ARGS_NONE());
+  mrb_define_method(mrb, s, "next!",           mrb_str_succ_bang,       MRB_ARGS_NONE());
+  mrb_define_method(mrb, s, "ord",             mrb_str_ord,             MRB_ARGS_NONE());
+  mrb_define_method(mrb, s, "delete_prefix!",  mrb_str_del_prefix_bang, MRB_ARGS_REQ(1));
+  mrb_define_method(mrb, s, "delete_prefix",   mrb_str_del_prefix,      MRB_ARGS_REQ(1));
+  mrb_define_method(mrb, s, "delete_suffix!",  mrb_str_del_suffix_bang, MRB_ARGS_REQ(1));
+  mrb_define_method(mrb, s, "delete_suffix",   mrb_str_del_suffix,      MRB_ARGS_REQ(1));
+  mrb_define_method(mrb, s, "__lines",         mrb_str_lines,           MRB_ARGS_NONE());
+  mrb_define_method(mrb, mrb_module_get(mrb, "Integral"), "chr", mrb_int_chr, MRB_ARGS_OPT(1));
+}

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-string-ext/test/string.rb

-              r331
+              r439
+# coding: utf-8
 ##
 # String(Ext) Test
+UTF8STRING = ("\343\201\202".size == 1)
+assert('String.try_convert') do
+  assert_nil String.try_convert(nil)
+  assert_nil String.try_convert(:foo)
+  assert_equal "", String.try_convert("")
+  assert_equal "1,2,3", String.try_convert("1,2,3")
+end
+assert('String#getbyte') do
+  str1 = "hello"
+  bytes1 = [104, 101, 108, 108, 111]
+  assert_equal bytes1[0], str1.getbyte(0)
+  assert_equal bytes1[-1], str1.getbyte(-1)
+  assert_equal bytes1[6], str1.getbyte(6)
+  str2 = "\xFF"
+  bytes2 = [0xFF]
+  assert_equal bytes2[0], str2.getbyte(0)
+end
+assert('String#setbyte') do
+  str1 = "hello"
+  h = "H".getbyte(0)
+  str1.setbyte(0, h)
+  assert_equal(h, str1.getbyte(0))
+  assert_equal("Hello", str1)
+end
+assert("String#setbyte raises IndexError if arg conversion resizes String") do
+  $s = "01234\n"
+  class Tmp
+      def to_i
+          $s.chomp! ''
+      end
+  end
+  tmp = Tmp.new
+  assert_raise(IndexError) { $s.setbyte(5, tmp) }
+end
+assert('String#byteslice') do
+  str1 = "hello"
+  assert_equal("e", str1.byteslice(1))
+  assert_equal("o", str1.byteslice(-1))
+  assert_equal("ell", str1.byteslice(1..3))
+  assert_equal("el", str1.byteslice(1...3))
+UTF8STRING = __ENCODING__ == "UTF-8"
+def assert_upto(exp, receiver, *args)
+  act = []
+  receiver.upto(*args) { |v| act << v }
+  assert_equal exp, act
 end
 assert('String#dump') do
+  ("\1" * 100).dump     # should not raise an exception - regress #1210
+  "\0".inspect == "\"\\000\"" and
+  "foo".dump == "\"foo\""
+  assert_equal("\"\\x00\"", "\0".dump)
+  assert_equal("\"foo\"", "foo".dump)
+  assert_equal('"\xe3\x82\x8b"', "る".dump)
+  assert_nothing_raised { ("\1" * 100).dump }   # regress #1210
 end
 assert('String#strip') do
   s = "  abc  "
+  "".strip == "" and " \t\r\n\f\v".strip == "" and
+  "\0a\0".strip == "\0a" and
+  "abc".strip     == "abc" and
+  "  abc".strip   == "abc" and
+  "abc  ".strip   == "abc" and
+  "  abc  ".strip == "abc" and
+  s == "  abc  "
+  assert_equal("abc", s.strip)
+  assert_equal("  abc  ", s)
+  assert_equal("", "".strip)
+  assert_equal("", " \t\r\n\f\v".strip)
+  assert_equal("\0a", "\0a\0".strip)
+  assert_equal("abc", "abc".strip)
+  assert_equal("abc", "  abc".strip)
+  assert_equal("abc", "abc  ".strip)
 end
 assert('String#lstrip') do
   s = "  abc  "
   s.lstrip
   "".lstrip == "" and " \t\r\n\f\v".lstrip == "" and
   "\0a\0".lstrip == "\0a\0" and
   "abc".lstrip     == "abc"   and
   "  abc".lstrip   == "abc"   and
   "abc  ".lstrip   == "abc  " and
   "  abc  ".lstrip == "abc  " and
   s == "  abc  "
+  assert_equal("abc  ", s.lstrip)
+  assert_equal("  abc  ", s)
+  assert_equal("", "".lstrip)
+  assert_equal("", " \t\r\n\f\v".lstrip)
+  assert_equal("\0a\0", "\0a\0".lstrip)
+  assert_equal("abc", "abc".lstrip)
+  assert_equal("abc", "  abc".lstrip)
+  assert_equal("abc  ", "abc  ".lstrip)
 end
 assert('String#rstrip') do
   s = "  abc  "
   s.rstrip
   "".rstrip == "" and " \t\r\n\f\v".rstrip == "" and
   "\0a\0".rstrip == "\0a" and
   "abc".rstrip     == "abc"   and
   "  abc".rstrip   == "  abc" and
   "abc  ".rstrip   == "abc"   and
   "  abc  ".rstrip == "  abc" and
   s == "  abc  "
+  assert_equal("  abc", s.rstrip)
+  assert_equal("  abc  ", s)
+  assert_equal("", "".rstrip)
+  assert_equal("", " \t\r\n\f\v".rstrip)
+  assert_equal("\0a", "\0a\0".rstrip)
+  assert_equal("abc", "abc".rstrip)
+  assert_equal("  abc", "  abc".rstrip)
+  assert_equal("abc", "abc  ".rstrip)
 end
 …
   s = "  abc  "
   t = "abc"
+  s.strip! == "abc" and s == "abc" and t.strip! == nil
+  assert_equal("abc", s.strip!)
+  assert_equal("abc", s)
+  assert_nil(t.strip!)
+  assert_equal("abc", t)
 end
 …
   s = "  abc  "
   t = "abc  "
+  s.lstrip! == "abc  " and s == "abc  " and t.lstrip! == nil
+  assert_equal("abc  ", s.lstrip!)
+  assert_equal("abc  ", s)
+  assert_nil(t.lstrip!)
+  assert_equal("abc  ", t)
 end
 …
   s = "  abc  "
   t = "  abc"
+  s.rstrip! == "  abc" and s == "  abc" and t.rstrip! == nil
+  assert_equal("  abc", s.rstrip!)
+  assert_equal("  abc", s)
+  assert_nil(t.rstrip!)
+  assert_equal("  abc", t)
 end
 …
   assert_equal "Hello World!", "Hello " << "World" << 33
   assert_equal "Hello World!", "Hello ".concat("World").concat(33)
-  o = Object.new
-  def o.to_str
-    "to_str"
-  end
-  assert_equal "hi to_str", "hi " << o
   assert_raise(TypeError) { "".concat(Object.new) }
+  if UTF8STRING
+    assert_equal "H«", "H" << 0xab
+    assert_equal "Hは", "H" << 12399
+  else
+    assert_equal "H\xab", "H" << 0xab
+    assert_raise(RangeError) { "H" << 12399 }
+  end
 end
 …
   assert_equal(-1, "abcdef".casecmp("abcdefg"))
   assert_equal 0, "abcdef".casecmp("ABCDEF")
+  o = Object.new
+  def o.to_str
+    "ABCDEF"
+  end
+  assert_equal 0, "abcdef".casecmp(o)
+end
+assert('String#count') do
+  s = "abccdeff123"
+  assert_equal 0, s.count("")
+  assert_equal 1, s.count("a")
+  assert_equal 2, s.count("ab")
+  assert_equal 9, s.count("^c")
+  assert_equal 8, s.count("a-z")
+  assert_equal 4, s.count("a0-9")
+end
+assert('String#tr') do
+  assert_equal "ABC", "abc".tr('a-z', 'A-Z')
+  assert_equal "hippo", "hello".tr('el', 'ip')
+  assert_equal "Ruby", "Lisp".tr("Lisp", "Ruby")
+  assert_equal "*e**o", "hello".tr('^aeiou', '*')
+  assert_equal "heo", "hello".tr('l', '')
+end
+assert('String#tr!') do
+  s = "abcdefghijklmnopqR"
+  assert_equal "ab12222hijklmnopqR", s.tr!("cdefg", "12")
+  assert_equal "ab12222hijklmnopqR", s
+end
+assert('String#tr_s') do
+  assert_equal "hero", "hello".tr_s('l', 'r')
+  assert_equal "h*o", "hello".tr_s('el', '*')
+  assert_equal "hhxo", "hello".tr_s('el', 'hx')
+end
+assert('String#tr_s!') do
+  s = "hello"
+  assert_equal "hero", s.tr_s!('l', 'r')
+  assert_equal "hero", s
+  assert_nil s.tr_s!('l', 'r')
+end
+assert('String#squeeze') do
+  assert_equal "yelow mon", "yellow moon".squeeze
+  assert_equal " now is the", "  now   is  the".squeeze(" ")
+  assert_equal "puters shot balls", "putters shoot balls".squeeze("m-z")
+end
+assert('String#squeeze!') do
+  s = "  now   is  the"
+  assert_equal " now is the", s.squeeze!(" ")
+  assert_equal " now is the", s
+end
+assert('String#delete') do
+  assert_equal "he", "hello".delete("lo")
+  assert_equal "hll", "hello".delete("aeiou")
+  assert_equal "ll", "hello".delete("^l")
+  assert_equal "ho", "hello".delete("ej-m")
+end
+assert('String#delete!') do
+  s = "hello"
+  assert_equal "he", s.delete!("lo")
+  assert_equal "he", s
+  assert_nil s.delete!("lz")
 end
 …
   assert_equal 8, "010".oct
   assert_equal (-8), "-10".oct
-end
-assert('String#chr') do
-  assert_equal "a", "abcde".chr
-  # test Fixnum#chr as well
-  assert_equal "a", 97.chr
 end
 …
 assert('String#upto') do
+  assert_equal %w(a8 a9 b0 b1 b2 b3 b4 b5 b6), "a8".upto("b6").to_a
+  assert_equal ["9", "10", "11"], "9".upto("11").to_a
+  assert_equal [], "25".upto("5").to_a
+  assert_equal ["07", "08", "09", "10", "11"], "07".upto("11").to_a
+if UTF8STRING
+  assert_equal ["あ", "ぃ", "い", "ぅ", "う", "ぇ", "え", "ぉ", "お"], "あ".upto("お").to_a
+end
+  assert_equal ["9", ":", ";", "<", "=", ">", "?", "@", "A"], "9".upto("A").to_a
+  assert_upto %w(a8 a9 b0 b1 b2 b3 b4 b5 b6), "a8", "b6"
+  assert_upto ["9", "10", "11"], "9", "11"
+  assert_upto [], "25", "5"
+  assert_upto ["07", "08", "09", "10", "11"], "07", "11"
+  assert_upto ["9", ":", ";", "<", "=", ">", "?", "@", "A"], "9", "A"
+  if UTF8STRING
+    assert_upto %w(あ ぃ い ぅ う ぇ え ぉ お), "あ", "お"
+  end
   a     = "aa"
 …
 assert('String#chr') do
+  assert_equal "a", "abcde".chr
   assert_equal "h", "hello!".chr
+end
+  assert_equal "", "".chr
+end
 assert('String#chr(UTF-8)') do
   assert_equal "こ", "こんにちは世界!".chr
 …
 assert('String#each_char') do
   s = ""
+  chars = []
   "hello!".each_char do |x|
     s += x
   end
   assert_equal "hello!", s
+    chars << x
+  end
+  assert_equal ["h", "e", "l", "l", "o", "!"], chars
 end
 assert('String#each_char(UTF-8)') do
   s = ""
+  chars = []
   "こんにちは世界!".each_char do |x|
     s += x
   end
   assert_equal "こんにちは世界!", s
+    chars << x
+  end
+  assert_equal ["こ", "ん", "に", "ち", "は", "世", "界", "!"], chars
 end if UTF8STRING
 …
   assert_equal expect, cp
 end if UTF8STRING
+assert('String#delete_prefix') do
+  assert_equal "llo", "hello".delete_prefix("he")
+  assert_equal "hello", "hello".delete_prefix("llo")
+  assert_equal "llo", "hello".delete_prefix!("he")
+  assert_nil "hello".delete_prefix!("llo")
+end
+assert('String#delete_suffix') do
+  assert_equal "he", "hello".delete_suffix("llo")
+  assert_equal "hello", "hello".delete_suffix("he")
+  assert_equal "he", "hello".delete_suffix!("llo")
+  assert_nil "hello".delete_suffix!("he")
+end

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-struct/mrblib/struct.rb

-              r331
+              r439
     end
+    def _inspect
+    def _inspect(recur_list)
+      return "#<struct #{self.class}:...>" if recur_list[self.object_id]
+      recur_list[self.object_id] = true
       name = self.class.to_s
       if name[0] == "#"
 …
       buf = []
       self.each_pair do |k,v|
         buf.push [k.to_s + "=" + v._inspect]
+        buf.push k.to_s + "=" + v._inspect(recur_list)
       end
       str + buf.join(", ") + ">"
 …
+    #
     def inspect
+      begin
+        self._inspect
+      rescue SystemStackError
+        "#<struct #{self.class.to_s}:...>"
+      end
+      self._inspect({})
     end
 …
+    #
     alias to_s inspect
-  end
+  ##
+  # call-seq:
+  #   hsh.dig(key,...)                 -> object
+  #
+  # Extracts the nested value specified by the sequence of <i>key</i>
+  # objects by calling +dig+ at each step, returning +nil+ if any
+  # intermediate step is +nil+.
+  #
+  def dig(idx,*args)
+    n = self[idx]
+    if args.size > 0
+      n&.dig(*args)
+    else
+      n
+    ##
+    # call-seq:
+    #   hsh.dig(key,...)                 -> object
+    #
+    # Extracts the nested value specified by the sequence of <i>key</i>
+    # objects by calling +dig+ at each step, returning +nil+ if any
+    # intermediate step is +nil+.
+    #
+    def dig(idx,*args)
+      n = self[idx]
+      if args.size > 0
+        n&.dig(*args)
+      else
+        n
+      end
     end
   end
 end

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-struct/src/struct.c

-              r331
+              r439
 #include <mruby/hash.h>
 #include <mruby/range.h>
+#define RSTRUCT_LEN(st) mrb_ary_ptr(st)->len
+#define RSTRUCT_PTR(st) mrb_ary_ptr(st)->ptr
+#include <mruby/proc.h>
+#define RSTRUCT_LEN(st) RARRAY_LEN(st)
+#define RSTRUCT_PTR(st) RARRAY_PTR(st)
 static struct RClass *
 …
 static inline mrb_value
 struct_ivar_get(mrb_state *mrb, mrb_value c, mrb_sym id)
+{
   struct RClass* kclass;
+struct_ivar_get(mrb_state *mrb, mrb_value cls, mrb_sym id)
+{
+  struct RClass* c = mrb_class_ptr(cls);
   struct RClass* sclass = struct_class(mrb);
   mrb_value ans;
   for (;;) {
     ans = mrb_iv_get(mrb, c, id);
+    ans = mrb_iv_get(mrb, mrb_obj_value(c), id);
     if (!mrb_nil_p(ans)) return ans;
     kclass = RCLASS_SUPER(c);
     if (kclass == 0 || kclass == sclass)
+    c = c->super;
+    if (c == sclass || c == 0)
       return mrb_nil_value();
-    c = mrb_obj_value(kclass);
+  }
+}
 …
     else {
       mrb_raisef(mrb, E_TYPE_ERROR,
                  "struct size differs (%S required %S given)",
                  mrb_fixnum_value(RARRAY_LEN(members)), mrb_fixnum_value(RSTRUCT_LEN(s)));
+                 "struct size differs (%i required %i given)",
+                 RARRAY_LEN(members), RSTRUCT_LEN(s));
+    }
+  }
 …
 mrb_struct_modify(mrb_state *mrb, mrb_value strct)
+{
+  if (MRB_FROZEN_P(mrb_basic_ptr(strct))) {
+    mrb_raise(mrb, E_RUNTIME_ERROR, "can't modify frozen struct");
+  }
+  mrb_check_frozen(mrb, mrb_basic_ptr(strct));
   mrb_write_barrier(mrb, mrb_basic_ptr(strct));
+}
 …
+}
-static mrb_value struct_aref_sym(mrb_state *mrb, mrb_value obj, mrb_sym id);
 static mrb_value
 mrb_struct_ref(mrb_state *mrb, mrb_value obj)
+{
+  return struct_aref_sym(mrb, obj, mrb->c->ci->mid);
+  mrb_int i = mrb_fixnum(mrb_proc_cfunc_env_get(mrb, 0));
+  mrb_value *ptr = RSTRUCT_PTR(obj);
+  if (!ptr) return mrb_nil_value();
+  return ptr[i];
+}
 …
 mrb_id_attrset(mrb_state *mrb, mrb_sym id)
+{
+#define ONSTACK_ALLOC_MAX 32
+#define ONSTACK_STRLEN_MAX (ONSTACK_ALLOC_MAX - 1) /* '=' character */
   const char *name;
   char *buf;
   mrb_int len;
   mrb_sym mid;
+  name = mrb_sym2name_len(mrb, id, &len);
+  buf = (char *)mrb_malloc(mrb, (size_t)len+2);
+  char onstack[ONSTACK_ALLOC_MAX];
+  name = mrb_sym_name_len(mrb, id, &len);
+  if (len > ONSTACK_STRLEN_MAX) {
+    buf = (char *)mrb_malloc(mrb, (size_t)len+1);
+  }
+  else {
+    buf = onstack;
+  }
   memcpy(buf, name, (size_t)len);
   buf[len] = '=';
-  buf[len+1] = '\0';
   mid = mrb_intern(mrb, buf, len+1);
+  mrb_free(mrb, buf);
+  if (buf != onstack) {
+    mrb_free(mrb, buf);
+  }
   return mid;
+}
-static mrb_value mrb_struct_aset_sym(mrb_state *mrb, mrb_value s, mrb_sym id, mrb_value val);
 static mrb_value
 mrb_struct_set_m(mrb_state *mrb, mrb_value obj)
+{
+  mrb_int i = mrb_fixnum(mrb_proc_cfunc_env_get(mrb, 0));
+  mrb_value *ptr;
   mrb_value val;
-  const char *name;
-  mrb_int slen;
-  mrb_sym mid;
   mrb_get_args(mrb, "o", &val);
+  /* get base id */
+  name = mrb_sym2name_len(mrb, mrb->c->ci->mid, &slen);
+  mid = mrb_intern(mrb, name, slen-1); /* omit last "=" */
+  return mrb_struct_aset_sym(mrb, obj, mid, val);
+}
+static mrb_bool
+is_local_id(mrb_state *mrb, const char *name)
+{
+  if (!name) return FALSE;
+  return !ISUPPER(name[0]);
+}
+static mrb_bool
+is_const_id(mrb_state *mrb, const char *name)
+{
+  if (!name) return FALSE;
+  return ISUPPER(name[0]);
+  mrb_struct_modify(mrb, obj);
+  ptr = RSTRUCT_PTR(obj);
+  if (ptr == NULL || i >= RSTRUCT_LEN(obj)) {
+    mrb_ary_set(mrb, obj, i, val);
+  }
+  else {
+    ptr[i] = val;
+  }
+  return val;
+}
 …
   for (i=0; i<len; i++) {
     mrb_sym id = mrb_symbol(ptr_members[i]);
+    const char *name = mrb_sym2name_len(mrb, id, NULL);
+    if (is_local_id(mrb, name) || is_const_id(mrb, name)) {
+      mrb_define_method_id(mrb, c, id, mrb_struct_ref, MRB_ARGS_NONE());
+      mrb_define_method_id(mrb, c, mrb_id_attrset(mrb, id), mrb_struct_set_m, MRB_ARGS_REQ(1));
+      mrb_gc_arena_restore(mrb, ai);
+    }
+  }
+}
+static mrb_value
+make_struct(mrb_state *mrb, mrb_value name, mrb_value members, struct RClass * klass)
+    mrb_method_t m;
+    mrb_value at = mrb_fixnum_value(i);
+    struct RProc *aref = mrb_proc_new_cfunc_with_env(mrb, mrb_struct_ref, 1, &at);
+    struct RProc *aset = mrb_proc_new_cfunc_with_env(mrb, mrb_struct_set_m, 1, &at);
+    MRB_METHOD_FROM_PROC(m, aref);
+    mrb_define_method_raw(mrb, c, id, m);
+    MRB_METHOD_FROM_PROC(m, aset);
+    mrb_define_method_raw(mrb, c, mrb_id_attrset(mrb, id), m);
+    mrb_gc_arena_restore(mrb, ai);
+  }
+}
+static mrb_value
+make_struct(mrb_state *mrb, mrb_value name, mrb_value members, struct RClass *klass)
+{
   mrb_value nstr;
 …
   else {
     /* old style: should we warn? */
     name = mrb_str_to_str(mrb, name);
+    mrb_to_str(mrb, name);
     id = mrb_obj_to_sym(mrb, name);
     if (!is_const_id(mrb, mrb_sym2name_len(mrb, id, NULL))) {
       mrb_name_error(mrb, id, "identifier %S needs to be constant", name);
+    if (!mrb_const_name_p(mrb, RSTRING_PTR(name), RSTRING_LEN(name))) {
+      mrb_name_error(mrb, id, "identifier %v needs to be constant", name);
+    }
     if (mrb_const_defined_at(mrb, mrb_obj_value(klass), id)) {
       mrb_warn(mrb, "redefining constant Struct::%S", name);
+      mrb_warn(mrb, "redefining constant Struct::%v", name);
       mrb_const_remove(mrb, mrb_obj_value(klass), id);
+    }
 …
   name = mrb_nil_value();
-  rest = mrb_nil_value();
   mrb_get_args(mrb, "*&", &argv, &argc, &b);
   if (argc == 0) { /* special case to avoid crash */
     rest = mrb_ary_new(mrb);
+    mrb_argnum_error(mrb, argc, 1, -1);
+  }
   else {
+    if (argc > 0) name = argv[0];
+    pargv = &argv[1];
+    argcnt = argc-1;
+    if (!mrb_nil_p(name) && mrb_symbol_p(name)) {
+      /* 1stArgument:symbol -> name=nil rest=argv[0]-[n] */
+      name = mrb_nil_value();
+      pargv = &argv[0];
+      argcnt++;
+    pargv = argv;
+    argcnt = argc;
+    if (argc > 0) {
+      name = argv[0];
+      if (mrb_symbol_p(name)) {
+        /* 1stArgument:symbol -> name=nil rest=argv[0..n] */
+        name = mrb_nil_value();
+      }
+      else {
+        pargv++;
+        argcnt--;
+      }
+    }
     rest = mrb_ary_new_from_values(mrb, argcnt, pargv);
     for (i=0; i<RARRAY_LEN(rest); i++) {
+    for (i=0; i<argcnt; i++) {
       id = mrb_obj_to_sym(mrb, RARRAY_PTR(rest)[i]);
       mrb_ary_set(mrb, rest, i, mrb_symbol_value(id));
+    }
+  }
+  st = make_struct(mrb, name, rest, mrb_class_ptr(klass));
+  if (!mrb_nil_p(b)) {
+    mrb_yield_with_class(mrb, b, 1, &st, st, mrb_class_ptr(st));
+  }
+  return st;
+    st = make_struct(mrb, name, rest, mrb_class_ptr(klass));
+    if (!mrb_nil_p(b)) {
+      mrb_yield_with_class(mrb, b, 1, &st, st, mrb_class_ptr(st));
+    }
+    return st;
+  }
+  /* not reached */
+  return mrb_nil_value();
+}
 …
   mrb_int argc;
   mrb_get_args(mrb, "*", &argv, &argc);
+  mrb_get_args(mrb, "*!", &argv, &argc);
   return mrb_struct_initialize_withArg(mrb, argc, argv, self);
+}
 …
+    }
+  }
   mrb_raisef(mrb, E_INDEX_ERROR, "'%S' is not a struct member", mrb_sym2str(mrb, id));
+  mrb_name_error(mrb, id, "no member '%n' in struct", id);
   return mrb_nil_value();       /* not reached */
+}
 …
 struct_aref_int(mrb_state *mrb, mrb_value s, mrb_int i)
+{
+  if (i < 0) i = RSTRUCT_LEN(s) + i;
+  if (i < 0)
+      mrb_raisef(mrb, E_INDEX_ERROR,
+                 "offset %S too small for struct(size:%S)",
+                 mrb_fixnum_value(i), mrb_fixnum_value(RSTRUCT_LEN(s)));
+  if (RSTRUCT_LEN(s) <= i)
+  mrb_int idx = i < 0 ? RSTRUCT_LEN(s) + i : i;
+  if (idx < 0)
     mrb_raisef(mrb, E_INDEX_ERROR,
+               "offset %S too large for struct(size:%S)",
+               mrb_fixnum_value(i), mrb_fixnum_value(RSTRUCT_LEN(s)));
+  return RSTRUCT_PTR(s)[i];
+               "offset %i too small for struct(size:%i)", i, RSTRUCT_LEN(s));
+  if (RSTRUCT_LEN(s) <= idx)
+    mrb_raisef(mrb, E_INDEX_ERROR,
+               "offset %i too large for struct(size:%i)", i, RSTRUCT_LEN(s));
+  return RSTRUCT_PTR(s)[idx];
+}
 …
     if (mrb_nil_p(sym)) {
       mrb_name_error(mrb, mrb_intern_str(mrb, idx), "no member '%S' in struct", idx);
+      mrb_name_error(mrb, mrb_intern_str(mrb, idx), "no member '%v' in struct", idx);
+    }
     idx = sym;
 …
+    }
+  }
   mrb_name_error(mrb, id, "no member '%S' in struct", mrb_sym2str(mrb, id));
+  mrb_name_error(mrb, id, "no member '%n' in struct", id);
   return val;                   /* not reach */
+}
 …
     if (mrb_nil_p(sym)) {
       mrb_name_error(mrb, mrb_intern_str(mrb, idx), "no member '%S' in struct", idx);
+      mrb_name_error(mrb, mrb_intern_str(mrb, idx), "no member '%v' in struct", idx);
+    }
     idx = sym;
 …
   if (i < 0) {
     mrb_raisef(mrb, E_INDEX_ERROR,
+               "offset %S too small for struct(size:%S)",
+               mrb_fixnum_value(i), mrb_fixnum_value(RSTRUCT_LEN(s)));
+               "offset %i too small for struct(size:%i)", i, RSTRUCT_LEN(s));
+  }
   if (RSTRUCT_LEN(s) <= i) {
     mrb_raisef(mrb, E_INDEX_ERROR,
+               "offset %S too large for struct(size:%S)",
+               mrb_fixnum_value(i), mrb_fixnum_value(RSTRUCT_LEN(s)));
+               "offset %i too large for struct(size:%i)", i, RSTRUCT_LEN(s));
+  }
   mrb_struct_modify(mrb, s);

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-struct/test/struct.rb

-              r331
+              r439
   assert_equal Struct, c.superclass
   assert_equal [:m1, :m2], c.members
-end
-# Check crash bug with Struc.new and no params.
-assert('Struct.new', '15.2.18.3.1') do
-  c = Struct.new()
-  assert_equal Struct, c.superclass
-  assert_equal [], c.members
 end
 …
 assert('struct inspect') do
+  c = Struct.new(:m1, :m2, :m3, :m4, :m5)
+  cc = c.new(1,2,3,4,5)
+  assert_equal "#<struct m1=1, m2=2, m3=3, m4=4, m5=5>", cc.inspect
+  c = Struct.new(:m1, :m2, :m3, :m4, :m5, :recur)
+  cc = c.new(1,2,3,4,5,nil)
+  cc.recur = cc
+  assert_equal "#<struct m1=1, m2=2, m3=3, m4=4, m5=5, recur=#<struct #{cc.class}:...>>", cc.inspect
 end
 …
 end
+assert("Struct.new removes existing constant") do
+  skip "redefining Struct with same name cause warnings"
   begin
     assert_not_equal Struct.new("Test", :a), Struct.new("Test", :a, :b)
   ensure
     Struct.remove_const :Test
   end
 end
+# TODO: suppress redefining Struct warning during test
+# assert("Struct.new removes existing constant") do
+#   begin
+#     assert_not_equal Struct.new("Test", :a), Struct.new("Test", :a, :b)
+#   ensure
+#     Struct.remove_const :Test
+#   end
+# end
 assert("Struct#initialize_copy requires struct to be the same type") do
 …
 end
+assert("Struct.new does not allow invalid class name") do
+  assert_raise(NameError) { Struct.new("Test-", :a) }
+end
 assert("Struct.new generates subclass of Struct") do
   begin
     original_struct = Struct
     Struct = String
     assert_equal original_struct, original_struct.new.superclass
+    assert_equal original_struct, original_struct.new(:foo).superclass
   ensure
     Struct = original_struct
 …
   o.freeze
   assert_raise(RuntimeError) { o.m = :modify }
   assert_raise(RuntimeError) { o[:m] = :modify }
+  assert_raise(FrozenError) { o.m = :modify }
+  assert_raise(FrozenError) { o[:m] = :modify }
   assert_equal :test, o.m
 end

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-symbol-ext/mrblib/symbol.rb

-              r321
+              r439
   alias intern to_sym
-  def to_proc
-    ->(obj,*args,&block) do
-      obj.__send__(self, *args, &block)
-    end
-  end
   ##
 …
     return nil unless other.kind_of?(Symbol)
     lhs =  self.to_s; lhs.upcase!
     rhs = other.to_s; rhs.upcase!
+    rhs = other.to_s.upcase
     lhs <=> rhs
+  end
+  ##
+  # call-seq:
+  #   sym.casecmp?(other)  -> true, false, or nil
+  #
+  # Returns true if sym and other_sym are equal after case folding,
+  # false if they are not equal, and nil if other_sym is not a string.
+  def casecmp?(sym)
+    c = self.casecmp(sym)
+    return nil if c.nil?
+    return c == 0
   end

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-symbol-ext/src/symbol.c

-              r331
+              r439
 #include <mruby/khash.h>
 #include <mruby/array.h>
+typedef struct symbol_name {
+  size_t len;
+  const char *name;
+} symbol_name;
+#include <mruby/string.h>
 /*
 …
  *                                     :wait2, :$>]
  */
+#ifdef MRB_ENABLE_ALL_SYMBOLS
 static mrb_value
 mrb_sym_all_symbols(mrb_state *mrb, mrb_value self)
 …
   for (i=1, lim=mrb->symidx+1; i<lim; i++) {
+    mrb_ary_push(mrb, ary, mrb_symbol_value(i));
+    mrb_sym sym = i<<1;
+    mrb_ary_push(mrb, ary, mrb_symbol_value(sym));
+  }
   return ary;
+}
+#endif
 /*
 …
+{
   mrb_int len;
+  mrb_sym2name_len(mrb, mrb_symbol(self), &len);
+#ifdef MRB_UTF8_STRING
+  mrb_int byte_len;
+  const char *name = mrb_sym_name_len(mrb, mrb_symbol(self), &byte_len);
+  len = mrb_utf8_strlen(name, byte_len);
+#else
+  mrb_sym_name_len(mrb, mrb_symbol(self), &len);
+#endif
   return mrb_fixnum_value(len);
+}
 …
+{
   struct RClass *s = mrb->symbol_class;
+#ifdef MRB_ENABLE_ALL_SYMBOLS
   mrb_define_class_method(mrb, s, "all_symbols", mrb_sym_all_symbols, MRB_ARGS_NONE());
+#endif
   mrb_define_method(mrb, s, "length", mrb_sym_length, MRB_ARGS_NONE());
   mrb_define_method(mrb, s, "size", mrb_sym_length, MRB_ARGS_NONE());

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-symbol-ext/test/symbol.rb

-              r321
+              r439
+# coding: utf-8
 ##
 # Symbol(Ext) Test
+assert('Symbol#to_proc') do
+  assert_equal 5, :abs.to_proc[-5]
+if Symbol.respond_to?(:all_symbols)
+  assert('Symbol.all_symbols') do
+    foo = [:__symbol_test_1, :__symbol_test_2, :__symbol_test_3].sort
+    symbols = Symbol.all_symbols.select{|sym|sym.to_s.include? '__symbol_test'}.sort
+    assert_equal foo, symbols
+  end
 end
+assert('Symbol.all_symbols') do
+  foo = [:__symbol_test_1, :__symbol_test_2, :__symbol_test_3].sort
+  symbols = Symbol.all_symbols.select{|sym|sym.to_s.include? '__symbol_test'}.sort
+  assert_equal foo, symbols
+end
+assert("Symbol#length") do
+  assert_equal 5, :hello.size
+  assert_equal 5, :mruby.length
+%w[size length].each do |n|
+  assert("Symbol##{n}") do
+    assert_equal 5, :hello.__send__(n)
+    assert_equal 4, :"aA\0b".__send__(n)
+    if __ENCODING__ == "UTF-8"
+      assert_equal 8, :"こんにちは世界!".__send__(n)
+      assert_equal 4, :"aあ\0b".__send__(n)
+    else
+      assert_equal 22, :"こんにちは世界!".__send__(n)
+      assert_equal 6, :"aあ\0b".__send__(n)
+    end
+  end
 end

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-test/driver.c

-              r331
+              r439
 #include <mruby/array.h>
+void
+mrb_init_mrbtest(mrb_state *);
+extern const uint8_t mrbtest_assert_irep[];
+void mrbgemtest_init(mrb_state* mrb);
+void mrb_init_test_vformat(mrb_state* mrb);
 /* Print a short remark for the user */
 …
 static int
-check_error(mrb_state *mrb)
+{
-  /* Error check */
-  /* $ko_test and $kill_test should be 0 */
-  mrb_value ko_test = mrb_gv_get(mrb, mrb_intern_lit(mrb, "$ko_test"));
-  mrb_value kill_test = mrb_gv_get(mrb, mrb_intern_lit(mrb, "$kill_test"));
-  return mrb_fixnum_p(ko_test) && mrb_fixnum(ko_test) == 0 && mrb_fixnum_p(kill_test) && mrb_fixnum(kill_test) == 0;
+}
-static int
 eval_test(mrb_state *mrb)
+{
   /* evaluate the test */
   mrb_funcall(mrb, mrb_top_self(mrb), "report", 0);
+  mrb_value result = mrb_funcall(mrb, mrb_top_self(mrb), "report", 0);
   /* did an exception occur? */
   if (mrb->exc) {
 …
     return EXIT_FAILURE;
+  }
+  else if (!check_error(mrb)) {
+    return EXIT_FAILURE;
+  }
+  return EXIT_SUCCESS;
+}
+static void
+t_printstr(mrb_state *mrb, mrb_value obj)
+{
+  char *s;
+  int len;
+  if (mrb_string_p(obj)) {
+    s = RSTRING_PTR(obj);
+    len = RSTRING_LEN(obj);
+    fwrite(s, len, 1, stdout);
+  }
+}
+mrb_value
+mrb_t_printstr(mrb_state *mrb, mrb_value self)
+{
+  mrb_value argv;
+  mrb_get_args(mrb, "o", &argv);
+  t_printstr(mrb, argv);
+  return argv;
+  else {
+    return mrb_bool(result) ? EXIT_SUCCESS : EXIT_FAILURE;
+  }
+}
+/* Implementation of print due to the reason that there might be no print */
+static mrb_value
+t_print(mrb_state *mrb, mrb_value self)
+{
+  mrb_value *argv;
+  mrb_int argc;
+  mrb_int i;
+  mrb_get_args(mrb, "*!", &argv, &argc);
+  for (i = 0; i < argc; ++i) {
+    mrb_value s = mrb_obj_as_string(mrb, argv[i]);
+    fwrite(RSTRING_PTR(s), RSTRING_LEN(s), 1, stdout);
+  }
+  fflush(stdout);
+  return mrb_nil_value();
+}
+#define UNESCAPE(p, endp) ((p) != (endp) && *(p) == '\\' ? (p)+1 : (p))
+#define CHAR_CMP(c1, c2) ((unsigned char)(c1) - (unsigned char)(c2))
+static const char *
+str_match_bracket(const char *p, const char *pat_end,
+                  const char *s, const char *str_end)
+{
+  mrb_bool ok = FALSE, negated = FALSE;
+  if (p == pat_end) return NULL;
+  if (*p == '!' || *p == '^') {
+    negated = TRUE;
+    ++p;
+  }
+  while (*p != ']') {
+    const char *t1 = p;
+    if ((t1 = UNESCAPE(t1, pat_end)) == pat_end) return NULL;
+    if ((p = t1 + 1) == pat_end) return NULL;
+    if (p[0] == '-' && p[1] != ']') {
+      const char *t2 = p + 1;
+      if ((t2 = UNESCAPE(t2, pat_end)) == pat_end) return NULL;
+      p = t2 + 1;
+      if (!ok && CHAR_CMP(*t1, *s) <= 0 && CHAR_CMP(*s, *t2) <= 0) ok = TRUE;
+    }
+    else {
+      if (!ok && CHAR_CMP(*t1, *s) == 0) ok = TRUE;
+    }
+  }
+  return ok == negated ? NULL : p + 1;
+}
+static mrb_bool
+str_match_no_brace_p(const char *pat, mrb_int pat_len,
+                     const char *str, mrb_int str_len)
+{
+  const char *p = pat, *s = str;
+  const char *pat_end = pat + pat_len, *str_end = str + str_len;
+  const char *p_tmp = NULL, *s_tmp = NULL;
+  for (;;) {
+    if (p == pat_end) return s == str_end;
+    switch (*p) {
+      case '*':
+        do { ++p; } while (p != pat_end && *p == '*');
+        if (UNESCAPE(p, pat_end) == pat_end) return TRUE;
+        if (s == str_end) return FALSE;
+        p_tmp = p;
+        s_tmp = s;
+        continue;
+      case '?':
+        if (s == str_end) return FALSE;
+        ++p;
+        ++s;
+        continue;
+      case '[': {
+        const char *t;
+        if (s == str_end) return FALSE;
+        if ((t = str_match_bracket(p+1, pat_end, s, str_end))) {
+          p = t;
+          ++s;
+          continue;
+        }
+        goto L_failed;
+      }
+    }
+    /* ordinary */
+    p = UNESCAPE(p, pat_end);
+    if (s == str_end) return p == pat_end;
+    if (p == pat_end) goto L_failed;
+    if (*p++ != *s++) goto L_failed;
+    continue;
+    L_failed:
+    if (p_tmp && s_tmp) {
+      /* try next '*' position */
+      p = p_tmp;
+      s = ++s_tmp;
+      continue;
+    }
+    return FALSE;
+  }
+}
+#define COPY_AND_INC(dst, src, len) \
+  do { memcpy(dst, src, len); dst += len; } while (0)
+static mrb_bool
+str_match_p(mrb_state *mrb,
+            const char *pat, mrb_int pat_len,
+            const char *str, mrb_int str_len)
+{
+  const char *p = pat, *pat_end = pat + pat_len;
+  const char *lbrace = NULL, *rbrace = NULL;
+  int nest = 0;
+  mrb_bool ret = FALSE;
+  for (; p != pat_end; ++p) {
+    if (*p == '{' && nest++ == 0) lbrace = p;
+    else if (*p == '}' && lbrace && --nest == 0) { rbrace = p; break; }
+    else if (*p == '\\' && ++p == pat_end) break;
+  }
+  if (lbrace && rbrace) {
+    /* expand brace */
+    char *ex_pat = (char *)mrb_malloc(mrb, pat_len-2);  /* expanded pattern */
+    char *ex_p = ex_pat;
+    COPY_AND_INC(ex_p, pat, lbrace-pat);
+    p = lbrace;
+    while (p < rbrace) {
+      char *orig_ex_p = ex_p;
+      const char *t = ++p;
+      for (nest = 0; p < rbrace && !(*p == ',' && nest == 0); ++p) {
+        if (*p == '{') ++nest;
+        else if (*p == '}') --nest;
+        else if (*p == '\\' && ++p == rbrace) break;
+      }
+      COPY_AND_INC(ex_p, t, p-t);
+      COPY_AND_INC(ex_p, rbrace+1, pat_end-rbrace-1);
+      if ((ret = str_match_p(mrb, ex_pat, ex_p-ex_pat, str, str_len))) break;
+      ex_p = orig_ex_p;
+    }
+    mrb_free(mrb, ex_pat);
+  }
+  else if (!lbrace && !rbrace) {
+    ret = str_match_no_brace_p(pat, pat_len, str, str_len);
+  }
+  return ret;
+}
+static mrb_value
+m_str_match_p(mrb_state *mrb, mrb_value self)
+{
+  const char *pat, *str;
+  mrb_int pat_len, str_len;
+  mrb_get_args(mrb, "ss", &pat, &pat_len, &str, &str_len);
+  return mrb_bool_value(str_match_p(mrb, pat, pat_len, str, str_len));
+}
 …
   krn = mrb->kernel_module;
+  mrb_define_method(mrb, krn, "__t_printstr__", mrb_t_printstr, MRB_ARGS_REQ(1));
+  mrb_define_method(mrb, krn, "t_print", t_print, MRB_ARGS_ANY());
+  mrb_define_method(mrb, krn, "_str_match?", m_str_match_p, MRB_ARGS_REQ(2));
   mrbtest = mrb_define_module(mrb, "Mrbtest");
 …
   mrb_define_const(mrb, mrbtest, "FIXNUM_BIT", mrb_fixnum_value(MRB_INT_BIT));
+#ifndef MRB_WITHOUT_FLOAT
 #ifdef MRB_USE_FLOAT
   mrb_define_const(mrb, mrbtest, "FLOAT_TOLERANCE", mrb_float_value(mrb, 1e-6));
 …
   mrb_define_const(mrb, mrbtest, "FLOAT_TOLERANCE", mrb_float_value(mrb, 1e-12));
 #endif
+#endif
+  mrb_init_test_vformat(mrb);
   if (verbose) {
 …
   TEST_COUNT_PASS(ko_test);
   TEST_COUNT_PASS(kill_test);
+  TEST_COUNT_PASS(warning_test);
+  TEST_COUNT_PASS(skip_test);
 #undef TEST_COUNT_PASS
 …
   mrb_init_test_driver(mrb, verbose);
+  mrb_init_mrbtest(mrb);
+  mrb_load_irep(mrb, mrbtest_assert_irep);
+  mrbgemtest_init(mrb);
   ret = eval_test(mrb);
   mrb_close(mrb);

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-test/mrbgem.rake

-              r331
+              r439
   exec = exefile("#{build.build_dir}/bin/mrbtest")
-  libmruby = libfile("#{build.build_dir}/lib/libmruby")
-  libmruby_core = libfile("#{build.build_dir}/lib/libmruby_core")
   mrbtest_lib = libfile("#{build_dir}/mrbtest")
   mrbtest_objs = []
+  driver_obj = objfile("#{build_dir}/driver")
+  driver = "#{spec.dir}/driver.c"
+  driver_objs = Dir.glob("#{dir}/*.{c,cpp,cxx,cc,m,asm,s,S}").map do |f|
+    objfile(f.relative_path_from(dir).to_s.pathmap("#{build_dir}/%X"))
+  end
   assert_c = "#{build_dir}/assert.c"
 …
   file assert_lib => assert_c
   file assert_c => assert_rb do |t|
+  file assert_c => [assert_rb, build.mrbcfile] do |t|
     open(t.name, 'w') do |f|
       mrbc.run f, assert_rb, 'mrbtest_assert_irep'
 …
     file test_rbobj => g.test_rbireps
     file g.test_rbireps => [g.test_rbfiles].flatten do |t|
       FileUtils.mkdir_p File.dirname(t.name)
+    file g.test_rbireps => [g.test_rbfiles, build.mrbcfile].flatten do |t|
+      mkdir_p File.dirname(t.name)
       open(t.name, 'w') do |f|
         g.print_gem_test_header(f)
 …
             f.puts %Q[  if (mrb2->exc) {]
             f.puts %Q[    mrb_print_error(mrb2);]
+            f.puts %Q[    mrb_close(mrb2);]
             f.puts %Q[    exit(EXIT_FAILURE);]
             f.puts %Q[  }]
 …
   unless build.build_mrbtest_lib_only?
     file exec => [driver_obj, mlib, mrbtest_lib, libmruby_core, libmruby] do |t|
+    file exec => [*driver_objs, mlib, mrbtest_lib, build.libmruby_static] do |t|
       gem_flags = build.gems.map { |g| g.linker.flags }
       gem_flags_before_libraries = build.gems.map { |g| g.linker.flags_before_libraries }
 …
       gem_libraries = build.gems.map { |g| g.linker.libraries }
       gem_library_paths = build.gems.map { |g| g.linker.library_paths }
+      build.linker.run t.name, t.prerequisites, gem_libraries, gem_library_paths, gem_flags, gem_flags_before_libraries
+      build.linker.run t.name, t.prerequisites, gem_libraries, gem_library_paths, gem_flags,
+                       gem_flags_before_libraries, gem_flags_after_libraries
     end
   end
-  init = "#{spec.dir}/init_mrbtest.c"
   # store the last gem selection and make the re-build
   # of the test gem depending on a change to the gem
   # selection
   active_gems = "#{build_dir}/active_gems.lst"
   FileUtils.mkdir_p File.dirname(active_gems)
   open(active_gems, 'w+') do |f|
     build.gems.each do |g|
       f.puts g.name
     end
+  active_gems_path = "#{build_dir}/active_gems_path.lst"
+  active_gem_list = File.read active_gems_path if File.exist? active_gems_path
+  current_gem_list = build.gems.map(&:name).join("\n")
+  task active_gems_path do |_t|
+    mkdir_p File.dirname(active_gems_path)
+    File.write active_gems_path, current_gem_list
   end
   file clib => active_gems
+  file clib => active_gems_path if active_gem_list != current_gem_list
   file mlib => clib
   file clib => init do |t|
+  file clib => [build.mrbcfile, __FILE__] do |_t|
     _pp "GEN", "*.rb", "#{clib.relative_path}"
     FileUtils.mkdir_p File.dirname(clib)
+    mkdir_p File.dirname(clib)
     open(clib, 'w') do |f|
       f.puts %Q[/*]
 …
       f.puts %Q[ */]
       f.puts %Q[]
+      f.puts IO.read(init)
+      f.puts %Q[struct mrb_state;]
+      f.puts %Q[typedef struct mrb_state mrb_state;]
       build.gems.each do |g|
         f.puts %Q[void GENERATED_TMP_mrb_#{g.funcname}_gem_test(mrb_state *mrb);]

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-time/src/time.c

-              r331
+              r439
 */
+#ifndef MRB_WITHOUT_FLOAT
 #include <math.h>
+#include <time.h>
+#endif
 #include <mruby.h>
 #include <mruby/class.h>
 #include <mruby/data.h>
 #ifndef DISABLE_STDIO
+#include <stdio.h>
 #else
+#include <mruby/numeric.h>
+#include <mruby/time.h>
+#ifdef MRB_DISABLE_STDIO
 #include <string.h>
 #endif
+#include <stdlib.h>
 #define NDIV(x,y) (-(-((x)+1)/(y))-1)
+#if _MSC_VER < 1800
+#define TO_S_FMT "%Y-%m-%d %H:%M:%S "
+#if defined(_MSC_VER) && _MSC_VER < 1800
 double round(double x) {
+  if (x >= 0.0) {
+    return (double)((int)(x + 0.5));
+  }
+  else {
+    return (double)((int)(x - 0.5));
+  }
+}
+#endif
+#if !defined(__MINGW64__) && defined(_WIN32)
+# define llround(x) round(x)
+  return floor(x + 0.5);
+}
+#endif
+#ifndef MRB_WITHOUT_FLOAT
+# if !defined(__MINGW64__) && defined(_WIN32)
+#  define llround(x) round(x)
+# endif
 #endif
 …
 #ifdef _WIN32
 #if _MSC_VER
+#ifdef _MSC_VER
 /* Win32 platform do not provide gmtime_r/localtime_r; emulate them using gmtime_s/localtime_s */
 #define gmtime_r(tp, tm)    ((gmtime_s((tm), (tp)) == 0) ? (tm) : NULL)
 …
   unsigned int *nday = (unsigned int*) ndays[is_leapyear(tm->tm_year+1900)];
+  for (i = 70; i < tm->tm_year; ++i)
+    r += is_leapyear(i+1900) ? 366*24*60*60 : 365*24*60*60;
+  static const int epoch_year = 70;
+  if(tm->tm_year >= epoch_year) {
+    for (i = epoch_year; i < tm->tm_year; ++i)
+      r += is_leapyear(i+1900) ? 366*24*60*60 : 365*24*60*60;
+  } else {
+    for (i = tm->tm_year; i < epoch_year; ++i)
+      r -= is_leapyear(i+1900) ? 366*24*60*60 : 365*24*60*60;
+  }
   for (i = 0; i < tm->tm_mon; ++i)
     r += nday[i] * 24 * 60 * 60;
 …
 */
-enum mrb_timezone {
-  MRB_TIMEZONE_NONE   = 0,
-  MRB_TIMEZONE_UTC    = 1,
-  MRB_TIMEZONE_LOCAL  = 2,
-  MRB_TIMEZONE_LAST   = 3
-};
 typedef struct mrb_timezone_name {
   const char name[8];
 …
 };
 #ifndef DISABLE_STDIO
+#ifndef MRB_DISABLE_STDIO
 static const char mon_names[12][4] = {
   "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
 …
 static const struct mrb_data_type mrb_time_type = { "Time", mrb_free };
+#ifndef MRB_WITHOUT_FLOAT
+void mrb_check_num_exact(mrb_state *mrb, mrb_float num);
+typedef mrb_float mrb_sec;
+#define mrb_sec_value(mrb, sec) mrb_float_value(mrb, sec)
+#else
+typedef mrb_int mrb_sec;
+#define mrb_sec_value(mrb, sec) mrb_fixnum_value(sec)
+#endif
+#define MRB_TIME_T_UINT (~(time_t)0 > 0)
+#define MRB_TIME_MIN (                                                      \
+  MRB_TIME_T_UINT ? 0 :                                                     \
+                    (sizeof(time_t) <= 4 ? INT32_MIN : INT64_MIN)           \
+)
+#define MRB_TIME_MAX (                                                      \
+  MRB_TIME_T_UINT ? (sizeof(time_t) <= 4 ? UINT32_MAX : UINT64_MAX) :       \
+                    (sizeof(time_t) <= 4 ? INT32_MAX : INT64_MAX)           \
+)
+static mrb_bool
+fixable_time_t_p(time_t v)
+{
+  if (MRB_INT_MIN <= MRB_TIME_MIN && MRB_TIME_MAX <= MRB_INT_MAX) return TRUE;
+  return FIXABLE(v);
+}
+static time_t
+mrb_to_time_t(mrb_state *mrb, mrb_value obj, time_t *usec)
+{
+  time_t t;
+  switch (mrb_type(obj)) {
+#ifndef MRB_WITHOUT_FLOAT
+    case MRB_TT_FLOAT:
+      {
+        mrb_float f = mrb_float(obj);
+        mrb_check_num_exact(mrb, f);
+        if (f >= ((mrb_float)MRB_TIME_MAX-1.0) || f < ((mrb_float)MRB_TIME_MIN+1.0)) {
+          goto out_of_range;
+        }
+        if (usec) {
+          t = (time_t)f;
+          *usec = (time_t)llround((f - t) * 1.0e+6);
+        }
+        else {
+          t = (time_t)llround(f);
+        }
+      }
+      break;
+#endif /* MRB_WITHOUT_FLOAT */
+    default:
+    case MRB_TT_FIXNUM:
+      {
+        mrb_int i = mrb_int(mrb, obj);
+        if ((MRB_INT_MAX > MRB_TIME_MAX && i > 0 && i > (mrb_int)MRB_TIME_MAX) ||
+            (MRB_TIME_MIN > MRB_INT_MIN && MRB_TIME_MIN > i)) {
+          goto out_of_range;
+        }
+        t = (time_t)i;
+        if (usec) { *usec = 0; }
+      }
+      break;
+  }
+  return t;
+out_of_range:
+  mrb_raisef(mrb, E_ARGUMENT_ERROR, "%v out of Time range", obj);
+  /* not reached */
+  if (usec) { *usec = 0; }
+  return 0;
+}
 /** Updates the datetime of a mrb_time based on it's timezone and
+seconds setting. Returns self on success, NULL of failure. */
+    seconds setting. Returns self on success, NULL of failure.
+    if `dealloc` is set `true`, it frees `self` on error. */
 static struct mrb_time*
 time_update_datetime(mrb_state *mrb, struct mrb_time *self)
+time_update_datetime(mrb_state *mrb, struct mrb_time *self, int dealloc)
+{
   struct tm *aid;
+  time_t t = self->sec;
   if (self->timezone == MRB_TIMEZONE_UTC) {
     aid = gmtime_r(&self->sec, &self->datetime);
+    aid = gmtime_r(&t, &self->datetime);
+  }
   else {
     aid = localtime_r(&self->sec, &self->datetime);
+    aid = localtime_r(&t, &self->datetime);
+  }
   if (!aid) {
+    mrb_raisef(mrb, E_ARGUMENT_ERROR, "%S out of Time range", mrb_float_value(mrb, (mrb_float)self->sec));
+    mrb_sec sec = (mrb_sec)t;
+    if (dealloc) mrb_free(mrb, self);
+    mrb_raisef(mrb, E_ARGUMENT_ERROR, "%v out of Time range", mrb_sec_value(mrb, sec));
     /* not reached */
     return NULL;
 …
+}
-void mrb_check_num_exact(mrb_state *mrb, mrb_float num);
 /* Allocates a mrb_time object and initializes it. */
 static struct mrb_time*
+time_alloc(mrb_state *mrb, double sec, double usec, enum mrb_timezone timezone)
+{
+  struct mrb_time *tm;
+  time_t tsec = 0;
+  mrb_check_num_exact(mrb, (mrb_float)sec);
+  mrb_check_num_exact(mrb, (mrb_float)usec);
+  if (sizeof(time_t) == 4 && (sec > (double)INT32_MAX || (double)INT32_MIN > sec)) {
+    goto out_of_range;
+  }
+  if (sizeof(time_t) == 8 && (sec > (double)INT64_MAX || (double)INT64_MIN > sec)) {
+    goto out_of_range;
+  }
+  tsec  = (time_t)sec;
+  if ((sec > 0 && tsec < 0) || (sec < 0 && (double)tsec > sec)) {
+  out_of_range:
+    mrb_raisef(mrb, E_ARGUMENT_ERROR, "%S out of Time range", mrb_float_value(mrb, sec));
+  }
+time_alloc_time(mrb_state *mrb, time_t sec, time_t usec, enum mrb_timezone timezone)
+{
+  struct mrb_time *tm;
   tm = (struct mrb_time *)mrb_malloc(mrb, sizeof(struct mrb_time));
   tm->sec  = tsec;
   tm->usec = (time_t)llround((sec - tm->sec) * 1.0e6 + usec);
+  tm->sec  = sec;
+  tm->usec = usec;
   if (tm->usec < 0) {
     long sec2 = (long)NDIV(usec,1000000); /* negative div */
+    long sec2 = (long)NDIV(tm->usec,1000000); /* negative div */
     tm->usec -= sec2 * 1000000;
     tm->sec += sec2;
+  }
   else if (tm->usec >= 1000000) {
     long sec2 = (long)(usec / 1000000);
+    long sec2 = (long)(tm->usec / 1000000);
     tm->usec -= sec2 * 1000000;
     tm->sec += sec2;
+  }
   tm->timezone = timezone;
   time_update_datetime(mrb, tm);
+  time_update_datetime(mrb, tm, TRUE);
   return tm;
+}
+static mrb_value
+mrb_time_make(mrb_state *mrb, struct RClass *c, double sec, double usec, enum mrb_timezone timezone)
+static struct mrb_time*
+time_alloc(mrb_state *mrb, mrb_value sec, mrb_value usec, enum mrb_timezone timezone)
+{
+  time_t tsec, tusec;
+  tsec = mrb_to_time_t(mrb, sec, &tusec);
+  tusec += mrb_to_time_t(mrb, usec, NULL);
+  return time_alloc_time(mrb, tsec, tusec, timezone);
+}
+static mrb_value
+mrb_time_make_time(mrb_state *mrb, struct RClass *c, time_t sec, time_t usec, enum mrb_timezone timezone)
+{
+  return mrb_time_wrap(mrb, c, time_alloc_time(mrb, sec, usec, timezone));
+}
+static mrb_value
+mrb_time_make(mrb_state *mrb, struct RClass *c, mrb_value sec, mrb_value usec, enum mrb_timezone timezone)
+{
   return mrb_time_wrap(mrb, c, time_alloc(mrb, sec, usec, timezone));
 …
 current_mrb_time(mrb_state *mrb)
+{
+  struct mrb_time *tm;
+  tm = (struct mrb_time *)mrb_malloc(mrb, sizeof(*tm));
+#if defined(TIME_UTC)
+  struct mrb_time tmzero = {0};
+  struct mrb_time *tm;
+  time_t sec, usec;
+#if defined(TIME_UTC) && !defined(__ANDROID__)
+  {
     struct timespec ts;
     if (timespec_get(&ts, TIME_UTC) == 0) {
-      mrb_free(mrb, tm);
       mrb_raise(mrb, E_RUNTIME_ERROR, "timespec_get() failed for unknown reasons");
+    }
     tm->sec = ts.tv_sec;
     tm->usec = ts.tv_nsec / 1000;
+    sec = ts.tv_sec;
+    usec = ts.tv_nsec / 1000;
+  }
 #elif defined(NO_GETTIMEOFDAY)
 …
     static time_t last_sec = 0, last_usec = 0;
     tm->sec  = time(NULL);
     if (tm->sec != last_sec) {
       last_sec = tm->sec;
+    sec = time(NULL);
+    if (sec != last_sec) {
+      last_sec = sec;
       last_usec = 0;
+    }
 …
       last_usec += 1;
+    }
     tm->usec = last_usec;
+    usec = last_usec;
+  }
 #else
 …
     gettimeofday(&tv, NULL);
+    tm->sec = tv.tv_sec;
+    tm->usec = tv.tv_usec;
+  }
+#endif
+    sec = tv.tv_sec;
+    usec = tv.tv_usec;
+  }
+#endif
+  tm = (struct mrb_time *)mrb_malloc(mrb, sizeof(*tm));
+  *tm = tmzero;
+  tm->sec = sec; tm->usec = usec;
   tm->timezone = MRB_TIMEZONE_LOCAL;
   time_update_datetime(mrb, tm);
+  time_update_datetime(mrb, tm, TRUE);
   return tm;
 …
+{
   return mrb_time_wrap(mrb, mrb_class_ptr(self), current_mrb_time(mrb));
+}
+MRB_API mrb_value
+mrb_time_at(mrb_state *mrb, time_t sec, time_t usec, enum mrb_timezone zone)
+{
+  return mrb_time_make_time(mrb, mrb_class_get(mrb, "Time"), sec, usec, zone);
+}
 …
 /* Creates an instance of time at the given time in seconds, etc. */
 static mrb_value
+mrb_time_at(mrb_state *mrb, mrb_value self)
+{
+  mrb_float f, f2 = 0;
+  mrb_get_args(mrb, "f|f", &f, &f2);
+  return mrb_time_make(mrb, mrb_class_ptr(self), f, f2, MRB_TIMEZONE_LOCAL);
+mrb_time_at_m(mrb_state *mrb, mrb_value self)
+{
+  mrb_value sec;
+  mrb_value usec = mrb_fixnum_value(0);
+  mrb_get_args(mrb, "o|o", &sec, &usec);
+  return mrb_time_make(mrb, mrb_class_ptr(self), sec, usec, MRB_TIMEZONE_LOCAL);
+}
 …
+  }
   return time_alloc(mrb, (double)nowsecs, ausec, timezone);
+  return time_alloc_time(mrb, nowsecs, ausec, timezone);
+}
 …
 mrb_time_plus(mrb_state *mrb, mrb_value self)
+{
+  mrb_float f;
+  struct mrb_time *tm;
+  mrb_get_args(mrb, "f", &f);
+  tm = time_get_ptr(mrb, self);
+  return mrb_time_make(mrb, mrb_obj_class(mrb, self), (double)tm->sec+f, (double)tm->usec, tm->timezone);
+  mrb_value o;
+  struct mrb_time *tm;
+  time_t sec, usec;
+  mrb_get_args(mrb, "o", &o);
+  tm = time_get_ptr(mrb, self);
+  sec = mrb_to_time_t(mrb, o, &usec);
+  return mrb_time_make_time(mrb, mrb_obj_class(mrb, self), tm->sec+sec, tm->usec+usec, tm->timezone);
+}
 …
 mrb_time_minus(mrb_state *mrb, mrb_value self)
+{
-  mrb_float f;
   mrb_value other;
   struct mrb_time *tm, *tm2;
 …
   tm2 = DATA_CHECK_GET_PTR(mrb, other, &mrb_time_type, struct mrb_time);
   if (tm2) {
+    f = (mrb_float)(tm->sec - tm2->sec)
+      + (mrb_float)(tm->usec - tm2->usec) / 1.0e6;
+#ifndef MRB_WITHOUT_FLOAT
+    mrb_float f;
+    f = (mrb_sec)(tm->sec - tm2->sec)
+      + (mrb_sec)(tm->usec - tm2->usec) / 1.0e6;
     return mrb_float_value(mrb, f);
+#else
+    mrb_int f;
+    f = tm->sec - tm2->sec;
+    if (tm->usec < tm2->usec) f--;
+    return mrb_fixnum_value(f);
+#endif
+  }
   else {
+    mrb_get_args(mrb, "f", &f);
+    return mrb_time_make(mrb, mrb_obj_class(mrb, self), (double)tm->sec-f, (double)tm->usec, tm->timezone);
+    time_t sec, usec;
+    sec = mrb_to_time_t(mrb, other, &usec);
+    return mrb_time_make_time(mrb, mrb_obj_class(mrb, self), tm->sec-sec, tm->usec-usec, tm->timezone);
+  }
+}
 …
   int len;
 #if defined(DISABLE_STDIO)
+#if defined(MRB_DISABLE_STDIO)
   char *s;
 # ifdef NO_ASCTIME_R
 …
   char buf[256];
   len = snprintf(buf, sizeof(buf), "%s %s %02d %02d:%02d:%02d %s%d",
+  len = snprintf(buf, sizeof(buf), "%s %s %2d %02d:%02d:%02d %.4d",
     wday_names[d->tm_wday], mon_names[d->tm_mon], d->tm_mday,
     d->tm_hour, d->tm_min, d->tm_sec,
-    tm->timezone == MRB_TIMEZONE_UTC ? "UTC " : "",
     d->tm_year + 1900);
 #endif
 …
   *tm2 = *tm;
   tm2->timezone = MRB_TIMEZONE_UTC;
   time_update_datetime(mrb, tm2);
+  time_update_datetime(mrb, tm2, TRUE);
   return mrb_time_wrap(mrb, mrb_obj_class(mrb, self), tm2);
+}
 …
   *tm2 = *tm;
   tm2->timezone = MRB_TIMEZONE_LOCAL;
   time_update_datetime(mrb, tm2);
+  time_update_datetime(mrb, tm2, TRUE);
   return mrb_time_wrap(mrb, mrb_obj_class(mrb, self), tm2);
+}
 …
   mrb_int ayear = 0, amonth = 1, aday = 1, ahour = 0,
   amin = 0, asec = 0, ausec = 0;
   int n;
+  mrb_int n;
   struct mrb_time *tm;
 …
   tm = time_get_ptr(mrb, self);
   tm->timezone = MRB_TIMEZONE_LOCAL;
   time_update_datetime(mrb, tm);
+  time_update_datetime(mrb, tm, FALSE);
   return self;
+}
 …
+}
+#ifndef MRB_WITHOUT_FLOAT
 /* 15.2.19.7.24 */
 /* Returns a Float with the time since the epoch in seconds. */
 …
   return mrb_float_value(mrb, (mrb_float)tm->sec + (mrb_float)tm->usec/1.0e6);
+}
+#endif
 /* 15.2.19.7.25 */
 /* Returns a Fixnum with the time since the epoch in seconds. */
+/* Returns an Integer with the time since the epoch in seconds. */
 static mrb_value
 mrb_time_to_i(mrb_state *mrb, mrb_value self)
 …
   tm = time_get_ptr(mrb, self);
+  if (tm->sec > MRB_INT_MAX || tm->sec < MRB_INT_MIN) {
+#ifndef MRB_WITHOUT_FLOAT
+  if (!fixable_time_t_p(tm->sec)) {
     return mrb_float_value(mrb, (mrb_float)tm->sec);
+  }
+#endif
   return mrb_fixnum_value((mrb_int)tm->sec);
+}
 /* 15.2.19.7.26 */
 /* Returns a Float with the time since the epoch in microseconds. */
+/* Returns an Integer with the time since the epoch in microseconds. */
 static mrb_value
 mrb_time_usec(mrb_state *mrb, mrb_value self)
 …
   tm = time_get_ptr(mrb, self);
+  if (tm->usec > MRB_INT_MAX || tm->usec < MRB_INT_MIN) {
+#ifndef MRB_WITHOUT_FLOAT
+  if (!fixable_time_t_p(tm->usec)) {
     return mrb_float_value(mrb, (mrb_float)tm->usec);
+  }
+#endif
   return mrb_fixnum_value((mrb_int)tm->usec);
+}
 …
   tm = time_get_ptr(mrb, self);
   tm->timezone = MRB_TIMEZONE_UTC;
   time_update_datetime(mrb, tm);
+  time_update_datetime(mrb, tm, FALSE);
   return self;
+}
 …
+}
+static size_t
+time_to_s_utc(mrb_state *mrb, struct mrb_time *tm, char *buf, size_t buf_len)
+{
+  return strftime(buf, buf_len, TO_S_FMT "UTC", &tm->datetime);
+}
+static size_t
+time_to_s_local(mrb_state *mrb, struct mrb_time *tm, char *buf, size_t buf_len)
+{
+#if defined(_MSC_VER) && _MSC_VER < 1900 || defined(__MINGW64__) || defined(__MINGW32__)
+  struct tm datetime = {0};
+  time_t utc_sec = timegm(&tm->datetime);
+  size_t len;
+  int offset;
+  if (utc_sec == (time_t)-1) {
+    mrb_raise(mrb, E_ARGUMENT_ERROR, "Not a valid time.");
+  }
+  offset = abs((int)(utc_sec - tm->sec) / 60);
+  datetime.tm_year = 100;
+  datetime.tm_hour = offset / 60;
+  datetime.tm_min = offset % 60;
+  len = strftime(buf, buf_len, TO_S_FMT, &tm->datetime);
+  buf[len++] = utc_sec < tm->sec ? '-' : '+';
+  return len + strftime(buf + len, buf_len - len, "%H%M", &datetime);
+#else
+  return strftime(buf, buf_len, TO_S_FMT "%z", &tm->datetime);
+#endif
+}
+static mrb_value
+mrb_time_to_s(mrb_state *mrb, mrb_value self)
+{
+  char buf[64];
+  struct mrb_time *tm = time_get_ptr(mrb, self);
+  mrb_bool utc = tm->timezone == MRB_TIMEZONE_UTC;
+  size_t len = (utc ? time_to_s_utc : time_to_s_local)(mrb, tm, buf, sizeof(buf));
+  return mrb_str_new(mrb, buf, len);
+}
 void
 …
   MRB_SET_INSTANCE_TT(tc, MRB_TT_DATA);
   mrb_include_module(mrb, tc, mrb_module_get(mrb, "Comparable"));
   mrb_define_class_method(mrb, tc, "at", mrb_time_at, MRB_ARGS_ARG(1, 1));      /* 15.2.19.6.1 */
+  mrb_define_class_method(mrb, tc, "at", mrb_time_at_m, MRB_ARGS_ARG(1, 1));      /* 15.2.19.6.1 */
   mrb_define_class_method(mrb, tc, "gm", mrb_time_gm, MRB_ARGS_ARG(1,6));       /* 15.2.19.6.2 */
   mrb_define_class_method(mrb, tc, "local", mrb_time_local, MRB_ARGS_ARG(1,6)); /* 15.2.19.6.3 */
 …
   mrb_define_method(mrb, tc, "+"      , mrb_time_plus   , MRB_ARGS_REQ(1)); /* 15.2.19.7.2 */
   mrb_define_method(mrb, tc, "-"      , mrb_time_minus  , MRB_ARGS_REQ(1)); /* 15.2.19.7.3 */
   mrb_define_method(mrb, tc, "to_s"   , mrb_time_asctime, MRB_ARGS_NONE());
   mrb_define_method(mrb, tc, "inspect", mrb_time_asctime, MRB_ARGS_NONE());
+  mrb_define_method(mrb, tc, "to_s"   , mrb_time_to_s   , MRB_ARGS_NONE());
+  mrb_define_method(mrb, tc, "inspect", mrb_time_to_s   , MRB_ARGS_NONE());
   mrb_define_method(mrb, tc, "asctime", mrb_time_asctime, MRB_ARGS_NONE()); /* 15.2.19.7.4 */
   mrb_define_method(mrb, tc, "ctime"  , mrb_time_asctime, MRB_ARGS_NONE()); /* 15.2.19.7.5 */
 …
   mrb_define_method(mrb, tc, "sec" , mrb_time_sec, MRB_ARGS_NONE());        /* 15.2.19.7.23 */
   mrb_define_method(mrb, tc, "to_i", mrb_time_to_i, MRB_ARGS_NONE());       /* 15.2.19.7.25 */
+#ifndef MRB_WITHOUT_FLOAT
   mrb_define_method(mrb, tc, "to_f", mrb_time_to_f, MRB_ARGS_NONE());       /* 15.2.19.7.24 */
+#endif
   mrb_define_method(mrb, tc, "usec", mrb_time_usec, MRB_ARGS_NONE());       /* 15.2.19.7.26 */
   mrb_define_method(mrb, tc, "utc" , mrb_time_utc, MRB_ARGS_NONE());        /* 15.2.19.7.27 */

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-time/test/time.rb

-              r331
+              r439
 assert('Time.new', '15.2.3.3.3') do
   Time.new.class == Time
+  assert_equal(Time, Time.new.class)
 end
 assert('Time', '15.2.19') do
   Time.class == Class
+  assert_equal(Class, Time.class)
 end
 …
 assert('Time.gm', '15.2.19.6.2') do
+  Time.gm(2012, 12, 23)
+  t = Time.gm(2012, 9, 23)
+  assert_operator(2012, :eql?, t.year)
+  assert_operator(   9, :eql?, t.month)
+  assert_operator(  23, :eql?, t.day)
+  assert_operator(   0, :eql?, t.hour)
+  assert_operator(   0, :eql?, t.min)
+  assert_operator(   0, :eql?, t.sec)
+  assert_operator(   0, :eql?, t.usec)
 end
 assert('Time.local', '15.2.19.6.3') do
+  Time.local(2012, 12, 23)
+  t = Time.local(2014, 12, 27, 18)
+  assert_operator(2014, :eql?, t.year)
+  assert_operator(  12, :eql?, t.month)
+  assert_operator(  27, :eql?, t.day)
+  assert_operator(  18, :eql?, t.hour)
+  assert_operator(   0, :eql?, t.min)
+  assert_operator(   0, :eql?, t.sec)
+  assert_operator(   0, :eql?, t.usec)
 end
 assert('Time.mktime', '15.2.19.6.4') do
+  Time.mktime(2012, 12, 23)
+  t = Time.mktime(2013, 10, 4, 6, 15, 58, 3485)
+  assert_operator(2013, :eql?, t.year)
+  assert_operator(  10, :eql?, t.month)
+  assert_operator(   4, :eql?, t.day)
+  assert_operator(   6, :eql?, t.hour)
+  assert_operator(  15, :eql?, t.min)
+  assert_operator(  58, :eql?, t.sec)
+  assert_operator(3485, :eql?, t.usec)
 end
 assert('Time.now', '15.2.19.6.5') do
   Time.now.class == Time
+  assert_equal(Time, Time.now.class)
 end
 assert('Time.utc', '15.2.19.6.6') do
+  Time.utc(2012, 12, 23)
+  t = Time.utc(2034)
+  assert_operator(2034, :eql?, t.year)
+  assert_operator(   1, :eql?, t.month)
+  assert_operator(   1, :eql?, t.day)
+  assert_operator(   0, :eql?, t.hour)
+  assert_operator(   0, :eql?, t.min)
+  assert_operator(   0, :eql?, t.sec)
+  assert_operator(   0, :eql?, t.usec)
 end
 …
   t2 = t1.+(60)
   assert_equal(t2.utc.asctime, "Sun Mar 13 07:07:40 UTC 2011")
+  assert_equal("Sun Mar 13 07:07:40 2011", t2.utc.asctime)
   assert_raise(FloatDomainError) { Time.at(0) + Float::NAN }
 …
   t2 = t1.-(60)
   assert_equal(t2.utc.asctime, "Sun Mar 13 07:05:40 UTC 2011")
+  assert_equal("Sun Mar 13 07:05:40 2011", t2.utc.asctime)
   assert_raise(FloatDomainError) { Time.at(0) - Float::NAN }
 …
   t3 = Time.at(1500000000.0)
   t2.<=>(t1) == 1 and
     t2.<=>(t2) == 0 and
     t2.<=>(t3) == -1 and
     t2.<=>(nil) == nil
+  assert_equal(1, t2 <=> t1)
+  assert_equal(0, t2 <=> t2)
+  assert_equal(-1, t2 <=> t3)
+  assert_nil(t2 <=> nil)
 end
 assert('Time#asctime', '15.2.19.7.4') do
   Time.at(1300000000.0).utc.asctime == "Sun Mar 13 07:06:40 UTC 2011"
+  assert_equal("Thu Mar  4 05:06:07 1982", Time.gm(1982,3,4,5,6,7).asctime)
 end
 assert('Time#ctime', '15.2.19.7.5') do
   Time.at(1300000000.0).utc.ctime == "Sun Mar 13 07:06:40 UTC 2011"
+  assert_equal("Thu Oct 24 15:26:47 2013", Time.gm(2013,10,24,15,26,47).ctime)
 end
 assert('Time#day', '15.2.19.7.6') do
   Time.gm(2012, 12, 23).day == 23
+  assert_equal(23, Time.gm(2012, 12, 23).day)
 end
 assert('Time#dst?', '15.2.19.7.7') do
   not Time.gm(2012, 12, 23).utc.dst?
+  assert_not_predicate(Time.gm(2012, 12, 23).utc, :dst?)
 end
 assert('Time#getgm', '15.2.19.7.8') do
   Time.at(1300000000.0).getgm.asctime == "Sun Mar 13 07:06:40 UTC 2011"
+  assert_equal("Sun Mar 13 07:06:40 2011", Time.at(1300000000.0).getgm.asctime)
 end
 …
   t3 = t1.getlocal
+  t1 == t3 and t3 == t2.getlocal
+  assert_equal(t1, t3)
+  assert_equal(t3, t2.getlocal)
 end
 assert('Time#getutc', '15.2.19.7.10') do
   Time.at(1300000000.0).getutc.asctime == "Sun Mar 13 07:06:40 UTC 2011"
+  assert_equal("Sun Mar 13 07:06:40 2011", Time.at(1300000000.0).getutc.asctime)
 end
 assert('Time#gmt?', '15.2.19.7.11') do
   Time.at(1300000000.0).utc.gmt?
+  assert_predicate(Time.at(1300000000.0).utc, :gmt?)
 end
 …
 assert('Time#gmtime', '15.2.19.7.13') do
+  Time.at(1300000000.0).gmtime
+  t = Time.now
+  assert_predicate(t.gmtime, :gmt?)
+  assert_predicate(t, :gmt?)
 end
 …
 assert('Time#hour', '15.2.19.7.15') do
   Time.gm(2012, 12, 23, 7, 6).hour == 7
+  assert_equal(7, Time.gm(2012, 12, 23, 7, 6).hour)
 end
 …
 assert('Time#initialize_copy', '15.2.19.7.17') do
   time_tmp_2 = Time.at(7.0e6)
   time_tmp_2.clone == time_tmp_2
+  t = Time.at(7.0e6)
+  assert_equal(t, t.clone)
 end
 assert('Time#localtime', '15.2.19.7.18') do
+  t1 = Time.at(1300000000.0)
+  t2 = Time.at(1300000000.0)
+  t1.localtime
+  t1 == t2.getlocal
+  t1 = Time.utc(2014, 5 ,6)
+  t2 = Time.utc(2014, 5 ,6)
+  t3 = t2.getlocal
+  assert_equal(t3, t1.localtime)
+  assert_equal(t3, t1)
 end
 assert('Time#mday', '15.2.19.7.19') do
   Time.gm(2012, 12, 23).mday == 23
+  assert_equal(23, Time.gm(2012, 12, 23).mday)
 end
 assert('Time#min', '15.2.19.7.20') do
   Time.gm(2012, 12, 23, 7, 6).min == 6
+  assert_equal(6, Time.gm(2012, 12, 23, 7, 6).min)
 end
 assert('Time#mon', '15.2.19.7.21') do
   Time.gm(2012, 12, 23).mon == 12
+  assert_equal(12, Time.gm(2012, 12, 23).mon)
 end
 assert('Time#month', '15.2.19.7.22') do
   Time.gm(2012, 12, 23).month == 12
+  assert_equal(12, Time.gm(2012, 12, 23).month)
 end
 assert('Times#sec', '15.2.19.7.23') do
   Time.gm(2012, 12, 23, 7, 6, 40).sec == 40
+  assert_equal(40, Time.gm(2012, 12, 23, 7, 6, 40).sec)
 end
 assert('Time#to_f', '15.2.19.7.24') do
   Time.at(1300000000.0).to_f == 1300000000.0
+  assert_operator(2.0, :eql?, Time.at(2).to_f)
 end
 assert('Time#to_i', '15.2.19.7.25') do
   Time.at(1300000000.0).to_i == 1300000000
+  assert_operator(2, :eql?, Time.at(2.0).to_i)
 end
 assert('Time#usec', '15.2.19.7.26') do
   Time.at(1300000000.0).usec == 0
+  assert_equal(0, Time.at(1300000000.0).usec)
 end
 assert('Time#utc', '15.2.19.7.27') do
+  Time.at(1300000000.0).utc
+  t = Time.now
+  assert_predicate(t.utc, :gmt?)
+  assert_predicate(t, :gmt?)
 end
 assert('Time#utc?', '15.2.19.7.28') do
   Time.at(1300000000.0).utc.utc?
+  assert_predicate(Time.at(1300000000.0).utc, :utc?)
 end
 …
 assert('Time#wday', '15.2.19.7.30') do
   Time.gm(2012, 12, 23).wday == 0
+  assert_equal(0, Time.gm(2012, 12, 23).wday)
 end
 assert('Time#yday', '15.2.19.7.31') do
   Time.gm(2012, 12, 23).yday == 358
+  assert_equal(358, Time.gm(2012, 12, 23).yday)
 end
 assert('Time#year', '15.2.19.7.32') do
   Time.gm(2012, 12, 23).year == 2012
+  assert_equal(2012, Time.gm(2012, 12, 23).year)
 end
 assert('Time#zone', '15.2.19.7.33') do
   Time.at(1300000000.0).utc.zone == 'UTC'
+  assert_equal('UTC', Time.at(1300000000.0).utc.zone)
 end
 …
 assert('Time#to_s') do
   Time.at(1300000000.0).utc.to_s == "Sun Mar 13 07:06:40 UTC 2011"
+  assert_equal("2003-04-05 06:07:08 UTC", Time.gm(2003,4,5,6,7,8,9).to_s)
 end
 assert('Time#inspect') do
+  Time.at(1300000000.0).utc.inspect == "Sun Mar 13 07:06:40 UTC 2011"
+  assert_match("2013-10-28 16:27:48 [+-][0-9][0-9][0-9][0-9]",
+               Time.local(2013,10,28,16,27,48).inspect)
 end
 …
     t += 0.0005
   end
+  t.usec == 0
+end
+  assert_equal(0, t.usec)
+end
+assert('Time.gm with Dec 31 23:59:59 1969 raise ArgumentError') do
+  assert_raise(ArgumentError) {Time.gm(1969, 12, 31, 23, 59, 59)}
+end

EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-toplevel-ext/test/toplevel.rb

-              r321
+              r439
   self.include ToplevelTestModule2, ToplevelTestModule1
   assert_true self.class.included_modules.include?( ToplevelTestModule1 )
   assert_true self.class.included_modules.include?( ToplevelTestModule2 )
+  assert_true self.class.ancestors.include?( ToplevelTestModule1 )
+  assert_true self.class.ancestors.include?( ToplevelTestModule2 )
   assert_equal :foo, method_foo
   assert_equal :bar2, CONST_BAR

Context Navigation

Legend:

Download in other formats: