script_core 0.2.3 → 0.3.0

data/ext/enterprise_script_service/mruby/mrbgems/stdlib-io.gembox

@@ -0,0 +1,12 @@
+# It also works with MRB_NO_FLOAT.
+
+MRuby::GemBox.new do |conf|
+  # Use standard IO/File class
+  conf.gem :core => "mruby-io"
+
+  # Use standard IO/File class
+  conf.gem :core => "mruby-socket"
+
+  # Use standard print/puts/p
+  conf.gem :core => "mruby-print"
+end

data/ext/enterprise_script_service/mruby/mrbgems/stdlib.gembox

@@ -0,0 +1,54 @@
+# It also works with MRB_NO_STDIO and MRB_NO_FLOAT.
+
+MRuby::GemBox.new do |conf|
+  # Use Comparable module extension
+  conf.gem :core => "mruby-compar-ext"
+
+  # Use Enumerable module extension
+  conf.gem :core => "mruby-enum-ext"
+
+  # Use String class extension
+  conf.gem :core => "mruby-string-ext"
+
+  # Use Numeric class extension
+  conf.gem :core => "mruby-numeric-ext"
+
+  # Use Array class extension
+  conf.gem :core => "mruby-array-ext"
+
+  # Use Hash class extension
+  conf.gem :core => "mruby-hash-ext"
+
+  # Use Range class extension
+  conf.gem :core => "mruby-range-ext"
+
+  # Use Proc class extension
+  conf.gem :core => "mruby-proc-ext"
+
+  # Use Symbol class extension
+  conf.gem :core => "mruby-symbol-ext"
+
+  # Use Object class extension
+  conf.gem :core => "mruby-object-ext"
+
+  # Use ObjectSpace class
+  conf.gem :core => "mruby-objectspace"
+
+  # Use Fiber class
+  conf.gem :core => "mruby-fiber"
+
+  # Use Enumerator class (require mruby-fiber)
+  conf.gem :core => "mruby-enumerator"
+
+  # Use Enumerator::Lazy class (require mruby-enumerator)
+  conf.gem :core => "mruby-enum-lazy"
+
+  # Use toplevel object (main) methods extension
+  conf.gem :core => "mruby-toplevel-ext"
+
+  # Use Kernel module extension
+  conf.gem :core => "mruby-kernel-ext"
+
+  # Use class/module extension
+  conf.gem :core => "mruby-class-ext"
+end

data/ext/enterprise_script_service/mruby/mrblib/00class.rb

@@ -1,3 +1,13 @@
+class BasicObject
+  def !=(other)
+    if self == other
+      false
+    else
+      true
+    end
+  end
+end
+
 class Module
    # 15.2.2.4.12
   def attr_accessor(*names)

data/ext/enterprise_script_service/mruby/mrblib/10error.rb

@@ -21,6 +21,10 @@ class RegexpError < StandardError
 class TypeError < StandardError
 end
 
+# ISO 15.2.30
+class ZeroDivisionError < StandardError
+end
+
 # ISO 15.2.31
 class NameError < StandardError
   attr_accessor :name

data/ext/enterprise_script_service/mruby/mrblib/array.rb

@@ -10,16 +10,16 @@ class Array
   # and pass the respective element.
   #
   # ISO 15.2.12.5.10
-  # def each(&block)
-  #   return to_enum :each unless block
+  def each(&block)
+    return to_enum :each unless block
 
-  #   idx = 0
-  #   while idx < length
-  #     block.call(self[idx])
-  #     idx += 1
-  #   end
-  #   self
-  # end
+    idx = 0
+    while idx < length
+      block.call(self[idx])
+      idx += 1
+    end
+    self
+  end
 
   ##
   # Calls the given block for each element of +self+
@@ -66,6 +66,10 @@ def collect!(&block)
   #
   # ISO 15.2.12.5.15
   def initialize(size=0, obj=nil, &block)
+    if size.is_a?(Array) && obj==nil && block == nil
+      self.replace(size)
+      return self
+    end
     size = size.__to_int
     raise ArgumentError, "negative array size" if size < 0
 
@@ -268,4 +272,8 @@ def sort!(&block)
   def sort(&block)
     self.dup.sort!(&block)
   end
+
+  def to_a
+    self
+  end
 end

data/ext/enterprise_script_service/mruby/mrblib/enum.rb

@@ -10,7 +10,7 @@
 # implement a meaningful `<=>` operator, as these methods
 # rely on an ordering between members of the collection.
 #
-# @ISO 15.3.2
+# ISO 15.3.2
 module Enumerable
 
   NONE = Object.new

data/ext/enterprise_script_service/mruby/mrblib/hash.rb

@@ -140,30 +140,10 @@ def each_key(&block)
   def each_value(&block)
     return to_enum :each_value unless block
 
-    self.keys.each{|k| block.call(self[k])}
+    self.values.each{|v| block.call(v)}
     self
   end
 
-  ##
-  # Replaces the contents of <i>hsh</i> with the contents of other hash
-  #
-  # ISO 15.2.13.4.23
-  def replace(hash)
-    raise TypeError, "Hash required (#{hash.class} given)" unless Hash === hash
-    self.clear
-    hash.each_key{|k|
-      self[k] = hash[k]
-    }
-    if hash.default_proc
-      self.default_proc = hash.default_proc
-    else
-      self.default = hash.default
-    end
-    self
-  end
-  # ISO 15.2.13.4.17
-  alias initialize_copy replace
-
   ##
   # Return a hash which contains the content of
   # +self+ and +other+. If a block is given
@@ -192,11 +172,11 @@ def _inspect(recur_list)
     recur_list[self.object_id] = true
     ary=[]
     keys=self.keys
+    vals=self.values
     size=keys.size
     i=0
     while i<size
-      k=keys[i]
-      ary<<(k._inspect(recur_list) + "=>" + self[k]._inspect(recur_list))
+      ary<<(keys[i]._inspect(recur_list) + "=>" + vals[i]._inspect(recur_list))
       i+=1
     end
     "{"+ary.join(", ")+"}"

data/ext/enterprise_script_service/mruby/mrblib/init_mrblib.c

@@ -1,11 +0,0 @@
-#include <mruby.h>
-#include <mruby/irep.h>
-
-extern const uint8_t mrblib_irep[];
-
-void
-mrb_init_mrblib(mrb_state *mrb)
-{
-  mrb_load_irep(mrb, mrblib_irep);
-}
-

data/ext/enterprise_script_service/mruby/mrblib/numeric.rb

@@ -34,11 +34,11 @@ def abs
 end
 
 ##
-# Integral
+# Integer
 #
-# mruby special - module to share methods between Floats and Integers
-#                 to make them compatible
-module Integral
+# ISO 15.2.8
+##
+class Integer
   ##
   # Calls the given block once for each Integer
   # from +self+ downto +num+.
@@ -125,14 +125,7 @@ def step(num=nil, step=1, &block)
     end
     self
   end
-end
 
-##
-# Integer
-#
-# ISO 15.2.8
-class Integer
-  include Integral
   ##
   # Returns the receiver simply.
   #
@@ -161,3 +154,35 @@ def floor
   # ISO 15.2.8.3.26
   alias truncate floor
 end
+
+class Float
+  ##
+  # Calls the given block from +self+ to +num+
+  # incremented by +step+ (default 1).
+  #
+  def step(num=nil, step=1, &block)
+    raise ArgumentError, "step can't be 0" if step == 0
+    return to_enum(:step, num, step) unless block
+
+    i = self
+    if num == self || step.infinite?
+      block.call(i) if step > 0 && i <= (num||i) || step < 0 && i >= (num||-i)
+    elsif num == nil
+      while true
+        block.call(i)
+        i += step
+      end
+    elsif step > 0
+      while i <= num
+        block.call(i)
+        i += step
+      end
+    else
+      while i >= num
+        block.call(i)
+        i += step
+      end
+    end
+    self
+  end
+end if Object.const_defined?(:Float)

data/ext/enterprise_script_service/mruby/mrblib/range.rb

@@ -12,10 +12,27 @@ class Range
   def each(&block)
     return to_enum :each unless block
 
-    val = self.first
-    last = self.last
+    val = self.begin
+    last = self.end
 
-    if val.kind_of?(Fixnum) && last.kind_of?(Fixnum) # fixnums are special
+    if val.kind_of?(Fixnum) && last.nil?
+      i = val
+      while true
+        block.call(i)
+        i += 1
+      end
+      return self
+    end
+
+    if val.kind_of?(String) && last.nil?
+      if val.respond_to? :__upto_endless
+        return val.__upto_endless(&block)
+      else
+        str_each = true
+      end
+    end
+
+    if val.kind_of?(Integer) && last.kind_of?(Integer) # fixnums are special
       lim = last
       lim += 1 unless exclude_end?
       i = val
@@ -56,6 +73,11 @@ def hash
     h += 1 if self.exclude_end?
     h
   end
+
+  def to_a
+    raise RangeError, "cannot convert endless range to an array" if self.last.nil?
+    super
+  end
 end
 
 ##

data/ext/enterprise_script_service/mruby/oss-fuzz/mruby_proto_fuzzer.cpp

@@ -5,8 +5,8 @@
 #include <mruby.h>
 #include <mruby/compile.h>
 
-#include "libprotobuf-mutator/src/libfuzzer/libfuzzer_macro.h"
-#include "ruby.pb.h"
+#include <src/libfuzzer/libfuzzer_macro.h>
+#include <ruby.pb.h>
 #include "proto_to_ruby.h"
 
 using namespace ruby_fuzzer;

data/ext/enterprise_script_service/mruby/oss-fuzz/proto_to_ruby.h

@@ -4,7 +4,7 @@
 #include <ostream>
 #include <sstream>
 #include <stack>
-#include "ruby.pb.h"
+#include <ruby.pb.h>
 
 namespace ruby_fuzzer {
 	class protoConverter

data/ext/enterprise_script_service/mruby/src/array.c

@@ -10,7 +10,7 @@
 #include <mruby/string.h>
 #include <mruby/range.h>
 #include <mruby/proc.h>
-#include <mruby/opcode.h>
+#include <mruby/presym.h>
 #include "value_array.h"
 
 #define ARY_DEFAULT_LEN   4
@@ -280,7 +280,7 @@ static mrb_value
 mrb_ary_s_create(mrb_state *mrb, mrb_value klass)
 {
   mrb_value ary;
-  mrb_value *vals;
+  const mrb_value *vals;
   mrb_int len;
   struct RArray *a;
 
@@ -340,7 +340,7 @@ mrb_ary_plus(mrb_state *mrb, mrb_value self)
 {
   struct RArray *a1 = mrb_ary_ptr(self);
   struct RArray *a2;
-  mrb_value *ptr;
+  const mrb_value *ptr;
   mrb_int blen, len1;
 
   mrb_get_args(mrb, "a", &ptr, &blen);
@@ -508,22 +508,26 @@ mrb_ary_push(mrb_state *mrb, mrb_value ary, mrb_value elem)
 static mrb_value
 mrb_ary_push_m(mrb_state *mrb, mrb_value self)
 {
-  mrb_value *argv;
-  mrb_int len, len2, alen;
+  mrb_int argc;
+  const mrb_value *argv;
+  mrb_int len, len2;
   struct RArray *a;
 
-  mrb_get_args(mrb, "*!", &argv, &alen);
+  argc = mrb_get_argc(mrb);
+  argv = mrb_get_argv(mrb);
   a = mrb_ary_ptr(self);
   ary_modify(mrb, a);
   len = ARY_LEN(a);
-  len2 = len + alen;
+  len2 = len + argc;
   if (ARY_CAPA(a) < len2) {
     ary_expand_capa(mrb, a, len2);
   }
-  array_copy(ARY_PTR(a)+len, argv, alen);
+  array_copy(ARY_PTR(a)+len, argv, argc);
   ARY_SET_LEN(a, len2);
-  mrb_write_barrier(mrb, (struct RBasic*)a);
-
+  while (argc--) {
+    mrb_field_write_barrier_value(mrb, (struct RBasic*)a, *argv);
+    argv++;
+  }
   return self;
 }
 
@@ -611,7 +615,8 @@ static mrb_value
 mrb_ary_unshift_m(mrb_state *mrb, mrb_value self)
 {
   struct RArray *a = mrb_ary_ptr(self);
-  mrb_value *vals, *ptr;
+  const mrb_value *vals;
+  mrb_value *ptr;
   mrb_int alen, len;
 
   mrb_get_args(mrb, "*!", &vals, &alen);
@@ -732,6 +737,10 @@ mrb_ary_splice(mrb_state *mrb, mrb_value ary, mrb_int head, mrb_int len, mrb_val
       argv = ARY_PTR(r);
     }
   }
+  else if (mrb_undef_p(rpl)) {
+    argc = 0;
+    argv = NULL;
+  }
   else {
     argc = 1;
     argv = &rpl;
@@ -804,20 +813,27 @@ ary_subseq(mrb_state *mrb, struct RArray *a, mrb_int beg, mrb_int len)
   return mrb_obj_value(b);
 }
 
+mrb_value
+mrb_ary_subseq(mrb_state *mrb, mrb_value ary, mrb_int beg, mrb_int len)
+{
+  struct RArray *a = mrb_ary_ptr(ary);
+  return ary_subseq(mrb, a, beg, len);
+}
+
 static mrb_int
 aget_index(mrb_state *mrb, mrb_value index)
 {
-  if (mrb_fixnum_p(index)) {
-    return mrb_fixnum(index);
+  if (mrb_integer_p(index)) {
+    return mrb_integer(index);
   }
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
   else if (mrb_float_p(index)) {
     return (mrb_int)mrb_float(index);
   }
 #endif
   else {
     mrb_int i, argc;
-    mrb_value *argv;
+    const mrb_value *argv;
 
     mrb_get_args(mrb, "i*!", &i, &argv, &argc);
     return i;
@@ -855,10 +871,12 @@ static mrb_value
 mrb_ary_aget(mrb_state *mrb, mrb_value self)
 {
   struct RArray *a = mrb_ary_ptr(self);
-  mrb_int i, len, alen;
+  mrb_int i;
+  mrb_int len, alen;
   mrb_value index;
 
-  if (mrb_get_args(mrb, "o|i", &index, &len) == 1) {
+  if (mrb_get_argc(mrb) == 1) {
+    index = mrb_get_arg1(mrb);
     switch (mrb_type(index)) {
       /* a[n..m] */
     case MRB_TT_RANGE:
@@ -868,13 +886,14 @@ mrb_ary_aget(mrb_state *mrb, mrb_value self)
       else {
         return mrb_nil_value();
       }
-    case MRB_TT_FIXNUM:
-      return mrb_ary_ref(mrb, self, mrb_fixnum(index));
+    case MRB_TT_INTEGER:
+      return mrb_ary_ref(mrb, self, mrb_integer(index));
     default:
       return mrb_ary_ref(mrb, self, aget_index(mrb, index));
     }
   }
 
+  mrb_get_args(mrb, "oi", &index, &len);
   i = aget_index(mrb, index);
   alen = ARY_LEN(a);
   if (i < 0) i += alen;
@@ -927,8 +946,11 @@ mrb_ary_aset(mrb_state *mrb, mrb_value self)
   mrb_value v1, v2, v3;
   mrb_int i, len;
 
-  mrb_ary_modify(mrb, mrb_ary_ptr(self));
-  if (mrb_get_args(mrb, "oo|o", &v1, &v2, &v3) == 2) {
+  ary_modify(mrb, mrb_ary_ptr(self));
+  if (mrb_get_argc(mrb) == 2) {
+    const mrb_value *vs = mrb_get_argv(mrb);
+    v1 = vs[0]; v2 = vs[1];
+
     /* a[n..m] = v */
     switch (mrb_range_beg_len(mrb, v1, &i, &len, RARRAY_LEN(self), FALSE)) {
     case MRB_RANGE_TYPE_MISMATCH:
@@ -944,6 +966,7 @@ mrb_ary_aset(mrb_state *mrb, mrb_value self)
     return v2;
   }
 
+  mrb_get_args(mrb, "ooo", &v1, &v2, &v3);
   /* a[n,m] = v */
   mrb_ary_splice(mrb, self, aget_index(mrb, v1), aget_index(mrb, v2), v3);
   return v3;
@@ -1027,10 +1050,9 @@ mrb_ary_last(mrb_state *mrb, mrb_value self)
 static mrb_value
 mrb_ary_index_m(mrb_state *mrb, mrb_value self)
 {
-  mrb_value obj;
+  mrb_value obj = mrb_get_arg1(mrb);
   mrb_int i;
 
-  mrb_get_args(mrb, "o", &obj);
   for (i = 0; i < RARRAY_LEN(self); i++) {
     if (mrb_equal(mrb, RARRAY_PTR(self)[i], obj)) {
       return mrb_fixnum_value(i);
@@ -1042,10 +1064,9 @@ mrb_ary_index_m(mrb_state *mrb, mrb_value self)
 static mrb_value
 mrb_ary_rindex_m(mrb_state *mrb, mrb_value self)
 {
-  mrb_value obj;
+  mrb_value obj = mrb_get_arg1(mrb);
   mrb_int i, len;
 
-  mrb_get_args(mrb, "o", &obj);
   for (i = RARRAY_LEN(self) - 1; i >= 0; i--) {
     if (mrb_equal(mrb, RARRAY_PTR(self)[i], obj)) {
       return mrb_fixnum_value(i);
@@ -1060,22 +1081,26 @@ mrb_ary_rindex_m(mrb_state *mrb, mrb_value self)
 MRB_API mrb_value
 mrb_ary_splat(mrb_state *mrb, mrb_value v)
 {
-  mrb_value a;
+  mrb_value ary;
+  struct RArray *a;
 
   if (mrb_array_p(v)) {
-    return v;
+    a = ary_dup(mrb, mrb_ary_ptr(v));
+    return mrb_obj_value(a);
   }
 
-  if (!mrb_respond_to(mrb, v, mrb_intern_lit(mrb, "to_a"))) {
+  if (!mrb_respond_to(mrb, v, MRB_SYM(to_a))) {
     return mrb_ary_new_from_values(mrb, 1, &v);
   }
 
-  a = mrb_funcall(mrb, v, "to_a", 0);
-  if (mrb_nil_p(a)) {
+  ary = mrb_funcall_id(mrb, v, MRB_SYM(to_a), 0);
+  if (mrb_nil_p(ary)) {
     return mrb_ary_new_from_values(mrb, 1, &v);
   }
-  mrb_ensure_array_type(mrb, a);
-  return a;
+  mrb_ensure_array_type(mrb, ary);
+  a = mrb_ary_ptr(ary);
+  a = ary_dup(mrb, a);
+  return mrb_obj_value(a);
 }
 
 static mrb_value
@@ -1099,8 +1124,14 @@ mrb_ary_clear(mrb_state *mrb, mrb_value self)
   else if (!ARY_EMBED_P(a)){
     mrb_free(mrb, a->as.heap.ptr);
   }
-  ARY_SET_EMBED_LEN(a, 0);
-
+  if (MRB_ARY_EMBED_LEN_MAX > 0) {
+    ARY_SET_EMBED_LEN(a, 0);
+  }
+  else {
+    a->as.heap.ptr = NULL;
+    a->as.heap.aux.capa = 0;
+    ARY_SET_LEN(a, 0);
+  }
   return self;
 }
 
@@ -1219,9 +1250,8 @@ mrb_ary_join_m(mrb_state *mrb, mrb_value ary)
 static mrb_value
 mrb_ary_eq(mrb_state *mrb, mrb_value ary1)
 {
-  mrb_value ary2;
+  mrb_value ary2 = mrb_get_arg1(mrb);
 
-  mrb_get_args(mrb, "o", &ary2);
   if (mrb_obj_equal(mrb, ary1, ary2)) return mrb_true_value();
   if (!mrb_array_p(ary2)) {
     return mrb_false_value();
@@ -1234,9 +1264,8 @@ mrb_ary_eq(mrb_state *mrb, mrb_value ary1)
 static mrb_value
 mrb_ary_cmp(mrb_state *mrb, mrb_value ary1)
 {
-  mrb_value ary2;
+  mrb_value ary2 = mrb_get_arg1(mrb);
 
-  mrb_get_args(mrb, "o", &ary2);
   if (mrb_obj_equal(mrb, ary1, ary2)) return mrb_fixnum_value(0);
   if (!mrb_array_p(ary2)) {
     return mrb_nil_value();
@@ -1259,56 +1288,6 @@ mrb_ary_svalue(mrb_state *mrb, mrb_value ary)
   }
 }
 
-static const mrb_code each_iseq[] = {
-  OP_ENTER, 0x0, 0x00, 0x1,  /* OP_ENTER     0:0:0:0:0:0:1 */
-  OP_JMPIF, 0x1, 0x0, 19,    /* OP_JMPIF     R1  19 */
-  OP_LOADSELF, 0x3,          /* OP_LOADSELF  R3 */
-  OP_LOADSYM, 0x4, 0x0,      /* OP_LOADSYM   R4  :each*/
-  OP_SEND, 0x3, 0x1, 0x1,    /* OP_SEND      R3  :to_enum   1 */
-  OP_RETURN, 0x3,            /* OP_RETURN    R3 */
-  OP_LOADI_0, 0x2,           /* OP_LOADI_0   R2 */
-  OP_JMP, 0x0, 43,           /* OP_JMP       49 */
-  OP_MOVE, 0x3, 0x1,         /* OP_MOVE      R3  R1 */
-  OP_LOADSELF, 0x4,          /* OP_LOADSELF  R4 */
-  OP_MOVE, 0x5, 0x2,         /* OP_MOVE      R5  R2 */
-  OP_SEND, 0x4, 0x2, 0x1,    /* OP_SEND      R4  :[]        1 */
-  OP_SEND, 0x3, 0x3, 0x1,    /* OP_SEND      R3  :call      1 */
-  OP_ADDI, 0x2, 1,           /* OP_ADDI      R3  1 */
-  OP_MOVE, 0x3, 0x2,         /* OP_MOVE      R3  R2 */
-  OP_LOADSELF, 0x4,          /* OP_LOADSELF  R4 */
-  OP_SEND, 0x4, 0x4, 0x0,    /* OP_SEND      R4  :length    0 */
-  OP_LT, 0x3,                /* OP_LT        R3 */
-  OP_JMPIF, 0x3, 0x0, 24,    /* OP_JMPIF     R3  24 */
-  OP_RETURN, 0x0             /* OP_RETURN    R3 */
-};
-
-static void
-init_ary_each(mrb_state *mrb, struct RClass *ary)
-{
-  struct RProc *p;
-  mrb_method_t m;
-  mrb_irep *each_irep = (mrb_irep*)mrb_malloc(mrb, sizeof(mrb_irep));
-  static const mrb_irep mrb_irep_zero = { 0 };
-
-  *each_irep = mrb_irep_zero;
-  each_irep->syms = (mrb_sym*)mrb_malloc(mrb, sizeof(mrb_sym)*5);
-  each_irep->syms[0] = mrb_intern_lit(mrb, "each");
-  each_irep->syms[1] = mrb_intern_lit(mrb, "to_enum");
-  each_irep->syms[2] = mrb_intern_lit(mrb, "[]");
-  each_irep->syms[3] = mrb_intern_lit(mrb, "call");
-  each_irep->syms[4] = mrb_intern_lit(mrb, "length");
-  each_irep->slen = 5;
-  each_irep->flags = MRB_ISEQ_NO_FREE;
-  each_irep->iseq = each_iseq;
-  each_irep->ilen = sizeof(each_iseq);
-  each_irep->nregs = 7;
-  each_irep->nlocals = 3;
-  p = mrb_proc_new(mrb, each_irep);
-  p->flags |= MRB_PROC_SCOPE | MRB_PROC_STRICT;
-  MRB_METHOD_FROM_PROC(m, p);
-  mrb_define_method_raw(mrb, ary, mrb_intern_lit(mrb, "each"), m);
-}
-
 void
 mrb_init_array(mrb_state *mrb)
 {
@@ -1349,6 +1328,4 @@ mrb_init_array(mrb_state *mrb)
   mrb_define_method(mrb, a, "__ary_cmp",       mrb_ary_cmp,          MRB_ARGS_REQ(1));
   mrb_define_method(mrb, a, "__ary_index",     mrb_ary_index_m,      MRB_ARGS_REQ(1));   /* kept for mruby-array-ext */
   mrb_define_method(mrb, a, "__svalue",        mrb_ary_svalue,       MRB_ARGS_NONE());
-
-  init_ary_each(mrb, a);
 }