script_core 0.2.1 → 0.2.2

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

@@ -11,6 +11,7 @@
 #include <mruby.h>
 #include <mruby/class.h>
 #include <mruby/data.h>
+#include <mruby/numeric.h>
 #include <mruby/time.h>
 
 #ifndef MRB_DISABLE_STDIO
@@ -75,11 +76,6 @@ double round(double x) {
 /* define following macro to use probably faster timegm() on the platform */
 /* #define USE_SYSTEM_TIMEGM */
 
-/* time_t */
-/* If your platform supports time_t as uint (e.g. uint32_t, uint64_t), */
-/* uncomment following macro. */
-/* #define MRB_TIME_T_UINT */
-
 /** end of Time class configuration */
 
 #ifndef NO_GETTIMEOFDAY
@@ -213,15 +209,22 @@ typedef mrb_int mrb_sec;
 #define mrb_sec_value(mrb, sec) mrb_fixnum_value(sec)
 #endif
 
-#ifdef MRB_TIME_T_UINT
-typedef uint64_t mrb_time_int;
-# define MRB_TIME_MIN 0
-# define MRB_TIME_MAX (sizeof(time_t) <= 4 ? UINT32_MAX : UINT64_MAX)
-#else
-typedef int64_t mrb_time_int;
-# define MRB_TIME_MIN (sizeof(time_t) <= 4 ? INT32_MIN : INT64_MIN)
-# define MRB_TIME_MAX (sizeof(time_t) <= 4 ? INT32_MAX : INT64_MAX)
-#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)
@@ -254,7 +257,8 @@ mrb_to_time_t(mrb_state *mrb, mrb_value obj, time_t *usec)
       {
         mrb_int i = mrb_int(mrb, obj);
 
-        if ((mrb_time_int)i > MRB_TIME_MAX || MRB_TIME_MIN > i) {
+        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;
         }
 
@@ -867,7 +871,7 @@ mrb_time_to_i(mrb_state *mrb, mrb_value self)
 
   tm = time_get_ptr(mrb, self);
 #ifndef MRB_WITHOUT_FLOAT
-  if (tm->sec > MRB_INT_MAX || tm->sec < MRB_INT_MIN) {
+  if (!fixable_time_t_p(tm->sec)) {
     return mrb_float_value(mrb, (mrb_float)tm->sec);
   }
 #endif
@@ -883,7 +887,7 @@ mrb_time_usec(mrb_state *mrb, mrb_value self)
 
   tm = time_get_ptr(mrb, self);
 #ifndef MRB_WITHOUT_FLOAT
-  if (tm->usec > MRB_INT_MAX || tm->usec < MRB_INT_MIN) {
+  if (!fixable_time_t_p(tm->usec)) {
     return mrb_float_value(mrb, (mrb_float)tm->usec);
   }
 #endif

data/ext/enterprise_script_service/mruby/mrblib/mrblib.rake

@@ -8,7 +8,7 @@
   file objfile("#{current_build_dir}/mrblib") => "#{current_build_dir}/mrblib.c"
   file "#{current_build_dir}/mrblib.c" => [mrbcfile, __FILE__] + Dir.glob("#{current_dir}/*.rb").sort do |t|
     _, _, *rbfiles = t.prerequisites
-    FileUtils.mkdir_p File.dirname(t.name)
+    mkdir_p File.dirname(t.name)
     open(t.name, 'w') do |f|
       _pp "GEN", "*.rb", "#{t.name.relative_path}"
       f.puts File.read("#{current_dir}/init_mrblib.c")

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

@@ -1304,6 +1304,7 @@ init_ary_each(mrb_state *mrb, struct RClass *ary)
   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);
 }

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

@@ -25,6 +25,9 @@ typedef void (*each_backtrace_func)(mrb_state*, const struct backtrace_location*
 
 static const mrb_data_type bt_type = { "Backtrace", mrb_free };
 
+mrb_value mrb_exc_inspect(mrb_state *mrb, mrb_value exc);
+mrb_value mrb_unpack_backtrace(mrb_state *mrb, mrb_value backtrace);
+
 static void
 each_backtrace(mrb_state *mrb, ptrdiff_t ciidx, const mrb_code *pc0, each_backtrace_func func, void *data)
 {
@@ -74,66 +77,27 @@ each_backtrace(mrb_state *mrb, ptrdiff_t ciidx, const mrb_code *pc0, each_backtr
 #ifndef MRB_DISABLE_STDIO
 
 static void
-print_backtrace(mrb_state *mrb, mrb_value backtrace)
+print_backtrace(mrb_state *mrb, struct RObject *exc, mrb_value backtrace)
 {
   int i;
-  mrb_int n;
+  mrb_int n = RARRAY_LEN(backtrace);
+  mrb_value *loc, mesg;
   FILE *stream = stderr;
 
-  n = RARRAY_LEN(backtrace) - 1;
-  if (n == 0) return;
-
-  fprintf(stream, "trace (most recent call last):\n");
-  for (i=0; i<n; i++) {
-    mrb_value entry = RARRAY_PTR(backtrace)[n-i-1];
-
-    if (mrb_string_p(entry)) {
-      fprintf(stream, "\t[%d] %.*s\n", i, (int)RSTRING_LEN(entry), RSTRING_PTR(entry));
+  if (n != 0) {
+    fprintf(stream, "trace (most recent call last):\n");
+    for (i=n-1,loc=&RARRAY_PTR(backtrace)[i]; i>0; i--,loc--) {
+      if (mrb_string_p(*loc)) {
+        fprintf(stream, "\t[%d] %.*s\n",
+                i, (int)RSTRING_LEN(*loc), RSTRING_PTR(*loc));
+      }
     }
-  }
-}
-
-static int
-packed_bt_len(const struct backtrace_location *bt, int n)
-{
-  int len = 0;
-  int i;
-
-  for (i=0; i<n; i++) {
-    if (!bt[i].filename && !bt[i].lineno && !bt[i].method_id)
-      continue;
-    len++;
-  }
-  return len;
-}
-
-static void
-print_packed_backtrace(mrb_state *mrb, mrb_value packed)
-{
-  FILE *stream = stderr;
-  const struct backtrace_location *bt;
-  int n, i;
-  int ai = mrb_gc_arena_save(mrb);
-
-  bt = (struct backtrace_location*)mrb_data_check_get_ptr(mrb, packed, &bt_type);
-  if (bt == NULL) return;
-  n = (mrb_int)RDATA(packed)->flags;
-
-  if (packed_bt_len(bt, n) == 0) return;
-  fprintf(stream, "trace (most recent call last):\n");
-  for (i = 0; i<n; i++) {
-    const struct backtrace_location *entry = &bt[n-i-1];
-    if (entry->filename == NULL) continue;
-    fprintf(stream, "\t[%d] %s:%d", i, entry->filename, entry->lineno);
-    if (entry->method_id != 0) {
-      const char *method_name;
-
-      method_name = mrb_sym_name(mrb, entry->method_id);
-      fprintf(stream, ":in %s", method_name);
-      mrb_gc_arena_restore(mrb, ai);
+    if (mrb_string_p(*loc)) {
+      fprintf(stream, "%.*s: ", (int)RSTRING_LEN(*loc), RSTRING_PTR(*loc));
     }
-    fprintf(stream, "\n");
   }
+  mesg = mrb_exc_inspect(mrb, mrb_obj_value(exc));
+  fprintf(stream, "%.*s\n", (int)RSTRING_LEN(mesg), RSTRING_PTR(mesg));
 }
 
 /* mrb_print_backtrace
@@ -152,12 +116,8 @@ mrb_print_backtrace(mrb_state *mrb)
 
   backtrace = mrb_obj_iv_get(mrb, mrb->exc, mrb_intern_lit(mrb, "backtrace"));
   if (mrb_nil_p(backtrace)) return;
-  if (mrb_array_p(backtrace)) {
-    print_backtrace(mrb, backtrace);
-  }
-  else {
-    print_packed_backtrace(mrb, backtrace);
-  }
+  if (!mrb_array_p(backtrace)) backtrace = mrb_unpack_backtrace(mrb, backtrace);
+  print_backtrace(mrb, mrb->exc, backtrace);
 }
 #else
 
@@ -175,7 +135,6 @@ count_backtrace_i(mrb_state *mrb,
 {
   int *lenp = (int*)data;
 
-  if (loc->filename == NULL) return;
   (*lenp)++;
 }
 
@@ -187,7 +146,6 @@ pack_backtrace_i(mrb_state *mrb,
   struct backtrace_location **pptr = (struct backtrace_location**)data;
   struct backtrace_location *ptr = *pptr;
 
-  if (loc->filename == NULL) return;
   *ptr = *loc;
   *pptr = ptr+1;
 }
@@ -205,7 +163,7 @@ packed_backtrace(mrb_state *mrb)
   size = len * sizeof(struct backtrace_location);
   ptr = mrb_malloc(mrb, size);
   backtrace = mrb_data_object_alloc(mrb, NULL, ptr, &bt_type);
-  backtrace->flags = (unsigned int)len;
+  backtrace->flags = (uint32_t)len;
   each_backtrace(mrb, ciidx, mrb->c->ci->pc, pack_backtrace_i, &ptr);
   return mrb_obj_value(backtrace);
 }
@@ -245,8 +203,7 @@ mrb_unpack_backtrace(mrb_state *mrb, mrb_value backtrace)
     const struct backtrace_location *entry = &bt[i];
     mrb_value btline;
 
-    if (entry->filename == NULL) continue;
-    btline = mrb_format(mrb, "%s:%d", entry->filename, entry->lineno);
+    btline = mrb_format(mrb, "%s:%d", entry->filename, (int)entry->lineno);
     if (entry->method_id != 0) {
       mrb_str_cat_lit(mrb, btline, ":in ");
       mrb_str_cat_cstr(mrb, btline, mrb_sym_name(mrb, entry->method_id));

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

@@ -285,11 +285,9 @@ mrb_define_class(mrb_state *mrb, const char *name, struct RClass *super)
 static mrb_value mrb_bob_init(mrb_state *mrb, mrb_value);
 #ifdef MRB_METHOD_CACHE
 static void mc_clear_all(mrb_state *mrb);
-static void mc_clear_by_class(mrb_state *mrb, struct RClass*);
 static void mc_clear_by_id(mrb_state *mrb, struct RClass*, mrb_sym);
 #else
 #define mc_clear_all(mrb)
-#define mc_clear_by_class(mrb,c)
 #define mc_clear_by_id(mrb,c,s)
 #endif
 
@@ -303,7 +301,7 @@ mrb_class_inherited(mrb_state *mrb, struct RClass *super, struct RClass *klass)
     super = mrb->object_class;
   super->flags |= MRB_FL_CLASS_IS_INHERITED;
   s = mrb_obj_value(super);
-  mc_clear_by_class(mrb, klass);
+  mrb_mc_clear_by_class(mrb, klass);
   mid = mrb_intern_lit(mrb, "inherited");
   if (!mrb_func_basic_p(mrb, s, mid, mrb_bob_init)) {
     mrb_value c = mrb_obj_value(klass);
@@ -542,15 +540,12 @@ MRB_API mrb_value*
 mrb_get_argv(mrb_state *mrb)
 {
   mrb_int argc = mrb->c->ci->argc;
-  mrb_value *array_argv;
+  mrb_value *array_argv = mrb->c->stack + 1;
   if (argc < 0) {
-    struct RArray *a = mrb_ary_ptr(mrb->c->stack[1]);
+    struct RArray *a = mrb_ary_ptr(*array_argv);
 
     array_argv = ARY_PTR(a);
   }
-  else {
-    array_argv = NULL;
-  }
   return array_argv;
 }
 
@@ -594,9 +589,9 @@ mrb_get_args(mrb_state *mrb, const char *format, ...)
   char c;
   mrb_int i = 0;
   va_list ap;
-  mrb_int argc = mrb_get_argc(mrb);
-  mrb_int arg_i = 0;
-  mrb_value *array_argv = mrb_get_argv(mrb);
+  mrb_int argc = mrb->c->ci->argc;
+  mrb_value *array_argv = mrb->c->stack+1;
+  mrb_bool argv_on_stack = argc >= 0;
   mrb_bool opt = FALSE;
   mrb_bool opt_skip = TRUE;
   mrb_bool given = TRUE;
@@ -604,10 +599,14 @@ mrb_get_args(mrb_state *mrb, const char *format, ...)
   mrb_bool reqkarg = FALSE;
   mrb_int needargc = 0;
 
+  if (!argv_on_stack) {
+    struct RArray *a = mrb_ary_ptr(*array_argv);
+    array_argv = ARY_PTR(a);
+    argc = ARY_LEN(a);
+  }
   va_start(ap, format);
 
-#define ARGV \
-  (array_argv ? array_argv : (mrb->c->stack + 1))
+#define ARGV array_argv
 
   while ((c = *fmt++)) {
     switch (c) {
@@ -620,11 +619,11 @@ mrb_get_args(mrb_state *mrb, const char *format, ...)
       goto check_exit;
     case '!':
       break;
-    case '&': case '?':
-      if (opt) opt_skip = FALSE;
-      break;
     case ':':
       reqkarg = TRUE;
+      /* fall through */
+    case '&': case '?':
+      if (opt) opt_skip = FALSE;
       break;
     default:
       if (!opt) needargc ++;
@@ -677,8 +676,7 @@ mrb_get_args(mrb_state *mrb, const char *format, ...)
 
         p = va_arg(ap, mrb_value*);
         if (i < argc) {
-          *p = argv[arg_i++];
-          i++;
+          *p = argv[i++];
         }
       }
       break;
@@ -690,12 +688,11 @@ mrb_get_args(mrb_state *mrb, const char *format, ...)
         if (i < argc) {
           mrb_value ss;
 
-          ss = argv[arg_i++];
+          ss = argv[i++];
           if (!class_ptr_p(ss)) {
             mrb_raisef(mrb, E_TYPE_ERROR, "%v is not class/module", ss);
           }
           *p = ss;
-          i++;
         }
       }
       break;
@@ -705,8 +702,7 @@ mrb_get_args(mrb_state *mrb, const char *format, ...)
 
         p = va_arg(ap, mrb_value*);
         if (i < argc) {
-          *p = argv[arg_i++];
-          i++;
+          *p = argv[i++];
           if (!(altmode && mrb_nil_p(*p))) {
             mrb_to_str(mrb, *p);
           }
@@ -719,8 +715,7 @@ mrb_get_args(mrb_state *mrb, const char *format, ...)
 
         p = va_arg(ap, mrb_value*);
         if (i < argc) {
-          *p = argv[arg_i++];
-          i++;
+          *p = argv[i++];
           if (!(altmode && mrb_nil_p(*p))) {
             *p = to_ary(mrb, *p);
           }
@@ -733,8 +728,7 @@ mrb_get_args(mrb_state *mrb, const char *format, ...)
 
         p = va_arg(ap, mrb_value*);
         if (i < argc) {
-          *p = argv[arg_i++];
-          i++;
+          *p = argv[i++];
           if (!(altmode && mrb_nil_p(*p))) {
             *p = to_hash(mrb, *p);
           }
@@ -750,8 +744,7 @@ mrb_get_args(mrb_state *mrb, const char *format, ...)
         ps = va_arg(ap, char**);
         pl = va_arg(ap, mrb_int*);
         if (i < argc) {
-          ss = argv[arg_i++];
-          i++;
+          ss = argv[i++];
           if (altmode && mrb_nil_p(ss)) {
             *ps = NULL;
             *pl = 0;
@@ -771,8 +764,7 @@ mrb_get_args(mrb_state *mrb, const char *format, ...)
 
         ps = va_arg(ap, const char**);
         if (i < argc) {
-          ss = argv[arg_i++];
-          i++;
+          ss = argv[i++];
           if (altmode && mrb_nil_p(ss)) {
             *ps = NULL;
           }
@@ -793,8 +785,7 @@ mrb_get_args(mrb_state *mrb, const char *format, ...)
         pb = va_arg(ap, mrb_value**);
         pl = va_arg(ap, mrb_int*);
         if (i < argc) {
-          aa = argv[arg_i++];
-          i++;
+          aa = argv[i++];
           if (altmode && mrb_nil_p(aa)) {
             *pb = 0;
             *pl = 0;
@@ -815,14 +806,12 @@ mrb_get_args(mrb_state *mrb, const char *format, ...)
 
         p = va_arg(ap, void**);
         if (i < argc) {
-          ss = argv[arg_i];
+          ss = argv[i++];
           if (!mrb_istruct_p(ss))
           {
             mrb_raisef(mrb, E_TYPE_ERROR, "%v is not inline struct", ss);
           }
           *p = mrb_istruct_ptr(ss);
-          arg_i++;
-          i++;
         }
       }
       break;
@@ -833,9 +822,7 @@ mrb_get_args(mrb_state *mrb, const char *format, ...)
 
         p = va_arg(ap, mrb_float*);
         if (i < argc) {
-          *p = mrb_to_flo(mrb, argv[arg_i]);
-          arg_i++;
-          i++;
+          *p = mrb_to_flo(mrb, argv[i++]);
         }
       }
       break;
@@ -846,9 +833,7 @@ mrb_get_args(mrb_state *mrb, const char *format, ...)
 
         p = va_arg(ap, mrb_int*);
         if (i < argc) {
-          *p = mrb_fixnum(mrb_to_int(mrb, argv[arg_i]));
-          arg_i++;
-          i++;
+          *p = mrb_fixnum(mrb_to_int(mrb, argv[i++]));
         }
       }
       break;
@@ -857,9 +842,8 @@ mrb_get_args(mrb_state *mrb, const char *format, ...)
         mrb_bool *boolp = va_arg(ap, mrb_bool*);
 
         if (i < argc) {
-          mrb_value b = argv[arg_i++];
+          mrb_value b = argv[i++];
           *boolp = mrb_test(b);
-          i++;
         }
       }
       break;
@@ -871,9 +855,8 @@ mrb_get_args(mrb_state *mrb, const char *format, ...)
         if (i < argc) {
           mrb_value ss;
 
-          ss = argv[arg_i++];
+          ss = argv[i++];
           *symp = to_sym(mrb, ss);
-          i++;
         }
       }
       break;
@@ -885,8 +868,7 @@ mrb_get_args(mrb_state *mrb, const char *format, ...)
         datap = va_arg(ap, void**);
         type = va_arg(ap, struct mrb_data_type const*);
         if (i < argc) {
-          mrb_value dd = argv[arg_i++];
-          i++;
+          mrb_value dd = argv[i++];
           if (altmode && mrb_nil_p(dd)) {
             *datap = 0;
           }
@@ -915,7 +897,7 @@ mrb_get_args(mrb_state *mrb, const char *format, ...)
       }
       break;
     case '|':
-      if (opt_skip && i == argc) return argc;
+      if (opt_skip && i == argc) goto finish;
       opt = TRUE;
       break;
     case '?':
@@ -931,7 +913,7 @@ mrb_get_args(mrb_state *mrb, const char *format, ...)
       {
         mrb_value **var;
         mrb_int *pl;
-        mrb_bool nocopy = altmode || array_argv ? TRUE : FALSE;
+        mrb_bool nocopy = altmode || argv_on_stack ? TRUE : FALSE;
 
         var = va_arg(ap, mrb_value**);
         pl = va_arg(ap, mrb_int*);
@@ -939,16 +921,15 @@ mrb_get_args(mrb_state *mrb, const char *format, ...)
           *pl = argc-i;
           if (*pl > 0) {
             if (nocopy) {
-              *var = argv+arg_i;
+              *var = argv+i;
             }
             else {
-              mrb_value args = mrb_ary_new_from_values(mrb, *pl, argv+arg_i);
+              mrb_value args = mrb_ary_new_from_values(mrb, *pl, argv+i);
               RARRAY(args)->c = NULL;
               *var = RARRAY_PTR(args);
             }
           }
           i = argc;
-          arg_i += *pl;
         }
         else {
           *pl = 0;
@@ -1023,6 +1004,8 @@ mrb_get_args(mrb_state *mrb, const char *format, ...)
   if (!c && argc > i) {
     mrb_raise(mrb, E_ARGUMENT_ERROR, "wrong number of arguments");
   }
+
+finish:
   va_end(ap);
   return i;
 }
@@ -1107,7 +1090,7 @@ include_module_at(mrb_state *mrb, struct RClass *c, struct RClass *ins_pos, stru
     m->flags |= MRB_FL_CLASS_IS_INHERITED;
     ins_pos->super = ic;
     mrb_field_write_barrier(mrb, (struct RBasic*)ins_pos, (struct RBasic*)ic);
-    mc_clear_by_class(mrb, ins_pos);
+    mrb_mc_clear_by_class(mrb, ins_pos);
     ins_pos = ic;
   skip:
     m = m->super;
@@ -1320,8 +1303,8 @@ mc_clear_all(mrb_state *mrb)
   }
 }
 
-static void
-mc_clear_by_class(mrb_state *mrb, struct RClass *c)
+void
+mrb_mc_clear_by_class(mrb_state *mrb, struct RClass *c)
 {
   struct mrb_cache_entry *mc = mrb->cache;
   int i;
@@ -2321,7 +2304,9 @@ mrb_init_class(mrb_state *mrb)
   mrb_define_method(mrb, mod, "dup",                     mrb_mod_dup,              MRB_ARGS_NONE());
 
   mrb_undef_method(mrb, cls, "append_features");
+  mrb_undef_method(mrb, cls, "prepend_features");
   mrb_undef_method(mrb, cls, "extend_object");
+  mrb_undef_method(mrb, cls, "module_function");
 
   mrb->top_self = (struct RObject*)mrb_obj_alloc(mrb, MRB_TT_OBJECT, mrb->object_class);
   mrb_define_singleton_method(mrb, mrb->top_self, "inspect", inspect_main, MRB_ARGS_NONE());