script_core 0.2.3 → 0.3.0

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

@@ -3,39 +3,10 @@
 #
 # ISO 15.3.1
 module Kernel
-  ##
-  # Invoke method +print+ on STDOUT and passing +*args+
-  #
-  # ISO 15.3.1.2.10
-  def print(*args)
-    i = 0
-    len = args.size
-    while i < len
-      __printstr__ args[i].to_s
-      i += 1
-    end
-  end
-
-  ##
-  # Invoke method +puts+ on STDOUT and passing +*args*+
-  #
-  # ISO 15.3.1.2.11
-  def puts(*args)
-    i = 0
-    len = args.size
-    while i < len
-      s = args[i].to_s
-      __printstr__ s
-      __printstr__ "\n" if (s[-1] != "\n")
-      i += 1
-    end
-    __printstr__ "\n" if len == 0
-    nil
-  end
-
   ##
   # Print human readable object description
   #
+  # ISO 15.3.1.2.9
   # ISO 15.3.1.3.34
   def p(*args)
     i = 0

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

@@ -1,6 +1,10 @@
 #include <mruby.h>
+
+#ifdef MRB_NO_STDIO
+# error print conflicts 'MRB_NO_STDIO' in your build configuration
+#endif
+
 #include <mruby/string.h>
-#include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #if defined(_WIN32)
@@ -13,40 +17,73 @@
 #endif
 
 static void
-printstr(mrb_state *mrb, mrb_value obj)
+printstr(mrb_state *mrb, const char *p, mrb_int len)
 {
-  if (mrb_string_p(obj)) {
 #if defined(_WIN32)
-    if (isatty(fileno(stdout))) {
-      DWORD written;
-      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 (MultiByteToWideChar(CP_UTF8, 0, utf8, mlen, utf16, wlen) > 0) {
-        utf16[wlen] = 0;
-        WriteConsoleW(GetStdHandle(STD_OUTPUT_HANDLE),
-          utf16, wlen, &written, NULL);
-      }
-      mrb_free(mrb, utf16);
-    } else
+  if (isatty(fileno(stdout))) {
+    DWORD written;
+    int wlen = MultiByteToWideChar(CP_UTF8, 0, p, (int)len, NULL, 0);
+    wchar_t* utf16 = (wchar_t*)mrb_malloc(mrb, (wlen+1) * sizeof(wchar_t));
+    if (MultiByteToWideChar(CP_UTF8, 0, p, (int)len, utf16, wlen) > 0) {
+      utf16[wlen] = 0;
+      WriteConsoleW(GetStdHandle(STD_OUTPUT_HANDLE),
+                    utf16, (DWORD)wlen, &written, NULL);
+    }
+    mrb_free(mrb, utf16);
+  } else
 #endif
-      fwrite(RSTRING_PTR(obj), RSTRING_LEN(obj), 1, stdout);
-    fflush(stdout);
-  }
+    fwrite(p, (size_t)len, 1, stdout);
+  fflush(stdout);
 }
 
-/* 15.3.1.2.9  */
-/* 15.3.1.3.34 */
-mrb_value
+static mrb_value
 mrb_printstr(mrb_state *mrb, mrb_value self)
 {
-  mrb_value argv;
+  mrb_value s = mrb_get_arg1(mrb);
 
-  mrb_get_args(mrb, "o", &argv);
-  printstr(mrb, argv);
+  if (mrb_string_p(s)) {
+    printstr(mrb, RSTRING_PTR(s), RSTRING_LEN(s));
+  }
+  return s;
+}
+
+/* 15.3.1.2.10  */
+/* 15.3.1.3.35 */
+static mrb_value
+mrb_print(mrb_state *mrb, mrb_value self)
+{
+  mrb_int argc, i;
+  const mrb_value *argv;
 
-  return argv;
+  mrb_get_args(mrb, "*", &argv, &argc);
+  for (i=0; i<argc; i++) {
+    mrb_value s = mrb_obj_as_string(mrb, argv[i]);
+    printstr(mrb, RSTRING_PTR(s), RSTRING_LEN(s));
+  }
+  return mrb_nil_value();
+}
+
+/* 15.3.1.2.11  */
+/* 15.3.1.3.39 */
+static mrb_value
+mrb_puts(mrb_state *mrb, mrb_value self)
+{
+  mrb_int argc, i;
+  const mrb_value *argv;
+
+  mrb_get_args(mrb, "*", &argv, &argc);
+  for (i=0; i<argc; i++) {
+    mrb_value s = mrb_obj_as_string(mrb, argv[i]);
+    mrb_int len = RSTRING_LEN(s);
+    printstr(mrb, RSTRING_PTR(s), len);
+    if (len == 0 || RSTRING_PTR(s)[len-1] != '\n') {
+      printstr(mrb, "\n", 1);
+    }
+  }
+  if (argc == 0) {
+    printstr(mrb, "\n", 1);
+  }
+  return mrb_nil_value();
 }
 
 void
@@ -55,6 +92,8 @@ mrb_mruby_print_gem_init(mrb_state* mrb)
   struct RClass *krn;
   krn = mrb->kernel_module;
   mrb_define_method(mrb, krn, "__printstr__", mrb_printstr, MRB_ARGS_REQ(1));
+  mrb_define_method(mrb, krn, "print", mrb_print, MRB_ARGS_ANY());
+  mrb_define_method(mrb, krn, "puts", mrb_puts, MRB_ARGS_ANY());
 }
 
 void

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

@@ -4,9 +4,10 @@
 #include <mruby/array.h>
 #include <mruby/string.h>
 #include <mruby/debug.h>
+#include <mruby/presym.h>
 
 static mrb_value
-mrb_proc_lambda(mrb_state *mrb, mrb_value self)
+mrb_proc_lambda_p(mrb_state *mrb, mrb_value self)
 {
   struct RProc *p = mrb_proc_ptr(self);
   return mrb_bool_value(MRB_PROC_STRICT_P(p));
@@ -21,7 +22,7 @@ mrb_proc_source_location(mrb_state *mrb, mrb_value self)
     return mrb_nil_value();
   }
   else {
-    mrb_irep *irep = p->body.irep;
+    const mrb_irep *irep = p->body.irep;
     int32_t line;
     const char *filename;
 
@@ -41,7 +42,7 @@ mrb_proc_inspect(mrb_state *mrb, mrb_value self)
   mrb_str_cat_str(mrb, str, mrb_ptr_to_str(mrb, mrb_cptr(self)));
 
   if (!MRB_PROC_CFUNC_P(p)) {
-    mrb_irep *irep = p->body.irep;
+    const mrb_irep *irep = p->body.irep;
     const char *filename;
     int32_t line;
     mrb_str_cat_lit(mrb, str, "@");
@@ -91,21 +92,24 @@ static mrb_value
 mrb_proc_parameters(mrb_state *mrb, mrb_value self)
 {
   struct parameters_type {
-    size_t len;
-    const char *name;
+    mrb_sym name;
     int size;
   } *p, parameters_list [] = {
-    {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}
+    {MRB_SYM(req),   0},
+    {MRB_SYM(opt),   0},
+    {MRB_SYM(rest),  0},
+    {MRB_SYM(req),   0},
+    {MRB_SYM(keyrest),   0},
+    {MRB_SYM(block), 0},
+    {MRB_SYM(key),   0},
+    {0, 0}
   };
   const struct RProc *proc = mrb_proc_ptr(self);
-  const struct mrb_irep *irep = proc->body.irep;
+  const struct mrb_irep *irep;
   mrb_aspec aspec;
   mrb_value parameters;
+  mrb_value krest = mrb_nil_value();
+  mrb_value block = mrb_nil_value();
   int i, j;
   int max = -1;
 
@@ -113,6 +117,7 @@ mrb_proc_parameters(mrb_state *mrb, mrb_value self)
     // TODO cfunc aspec is not implemented yet
     return mrb_ary_new(mrb);
   }
+  irep = proc->body.irep;
   if (!irep) {
     return mrb_ary_new(mrb);
   }
@@ -124,10 +129,8 @@ mrb_proc_parameters(mrb_state *mrb, mrb_value self)
   }
 
   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";
+    parameters_list[0].name = MRB_SYM(opt);
+    parameters_list[3].name = MRB_SYM(opt);
   }
 
   aspec = PEEK_W(irep->iseq+1);
@@ -135,21 +138,23 @@ mrb_proc_parameters(mrb_state *mrb, mrb_value self)
   parameters_list[1].size = MRB_ASPEC_OPT(aspec);
   parameters_list[2].size = MRB_ASPEC_REST(aspec);
   parameters_list[3].size = MRB_ASPEC_POST(aspec);
-  parameters_list[4].size = MRB_ASPEC_BLOCK(aspec);
+  parameters_list[4].size = MRB_ASPEC_KDICT(aspec);
+  parameters_list[5].size = MRB_ASPEC_BLOCK(aspec);
+  parameters_list[6].size = MRB_ASPEC_KEY(aspec);
 
   parameters = mrb_ary_new_capa(mrb, irep->nlocals-1);
 
   max = irep->nlocals-1;
   for (i = 0, p = parameters_list; p->name; p++) {
-    mrb_value sname = mrb_symbol_value(mrb_intern_static(mrb, p->name, p->len));
+    mrb_value sname = mrb_symbol_value(p->name);
 
     for (j = 0; j < p->size; i++, j++) {
       mrb_value a;
 
       a = mrb_ary_new(mrb);
       mrb_ary_push(mrb, a, sname);
-      if (i < max && irep->lv[i].name) {
-        mrb_sym sym = irep->lv[i].name;
+      if (i < max && irep->lv[i]) {
+        mrb_sym sym = irep->lv[i];
         const char *name = mrb_sym_name(mrb, sym);
         switch (name[0]) {
         case '*': case '&':
@@ -159,9 +164,17 @@ mrb_proc_parameters(mrb_state *mrb, mrb_value self)
           break;
         }
       }
+      if (p->name == MRB_SYM(block)) {
+        block = a; continue;
+      }
+      if (p->name == MRB_SYM(keyrest)) {
+        krest = a; continue;
+      }
       mrb_ary_push(mrb, parameters, a);
     }
   }
+  if (!mrb_nil_p(krest)) mrb_ary_push(mrb, parameters, krest);
+  if (!mrb_nil_p(block)) mrb_ary_push(mrb, parameters, block);
   return parameters;
 }
 
@@ -169,7 +182,7 @@ void
 mrb_mruby_proc_ext_gem_init(mrb_state* mrb)
 {
   struct RClass *p = mrb->proc_class;
-  mrb_define_method(mrb, p, "lambda?",         mrb_proc_lambda,          MRB_ARGS_NONE());
+  mrb_define_method(mrb, p, "lambda?",         mrb_proc_lambda_p,        MRB_ARGS_NONE());
   mrb_define_method(mrb, p, "source_location", mrb_proc_source_location, MRB_ARGS_NONE());
   mrb_define_method(mrb, p, "to_s",            mrb_proc_inspect,         MRB_ARGS_NONE());
   mrb_define_method(mrb, p, "inspect",         mrb_proc_inspect,         MRB_ARGS_NONE());

data/ext/enterprise_script_service/mruby/mrbgems/mruby-proc-ext/test/proc.c

@@ -35,7 +35,7 @@ static mrb_value
 cfunc_env_get(mrb_state *mrb, mrb_value self)
 {
   mrb_sym n;
-  mrb_value *argv; mrb_int argc;
+  const mrb_value *argv; mrb_int argc;
   mrb_method_t m;
   struct RProc *p;
   mrb_get_args(mrb, "na", &n, &argv, &argc);

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

@@ -10,16 +10,41 @@
 #include <mruby/data.h>
 #include <mruby/array.h>
 #include <mruby/istruct.h>
-#if INT32_MAX <= INTPTR_MAX
+#include <mruby/presym.h>
+
+#include <time.h>
+
+/*  Written in 2019 by David Blackman and Sebastiano Vigna (vigna@acm.org)
+
+To the extent possible under law, the author has dedicated all copyright
+and related and neighboring rights to this software to the public domain
+worldwide. This software is distributed without any warranty.
+
+See <https://creativecommons.org/publicdomain/zero/1.0/>. */
+
+#include <stdint.h>
+
+/* This is xoshiro128++ 1.0, one of our 32-bit all-purpose, rock-solid
+   generators. It has excellent speed, a state size (128 bits) that is
+   large enough for mild parallelism, and it passes all tests we are aware
+   of.
+
+   For generating just single-precision (i.e., 32-bit) floating-point
+   numbers, xoshiro128+ is even faster.
+
+   The state must be seeded so that it is not everywhere zero. */
+
+
+#ifdef MRB_32BIT
 # define XORSHIFT96
 # define NSEEDS 3
+# define SEEDPOS 2
 #else
 # define NSEEDS 4
+# define SEEDPOS 0
 #endif
 #define LASTSEED (NSEEDS-1)
 
-#include <time.h>
-
 typedef struct rand_state {
   uint32_t seed[NSEEDS];
 } rand_state;
@@ -38,16 +63,23 @@ rand_init(rand_state *t)
 static uint32_t
 rand_seed(rand_state *t, uint32_t seed)
 {
-  uint32_t old_seed = t->seed[LASTSEED];
+  uint32_t old_seed = t->seed[SEEDPOS];
   rand_init(t);
-  t->seed[LASTSEED] = seed;
+  t->seed[SEEDPOS] = seed;
   return old_seed;
 }
 
-#ifdef XORSHIFT96
+#ifndef XORSHIFT96
+static inline uint32_t
+rotl(const uint32_t x, int k) {
+  return (x << k) | (x >> (32 - k));
+}
+#endif
+
 static uint32_t
 rand_uint32(rand_state *state)
 {
+#ifdef XORSHIFT96
   uint32_t *seed = state->seed;
   uint32_t x = seed[0];
   uint32_t y = seed[1];
@@ -61,36 +93,29 @@ rand_uint32(rand_state *state)
   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;
+#else
+  uint32_t *s = state->seed;
+  const uint32_t result = rotl(s[0] + s[3], 7) + s[0];
+  const uint32_t t = s[1] << 9;
 
-  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;
+  s[2] ^= s[0];
+  s[3] ^= s[1];
+  s[1] ^= s[2];
+  s[0] ^= s[3];
 
-  return w;
-}
+  s[2] ^= t;
+  s[3] = rotl(s[3], 11);
+
+  return result;
 #endif  /* XORSHIFT96 */
+  }
 
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
 static double
 rand_real(rand_state *t)
 {
   uint32_t x = rand_uint32(t);
-  return x*(1.0/4294967295.0);
+  return x*(1.0/4294967296.0);
 }
 #endif
 
@@ -99,15 +124,15 @@ random_rand(mrb_state *mrb, rand_state *t, mrb_value max)
 {
   mrb_value value;
 
-  if (mrb_fixnum(max) == 0) {
-#ifndef MRB_WITHOUT_FLOAT
+  if (mrb_integer(max) == 0) {
+#ifndef MRB_NO_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));
+    value = mrb_int_value(mrb, rand_uint32(t) % mrb_integer(max));
   }
 
   return value;
@@ -125,7 +150,7 @@ get_opt(mrb_state* mrb)
     mrb_int i;
 
     arg = mrb_to_int(mrb, arg);
-    i = mrb_fixnum(arg);
+    i = mrb_integer(arg);
     if (i < 0) {
       arg = mrb_fixnum_value(0 - i);
     }
@@ -135,7 +160,7 @@ get_opt(mrb_state* mrb)
 
 static void
 random_check(mrb_state *mrb, mrb_value random) {
-  struct RClass *c = mrb_class_get(mrb, "Random");
+  struct RClass *c = mrb_class_get_id(mrb, MRB_SYM(Random));
   if (!mrb_obj_is_kind_of(mrb, random, c) || !mrb_istruct_p(random)) {
     mrb_raise(mrb, E_TYPE_ERROR, "Random instance required");
   }
@@ -144,7 +169,7 @@ random_check(mrb_state *mrb, mrb_value random) {
 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"));
+  mrb_value d = mrb_const_get(mrb, mrb_obj_value(c), MRB_SYM(DEFAULT));
   if (!mrb_obj_is_kind_of(mrb, d, c)) {
     mrb_raise(mrb, E_TYPE_ERROR, "Random::DEFAULT replaced");
   }
@@ -167,7 +192,7 @@ random_m_init(mrb_state *mrb, mrb_value self)
     rand_init(t);
   }
   else {
-    rand_seed(t, (uint32_t)mrb_fixnum(seed));
+    rand_seed(t, (uint32_t)mrb_integer(seed));
   }
 
   return self;
@@ -196,11 +221,11 @@ random_m_srand(mrb_state *mrb, mrb_value self)
     seed = (uint32_t)time(NULL) + rand_uint32(t);
   }
   else {
-    seed = (uint32_t)mrb_fixnum(sv);
+    seed = (uint32_t)mrb_integer(sv);
   }
   old_seed = rand_seed(t, seed);
 
-  return mrb_fixnum_value((mrb_int)old_seed);
+  return mrb_int_value(mrb, (mrb_int)old_seed);
 }
 
 /*
@@ -218,6 +243,34 @@ mrb_ary_shuffle_bang(mrb_state *mrb, mrb_value ary)
   mrb_value r = mrb_nil_value();
   rand_state *random;
 
+ /*
+ * MSC compiler bug generating invalid instructions with optimization
+ * enabled. MSC errantly uses a hardcoded value with optimizations on
+ * when using a fixed value from a union.
+ * Creating a temp volatile variable and reassigning back to the original
+ * value tricks the compiler to not perform this optimization;
+ */
+#if defined _MSC_VER && _MSC_VER >= 1923
+  /* C++ will not cast away volatile easily, so we cannot do something like
+   * volatile mrb_value rr = r; r = (mrb_value)rr; with C++.
+   * That cast does work with C.
+   * We also have to trick the compiler to not optimize away the const_cast entirely
+   * by creating and manipulating an intermediate volatile pointer.
+   */
+  volatile mrb_value *v_r;
+  volatile mrb_int ii;
+  mrb_value *p_r;
+  v_r = &r;
+  ii = 2;
+  v_r = v_r + 2;
+#if defined __cplusplus
+  p_r = const_cast<mrb_value*>(v_r - ii);
+#else
+  p_r = (mrb_value*)v_r - ii;
+#endif
+  r = *p_r;
+#endif
+
   if (RARRAY_LEN(ary) > 1) {
     mrb_get_args(mrb, "|o", &r);
 
@@ -235,7 +288,7 @@ mrb_ary_shuffle_bang(mrb_state *mrb, mrb_value ary)
       mrb_value *ptr = RARRAY_PTR(ary);
       mrb_value tmp;
 
-      j = mrb_fixnum(random_rand(mrb, random, max));
+      j = mrb_integer(random_rand(mrb, random, max));
 
       tmp = ptr[i];
       ptr[i] = ptr[j];
@@ -320,16 +373,18 @@ mrb_ary_sample(mrb_state *mrb, mrb_value ary)
         r = (mrb_int)(rand_uint32(random) % len);
 
         for (j=0; j<i; j++) {
-          if (mrb_fixnum(RARRAY_PTR(result)[j]) == r) {
+          if (mrb_integer(RARRAY_PTR(result)[j]) == r) {
             goto retry;         /* retry if duplicate */
           }
         }
         break;
       }
-      mrb_ary_push(mrb, result, mrb_fixnum_value(r));
+      mrb_ary_push(mrb, result, mrb_int_value(mrb, r));
     }
     for (i=0; i<n; i++) {
-      mrb_ary_set(mrb, result, i, RARRAY_PTR(ary)[mrb_fixnum(RARRAY_PTR(result)[i])]);
+      mrb_int idx = mrb_integer(RARRAY_PTR(result)[i]);
+      mrb_value elem = RARRAY_PTR(ary)[idx];
+      mrb_ary_set(mrb, result, i, elem);
     }
     return result;
   }
@@ -355,7 +410,7 @@ void mrb_mruby_random_gem_init(mrb_state *mrb)
   struct RClass *random;
   struct RClass *array = mrb->array_class;
 
-  mrb_assert(sizeof(rand_state) <= ISTRUCT_DATA_SIZE);
+  mrb_static_assert1(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));
@@ -373,7 +428,7 @@ void mrb_mruby_random_gem_init(mrb_state *mrb)
   mrb_define_method(mrb, array, "shuffle!", mrb_ary_shuffle_bang, MRB_ARGS_OPT(1));
   mrb_define_method(mrb, array, "sample", mrb_ary_sample, MRB_ARGS_OPT(2));
 
-  mrb_const_set(mrb, mrb_obj_value(random), mrb_intern_lit(mrb, "DEFAULT"),
+  mrb_const_set(mrb, mrb_obj_value(random), MRB_SYM(DEFAULT),
           mrb_obj_new(mrb, random, 0, NULL));
 }