enclave 0.1.0

data/ext/enclave/mruby/tasks/amalgam.rake

@@ -0,0 +1,34 @@
+require_relative '../lib/mruby/amalgam'
+
+MRuby.each_target do
+  next unless libmruby_enabled?
+
+  amalgam_dir = "#{build_dir}/amalgam"
+  header_file = "#{amalgam_dir}/mruby.h"
+  source_file = "#{amalgam_dir}/mruby.c"
+
+  # Header depends on presym generation (for presym headers)
+  file header_file => [:gensym] do |t|
+    amalgam = MRuby::Amalgam.new(self)
+    amalgam.generate_header(t.name)
+  end
+
+  # Source depends on generated files (mrblib.c, gem_init.c, etc.)
+  mrblib_src = "#{build_dir}/mrblib/mrblib.c"
+  gem_init_src = "#{build_dir}/mrbgems/gem_init.c"
+
+  source_deps = [:gensym]
+  source_deps << mrblib_src if File.exist?(mrblib_src) || libmruby_enabled?
+
+  file source_file => source_deps do |t|
+    amalgam = MRuby::Amalgam.new(self)
+    amalgam.generate_source(t.name)
+  end
+
+  desc "Generate amalgamated mruby.h and mruby.c in #{amalgam_dir}"
+  task :amalgam => [header_file, source_file] do
+    puts "Amalgamation complete:"
+    puts "  Header: #{header_file}"
+    puts "  Source: #{source_file}"
+  end
+end

data/ext/enclave/mruby/tasks/benchmark.rake

@@ -0,0 +1,93 @@
+module MRuby
+  BENCHMARK_REPEAT = 4
+end
+
+$dat_files = []
+
+def bm_files
+  Dir.glob("#{MRUBY_ROOT}/benchmark/bm_*.rb").sort
+end
+
+def build_config_name
+  path = MRuby::Build.mruby_config_path
+  File.basename(path, '.rb').gsub('build_config_', '')
+end
+
+def plot_file
+  File.join(MRUBY_ROOT, 'benchmark', "#{build_config_name}.png")
+end
+
+def plot
+  raise "no build target to benchmark against" if $dat_files.empty?
+
+  opts_file = "#{MRUBY_ROOT}/benchmark/plot.gpl"
+  opts = File.read(opts_file).each_line.to_a.map(&:strip).join(';')
+
+  dat_files = $dat_files.group_by {|f| File.dirname(f).split(File::SEPARATOR)[-1]}
+
+  opts += ";set output '#{plot_file}'"
+
+  opts += ';plot '
+
+  opts += dat_files.keys.map do |data_file|
+    %Q['-' u 2:3:4:xtic(1) w hist title columnheader(1)]
+  end.join(',')
+  opts += ';'
+
+  cmd = %Q{gnuplot -p -e "#{opts}"}
+
+  IO.popen(cmd, 'w') do |p|
+    dat_files.each do |target_name, bm_files|
+      p.puts target_name.gsub('_', '-')
+      bm_files.each do |bm_file|
+        p.write File.read(bm_file)
+      end
+      p.puts "e"
+    end
+  end
+
+  puts "Benchmark results output to #{plot_file}"
+end
+
+
+MRuby.each_target do |target|
+  next if !target.benchmark_enabled? || target.internal?
+  mruby_bin = "#{target.build_dir}/bin/mruby"
+
+  bm_files.each do |bm_file|
+    bm_name = File.basename bm_file, ".rb"
+
+    dat_dir = File.join('benchmark', build_config_name, target.name)
+    dat_file = File.join(dat_dir, "#{bm_name}.dat")
+    $dat_files << dat_file
+
+    directory dat_dir
+
+    file dat_file => [bm_file, dat_dir, mruby_bin] do |task|
+      print bm_name
+      puts "..."
+
+      data = (0...MRuby::BENCHMARK_REPEAT).map do |n|
+        str = %x{(time -p #{mruby_bin} #{bm_file}) 2>&1 >/dev/null}
+        str.scan(/\d+\.\d+$/).map(&:to_f) # [real, user, sys]
+      end
+
+      File.open(task.name, "w") do |f|
+        data = data.map {|_,r,s| (r + s) / 2.0}
+        min = data.min
+        max = data.max
+        avg = data.inject(&:+) / data.size
+        f.puts "#{bm_name.gsub('_', '-')} #{avg} #{min} #{max}"
+      end
+    end
+  end
+end
+
+file plot_file => $dat_files do
+  plot
+end
+
+desc "run benchmark tests"
+task :benchmark => plot_file do
+  plot
+end

data/ext/enclave/mruby/tasks/bin.rake

@@ -0,0 +1,23 @@
+MRuby.each_target do |build|
+  if build.host? && build.mrbc_build && !build.gems["mruby-bin-mrbc"]
+    exe = build.exefile("#{build.mrbc_build.build_dir}/bin/mrbc")
+    build.products << build.define_installer(exe)
+  end
+
+  build.bins.each{|bin| build.products << define_installer_if_needed(bin)}
+
+  build.gems.each do |gem|
+    linker_attrs = build.gems.linker_attrs(gem)
+    gem.bins.each do |bin|
+      exe = build.exefile("#{build.build_dir}/bin/#{bin}")
+      objs = Dir["#{gem.dir}/tools/#{bin}/*.{c,cpp,cxx,cc}"].map do |f|
+        build.objfile(f.pathmap("#{gem.build_dir}/tools/#{bin}/%n"))
+      end
+      file exe => objs.concat(build.libraries) do |t|
+        build.linker.run t.name, t.prerequisites, *linker_attrs
+      end
+
+      build.products << define_installer_if_needed(bin)
+    end
+  end
+end

data/ext/enclave/mruby/tasks/core.rake

@@ -0,0 +1,12 @@
+as_cxx_srcs = %w[vm error gc].map{|name| "#{MRUBY_ROOT}/src/#{name}.c"}
+
+MRuby.each_target do
+  objs = Dir.glob("#{MRUBY_ROOT}/src/*.c").map do |src|
+    if cxx_exception_enabled? && as_cxx_srcs.include?(src)
+      compile_as_cxx(src)
+    else
+      objfile(src.pathmap("#{build_dir}/src/%n"))
+    end
+  end
+  self.libmruby_core_objs << objs
+end

data/ext/enclave/mruby/tasks/doc.rake

@@ -0,0 +1,118 @@
+MRuby.autoload :Documentation, 'mruby/doc'
+
+desc 'generate document'
+task :doc => %w[doc:api doc:capi]
+
+namespace :doc do
+  desc 'generate yard docs'
+  task :api do
+    begin
+      sh "mrbdoc"
+    rescue
+      puts "ERROR: To generate YARD documentation, you should install the yard-coderay and yard-mruby gems."
+      puts "  $ gem install yard-coderay yard-mruby"
+      puts "https://yardoc.org/"
+      puts "https://rubygems.org/gems/yard-mruby"
+      puts "https://rubygems.org/gems/yard-coderay"
+    end
+  end
+
+  desc 'generate doxygen docs'
+  task :capi do
+    begin
+      sh "doxygen Doxyfile"
+    rescue
+      puts "ERROR: To generate C API documentation, you should install Doxygen and Graphviz."
+      puts "On Debian-based systems:"
+      puts "  $ sudo apt-get install doxygen graphviz"
+      puts "On RHEL-based systems:"
+      puts "  $ sudo dnf install doxygen graphviz"
+      puts "On macOS-based systems:"
+      puts "  $ brew install doxygen graphviz"
+      puts "https://www.doxygen.nl/"
+      puts "https://graphviz.org/"
+    end
+  end
+
+  desc 'clean all built docs'
+  task :clean => %w[clean:api clean:capi]
+
+  namespace :clean do
+    desc 'clean yard docs'
+    task :api do
+      rm_rf %w(doc/api .yardoc)
+    end
+
+    desc 'clean doxygen docs'
+    task :capi do
+      rm_rf 'doc/capi'
+    end
+  end
+
+  namespace :view do
+    desc 'open yard docs'
+    task :api do
+      if RUBY_PLATFORM.include?('darwin')
+        sh 'open doc/api/index.html'
+      else
+        sh 'xdg-open doc/api/index.html'
+      end
+    end
+
+    desc 'open doxygen docs'
+    task :capi do
+      if RUBY_PLATFORM.include?('darwin')
+        sh 'open doc/capi/html/index.html'
+      else
+        sh 'xdg-open doc/capi/html/index.html'
+      end
+    end
+  end
+
+  desc 'update doc/internal/opcode.md'
+  task 'update-opcode.md' do
+    unless system(*%W(git --git-dir #{MRUBY_ROOT}/.git --work-tree #{MRUBY_ROOT} diff --quiet @ -- doc/internal/opcode.md))
+      abort <<~'ERRMESG'
+        The file "doc/internal/opcode.md" has been modified but not committed.
+        To avoid loss of your edits, the automatic update process has been aborted.
+      ERRMESG
+    end
+
+    MRuby::Documentation.update_opcode_md
+  end
+
+  task 'update-index' do
+    rev_order = %w(doc/internal/ doc/guides/ doc/)
+    cmd = %W(git --git-dir #{MRUBY_ROOT}/.git --work-tree #{MRUBY_ROOT} ls-files -- doc/*.md)
+    doc = IO.popen(cmd, "r") { |io| io.read.split("\n") }
+    doc.sort_by! { |e| [-rev_order.index { |o| e.start_with?(o) }, e] }
+    readme_path = File.join(MRUBY_ROOT, "README.md")
+    readme = File.read(readme_path)
+    matched = false
+    mark_begin = "<!-- BEGIN OF MRUBY DOCUMENT INDEX -->\n"
+    mark_end = "<!-- END OF MRUBY DOCUMENT INDEX -->\n"
+    readme1 = readme.sub(/^#{mark_begin}\n\K.*(?=^\n#{mark_end})/m) {
+      matched = true
+      doc.each_with_object("") { |d, a|
+        summary = File.open(File.join(MRUBY_ROOT, d)) { |f|
+          f.each_line.first.slice(/^<!--\s*summary:\s*(.*?)\s*-->/, 1)
+        }
+        if summary
+          summary = "Internal Implementation / #{summary}" if d.start_with?("doc/internal/")
+          a << "- [#{summary}](#{d})\n"
+        end
+      }
+    }
+    raise "missing marker for document index in README.md" unless matched
+    File.write(readme_path, readme1, mode: "wb") unless readme == readme1
+  end
+end
+
+# deprecated
+task "api_doc" => "doc:api"
+task "capi_doc" => "doc:capi"
+task "clean_doc" => "doc:clean"
+task "clean_api_doc" => "doc:clean:api"
+task "clean_capi_doc" => "doc:clean:capi"
+task "view_api" => "doc:view:api"
+task "view_capi" => "doc:view:capi"

data/ext/enclave/mruby/tasks/install.rake

@@ -0,0 +1,40 @@
+desc "install compiled products (on host)"
+task :install => "install:full:host"
+
+desc "install compiled executable (on host)"
+task :install_bin => "install:bin:host"
+
+desc "install compiled products (all build targets)"
+task "install:full"
+
+desc "install compiled executable (all build targets)"
+task "install:bin"
+
+MRuby.each_target do |build|
+  next if build.internal?
+
+  prefix = File.join(MRuby::INSTALL_DESTDIR, build.install_prefix)
+  exclude_filter = build.install_excludes.flatten
+
+  task "install:full" => "install:full:#{build.name}"
+
+  task "install:full:#{build.name}" => "install:bin:#{build.name}" do
+    Dir.glob(File.join(build.build_dir.gsub(/[\[\{\*\?]/, "\\\0"), "{include,#{libdir_name}}/**/*")) do |path|
+      next unless File.file? path
+      file = path.relative_path_from(build.build_dir)
+      next if exclude_filter.any? { |filter| filter.respond_to?(:call) ? filter.call(file) : filter.match?(file) }
+      install_D path, File.join(prefix, file)
+    end
+  end
+
+  task "install:bin" => "install:bin:#{build.name}"
+
+  task "install:bin:#{build.name}" => "all" do
+    Dir.glob(File.join(build.build_dir.gsub(/[\[\{\*\?]/, "\\\0"), "{bin,host-bin}/**/*")) do |path|
+      next unless File.file? path
+      file = path.relative_path_from(build.build_dir)
+      next if exclude_filter.any? { |filter| filter.respond_to?(:call) ? filter.call(file) : filter.match?(file) }
+      install_D path, File.join(prefix, file)
+    end
+  end
+end

data/ext/enclave/mruby/tasks/libmruby.rake

@@ -0,0 +1,90 @@
+MRuby.each_target do
+  file libmruby_core_static => libmruby_core_objs.flatten do |t|
+    archiver.run t.name, t.prerequisites
+  end
+
+  products << libmruby_core_static
+
+  next unless libmruby_enabled?
+
+  copy_headers_task = "expose_header_files:#{self.name}"
+  file libmruby_static => libmruby_objs.flatten do |t|
+    Rake::Task[copy_headers_task].invoke
+    archiver.run t.name, t.prerequisites
+  end
+
+  task copy_headers_task do |t|
+    # Since header files may be generated dynamically and it is hard to know all of them,
+    # the task is executed depending on when libmruby.a is generated.
+
+    gemsbasedir = File.join(build_dir, "include/mruby/gems")
+    dirmap = {
+      MRUBY_ROOT => build_dir
+    }
+    gems.each { |g|
+      dirmap[g.dir] = File.join(gemsbasedir, g.name)
+      dirmap[g.build_dir] = File.join(gemsbasedir, g.name)
+    }
+
+    dirs = each_header_files.to_a
+    dirs.uniq!
+    dirs.replace_prefix_by(dirmap).zip(dirs).each do |dest, src|
+      if File.mtime(src).to_i > (File.mtime(dest).to_i rescue 0)
+        mkpath File.dirname(dest)
+        cp src, dest
+      end
+    end
+  end
+
+  file "#{build_dir}/#{libdir_name}/libmruby.flags.mak" => [__FILE__, libmruby_static] do |t|
+    mkdir_p File.dirname t.name
+    open(t.name, 'w') do |f|
+      f.puts <<~FLAGS_MAKE
+        # GNU make is required to use this file.
+        MRUBY_PACKAGE_DIR_GNU := $(shell dirname "$(lastword $(MAKEFILE_LIST))")
+        MRUBY_PACKAGE_DIR != dirname "$(MRUBY_PACKAGE_DIR_GNU)"
+      FLAGS_MAKE
+
+      [
+        [cc,   "MRUBY_CC",   "MRUBY_CFLAGS"],
+        [cxx,  "MRUBY_CXX",  "MRUBY_CXXFLAGS"],
+        [asm,  "MRUBY_AS",   "MRUBY_ASFLAGS"],
+        [objc, "MRUBY_OBJC", "MRUBY_OBJCFLAGS"]
+      ].each do |cc, cmd, flags|
+        incpaths = cc.include_paths.dup
+        dirmaps = {
+          MRUBY_ROOT => "$(MRUBY_PACKAGE_DIR)",
+          build_dir => "$(MRUBY_PACKAGE_DIR)"
+        }
+        gems.each do |g|
+          incpaths.concat g.export_include_paths
+          dirmaps[g.dir] = "$(MRUBY_PACKAGE_DIR)/include/mruby/gems/#{g.name}"
+          dirmaps[g.build_dir] = "$(MRUBY_PACKAGE_DIR)/include/mruby/gems/#{g.name}"
+        end
+        modcc = cc.clone
+        modcc.include_paths = incpaths.replace_prefix_by(dirmaps).uniq
+
+        f.puts "#{cmd} = #{cc.command}"
+        f.puts "#{flags} = #{modcc.all_flags}"
+      end
+
+      f.puts "MRUBY_LD = #{linker.command}"
+
+      libgems = gems.reject{|g| g.bin?}
+      gem_flags = libgems.map {|g| g.linker.flags }
+      gem_library_paths = libgems.map {|g| g.linker.library_paths }
+      f.puts "MRUBY_LDFLAGS = #{linker.all_flags(gem_library_paths, gem_flags)} #{linker.option_library_path % "$(MRUBY_PACKAGE_DIR)/#{libdir_name}"}"
+
+      gem_flags_before_libraries = libgems.map {|g| g.linker.flags_before_libraries }
+      f.puts "MRUBY_LDFLAGS_BEFORE_LIBS = #{[linker.flags_before_libraries, gem_flags_before_libraries].flatten.join(' ')}"
+
+      gem_libraries = libgems.map {|g| g.linker.libraries }
+      libmruby = (toolchains.find { |e| e == "visualcpp" }) ? "libmruby" : "mruby"
+      f.puts "MRUBY_LIBS = #{linker.option_library % libmruby} #{linker.library_flags(gem_libraries)}"
+
+      f.puts "MRUBY_LIBMRUBY_PATH = #{libmruby_static.replace_prefix_by(build_dir => "$(MRUBY_PACKAGE_DIR)")}"
+    end
+  end
+
+  products << libmruby_static
+end

data/ext/enclave/mruby/tasks/mrbgems.rake

@@ -0,0 +1,152 @@
+MRuby.each_target do
+  active_gems_txt = "#{build_dir}/mrbgems/active_gems.txt"
+
+  if enable_gems?
+    gems.setup_build
+    gems.check self
+
+    # loader all gems
+    self.libmruby_objs << objfile("#{build_dir}/mrbgems/gem_init")
+    file objfile("#{build_dir}/mrbgems/gem_init") => ["#{build_dir}/mrbgems/gem_init.c", "#{build_dir}/LEGAL"]
+    file "#{build_dir}/mrbgems/gem_init.c" => [active_gems_txt, MRUBY_CONFIG, __FILE__] do |t|
+      mkdir_p "#{build_dir}/mrbgems"
+      open(t.name, 'w') do |f|
+        gem_func_gems = gems.select { |g| g.generate_functions }
+        gem_func_decls = +''
+        gem_funcs = +''
+        gem_func_gems.each do |g|
+          init = "GENERATED_TMP_mrb_#{g.funcname}_gem_init"
+          final = "GENERATED_TMP_mrb_#{g.funcname}_gem_final"
+          gem_func_decls << "void #{init}(mrb_state*);\n" \
+                            "void #{final}(mrb_state*);\n"
+          gem_funcs << "  { #{init}, #{final} },\n"
+        end
+        f.puts %Q[/*]
+        f.puts %Q[ * This file contains a list of all]
+        f.puts %Q[ * initializing methods which are]
+        f.puts %Q[ * necessary to bootstrap all gems.]
+        f.puts %Q[ *]
+        f.puts %Q[ * This file was generated by mruby/#{__FILE__.relative_path_from(MRUBY_ROOT)}.]
+        f.puts %Q[ *]
+        f.puts %Q[ * IMPORTANT:]
+        f.puts %Q[ *   This file was generated!]
+        f.puts %Q[ *   All manual changes will get lost.]
+        f.puts %Q[ */]
+        f.puts %Q[]
+        f.puts %Q[#include <mruby.h>]
+        f.puts %Q[#include <mruby/error.h>]
+        f.puts %Q[#include <mruby/proc.h>]
+        f.puts %Q[]
+        unless gem_funcs.empty?
+          f.write gem_func_decls
+          f.puts %Q[]
+          f.puts %Q[static const struct {]
+          f.puts %Q[  void (*init)(mrb_state*);]
+          f.puts %Q[  void (*final)(mrb_state*);]
+          f.puts %Q[} gem_funcs[] = {]
+          f.write gem_funcs
+          f.puts %Q[};]
+          f.puts %Q[]
+          f.puts %Q[#define NUM_GEMS ((int)(sizeof(gem_funcs) / sizeof(gem_funcs[0])))]
+          f.puts %Q[]
+          f.puts %Q[struct final_mrbgems {]
+          f.puts %Q[  int i;]
+          f.puts %Q[  int ai;]
+          f.puts %Q[};]
+          f.puts %Q[]
+          f.puts %Q[static mrb_value]
+          f.puts %Q[final_mrbgems_body(mrb_state *mrb, void *ud) {]
+          f.puts %Q[  struct final_mrbgems *p = (struct final_mrbgems*)ud;]
+          f.puts %Q[  for (; p->i >= 0; p->i--) {]
+          f.puts %Q[    gem_funcs[p->i].final(mrb);]
+          f.puts %Q[    mrb_gc_arena_restore(mrb, p->ai);]
+          f.puts %Q[  }]
+          f.puts %Q[  return mrb_nil_value();]
+          f.puts %Q[}]
+          f.puts %Q[]
+          f.puts %Q[static void]
+          f.puts %Q[mrb_final_mrbgems(mrb_state *mrb) {]
+          f.puts %Q[  struct final_mrbgems a = { NUM_GEMS - 1, mrb_gc_arena_save(mrb) };]
+          f.puts %Q[  for (; a.i >= 0; a.i--) {]
+          f.puts %Q[    mrb_protect_error(mrb, final_mrbgems_body, &a, NULL);]
+          f.puts %Q[    mrb_gc_arena_restore(mrb, a.ai);]
+          f.puts %Q[  }]
+          f.puts %Q[}]
+          f.puts %Q[]
+        end
+        f.puts %Q[void]
+        f.puts %Q[mrb_init_mrbgems(mrb_state *mrb) {]
+        unless gem_funcs.empty?
+          f.puts %Q[  int ai = mrb_gc_arena_save(mrb);]
+          f.puts %Q[  for (int i = 0; i < NUM_GEMS; i++) {]
+          f.puts %Q[    gem_funcs[i].init(mrb);]
+          f.puts %Q[    mrb_gc_arena_restore(mrb, ai);]
+          f.puts %Q[    mrb_vm_ci_env_clear(mrb, mrb->c->cibase);]
+          f.puts %Q[    if (mrb->exc) {]
+          f.puts %Q[      mrb_exc_raise(mrb, mrb_obj_value(mrb->exc));]
+          f.puts %Q[    }]
+          f.puts %Q[  }]
+          f.puts %Q[  mrb_state_atexit(mrb, mrb_final_mrbgems);]
+        end
+        f.puts %Q[}]
+      end
+    end
+  end
+
+  file active_gems_txt => :generate_active_gems_txt
+  desc "generate the active gems text files"
+  task :generate_active_gems_txt do |t|
+    def t.timestamp; Time.at(0) end
+    active_gems = gems.sort_by(&:name).inject(+""){|s, g| s << "#{g.name}\n"}
+    if !File.exist?(active_gems_txt) || File.read(active_gems_txt) != active_gems
+      mkdir_p File.dirname(active_gems_txt)
+      File.write(active_gems_txt, active_gems)
+    end
+  end
+
+  # legal documents
+  file "#{build_dir}/LEGAL" => [MRUBY_CONFIG, __FILE__] do |t|
+    mkdir_p File.dirname t.name
+    open(t.name, 'w+') do |f|
+      f.puts <<LEGAL
+Copyright (c) #{Time.now.year} mruby developers
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the "Software"),
+to deal in the Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and/or sell copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+LEGAL
+
+      if enable_gems?
+        f.puts <<GEMS_LEGAL
+
+Additional Licenses
+
+Due to the reason that you chose additional mruby packages (GEMS),
+please check the following additional licenses too:
+GEMS_LEGAL
+
+        gems.map do |g|
+          authors = [g.authors].flatten.sort.join(", ")
+          f.puts
+          f.puts "GEM: #{g.name}"
+          f.puts "Copyright (c) #{Time.now.year} #{authors}"
+          f.puts "License: #{g.licenses}"
+        end
+      end
+    end
+  end
+end

data/ext/enclave/mruby/tasks/mrblib.rake

@@ -0,0 +1,29 @@
+MRuby.each_target do
+  next unless libmruby_enabled?
+
+  src = "#{build_dir}/mrblib/mrblib.c"
+  rbfiles = Dir["#{MRUBY_ROOT}/mrblib/*.rb"].sort!
+
+  self.libmruby_objs << objfile(src.ext)
+
+  file src => [mrbcfile, __FILE__, *rbfiles] do |t|
+    mkdir_p File.dirname(t.name)
+    File.open(t.name, 'w') do |f|
+      _pp "GEN", "mrblib/*.rb", "#{t.name.relative_path}"
+      f.puts %Q[/*]
+      f.puts %Q[ * This file is loading the mrblib]
+      f.puts %Q[ *]
+      f.puts %Q[ * IMPORTANT:]
+      f.puts %Q[ *   This file was generated!]
+      f.puts %Q[ *   All manual changes will get lost.]
+      f.puts %Q[ */]
+      mrbc.run f, rbfiles, "mrblib_proc", cdump: true, static: true
+      f.puts %Q[void]
+      f.puts %Q[mrb_init_mrblib(mrb_state *mrb)]
+      f.puts %Q[{]
+      f.puts %Q[  mrblib_proc_init_syms(mrb);]
+      f.puts %Q[  mrb_load_proc(mrb, mrblib_proc);]
+      f.puts %Q[}]
+    end
+  end
+end

data/ext/enclave/mruby/tasks/presym.rake

@@ -0,0 +1,57 @@
+all_prerequisites = ->(task_name, prereqs) do
+  Rake::Task[task_name].prerequisites.each do |prereq_name|
+    next if prereqs[prereq_name]
+    prereqs[prereq_name] = true
+    all_prerequisites.(Rake::Task[prereq_name].name, prereqs)
+  end
+end
+
+MRuby.each_target do |build|
+  gensym_task = task(:gensym)
+
+  presym = build.presym
+
+  include_dir = "#{build.build_dir}/include"
+  build.compilers.each{|c| c.include_paths << include_dir}
+  build.gems.each{|gem| gem.compilers.each{|c| c.include_paths << include_dir}}
+
+  prereqs = {}
+  ppps = []
+  build_dir = "#{build.build_dir}/"
+  mrbc_build_dir = "#{build.mrbc_build.build_dir}/" if build.mrbc_build
+  build.products.each{|product| all_prerequisites.(product, prereqs)}
+  prereqs.each_key do |prereq|
+    next unless File.extname(prereq) == build.exts.object
+    next unless prereq.start_with?(build_dir)
+    next if mrbc_build_dir && prereq.start_with?(mrbc_build_dir)
+    ppp = prereq.ext(build.exts.presym_preprocessed)
+    if Rake.application.lookup(ppp) ||
+       Rake.application.enhance_with_matching_rule(ppp)
+      ppps << ppp
+    end
+  end
+
+  file presym.list_path => ppps do
+    presyms = presym.scan(ppps)
+    current_presyms = presym.read_list if File.exist?(presym.list_path)
+    update = presyms != current_presyms
+    presym.write_list(presyms) if update
+    mkdir_p presym.header_dir
+    %w[id table].each do |type|
+      next if !update && File.exist?(presym.send("#{type}_header_path"))
+      presym.send("write_#{type}_header", presyms)
+    end
+  end
+
+  # Ensure object files depend on presym headers being generated.
+  # This is necessary for sub-builds (e.g., mrbc) whose compilation
+  # may be triggered during another build's presym scanning.
+  prereqs.each_key do |prereq|
+    next unless File.extname(prereq) == build.exts.object
+    next unless prereq.start_with?(build_dir)
+    next if mrbc_build_dir && prereq.start_with?(mrbc_build_dir)
+    file prereq => presym.list_path
+  end
+
+  gensym_task.enhance([presym.list_path])
+end