From 5da14042f70711ea5cf66e034699730335462f66 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 5 May 2024 14:08:03 +0200 Subject: Merging upstream version 1.45.3+dfsg. Signed-off-by: Daniel Baumann --- .../deps/mruby/mrbgems/mruby-proc-ext/mrbgem.rake | 5 + .../mruby/mrbgems/mruby-proc-ext/mrblib/proc.rb | 42 +++++ .../deps/mruby/mrbgems/mruby-proc-ext/src/proc.c | 173 +++++++++++++++++++++ .../deps/mruby/mrbgems/mruby-proc-ext/test/proc.c | 56 +++++++ .../deps/mruby/mrbgems/mruby-proc-ext/test/proc.rb | 96 ++++++++++++ 5 files changed, 372 insertions(+) create mode 100644 src/web/server/h2o/libh2o/deps/mruby/mrbgems/mruby-proc-ext/mrbgem.rake create mode 100644 src/web/server/h2o/libh2o/deps/mruby/mrbgems/mruby-proc-ext/mrblib/proc.rb create mode 100644 src/web/server/h2o/libh2o/deps/mruby/mrbgems/mruby-proc-ext/src/proc.c create mode 100644 src/web/server/h2o/libh2o/deps/mruby/mrbgems/mruby-proc-ext/test/proc.c create mode 100644 src/web/server/h2o/libh2o/deps/mruby/mrbgems/mruby-proc-ext/test/proc.rb (limited to 'src/web/server/h2o/libh2o/deps/mruby/mrbgems/mruby-proc-ext') diff --git a/src/web/server/h2o/libh2o/deps/mruby/mrbgems/mruby-proc-ext/mrbgem.rake b/src/web/server/h2o/libh2o/deps/mruby/mrbgems/mruby-proc-ext/mrbgem.rake new file mode 100644 index 000000000..e4d15a140 --- /dev/null +++ b/src/web/server/h2o/libh2o/deps/mruby/mrbgems/mruby-proc-ext/mrbgem.rake @@ -0,0 +1,5 @@ +MRuby::Gem::Specification.new('mruby-proc-ext') do |spec| + spec.license = 'MIT' + spec.author = 'mruby developers' + spec.summary = 'Proc class extension' +end diff --git a/src/web/server/h2o/libh2o/deps/mruby/mrbgems/mruby-proc-ext/mrblib/proc.rb b/src/web/server/h2o/libh2o/deps/mruby/mrbgems/mruby-proc-ext/mrblib/proc.rb new file mode 100644 index 000000000..b71663938 --- /dev/null +++ b/src/web/server/h2o/libh2o/deps/mruby/mrbgems/mruby-proc-ext/mrblib/proc.rb @@ -0,0 +1,42 @@ +class Proc + + def ===(*args) + call(*args) + end + + def yield(*args) + call(*args) + end + + def to_proc + self + end + + 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 (#{arity} for #{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 + +end diff --git a/src/web/server/h2o/libh2o/deps/mruby/mrbgems/mruby-proc-ext/src/proc.c b/src/web/server/h2o/libh2o/deps/mruby/mrbgems/mruby-proc-ext/src/proc.c new file mode 100644 index 000000000..b13606f5f --- /dev/null +++ b/src/web/server/h2o/libh2o/deps/mruby/mrbgems/mruby-proc-ext/src/proc.c @@ -0,0 +1,173 @@ +#include +#include +#include +#include +#include +#include + +static mrb_value +mrb_proc_lambda(mrb_state *mrb, mrb_value self) +{ + struct RProc *p = mrb_proc_ptr(self); + return mrb_bool_value(MRB_PROC_STRICT_P(p)); +} + +static mrb_value +mrb_proc_source_location(mrb_state *mrb, mrb_value self) +{ + struct RProc *p = mrb_proc_ptr(self); + + if (MRB_PROC_CFUNC_P(p)) { + return mrb_nil_value(); + } + else { + mrb_irep *irep = p->body.irep; + int32_t line; + const char *filename; + + filename = mrb_debug_get_filename(irep, 0); + line = mrb_debug_get_line(irep, 0); + + return (!filename && line == -1)? mrb_nil_value() + : mrb_assoc_new(mrb, mrb_str_new_cstr(mrb, filename), mrb_fixnum_value(line)); + } +} + +static mrb_value +mrb_proc_inspect(mrb_state *mrb, mrb_value self) +{ + struct RProc *p = mrb_proc_ptr(self); + mrb_value str = mrb_str_new_lit(mrb, "#body.irep; + const char *filename; + int32_t line; + mrb_str_cat_lit(mrb, str, "@"); + + filename = mrb_debug_get_filename(irep, 0); + mrb_str_cat_cstr(mrb, str, filename ? filename : "-"); + mrb_str_cat_lit(mrb, str, ":"); + + line = mrb_debug_get_line(irep, 0); + if (line != -1) { + str = mrb_format(mrb, "%S:%S", 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; +} + +static mrb_value +mrb_kernel_proc(mrb_state *mrb, mrb_value self) +{ + mrb_value blk; + + mrb_get_args(mrb, "&", &blk); + if (mrb_nil_p(blk)) { + mrb_raise(mrb, E_ARGUMENT_ERROR, "tried to create Proc object without a block"); + } + + 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]] + */ + +static mrb_value +mrb_proc_parameters(mrb_state *mrb, mrb_value self) +{ + struct parameters_type { + int size; + const char *name; + } *p, parameters_list [] = { + {0, "req"}, + {0, "opt"}, + {0, "rest"}, + {0, "req"}, + {0, "block"}, + {0, NULL} + }; + const struct RProc *proc = mrb_proc_ptr(self); + const struct mrb_irep *irep = proc->body.irep; + mrb_aspec aspec; + mrb_value sname, parameters; + int i, j; + + if (MRB_PROC_CFUNC_P(proc)) { + // TODO cfunc aspec is not implemented yet + return mrb_ary_new(mrb); + } + if (!irep) { + return mrb_ary_new(mrb); + } + if (!irep->lv) { + return mrb_ary_new(mrb); + } + if (GET_OPCODE(*irep->iseq) != OP_ENTER) { + return mrb_ary_new(mrb); + } + + if (!MRB_PROC_STRICT_P(proc)) { + parameters_list[0].name = "opt"; + parameters_list[3].name = "opt"; + } + + aspec = GETARG_Ax(*irep->iseq); + 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_BLOCK(aspec); + + parameters = mrb_ary_new_capa(mrb, irep->nlocals-1); + + for (i = 0, p = parameters_list; p->name; p++) { + if (p->size <= 0) continue; + sname = mrb_symbol_value(mrb_intern_cstr(mrb, p->name)); + for (j = 0; j < p->size; i++, j++) { + mrb_value a = mrb_ary_new(mrb); + mrb_ary_push(mrb, a, sname); + if (irep->lv[i].name) { + mrb_ary_push(mrb, a, mrb_symbol_value(irep->lv[i].name)); + } + mrb_ary_push(mrb, parameters, a); + } + } + return parameters; +} + +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, "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()); + mrb_define_method(mrb, p, "parameters", mrb_proc_parameters, MRB_ARGS_NONE()); + + mrb_define_class_method(mrb, mrb->kernel_module, "proc", mrb_kernel_proc, MRB_ARGS_NONE()); + mrb_define_method(mrb, mrb->kernel_module, "proc", mrb_kernel_proc, MRB_ARGS_NONE()); +} + +void +mrb_mruby_proc_ext_gem_final(mrb_state* mrb) +{ +} diff --git a/src/web/server/h2o/libh2o/deps/mruby/mrbgems/mruby-proc-ext/test/proc.c b/src/web/server/h2o/libh2o/deps/mruby/mrbgems/mruby-proc-ext/test/proc.c new file mode 100644 index 000000000..a77b68e9d --- /dev/null +++ b/src/web/server/h2o/libh2o/deps/mruby/mrbgems/mruby-proc-ext/test/proc.c @@ -0,0 +1,56 @@ +#include +#include +#include + +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_get_args(mrb, "n", &n); + n_val = mrb_symbol_value(n); + mrb_define_method_raw(mrb, mrb_class_ptr(self), n, + mrb_proc_new_cfunc_with_env(mrb, return_func_name, 1, &n_val)); + 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; + mrb_value *argv; mrb_int argc; + mrb_get_args(mrb, "na", &n, &argv, &argc); + mrb_define_method_raw(mrb, mrb_class_ptr(self), n, + mrb_proc_new_cfunc_with_env(mrb, return_env, argc, argv)); + 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_module_function(mrb, cls, "mrb_proc_new_cfunc_with_env", proc_new_cfunc_with_env, MRB_ARGS_REQ(1)); + mrb_define_module_function(mrb, cls, "mrb_cfunc_env_get", cfunc_env_get, MRB_ARGS_REQ(2)); + mrb_define_module_function(mrb, cls, "cfunc_without_env", cfunc_without_env, MRB_ARGS_NONE()); +} diff --git a/src/web/server/h2o/libh2o/deps/mruby/mrbgems/mruby-proc-ext/test/proc.rb b/src/web/server/h2o/libh2o/deps/mruby/mrbgems/mruby-proc-ext/test/proc.rb new file mode 100644 index 000000000..037d8d124 --- /dev/null +++ b/src/web/server/h2o/libh2o/deps/mruby/mrbgems/mruby-proc-ext/test/proc.rb @@ -0,0 +1,96 @@ +## +# Proc(Ext) Test + +assert('Proc#source_location') do + loc = Proc.new {}.source_location + next true if loc.nil? + assert_equal loc[0][-7, 7], 'proc.rb' + assert_equal loc[1], 5 +end + +assert('Proc#inspect') do + ins = Proc.new{}.inspect + assert_kind_of String, 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, :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('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 -- cgit v1.2.3