script_core 0.2.7 → 0.3.0

data/ext/enterprise_script_service/mruby/mrbgems/mruby-compiler/mrbgem.rake

@@ -3,36 +3,35 @@
   spec.author  = 'mruby developers'
   spec.summary = 'mruby compiler library'
 
-  lex_def = "#{dir}/core/lex.def"
-  core_objs = Dir.glob("#{dir}/core/*.c").map { |f|
-    next nil if build.cxx_exception_enabled? and f =~ /(codegen).c$/
-    objfile(f.pathmap("#{build_dir}/core/%n"))
-  }.compact
-
-  if build.cxx_exception_enabled?
-    core_objs <<
-      build.compile_as_cxx("#{dir}/core/y.tab.c", "#{build_dir}/core/y.tab.cxx",
-                           objfile("#{build_dir}/y.tab"), ["#{dir}/core"]) <<
-      build.compile_as_cxx("#{dir}/core/codegen.c", "#{build_dir}/core/codegen.cxx")
-  else
-    core_objs << objfile("#{build_dir}/core/y.tab")
-    file objfile("#{build_dir}/core/y.tab") => "#{dir}/core/y.tab.c" do |t|
-      cc.run t.name, t.prerequisites.first, [], ["#{dir}/core"]
+  objs = %w[codegen y.tab].map do |name|
+    src = "#{dir}/core/#{name}.c"
+    if build.cxx_exception_enabled?
+      build.compile_as_cxx(src)
+    else
+      objfile(src.pathmap("#{build_dir}/core/%n"))
     end
   end
+  build.libmruby_core_objs << objs
+
+  lex_def = "#{dir}/core/lex.def"
 
   # Parser
   file "#{dir}/core/y.tab.c" => ["#{dir}/core/parse.y", lex_def] do |t|
     yacc.run t.name, t.prerequisites.first
-    content = File.read(t.name).gsub(/^#line +\d+ +"\K.*$/){$&.relative_path}
-    File.write(t.name, content)
+    replace_line_directive(t.name)
   end
 
   # Lexical analyzer
   file lex_def => "#{dir}/core/keywords" do |t|
     gperf.run t.name, t.prerequisites.first
+    replace_line_directive(t.name)
   end
 
-  file build.libmruby_core_static => core_objs
-  build.libmruby << core_objs
+  def replace_line_directive(path)
+    content = File.read(path).gsub(%r{
+      ^\#line\s+\d+\s+"\K.*$ |                  # #line directive
+      ^/\*\s+Command-line:.*\s\K\S+(?=\s+\*/$)  # header comment in lex.def
+    }x, &:relative_path)
+    File.write(path, content)
+  end
 end

data/ext/enterprise_script_service/mruby/mrbgems/mruby-complex/mrblib/complex.rb

@@ -104,7 +104,7 @@ def to_r
 
   alias_method :imag, :imaginary
 
-  [Fixnum, Float].each do |cls|
+  [Integer, Float].each do |cls|
     [:+, :-, :*, :/, :==].each do |op|
       cls.instance_eval do
         original_operator_name = :"__original_operator_#{op}_complex"

data/ext/enterprise_script_service/mruby/mrbgems/mruby-complex/src/complex.c

@@ -1,10 +1,11 @@
 #include <mruby.h>
 #include <mruby/class.h>
 #include <mruby/numeric.h>
+#include <mruby/presym.h>
 #include <math.h>
 
-#ifdef MRB_WITHOUT_FLOAT
-# error Complex conflicts 'MRB_WITHOUT_FLOAT' configuration in your 'build_config.rb'
+#ifdef MRB_NO_FLOAT
+# error Complex conflicts with 'MRB_NO_FLOAT' configuration
 #endif
 
 struct mrb_complex {
@@ -12,13 +13,13 @@ struct mrb_complex {
   mrb_float imaginary;
 };
 
-#ifdef MRB_USE_FLOAT
+#ifdef MRB_USE_FLOAT32
 #define F(x) x##f
 #else
 #define F(x) x
 #endif
 
-#if defined(MRB_64BIT) || defined(MRB_USE_FLOAT)
+#if defined(MRB_64BIT) || defined(MRB_USE_FLOAT32)
 
 #define COMPLEX_USE_ISTRUCT
 /* use TT_ISTRUCT */
@@ -69,7 +70,7 @@ complex_ptr(mrb_state *mrb, mrb_value v)
 static mrb_value
 complex_new(mrb_state *mrb, mrb_float real, mrb_float imaginary)
 {
-  struct RClass *c = mrb_class_get(mrb, "Complex");
+  struct RClass *c = mrb_class_get_id(mrb, MRB_SYM(Complex));
   struct mrb_complex *p;
   struct RBasic *comp = complex_alloc(mrb, c, &p);
   p->real = real;
@@ -122,7 +123,7 @@ complex_to_i(mrb_state *mrb, mrb_value self)
   if (p->imaginary != 0) {
     mrb_raisef(mrb, E_RANGE_ERROR, "can't convert %v into Float", self);
   }
-  return mrb_int_value(mrb, p->real);
+  return mrb_int_value(mrb, (mrb_int)p->real);
 }
 
 static mrb_value
@@ -224,7 +225,7 @@ void mrb_mruby_complex_gem_init(mrb_state *mrb)
 #ifdef COMPLEX_USE_ISTRUCT
   mrb_assert(sizeof(struct mrb_complex) < ISTRUCT_DATA_SIZE);
 #endif
-  comp = mrb_define_class(mrb, "Complex", mrb_class_get(mrb, "Numeric"));
+  comp = mrb_define_class(mrb, "Complex", mrb_class_get_id(mrb, MRB_SYM(Numeric)));
 #ifdef COMPLEX_USE_ISTRUCT
   MRB_SET_INSTANCE_TT(comp, MRB_TT_ISTRUCT);
 #else

data/ext/enterprise_script_service/mruby/mrbgems/mruby-complex/test/complex.rb

@@ -56,11 +56,11 @@ def assert_complex(real, exp)
 assert 'Complex#/' do
   assert_complex Complex(2, 3)  / Complex(2, 3) , (1                  + 0i)
   assert_complex Complex(900)   / Complex(1)    , (900                + 0i)
-  assert_complex Complex(-2, 9) / Complex(-9, 2), ((36 / 85)          - (77i / 85))
-  assert_complex Complex(9, 8)  / 4             , ((9 / 4)            + 2i)
+  assert_complex Complex(-2, 9) / Complex(-9, 2), ((36.0 / 85)        - (77i / 85))
+  assert_complex Complex(9, 8)  / 4             , ((9.0 / 4)          + 2i)
   assert_complex Complex(20, 9) / 9.8           , (2.0408163265306123 + 0.9183673469387754i)
   if 1e39.infinite? then
-    # MRB_USE_FLOAT in effect
+    # MRB_USE_FLOAT32 in effect
     ten = 1e21
     one = 1e20
   else
@@ -80,7 +80,7 @@ def assert_complex(real, exp)
   assert_float Complex(-1).abs,        1
   assert_float Complex(3.0, -4.0).abs, 5.0
   if 1e39.infinite? then
-    # MRB_USE_FLOAT in effect
+    # MRB_USE_FLOAT32 in effect
     exp = 125
   else
     exp = 1021

data/ext/enterprise_script_service/mruby/mrbgems/mruby-enumerator/mrblib/enumerator.rb

@@ -130,6 +130,7 @@ def initialize(obj=NONE, meth=:each, *args, &block)
     @feedvalue = nil
     @stop_exc = false
   end
+
   attr_accessor :obj, :meth, :args
   attr_reader :fib
 

data/ext/enterprise_script_service/mruby/mrbgems/mruby-enumerator/test/enumerator.rb

@@ -445,7 +445,7 @@ def (o = Object.new).each
   }
 end
 
-assert 'Integral#times' do
+assert 'Integer#times' do
   a = 3
   b = a.times
   c = []
@@ -567,7 +567,7 @@ def (o = Object.new).each
   # Without initial object
   passed_args = []
   enum = Enumerator.produce {|obj| passed_args << obj; (obj || 0).succ }
-  assert_equal Enumerator, enum.class 
+  assert_equal Enumerator, enum.class
   assert_take [1, 2, 3], enum
   assert_equal [nil, 1, 2], passed_args
 

data/ext/enterprise_script_service/mruby/mrbgems/mruby-error/mrbgem.rake

@@ -4,7 +4,7 @@
   spec.summary = 'extensional error handling'
 
   if build.cxx_exception_enabled?
-    @objs << build.compile_as_cxx("#{spec.dir}/src/exception.c", "#{spec.build_dir}/src/exception.cxx")
-    @objs.delete_if { |v| v == objfile("#{spec.build_dir}/src/exception") }
+    objs << build.compile_as_cxx("#{spec.dir}/src/exception.c")
+    objs.delete_if { |v| v == objfile("#{spec.build_dir}/src/exception") }
   end
 end

data/ext/enterprise_script_service/mruby/mrbgems/mruby-eval/src/eval.c

@@ -5,14 +5,16 @@
 #include <mruby/proc.h>
 #include <mruby/opcode.h>
 #include <mruby/error.h>
+#include <mruby/presym.h>
 
+struct REnv *mrb_env_new(mrb_state *mrb, struct mrb_context *c, mrb_callinfo *ci, int nstacks, mrb_value *stack, struct RClass *tc);
 mrb_value mrb_exec_irep(mrb_state *mrb, mrb_value self, struct RProc *p);
 mrb_value mrb_obj_instance_eval(mrb_state *mrb, mrb_value self);
 
 void mrb_codedump_all(mrb_state*, struct RProc*);
 
 static struct RProc*
-create_proc_from_string(mrb_state *mrb, char *s, mrb_int len, mrb_value binding, const char *file, mrb_int line)
+create_proc_from_string(mrb_state *mrb, const char *s, mrb_int len, mrb_value binding, const char *file, mrb_int line)
 {
   mrbc_context *cxt;
   struct mrb_parser_state *p;
@@ -20,7 +22,6 @@ create_proc_from_string(mrb_state *mrb, char *s, mrb_int len, mrb_value binding,
   struct REnv *e;
   mrb_callinfo *ci; /* callinfo of eval caller */
   struct RClass *target_class = NULL;
-  int bidx;
 
   if (!mrb_nil_p(binding)) {
     mrb_raise(mrb, E_ARGUMENT_ERROR, "Binding of eval must be nil.");
@@ -39,7 +40,7 @@ create_proc_from_string(mrb_state *mrb, char *s, mrb_int len, mrb_value binding,
 
   /* only occur when memory ran out */
   if (!p) {
-    mrb_raise(mrb, E_RUNTIME_ERROR, "Failed to create parser state.");
+    mrb_raise(mrb, E_RUNTIME_ERROR, "Failed to create parser state (out of memory)");
   }
 
   if (0 < p->nerr) {
@@ -79,28 +80,19 @@ create_proc_from_string(mrb_state *mrb, char *s, mrb_int len, mrb_value binding,
     target_class = MRB_PROC_TARGET_CLASS(ci->proc);
   }
   if (ci->proc && !MRB_PROC_CFUNC_P(ci->proc)) {
-    if (ci->env) {
-      e = ci->env;
+    if ((e = mrb_vm_ci_env(ci)) != NULL) {
+      /* do nothing, because e is assigned already */
     }
     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_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;
+      e = mrb_env_new(mrb, mrb->c, ci, ci->proc->body.irep->nlocals, ci->stack, target_class);
+      ci->u.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;
+  mrb_vm_ci_target_class_set(mrb->c->ci, target_class);
   /* mrb_codedump_all(mrb, proc); */
 
   mrb_parser_free(p);
@@ -124,17 +116,17 @@ exec_irep(mrb_state *mrb, mrb_value self, struct RProc *proc)
     return ret;
   }
   /* clear block */
-  mrb->c->stack[1] = mrb_nil_value();
+  mrb->c->ci->stack[1] = mrb_nil_value();
   return mrb_exec_irep(mrb, self, proc);
 }
 
 static mrb_value
 f_eval(mrb_state *mrb, mrb_value self)
 {
-  char *s;
+  const char *s;
   mrb_int len;
   mrb_value binding = mrb_nil_value();
-  char *file = NULL;
+  const char *file = NULL;
   mrb_int line = 1;
   struct RProc *proc;
 
@@ -149,14 +141,14 @@ static mrb_value
 f_instance_eval(mrb_state *mrb, mrb_value self)
 {
   mrb_value b;
-  mrb_int argc; mrb_value *argv;
+  mrb_int argc; const mrb_value *argv;
 
   mrb_get_args(mrb, "*!&", &argv, &argc, &b);
 
   if (mrb_nil_p(b)) {
-    char *s;
+    const char *s;
     mrb_int len;
-    char *file = NULL;
+    const char *file = NULL;
     mrb_int line = 1;
     mrb_value cv;
     struct RProc *proc;
@@ -166,7 +158,7 @@ f_instance_eval(mrb_state *mrb, mrb_value self)
     proc = create_proc_from_string(mrb, s, len, mrb_nil_value(), file, line);
     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);
+    mrb_vm_ci_target_class_set(mrb->c->ci, mrb_class_ptr(cv));
     return exec_irep(mrb, self, proc);
   }
   else {
@@ -179,7 +171,7 @@ void
 mrb_mruby_eval_gem_init(mrb_state* mrb)
 {
   mrb_define_module_function(mrb, mrb->kernel_module, "eval", f_eval, MRB_ARGS_ARG(1, 3));
-  mrb_define_method(mrb, mrb_class_get(mrb, "BasicObject"), "instance_eval", f_instance_eval, MRB_ARGS_OPT(3)|MRB_ARGS_BLOCK());
+  mrb_define_method(mrb, mrb_class_get_id(mrb, MRB_SYM(BasicObject)), "instance_eval", f_instance_eval, MRB_ARGS_OPT(3)|MRB_ARGS_BLOCK());
 }
 
 void

data/ext/enterprise_script_service/mruby/mrbgems/mruby-fiber/src/fiber.c

@@ -93,7 +93,6 @@ fiber_init(mrb_state *mrb, mrb_value self)
   }
   c->stbase = (mrb_value *)mrb_malloc(mrb, slen*sizeof(mrb_value));
   c->stend = c->stbase + slen;
-  c->stack = c->stbase;
 
 #ifdef MRB_NAN_BOXING
   {
@@ -110,20 +109,19 @@ fiber_init(mrb_state *mrb, mrb_value self)
 #endif
 
   /* copy receiver from a block */
-  c->stack[0] = mrb->c->stack[0];
+  c->stbase[0] = mrb->c->ci->stack[0];
 
   /* initialize callinfo stack */
   c->cibase = (mrb_callinfo *)mrb_calloc(mrb, FIBER_CI_INIT_SIZE, sizeof(mrb_callinfo));
   c->ciend = c->cibase + FIBER_CI_INIT_SIZE;
   c->ci = c->cibase;
-  c->ci->stackent = c->stack;
 
   /* adjust return callinfo */
   ci = c->ci;
-  ci->target_class = MRB_PROC_TARGET_CLASS(p);
-  ci->proc = p;
+  mrb_vm_ci_target_class_set(ci, MRB_PROC_TARGET_CLASS(p));
+  mrb_vm_ci_proc_set(ci, p);
   mrb_field_write_barrier(mrb, (struct RBasic*)mrb_obj_ptr(self), (struct RBasic*)p);
-  ci->pc = p->body.irep->iseq;
+  ci->stack = c->stbase;
   ci[1] = ci[0];
   c->ci++;                      /* push dummy callinfo */
 
@@ -154,7 +152,7 @@ fiber_result(mrb_state *mrb, const mrb_value *a, mrb_int len)
 }
 
 /* mark return from context modifying method */
-#define MARK_CONTEXT_MODIFY(c) (c)->ci->target_class = NULL
+#define MARK_CONTEXT_MODIFY(c) (c)->ci->u.target_class = NULL
 
 static void
 fiber_check_cfunc(mrb_state *mrb, struct mrb_context *c)
@@ -214,21 +212,27 @@ fiber_switch(mrb_state *mrb, mrb_value self, mrb_int len, const mrb_value *a, mr
       mrb_raise(mrb, E_FIBER_ERROR, "double resume (current)");
     }
     mrb_stack_extend(mrb, len+2); /* for receiver and (optional) block */
-    b = c->stack+1;
+    b = c->stbase+1;
     e = b + len;
     while (b<e) {
       *b++ = *a++;
     }
+    if (vmexec) {
+      c->ci--;                    /* pop dummy callinfo */
+    }
     c->cibase->argc = (int)len;
-    value = c->stack[0] = MRB_PROC_ENV(c->ci->proc)->stack[0];
+    value = c->stbase[0] = MRB_PROC_ENV(c->cibase->proc)->stack[0];
   }
   else {
     value = fiber_result(mrb, a, len);
+    if (vmexec) {
+      c->ci->stack[c->ci[1].acc] = value;
+    }
   }
 
   if (vmexec) {
     c->vmexec = TRUE;
-    value = mrb_vm_exec(mrb, c->ci[-1].proc, c->ci->pc);
+    value = mrb_vm_exec(mrb, c->ci->proc, c->ci->pc);
     mrb->c = old_c;
   }
   else {
@@ -255,7 +259,7 @@ fiber_switch(mrb_state *mrb, mrb_value self, mrb_int len, const mrb_value *a, mr
 static mrb_value
 fiber_resume(mrb_state *mrb, mrb_value self)
 {
-  mrb_value *a;
+  const mrb_value *a;
   mrb_int len;
   mrb_bool vmexec = FALSE;
 
@@ -315,7 +319,7 @@ static mrb_value
 fiber_transfer(mrb_state *mrb, mrb_value self)
 {
   struct mrb_context *c = fiber_check(mrb, self);
-  mrb_value* a;
+  const mrb_value* a;
   mrb_int len;
 
   fiber_check_cfunc(mrb, mrb->c);
@@ -354,6 +358,7 @@ mrb_fiber_yield(mrb_state *mrb, mrb_int len, const mrb_value *a)
   if (c->vmexec) {
     c->vmexec = FALSE;
     mrb->c->ci->acc = CI_ACC_RESUMED;
+    c->ci--;                    /* pop callinfo for yield */
   }
   MARK_CONTEXT_MODIFY(mrb->c);
   return fiber_result(mrb, a, len);
@@ -374,7 +379,7 @@ mrb_fiber_yield(mrb_state *mrb, mrb_int len, const mrb_value *a)
 static mrb_value
 fiber_yield(mrb_state *mrb, mrb_value self)
 {
-  mrb_value *a;
+  const mrb_value *a;
   mrb_int len;
 
   mrb_get_args(mrb, "*!", &a, &len);

data/ext/enterprise_script_service/mruby/mrbgems/mruby-hash-ext/src/hash-ext.c

@@ -22,7 +22,8 @@
 static mrb_value
 hash_values_at(mrb_state *mrb, mrb_value hash)
 {
-  mrb_value *argv, result;
+  const mrb_value *argv;
+  mrb_value result;
   mrb_int argc, i;
   int ai;
 
@@ -49,7 +50,8 @@ hash_values_at(mrb_state *mrb, mrb_value hash)
 static mrb_value
 hash_slice(mrb_state *mrb, mrb_value hash)
 {
-  mrb_value *argv, result;
+  const mrb_value *argv;
+  mrb_value result;
   mrb_int argc, i;
 
   mrb_get_args(mrb, "*", &argv, &argc);
@@ -67,6 +69,31 @@ hash_slice(mrb_state *mrb, mrb_value hash)
   return result;
 }
 
+/*
+ *  call-seq:
+ *     hsh.except(*keys) -> a_hash
+ *
+ *  Returns a hash excluding the given keys and their values.
+ * 
+ *     h = { a: 100, b: 200, c: 300 }
+ *     h.except(:a)          #=> {:b=>200, :c=>300}
+ *     h.except(:b, :c, :d)  #=> {:a=>100}
+ */
+static mrb_value
+hash_except(mrb_state *mrb, mrb_value hash)
+{
+  const mrb_value *argv;
+  mrb_value result;
+  mrb_int argc, i;
+
+  mrb_get_args(mrb, "*", &argv, &argc);
+  result = mrb_hash_dup(mrb, hash);
+  for (i = 0; i < argc; i++) {
+    mrb_hash_delete_key(mrb, result, argv[i]);
+  }
+  return result;
+}
+
 void
 mrb_mruby_hash_ext_gem_init(mrb_state *mrb)
 {
@@ -75,6 +102,7 @@ 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());
+  mrb_define_method(mrb, h, "except",    hash_except, MRB_ARGS_ANY());
 }
 
 void