enclave 0.1.0

data/ext/enclave/mruby/mrbgems/mruby-proc-ext/mrblib/proc.rb

@@ -0,0 +1,130 @@
+class Proc
+
+  #
+  # call-seq:
+  #   prc === obj -> result_of_proc
+  #
+  # Invokes the block with obj as the parameter like Proc#call.
+  # This allows a proc object to be the target of a when clause
+  # in a case statement.
+  #
+  #   def the_answer
+  #     42
+  #   end
+  #
+  #   case the_answer
+  #   when proc { |x| x > 40 }
+  #     "correct"
+  #   else
+  #     "incorrect"
+  #   end
+  #   #=> "correct"
+  #
+  def ===(*args)
+    call(*args)
+  end
+
+  #
+  # call-seq:
+  #   prc.yield(params,...) -> obj
+  #
+  # Invokes the block with the given arguments. This method is provided
+  # for compatibility and is equivalent to Proc#call.
+  #
+  #   prc = proc { |x| x * 2 }
+  #   prc.yield(5)   #=> 10
+  #
+  def yield(*args)
+    call(*args)
+  end
+
+  #
+  # call-seq:
+  #   prc.to_proc -> prc
+  #
+  # Part of the protocol for converting objects to Proc objects.
+  # Instances of class Proc simply return themselves.
+  #
+  #   prc = proc { "hello" }
+  #   prc.to_proc   #=> #<Proc:0x401b3d30@(irb):3>
+  #
+  def to_proc
+    self
+  end
+
+  #
+  # call-seq:
+  #   prc.curry -> curried_proc
+  #   prc.curry(arity) -> curried_proc
+  #
+  # Returns a curried proc. If the optional arity argument is given, it
+  # determines the number of arguments. A curried proc receives some
+  # arguments. If a sufficient number of arguments are supplied, it passes
+  # the supplied arguments to the original proc and returns the result.
+  # Otherwise, returns another curried proc that takes the rest of arguments.
+  #
+  #   b = proc {|x, y, z| (x||0) + (y||0) + (z||0) }
+  #   p b.curry[1][2][3]           #=> 6
+  #   p b.curry[1, 2][3, 4]        #=> 6
+  #   p b.curry(5)[1][2][3][4][5]  #=> 6
+  #
+  def curry(arity=self.arity)
+    type = :proc
+    abs = lambda {|a| a < 0 ? -a - 1 : a}
+    arity = abs[arity]
+    if lambda?
+      type = :lambda
+      self_arity = self.arity
+      if (self_arity >= 0 && arity != self_arity) ||
+         (self_arity < 0 && abs[self_arity] > arity)
+        raise ArgumentError, "wrong number of arguments (given #{arity}, expected #{abs[self_arity]})"
+      end
+    end
+
+    pproc = self
+    make_curry = proc do |given_args=[]|
+      __send__(type) do |*args|
+        new_args = given_args + args
+        if new_args.size >= arity
+          pproc[*new_args]
+        else
+          make_curry[new_args]
+        end
+      end
+    end
+    make_curry.call
+  end
+
+  #
+  # call-seq:
+  #   prc << other_proc -> new_proc
+  #
+  # Returns a new Proc which is the composition of this proc and the given
+  # other_proc. The returned proc takes a variable number of arguments, calls
+  # other_proc with them then calls this proc with the result.
+  #
+  #   f = proc {|x| x * x }
+  #   g = proc {|x| x + x }
+  #   p (f << g).call(2) #=> 16
+  #
+  def <<(other)
+    ->(*args, **opts, &block) { call(other.call(*args, **opts, &block)) }
+  end
+
+  #
+  # call-seq:
+  #   prc >> other_proc -> new_proc
+  #
+  # Returns a new Proc which is the composition of this proc and the given
+  # other_proc. The returned proc takes a variable number of arguments, calls
+  # this proc with them then calls other_proc with the result.
+  #
+  #   f = proc {|x| x * x }
+  #   g = proc {|x| x + x }
+  #   p (f >> g).call(2) #=> 8
+  #
+  def >>(other)
+    ->(*args, **opts, &block) { other.call(call(*args, **opts, &block)) }
+  end
+
+end

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

@@ -0,0 +1,267 @@
+#include <mruby.h>
+#include <mruby/class.h>
+#include <mruby/proc.h>
+#include <mruby/opcode.h>
+#include <mruby/array.h>
+#include <mruby/string.h>
+#include <mruby/debug.h>
+#include <mruby/internal.h>
+#include <mruby/presym.h>
+
+/*
+ *  call-seq:
+ *     prc.lambda?    -> true or false
+ *
+ *  Returns `true` if `prc` is a lambda, `false` if it is a proc.
+ *  The difference is how they react to a `return` statement. In a lambda,
+ *  `return` makes the lambda return. In a proc, `return` makes the method
+ *  that called the proc return.
+ *
+ *     def gen_times(factor)
+ *       return proc {|n| n*factor }  # return from the proc
+ *     end
+ *
+ *     times3 = gen_times(3)
+ *     times5 = gen_times(5)
+ *
+ *     times3.lambda?   #=> false
+ *     times5.lambda?   #=> false
+ *
+ *     def gen_times(factor)
+ *       return lambda {|n| n*factor }  # return from the lambda
+ *     end
+ *
+ *     times3 = gen_times(3)
+ *     times5 = gen_times(5)
+ *
+ *     times3.lambda?   #=> true
+ *     times5.lambda?   #=> true
+ */
+
+static mrb_value
+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));
+}
+
+/* Internal helper function to extract source location from a proc */
+mrb_value
+mrb_proc_source_location(mrb_state *mrb, const struct RProc *p)
+{
+  if (MRB_PROC_CFUNC_P(p)) {
+    return mrb_nil_value();
+  }
+
+  /* handle alias */
+  if (MRB_PROC_ALIAS_P(p)) {
+    p = p->upper;
+  }
+
+  const mrb_irep *irep = p->body.irep;
+  int32_t line;
+  const char *filename;
+
+  if (!mrb_debug_get_position(mrb, irep, 0, &line, &filename)) {
+    return mrb_nil_value();
+  }
+  return mrb_assoc_new(mrb, mrb_str_new_cstr(mrb, filename), mrb_fixnum_value(line));
+}
+
+/*
+ *  call-seq:
+ *     prc.source_location  -> [filename, line] or nil
+ *
+ *  Returns the Ruby source filename and line number containing this proc
+ *  or `nil` if this proc was not defined in Ruby (i.e. native).
+ *
+ *     p = proc { puts "hello" }
+ *     p.source_location   #=> ["prog.rb", 1]
+ */
+
+static mrb_value
+proc_source_location(mrb_state *mrb, mrb_value self)
+{
+  return mrb_proc_source_location(mrb, mrb_proc_ptr(self));
+}
+
+/*
+ *  call-seq:
+ *     prc.to_s    -> string
+ *     prc.inspect -> string
+ *
+ *  Returns the unique identifier for this proc, along with
+ *  an indication of where the proc was defined.
+ *
+ *     p = proc { puts "hello" }
+ *     p.inspect   #=> "#<Proc:0x401b2e88@prog.rb:1>"
+ *     p.to_s      #=> "#<Proc:0x401b2e88@prog.rb:1>"
+ *
+ *     l = lambda { puts "hello" }
+ *     l.inspect   #=> "#<Proc:0x401b2e88@prog.rb:1 (lambda)>"
+ */
+
+static mrb_value
+proc_inspect(mrb_state *mrb, mrb_value self)
+{
+  struct RProc *p = mrb_proc_ptr(self);
+  mrb_value str = mrb_str_new_lit(mrb, "#<Proc:");
+  mrb_str_cat_str(mrb, str, mrb_ptr_to_str(mrb, p));
+
+  if (!MRB_PROC_CFUNC_P(p)) {
+    const mrb_irep *irep = p->body.irep;
+    const char *filename;
+    int32_t line;
+    mrb_str_cat_lit(mrb, str, " ");
+
+    if (mrb_debug_get_position(mrb, irep, 0, &line, &filename)) {
+      mrb_str_cat_cstr(mrb, str, filename);
+      mrb_str_cat_lit(mrb, str, ":");
+      mrb_str_concat(mrb, str, mrb_fixnum_value(line));
+    }
+    else {
+      mrb_str_cat_lit(mrb, str, "-:-");
+    }
+  }
+
+  if (MRB_PROC_STRICT_P(p)) {
+    mrb_str_cat_lit(mrb, str, " (lambda)");
+  }
+
+  mrb_str_cat_lit(mrb, str, ">");
+  return str;
+}
+
+/*
+ *  call-seq:
+ *     proc { |...| block }  -> a_proc
+ *
+ *  Equivalent to `Proc.new`.
+ *
+ *     def proc(&block)
+ *       block
+ *     end
+ *
+ *     proc { puts "Hello world" }   #=> #<Proc:0x401b2e88@-e:58>
+ */
+
+static mrb_value
+kernel_proc(mrb_state *mrb, mrb_value self)
+{
+  mrb_value blk;
+
+  mrb_get_args(mrb, "&!", &blk);
+
+  return blk;
+}
+
+/*
+ * call-seq:
+ *    prc.parameters  -> array
+ *
+ * Returns the parameter information of this proc.
+ *
+ *    prc = lambda{|x, y=42, *other|}
+ *    prc.parameters  #=> [[:req, :x], [:opt, :y], [:rest, :other]]
+ */
+
+mrb_value
+mrb_proc_parameters(mrb_state *mrb, mrb_value self)
+{
+  struct parameters_type {
+    mrb_sym name;
+    int size;
+  } *p, parameters_list [] = {
+    {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}
+  };
+  int i;
+  const struct RProc *proc = mrb_proc_ptr(self);
+  if (MRB_PROC_CFUNC_P(proc)) {
+    /* TODO: cfunc aspec is not implemented yet - C functions don't store argument spec info */
+    return mrb_ary_new(mrb);
+  }
+  const struct mrb_irep *irep = proc->body.irep;
+  if (!irep || !irep->lv || *irep->iseq != OP_ENTER) {
+    return mrb_ary_new(mrb);
+  }
+
+  if (!MRB_PROC_STRICT_P(proc)) {
+    parameters_list[0].name = MRB_SYM(opt);
+    parameters_list[3].name = MRB_SYM(opt);
+  }
+
+  mrb_aspec aspec = PEEK_W(irep->iseq+1);
+  parameters_list[0].size = MRB_ASPEC_REQ(aspec);
+  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_KDICT(aspec);
+  parameters_list[5].size = MRB_ASPEC_BLOCK(aspec);
+  parameters_list[6].size = MRB_ASPEC_KEY(aspec);
+
+  int max = 0;
+  for (i = 0; parameters_list[i].name; i++) {
+    max += parameters_list[i].size;
+  }
+
+  mrb_value parameters = mrb_ary_new_capa(mrb, max);
+  mrb_value krest = mrb_nil_value();
+  mrb_value block = mrb_nil_value();
+
+  for (i = 0, p = parameters_list; p->name; p++) {
+    mrb_value sname = mrb_symbol_value(p->name);
+
+    for (int j = 0; j < p->size; i++, j++) {
+      mrb_value a = mrb_ary_new(mrb);
+      mrb_ary_push(mrb, a, sname);
+      if (i < max && irep->lv[i]) {
+        mrb_ary_push(mrb, a, mrb_symbol_value(irep->lv[i]));
+      }
+      if (p->name == MRB_SYM(block)) {
+        if (irep->lv[i+1]) {
+          mrb_ary_push(mrb, a, mrb_symbol_value(irep->lv[i+1]));
+        }
+        block = a; continue;
+      }
+      if (p->name == MRB_SYM(keyrest)) {
+        krest = a; continue;
+      }
+      mrb_ary_push(mrb, parameters, a);
+    }
+    /* need to skip empty block slot */
+    if (p->size == 0 && p->name == MRB_SYM(block)) i++;
+  }
+  if (!mrb_nil_p(krest)) mrb_ary_push(mrb, parameters, krest);
+  if (!mrb_nil_p(block)) mrb_ary_push(mrb, parameters, block);
+  return parameters;
+}
+
+/* ---------------------------*/
+static const mrb_mt_entry proc_ext_rom_entries[] = {
+  MRB_MT_ENTRY(proc_inspect,         MRB_SYM(inspect),      MRB_ARGS_NONE()),
+  MRB_MT_ENTRY(proc_lambda_p,        MRB_SYM_Q(lambda),     MRB_ARGS_NONE()),
+  MRB_MT_ENTRY(mrb_proc_parameters,  MRB_SYM(parameters),   MRB_ARGS_NONE()),
+  MRB_MT_ENTRY(proc_source_location, MRB_SYM(source_location), MRB_ARGS_NONE()),
+  MRB_MT_ENTRY(proc_inspect,         MRB_SYM(to_s),         MRB_ARGS_NONE()),
+};
+
+void
+mrb_mruby_proc_ext_gem_init(mrb_state* mrb)
+{
+  struct RClass *p = mrb->proc_class;
+
+  MRB_MT_INIT_ROM(mrb, p, proc_ext_rom_entries);
+  mrb_define_private_method_id(mrb, mrb->kernel_module, MRB_SYM(proc), kernel_proc, MRB_ARGS_BLOCK());
+}
+
+void
+mrb_mruby_proc_ext_gem_final(mrb_state* mrb)
+{
+}

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

@@ -0,0 +1,62 @@
+#include <mruby.h>
+#include <mruby/proc.h>
+#include <mruby/class.h>
+
+static mrb_value
+return_func_name(mrb_state *mrb, mrb_value self)
+{
+  return mrb_cfunc_env_get(mrb, 0);
+}
+
+static mrb_value
+proc_new_cfunc_with_env(mrb_state *mrb, mrb_value self)
+{
+  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);
+  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;
+}
+
+static mrb_value
+return_env(mrb_state *mrb, mrb_value self)
+{
+  mrb_int idx;
+  mrb_get_args(mrb, "i", &idx);
+  return mrb_cfunc_env_get(mrb, idx);
+}
+
+static mrb_value
+cfunc_env_get(mrb_state *mrb, mrb_value self)
+{
+  mrb_sym n;
+  const mrb_value *argv;
+  mrb_int argc;
+  mrb_get_args(mrb, "na", &n, &argv, &argc);
+  struct RProc *p = mrb_proc_new_cfunc_with_env(mrb, return_env, argc, argv);
+  mrb_method_t m;
+  MRB_METHOD_FROM_PROC(m, p);
+  mrb_define_method_raw(mrb, mrb_class_ptr(self), n, m);
+  return self;
+}
+
+static mrb_value
+cfunc_without_env(mrb_state *mrb, mrb_value self)
+{
+  return mrb_cfunc_env_get(mrb, 0);
+}
+
+void mrb_mruby_proc_ext_gem_test(mrb_state *mrb)
+{
+  struct RClass *cls;
+
+  cls = mrb_define_class(mrb, "ProcExtTest", mrb->object_class);
+  mrb_define_class_method(mrb, cls, "mrb_proc_new_cfunc_with_env", proc_new_cfunc_with_env, MRB_ARGS_REQ(1));
+  mrb_define_class_method(mrb, cls, "mrb_cfunc_env_get", cfunc_env_get, MRB_ARGS_REQ(2));
+  mrb_define_method(mrb, cls, "cfunc_without_env", cfunc_without_env, MRB_ARGS_NONE());
+}

data/ext/enclave/mruby/mrbgems/mruby-proc-ext/test/proc.rb

@@ -0,0 +1,130 @@
+##
+# 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?
+    if @enable_debug_info && e.backtrace[0].include?("(unknown)")
+      @enable_debug_info = false
+    end
+    return @enable_debug_info
+  end
+end
+
+assert('Proc#source_location') do
+  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
+  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#lambda?') do
+  assert_true lambda{}.lambda?
+  assert_true !Proc.new{}.lambda?
+end
+
+assert('Proc#===') do
+  proc = Proc.new {|a| a * 2}
+  assert_equal 20, (proc === 10)
+end
+
+assert('Proc#yield') do
+  proc = Proc.new {|a| a * 2}
+  assert_equal 20, proc.yield(10)
+end
+
+assert('Proc#curry') do
+  b = proc {|x, y, z| (x||0) + (y||0) + (z||0) }
+  assert_equal 6, b.curry[1][2][3]
+  assert_equal 6, b.curry[1, 2][3, 4]
+  assert_equal 6, b.curry(5)[1][2][3][4][5]
+  assert_equal 6, b.curry(5)[1, 2][3, 4][5]
+  assert_equal 1, b.curry(1)[1]
+
+  b = lambda {|x, y, z| (x||0) + (y||0) + (z||0) }
+  assert_equal 6, b.curry[1][2][3]
+  assert_raise(ArgumentError) { b.curry[1, 2][3, 4] }
+  assert_raise(ArgumentError) { b.curry(5) }
+  assert_raise(ArgumentError) { b.curry(1) }
+
+  assert_false(proc{}.curry.lambda?)
+  assert_true(lambda{}.curry.lambda?)
+end
+
+assert('Proc#parameters') do
+  assert_equal([], Proc.new {}.parameters)
+  assert_equal([], Proc.new {||}.parameters)
+  assert_equal([[:opt, :a]], Proc.new {|a|}.parameters)
+  assert_equal([[:req, :a]], lambda {|a|}.parameters)
+  assert_equal([[:opt, :a]], lambda {|a=nil|}.parameters)
+  assert_equal([[:req, :a]], ->(a){}.parameters)
+  assert_equal([[:rest, :*]], lambda { |*| }.parameters)
+  assert_equal([[:rest, :a]], Proc.new {|*a|}.parameters)
+  assert_equal([[:opt, :x], [:opt, :y], [:rest, :other]], Proc.new{|x,y=42,*other|}.parameters)
+  assert_equal([[:opt, :a], [:opt, :b], [:opt, :c], [:opt, :d], [:rest, :e], [:opt, :f], [:opt, :g], [:block, :h]], Proc.new {|a,b,c=:c,d=:d,*e,f,g,&h|}.parameters)
+  assert_equal([[:req, :a], [:req, :b], [:opt, :c], [:opt, :d], [:rest, :e], [:req, :f], [:req, :g], [:block, :h]], lambda {|a,b,c=:c,d=:d,*e,f,g,&h|}.parameters)
+end
+
+assert('Proc#to_proc') do
+  proc = Proc.new {}
+  assert_equal proc, proc.to_proc
+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
+
+assert('mrb_proc_new_cfunc_with_env') do
+  ProcExtTest.mrb_proc_new_cfunc_with_env(:test)
+  ProcExtTest.mrb_proc_new_cfunc_with_env(:mruby)
+
+  t = ProcExtTest.new
+
+  assert_equal :test, t.test
+  assert_equal :mruby, t.mruby
+end
+
+assert('mrb_cfunc_env_get') do
+  ProcExtTest.mrb_cfunc_env_get :get_int, [0, 1, 2]
+
+  t = ProcExtTest.new
+
+  assert_raise(TypeError) { t.cfunc_without_env }
+
+  assert_raise(IndexError) { t.get_int(-1) }
+  assert_raise(IndexError) { t.get_int(3) }
+
+  assert_equal 1, t.get_int(1)
+end