enclave 0.1.0

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

@@ -0,0 +1,84 @@
+desc "build and run all mruby tests"
+task :test => "test:build" do
+  Rake::Task["test:run"].invoke
+end
+
+namespace :test do |test_ns|
+  desc "build and run library tests"
+  task :lib => "build:lib" do
+    test_ns["run:lib"].invoke
+  end
+
+  desc "build and run command binaries tests"
+  task :bin => "rake:all" do
+    test_ns["run:bin"].invoke
+  end
+
+  desc "build all mruby tests"
+  task :build => "build:lib"
+
+  namespace :build do |test_build_ns|
+    desc "build library tests"
+    task :lib => "rake:all" do
+      MRuby.each_target{|build| build.gem(core: 'mruby-test')}
+      test = test_build_ns["lib_without_loading_gem"]
+      test.invoke if test
+    end
+  end
+
+  desc "run all mruby tests"
+  task :run
+
+  namespace :run do
+    desc "run library tests"
+    task :lib
+
+    desc "run command binaries tests"
+    task :bin
+  end
+
+  desc "run all mruby tests serially"
+  task "run:serial" => "build" do
+    Rake::Task["test:run"].prerequisite_tasks.each(&:invoke)
+  end
+
+  desc "run library tests serially"
+  task "run:serial:bin" => "build:bin" do
+    Rake::Task["test:run:lib"].prerequisite_tasks.each(&:invoke)
+  end
+
+  desc "run command binaries tests serially"
+  task "run:serial:lib" => "build:lib" do
+    Rake::Task["test:run:bin"].prerequisite_tasks.each(&:invoke)
+  end
+end
+
+MRuby.each_target do |build|
+  if build.test_enabled?
+    t = task "test:build:lib_without_loading_gem:#{build.name}" do
+      gem = build.gems["mruby-test"]
+      gem.setup
+      gem.setup_compilers
+      Rake::Task[build.define_installer_if_needed("mrbtest")].invoke
+    end
+    task "test:build:lib_without_loading_gem" => t
+
+    t = task "test:run:lib:#{build.name}" do
+      build.run_test
+    end
+    task "test:run" => t
+    task "test:run:lib" => t
+  end
+  if build.bintest_enabled?
+    t = task "test:run:bin:#{build.name}" do
+      build.run_bintest
+    end
+    task "test:run" => t
+    task "test:run:bin" => t
+  end
+end
+
+task :clean do
+  host = MRuby.targets["host"]
+  rm_f host.exefile("#{host.class.install_dir}/mrbtest") if host && host.test_enabled?
+end

data/ext/enclave/mruby/tasks/toolchains/android.rake

@@ -0,0 +1,228 @@
+require "json"
+
+class MRuby::Toolchain::Android
+
+  DEFAULT_ARCH = 'armeabi-v7a' # TODO : Revise if arch should have a default
+
+  DEFAULT_TOOLCHAIN = :clang
+
+  DEFAULT_NDK_HOMES = %w{
+    /usr/local/opt/android-sdk/ndk-bundle
+    /usr/local/opt/android-ndk
+    ~/Android/Sdk/ndk-bundle
+    %LOCALAPPDATA%/Android/android-sdk/ndk-bundle
+    %LOCALAPPDATA%/Android/android-ndk
+    %LOCALAPPDATA%/Android/Sdk/ndk/*
+    ~/Library/Android/sdk/ndk-bundle
+    ~/Library/Android/ndk
+    /opt/android-ndk
+  }
+
+  TOOLCHAINS = [:clang]
+
+  ARCHITECTURES = %w{
+    armeabi-v7a arm64-v8a
+    x86 x86_64
+  }
+
+  class AndroidNDKHomeNotFound < StandardError
+    def message
+        <<-EOM
+Couldn't find Android NDK Home.
+Set ANDROID_NDK_HOME environment variable or set :ndk_home parameter
+        EOM
+    end
+  end
+
+  attr_reader :params
+
+  def initialize(params)
+    @params = params
+  end
+
+  def bin(command)
+    command = command.to_s
+    toolchain_path.join('bin', command).to_s
+  end
+
+  def home_path
+    @home_path ||= Pathname.new(
+      params[:ndk_home] ||
+      ENV['ANDROID_NDK_HOME'] ||
+      DEFAULT_NDK_HOMES.find { |path|
+        path.gsub! '%LOCALAPPDATA%', ENV['LOCALAPPDATA'] || '%LOCALAPPDATA%'
+        path.gsub! '\\', '/'
+        path.gsub! '~', Dir.home || '~'
+        path.gsub!('*') do
+          next nil unless path[-1] == "*"
+          dirs = Dir.glob(path).collect do |d|
+            m = d.match(/(\d+)\.(\d+)\.(\d+)$/)
+            m ? [m[1], m[2], m[3]].collect(&:to_i) : nil
+          end
+          dirs.compact!
+          dirs.sort! do |before, after|
+            f = 0
+            if (f = (after.first <=> before.first)) != 0
+              next f
+            elsif (f = (after[1] <=> before[1])) != 0
+              next f
+            else
+              next after.last <=> before.last
+            end
+          end
+          dirs.empty? ? nil.to_s : dirs.first.join(".")
+        end
+        File.directory?(path)
+      } || raise(AndroidNDKHomeNotFound)
+    )
+  end
+
+  def toolchain
+    @toolchain ||= params.fetch(:toolchain){ DEFAULT_TOOLCHAIN }
+  end
+
+  def toolchain_path
+    @toolchain_path ||= home_path.join('toolchains', 'llvm' , 'prebuilt', host_platform)
+  end
+
+  def host_platform
+    @host_platform ||= case RUBY_PLATFORM
+      when /cygwin|mswin|mingw|bccwin|wince|emx/i
+        path = home_path.join('toolchains', 'llvm' , 'prebuilt', 'windows*')
+        Dir.glob(path.to_s){ |item|
+          next if File.file?(item)
+          path = Pathname.new(item)
+          break
+        }
+        path.basename
+      when /x86_64-darwin/i
+        'darwin-x86_64'
+      when /darwin/i
+        'darwin-x86'
+      when /x86_64-linux/i
+        'linux-x86_64'
+      when /linux/i
+        'linux-x86'
+      else
+        raise NotImplementedError, "Unknown host platform (#{RUBY_PLATFORM})"
+      end
+  end
+
+  def arch
+    @arch ||= (params[:arch] || ENV['ANDROID_ARCH'] || DEFAULT_ARCH).to_s
+  end
+
+  def armeabi_v7a_mfpu
+    @armeabi_v7a_mfpu ||= (params[:mfpu] || 'vfpv3-d16').to_s
+  end
+
+  def armeabi_v7a_mfloat_abi
+    @armeabi_v7a_mfloat_abi ||= (params[:mfloat_abi] || 'softfp').to_s
+  end
+
+  def sdk_version
+    @sdk_version ||= params[:sdk_version]
+    if !@sdk_version then
+      # Higher SDK version will be used.
+      json = nil
+      File.open(home_path + "meta/platforms.json") do |f|
+        json = JSON.load(f)
+      end
+      @sdk_version = json["max"]
+    end
+    @sdk_version
+  end
+
+  def no_warn_mismatch
+    if %W(soft softfp).include? armeabi_v7a_mfloat_abi
+      ''
+    else
+      ',--no-warn-mismatch'
+    end
+  end
+
+  def cc
+    case toolchain
+    when :clang then bin('clang')
+    end
+  end
+
+  def ar
+    case toolchain
+    when :clang then bin('llvm-ar')
+    end
+  end
+
+  def ctarget
+    flags = []
+
+    v = sdk_version
+    case toolchain
+    when :clang
+      case arch
+      when /armeabi-v7a/  then flags += %W(-target armv7a-linux-androideabi#{v} -mfpu=#{armeabi_v7a_mfpu} -mfloat-abi=#{armeabi_v7a_mfloat_abi})
+      when /arm64-v8a/    then flags += %W(-target aarch64-linux-android#{v})
+      when /x86_64/       then flags += %W(-target x86_64-linux-android#{v})
+      when /x86/          then flags += %W(-target i686-linux-android#{v})
+      end
+    end
+
+    flags
+  end
+
+  def cflags
+    flags = []
+
+    case RUBY_PLATFORM
+    when /mswin|mingw|win32/
+      # Build for Android don't need window flag
+      flags += %W(-U_WIN32 -U_WIN64)
+    end
+
+    flags += %W(-MMD -MP -D__android__ -DANDROID)
+    flags += ctarget
+    flags += %W(-fpic -ffunction-sections -funwind-tables -fstack-protector-strong -no-canonical-prefixes)
+
+    flags
+  end
+
+  def ldflags
+    flags = []
+
+    flags
+  end
+
+  def ldflags_before_libraries
+    flags = []
+
+    v = sdk_version
+    case toolchain
+    when :clang
+      case arch
+      when /armeabi-v7a/  then flags += %W(-target armv7-none-linux-androideabi#{v} -Wl,--fix-cortex-a8#{no_warn_mismatch})
+      when /arm64-v8a/    then flags += %W(-target aarch64-none-linux-android#{v})
+      when /x86_64/       then flags += %W(-target x86_64-none-linux-android#{v})
+      when /x86/          then flags += %W(-target i686-none-linux-android#{v})
+      end
+    end
+    flags += %W(-no-canonical-prefixes)
+
+    flags
+  end
+end
+
+MRuby::Toolchain.new(:android) do |conf, params|
+  android = MRuby::Toolchain::Android.new(params)
+
+  toolchain android.toolchain
+
+  [conf.cc, conf.cxx, conf.objc, conf.asm].each do |cc|
+    cc.command = android.cc
+    cc.flags = android.cflags
+  end
+
+  conf.archiver.command = android.ar
+  conf.linker.command = android.cc
+  conf.linker.flags = android.ldflags
+  conf.linker.flags_before_libraries = android.ldflags_before_libraries
+end

data/ext/enclave/mruby/tasks/toolchains/clang.rake

@@ -0,0 +1,8 @@
+MRuby::Toolchain.new(:clang) do |conf, _params|
+  toolchain :gcc, default_command: 'clang'
+
+  [conf.cc, conf.objc, conf.asm].each do |cc|
+    cc.flags << '-Wzero-length-array' unless ENV['CFLAGS']
+  end
+  conf.cxx.flags << '-Wzero-length-array' unless ENV['CXXFLAGS'] || ENV['CFLAGS']
+end

data/ext/enclave/mruby/tasks/toolchains/emscripten.rake

@@ -0,0 +1,57 @@
+MRuby::Toolchain.new(:emscripten) do |conf|
+  toolchain :clang
+
+  # See:
+  # - https://emscripten.org/docs/tools_reference/emcc.html
+  # - https://emscripten.org/docs/tools_reference/settings_reference.html
+  # - https://github.com/emscripten-core/emscripten/blob/main/src/settings.js
+  #
+  # == WASM Exception Handling ==
+  #
+  # mruby uses setjmp/longjmp for non-local exits (exceptions, break/return
+  # from blocks). This toolchain uses native WASM exception handling which
+  # is more efficient than Asyncify-based emulation:
+  #
+  #   - Minimal memory overhead (no shadow stack)
+  #   - No code size penalty
+  #   - Works with both C and C++ code
+  #
+  # Supported runtimes (as of 2024):
+  #   - Chrome 95+, Firefox 100+, Safari 15.2+
+  #   - Node.js 17+, Wasmtime, Wasmer
+  #
+  # For older runtimes, override with CFLAGS/LDFLAGS environment variables.
+  #
+  # See: https://emscripten.org/docs/porting/exceptions.html
+  #      https://emscripten.org/docs/porting/setjmp-longjmp.html
+  compile_and_link_flags = [
+    '-fwasm-exceptions',
+  ]
+  compile_flags = [
+    *compile_and_link_flags,
+    '-Wno-unused-but-set-variable',
+  ]
+  link_flags = [
+    *compile_and_link_flags,
+    '-sSUPPORT_LONGJMP=wasm',
+  ]
+
+  conf.cc do |cc|
+    cc.command = 'emcc'
+    cc.flags.concat(compile_flags) unless ENV['CFLAGS']
+  end
+
+  conf.cxx do |cxx|
+    cxx.command = 'em++'
+    cxx.flags.concat(compile_flags) unless ENV['CXXFLAGS'] || ENV['CFLAGS']
+  end
+
+  conf.linker do |linker|
+    linker.command = 'emcc'
+    linker.flags.concat(link_flags) unless ENV['LDFLAGS']
+  end
+
+  conf.archiver do |archiver|
+    archiver.command = 'emar'
+  end
+end

data/ext/enclave/mruby/tasks/toolchains/gcc.rake

@@ -0,0 +1,74 @@
+MRuby::Toolchain.new(:gcc) do |conf, params|
+  default_command = params[:default_command] || 'gcc'
+  compiler_flags = %w(-g -O3 -Wall -Wundef)
+  c_mandatory_flags = %w(-std=gnu99)
+  cxx_invalid_flags = %w(-Werror-implicit-function-declaration)
+  compile_opt = '%{flags} -o "%{outfile}" "%{infile}"'
+
+  [conf.cc, conf.objc, conf.asm, conf.cxx].each do |compiler|
+    if compiler == conf.cxx
+      compiler.command = ENV['CXX'] || conf.cc.command.sub(/g\Kcc|$/, '++')
+      compiler.flags = [ENV['CXXFLAGS'] || ENV['CFLAGS'] || compiler_flags]
+    else
+      compiler.command = ENV['CC'] || default_command
+      compiler.flags = [c_mandatory_flags, ENV['CFLAGS'] || [compiler_flags, cxx_invalid_flags, %w(-Wwrite-strings)]]
+    end
+    compiler.option_include_path = %q[-I"%s"]
+    compiler.option_define = '-D%s'
+    compiler.compile_options = "-MMD -c #{compile_opt}"
+    compiler.preprocess_options = "-E -P #{compile_opt}"
+    compiler.cxx_compile_flag = '-x c++ -std=gnu++03'
+    compiler.cxx_exception_flag = '-fexceptions'
+    compiler.cxx_invalid_flags = c_mandatory_flags + cxx_invalid_flags
+
+    def compiler.setup_debug(conf)
+      self.flags << %w(-g3 -O0)
+    end
+  end
+
+  conf.linker do |linker|
+    linker.command = ENV['LD'] || ENV['CXX'] || ENV['CC'] || default_command
+    linker.flags = [ENV['LDFLAGS'] || %w()]
+    if ENV['OS'] == 'Windows_NT'
+      linker.libraries = []
+    else
+      linker.libraries = %w(m)
+    end
+    linker.library_paths = []
+    linker.option_library = '-l%s'
+    linker.option_library_path = '-L%s'
+    linker.link_options = '%{flags} -o "%{outfile}" %{objs} %{flags_before_libraries} %{libs} %{flags_after_libraries}'
+  end
+
+  [[conf.cc, 'c'], [conf.cxx, 'c++']].each do |cc, lang|
+    cc.instance_variable_set :@header_search_language, lang
+    def cc.header_search_paths
+      if @header_search_command != command
+        result = `echo | #{build.filename command} -x#{@header_search_language} -Wp,-v - -fsyntax-only 2>&1`
+        return include_paths if $?.exitstatus != 0
+
+        @frameworks = []
+        @header_search_paths = result.lines.map { |v|
+          framework = v.match(/^ (.*)(?: \(framework directory\))$/)
+          if framework
+            @frameworks << framework[1]
+            next nil
+          end
+
+          v.match(/^ (.*)$/)
+        }.compact.map { |v| v[1] }.select { |v| File.directory? v }
+        @header_search_paths += include_paths
+        @header_search_command = command
+      end
+      @header_search_paths
+    end
+  end
+
+  def conf.enable_sanitizer(*opts)
+    fail 'sanitizer already set' if @sanitizer_list
+
+    @sanitizer_list = opts
+    flg = "-fsanitize=#{opts.join ','}"
+    [self.cc, self.cxx, self.linker].each{|cmd| cmd.flags << flg }
+  end
+end

data/ext/enclave/mruby/tasks/toolchains/openwrt.rake

@@ -0,0 +1,32 @@
+# usage of environmental variables to set the
+# cross compiling toolchain proper
+MRuby::Toolchain.new(:openwrt) do |conf|
+  [conf.cc, conf.cxx, conf.objc, conf.asm].each do |cc|
+    if cc == conf.cxx
+      cc.command = ENV['TARGET_CXX']
+      cc.flags = ENV['TARGET_CXXFLAGS']
+    else
+      cc.command = ENV['TARGET_CC']
+      cc.flags = ENV['TARGET_CFLAGS']
+    end
+    cc.option_include_path = %q[-I"%s"]
+    cc.option_define = '-D%s'
+    cc.compile_options = '%{flags} -MMD -o "%{outfile}" -c "%{infile}"'
+    cc.preprocess_options = '%{flags} -o "%{outfile}" -E -P "%{infile}"'
+  end
+
+  conf.linker do |linker|
+    linker.command = ENV['TARGET_CC']
+    linker.flags = ENV['TARGET_LDFLAGS']
+    linker.libraries = %w(m)
+    linker.library_paths = []
+    linker.option_library = '-l%s'
+    linker.option_library_path = '-L%s'
+    linker.link_options = '%{flags} -o "%{outfile}" %{objs} %{flags_before_libraries} %{libs} %{flags_after_libraries}'
+  end
+
+  conf.archiver do |archiver|
+    archiver.command = ENV['TARGET_AR']
+    archiver.archive_options = 'rs "%{outfile}" %{objs}'
+  end
+end

data/ext/enclave/mruby/tasks/toolchains/visualcpp.rake

@@ -0,0 +1,48 @@
+MRuby::Toolchain.new(:visualcpp) do |conf, _params|
+  compiler_flags = %w(/nologo /W3 /MD /O2 /D_CRT_SECURE_NO_WARNINGS)
+  [conf.cc, conf.cxx].each do |compiler|
+    if compiler == conf.cc
+      compiler.command = ENV['CC'] || 'cl.exe'
+      # C4013: implicit function declaration
+      compiler.flags = [*(ENV['CFLAGS'] || compiler_flags + %w(/we4013))]
+    else
+      compiler.command = ENV['CXX'] || 'cl.exe'
+      compiler.flags = [*(ENV['CXXFLAGS'] || ENV['CFLAGS'] || compiler_flags + %w(/EHs))]
+    end
+    compiler.defines = %w(MRB_STACK_EXTEND_DOUBLING)
+    compiler.option_include_path = %q[/I"%s"]
+    compiler.option_define = '/D%s'
+    compiler.compile_options = %Q[/Zi /c /Fo"%{outfile}" %{flags} "%{infile}"]
+    compiler.preprocess_options = %Q[/EP %{flags} "%{infile}" > "%{outfile}"]
+    compiler.cxx_compile_flag = '/TP'
+    compiler.cxx_exception_flag = '/EHs'
+  end
+
+  conf.linker do |linker|
+    linker.command = ENV['LD'] || 'link.exe'
+    linker.flags = [ENV['LDFLAGS'] || %w(/NOLOGO /DEBUG /INCREMENTAL:NO /OPT:ICF /OPT:REF)]
+    linker.libraries = %w()
+    linker.library_paths = %w()
+    linker.option_library = '%s.lib'
+    linker.option_library_path = '/LIBPATH:%s'
+    linker.link_options = %Q[%{flags} /OUT:"%{outfile}" %{objs} %{flags_before_libraries} %{libs} %{flags_after_libraries}]
+  end
+
+  conf.archiver do |archiver|
+    archiver.command = ENV['AR'] || 'lib.exe'
+    archiver.archive_options = '/nologo /OUT:"%{outfile}" %{objs}'
+  end
+
+  conf.gperf do |gperf|
+    gperf.command = 'gperf.exe'
+    gperf.compile_options = %q[-L ANSI-C -C -j1 -i 1 -o -t -N mrb_reserved_word -k"1,3,$" "%{infile}" > "%{outfile}"]
+  end
+
+  conf.exts do |exts|
+    exts.object = '.obj'
+    exts.executable = '.exe'
+    exts.library = '.lib'
+  end
+
+  conf.file_separator = '\\'
+end