diff options
Diffstat (limited to 'web/server/h2o/libh2o/deps/mruby/lib')
6 files changed, 1369 insertions, 0 deletions
diff --git a/web/server/h2o/libh2o/deps/mruby/lib/mruby-core-ext.rb b/web/server/h2o/libh2o/deps/mruby/lib/mruby-core-ext.rb new file mode 100644 index 00000000..4c6d3ca7 --- /dev/null +++ b/web/server/h2o/libh2o/deps/mruby/lib/mruby-core-ext.rb @@ -0,0 +1,79 @@ +class Object + class << self + def attr_block(*syms) + syms.flatten.each do |sym| + class_eval "def #{sym}(&block);block.call(@#{sym}) if block_given?;@#{sym};end" + end + end + end +end + +class String + def relative_path_from(dir) + Pathname.new(File.expand_path(self)).relative_path_from(Pathname.new(File.expand_path(dir))).to_s + end + + def relative_path + relative_path_from(Dir.pwd) + end + + # Compatible with 1.9 on 1.8 + def %(params) + if params.is_a?(Hash) + str = self.clone + params.each do |k, v| + str.gsub!("%{#{k}}") { v } + end + str + else + if params.is_a?(Array) + sprintf(self, *params) + else + sprintf(self, params) + end + end + end +end + +class Symbol + # Compatible with 1.9 on 1.8 + def to_proc + proc { |obj, *args| obj.send(self, *args) } + end +end + +module Enumerable + # Compatible with 1.9 on 1.8 + def each_with_object(memo) + return to_enum :each_with_object, memo unless block_given? + each { |obj| yield obj, memo } + memo + end +end + +$pp_show = true + +if $verbose.nil? + if Rake.respond_to?(:verbose) && !Rake.verbose.nil? + if Rake.verbose.class == TrueClass + # verbose message logging + $pp_show = false + else + $pp_show = true + Rake.verbose(false) + end + else + # could not identify rake version + $pp_show = false + end +else + $pp_show = false if $verbose +end + +def _pp(cmd, src, tgt=nil, options={}) + return unless $pp_show + + width = 5 + template = options[:indent] ? "%#{width*options[:indent]}s %s %s" : "%-#{width}s %s %s" + puts template % [cmd, src, tgt ? "-> #{tgt}" : nil] +end diff --git a/web/server/h2o/libh2o/deps/mruby/lib/mruby/build.rb b/web/server/h2o/libh2o/deps/mruby/lib/mruby/build.rb new file mode 100644 index 00000000..7d6aa49e --- /dev/null +++ b/web/server/h2o/libh2o/deps/mruby/lib/mruby/build.rb @@ -0,0 +1,355 @@ +require "mruby/build/load_gems" +require "mruby/build/command" + +module MRuby + class << self + def targets + @targets ||= {} + end + + def each_target(&block) + return to_enum(:each_target) if block.nil? + @targets.each do |key, target| + target.instance_eval(&block) + end + end + end + + class Toolchain + class << self + attr_accessor :toolchains + end + + def initialize(name, &block) + @name, @initializer = name.to_s, block + MRuby::Toolchain.toolchains ||= {} + MRuby::Toolchain.toolchains[@name] = self + end + + def setup(conf,params={}) + conf.instance_exec(conf, params, &@initializer) + end + + def self.load + Dir.glob("#{MRUBY_ROOT}/tasks/toolchains/*.rake").each do |file| + Kernel.load file + end + end + end + Toolchain.load + + class Build + class << self + attr_accessor :current + end + include Rake::DSL + include LoadGems + attr_accessor :name, :bins, :exts, :file_separator, :build_dir, :gem_clone_dir + attr_reader :libmruby, :gems, :toolchains + attr_writer :enable_bintest, :enable_test + + COMPILERS = %w(cc cxx objc asm) + COMMANDS = COMPILERS + %w(linker archiver yacc gperf git exts mrbc) + attr_block MRuby::Build::COMMANDS + + Exts = Struct.new(:object, :executable, :library) + + def initialize(name='host', build_dir=nil, &block) + @name = name.to_s + + unless MRuby.targets[@name] + if ENV['OS'] == 'Windows_NT' + @exts = Exts.new('.o', '.exe', '.a') + else + @exts = Exts.new('.o', '', '.a') + end + + build_dir = build_dir || ENV['MRUBY_BUILD_DIR'] || "#{MRUBY_ROOT}/build" + + @file_separator = '/' + @build_dir = "#{build_dir}/#{@name}" + @gem_clone_dir = "#{build_dir}/mrbgems" + @cc = Command::Compiler.new(self, %w(.c)) + @cxx = Command::Compiler.new(self, %w(.cc .cxx .cpp)) + @objc = Command::Compiler.new(self, %w(.m)) + @asm = Command::Compiler.new(self, %w(.S .asm)) + @linker = Command::Linker.new(self) + @archiver = Command::Archiver.new(self) + @yacc = Command::Yacc.new(self) + @gperf = Command::Gperf.new(self) + @git = Command::Git.new(self) + @mrbc = Command::Mrbc.new(self) + + @bins = [] + @gems, @libmruby = MRuby::Gem::List.new, [] + @build_mrbtest_lib_only = false + @cxx_exception_enabled = false + @cxx_exception_disabled = false + @cxx_abi_enabled = false + @enable_bintest = false + @enable_test = false + @toolchains = [] + + MRuby.targets[@name] = self + end + + MRuby::Build.current = MRuby.targets[@name] + MRuby.targets[@name].instance_eval(&block) + + build_mrbc_exec if name == 'host' + build_mrbtest if test_enabled? + end + + def enable_debug + compilers.each do |c| + c.defines += %w(MRB_DEBUG) + if toolchains.any? { |toolchain| toolchain == "gcc" } + c.flags += %w(-g3 -O0) + end + end + @mrbc.compile_options += ' -g' + end + + def disable_cxx_exception + if @cxx_exception_enabled or @cxx_abi_enabled + raise "cxx_exception already enabled" + end + @cxx_exception_disabled = true + end + + def enable_cxx_exception + return if @cxx_exception_enabled + return if @cxx_abi_enabled + if @cxx_exception_disabled + raise "cxx_exception disabled" + end + @cxx_exception_enabled = true + compilers.each { |c| + c.defines += %w(MRB_ENABLE_CXX_EXCEPTION) + c.flags << c.cxx_exception_flag + } + linker.command = cxx.command if toolchains.find { |v| v == 'gcc' } + end + + def cxx_exception_enabled? + @cxx_exception_enabled + end + + def cxx_abi_enabled? + @cxx_abi_enabled + end + + def enable_cxx_abi + return if @cxx_abi_enabled + if @cxx_exception_enabled + raise "cxx_exception already enabled" + end + compilers.each { |c| + c.defines += %w(MRB_ENABLE_CXX_EXCEPTION MRB_ENABLE_CXX_ABI) + c.flags << c.cxx_compile_flag + } + compilers.each { |c| c.flags << c.cxx_compile_flag } + linker.command = cxx.command if toolchains.find { |v| v == 'gcc' } + @cxx_abi_enabled = true + end + + def compile_as_cxx src, cxx_src, obj = nil, includes = [] + src = File.absolute_path src + cxx_src = File.absolute_path cxx_src + obj = objfile(cxx_src) if obj.nil? + + file cxx_src => [src, __FILE__] do |t| + FileUtils.mkdir_p File.dirname t.name + IO.write t.name, <<EOS +#define __STDC_CONSTANT_MACROS +#define __STDC_LIMIT_MACROS + +#ifndef MRB_ENABLE_CXX_ABI +extern "C" { +#endif +#include "#{src}" +#ifndef MRB_ENABLE_CXX_ABI +} +#endif +EOS + end + + file obj => cxx_src do |t| + cxx.run t.name, t.prerequisites.first, [], ["#{MRUBY_ROOT}/src"] + includes + end + + obj + end + + def enable_bintest + @enable_bintest = true + end + + def bintest_enabled? + @enable_bintest + end + + def toolchain(name, params={}) + tc = Toolchain.toolchains[name.to_s] + fail "Unknown #{name} toolchain" unless tc + tc.setup(self, params) + @toolchains.unshift name.to_s + end + + def primary_toolchain + @toolchains.first + end + + def root + MRUBY_ROOT + end + + def enable_test + @enable_test = true + end + + def test_enabled? + @enable_test + end + + def build_mrbtest + gem :core => 'mruby-test' + end + + def build_mrbc_exec + gem :core => 'mruby-bin-mrbc' + end + + def mrbcfile + return @mrbcfile if @mrbcfile + + mrbc_build = MRuby.targets['host'] + gems.each { |v| mrbc_build = self if v.name == 'mruby-bin-mrbc' } + @mrbcfile = mrbc_build.exefile("#{mrbc_build.build_dir}/bin/mrbc") + end + + def compilers + COMPILERS.map do |c| + instance_variable_get("@#{c}") + end + end + + def define_rules + compilers.each do |compiler| + if respond_to?(:enable_gems?) && enable_gems? + compiler.defines -= %w(DISABLE_GEMS) + else + compiler.defines += %w(DISABLE_GEMS) + end + compiler.define_rules build_dir, File.expand_path(File.join(File.dirname(__FILE__), '..', '..')) + end + end + + def filename(name) + if name.is_a?(Array) + name.flatten.map { |n| filename(n) } + else + '"%s"' % name.gsub('/', file_separator) + end + end + + def cygwin_filename(name) + if name.is_a?(Array) + name.flatten.map { |n| cygwin_filename(n) } + else + '"%s"' % `cygpath -w "#{filename(name)}"`.strip + end + end + + def exefile(name) + if name.is_a?(Array) + name.flatten.map { |n| exefile(n) } + else + "#{name}#{exts.executable}" + end + end + + def objfile(name) + if name.is_a?(Array) + name.flatten.map { |n| objfile(n) } + else + "#{name}#{exts.object}" + end + end + + def libfile(name) + if name.is_a?(Array) + name.flatten.map { |n| libfile(n) } + else + "#{name}#{exts.library}" + end + end + + def build_mrbtest_lib_only + @build_mrbtest_lib_only = true + end + + def build_mrbtest_lib_only? + @build_mrbtest_lib_only + end + + def run_test + puts ">>> Test #{name} <<<" + mrbtest = exefile("#{build_dir}/bin/mrbtest") + sh "#{filename mrbtest.relative_path}#{$verbose ? ' -v' : ''}" + puts + run_bintest if bintest_enabled? + end + + def run_bintest + targets = @gems.select { |v| File.directory? "#{v.dir}/bintest" }.map { |v| filename v.dir } + targets << filename(".") if File.directory? "./bintest" + sh "ruby test/bintest.rb #{targets.join ' '}" + end + + def print_build_summary + puts "================================================" + puts " Config Name: #{@name}" + puts " Output Directory: #{self.build_dir.relative_path}" + puts " Binaries: #{@bins.join(', ')}" unless @bins.empty? + unless @gems.empty? + puts " Included Gems:" + @gems.map do |gem| + gem_version = " - #{gem.version}" if gem.version != '0.0.0' + gem_summary = " - #{gem.summary}" if gem.summary + puts " #{gem.name}#{gem_version}#{gem_summary}" + puts " - Binaries: #{gem.bins.join(', ')}" unless gem.bins.empty? + end + end + puts "================================================" + puts + end + end # Build + + class CrossBuild < Build + attr_block %w(test_runner) + # cross compiling targets for building native extensions. + # host - arch of where the built binary will run + # build - arch of the machine building the binary + attr_accessor :host_target, :build_target + + def initialize(name, build_dir=nil, &block) + @test_runner = Command::CrossTestRunner.new(self) + super + end + + def mrbcfile + MRuby.targets['host'].exefile("#{MRuby.targets['host'].build_dir}/bin/mrbc") + end + + def run_test + mrbtest = exefile("#{build_dir}/bin/mrbtest") + if (@test_runner.command == nil) + puts "You should run #{mrbtest} on target device." + puts + else + @test_runner.run(mrbtest) + end + end + end # CrossBuild +end # MRuby diff --git a/web/server/h2o/libh2o/deps/mruby/lib/mruby/build/command.rb b/web/server/h2o/libh2o/deps/mruby/lib/mruby/build/command.rb new file mode 100644 index 00000000..694b4a24 --- /dev/null +++ b/web/server/h2o/libh2o/deps/mruby/lib/mruby/build/command.rb @@ -0,0 +1,324 @@ +require 'forwardable' + +module MRuby + class Command + include Rake::DSL + extend Forwardable + def_delegators :@build, :filename, :objfile, :libfile, :exefile, :cygwin_filename + attr_accessor :build, :command + + def initialize(build) + @build = build + end + + # clone is deep clone without @build + def clone + target = super + excepts = %w(@build) + instance_variables.each do |attr| + unless excepts.include?(attr.to_s) + val = Marshal::load(Marshal.dump(instance_variable_get(attr))) # deep clone + target.instance_variable_set(attr, val) + end + end + target + end + + NotFoundCommands = {} + + private + def _run(options, params={}) + return sh command + ' ' + ( options % params ) if NotFoundCommands.key? @command + begin + sh build.filename(command) + ' ' + ( options % params ) + rescue RuntimeError + NotFoundCommands[@command] = true + _run options, params + end + end + end + + class Command::Compiler < Command + attr_accessor :flags, :include_paths, :defines, :source_exts + attr_accessor :compile_options, :option_define, :option_include_path, :out_ext + attr_accessor :cxx_compile_flag, :cxx_exception_flag + + def initialize(build, source_exts=[]) + super(build) + @command = ENV['CC'] || 'cc' + @flags = [ENV['CFLAGS'] || []] + @source_exts = source_exts + @include_paths = ["#{MRUBY_ROOT}/include"] + @defines = %w() + @option_include_path = '-I%s' + @option_define = '-D%s' + @compile_options = '%{flags} -o %{outfile} -c %{infile}' + end + + alias header_search_paths include_paths + def search_header_path(name) + header_search_paths.find do |v| + File.exist? build.filename("#{v}/#{name}").sub(/^"(.*)"$/, '\1') + end + end + + def search_header(name) + path = search_header_path name + path && build.filename("#{path}/#{name}").sub(/^"(.*)"$/, '\1') + end + + def all_flags(_defineds=[], _include_paths=[], _flags=[]) + define_flags = [defines, _defineds].flatten.map{ |d| option_define % d } + include_path_flags = [include_paths, _include_paths].flatten.map do |f| + if MRUBY_BUILD_HOST_IS_CYGWIN + option_include_path % cygwin_filename(f) + else + option_include_path % filename(f) + end + end + [flags, define_flags, include_path_flags, _flags].flatten.join(' ') + end + + def run(outfile, infile, _defineds=[], _include_paths=[], _flags=[]) + FileUtils.mkdir_p File.dirname(outfile) + _pp "CC", infile.relative_path, outfile.relative_path + if MRUBY_BUILD_HOST_IS_CYGWIN + _run compile_options, { :flags => all_flags(_defineds, _include_paths, _flags), + :infile => cygwin_filename(infile), :outfile => cygwin_filename(outfile) } + else + _run compile_options, { :flags => all_flags(_defineds, _include_paths, _flags), + :infile => filename(infile), :outfile => filename(outfile) } + end + end + + def define_rules(build_dir, source_dir='') + @out_ext = build.exts.object + gemrake = File.join(source_dir, "mrbgem.rake") + rakedep = File.exist?(gemrake) ? [ gemrake ] : [] + + if build_dir.include? "mrbgems/" + generated_file_matcher = Regexp.new("^#{Regexp.escape build_dir}/(.*)#{Regexp.escape out_ext}$") + else + generated_file_matcher = Regexp.new("^#{Regexp.escape build_dir}/(?!mrbgems/.+/)(.*)#{Regexp.escape out_ext}$") + end + source_exts.each do |ext, compile| + rule generated_file_matcher => [ + proc { |file| + file.sub(generated_file_matcher, "#{source_dir}/\\1#{ext}") + }, + proc { |file| + get_dependencies(file) + rakedep + } + ] do |t| + run t.name, t.prerequisites.first + end + + rule generated_file_matcher => [ + proc { |file| + file.sub(generated_file_matcher, "#{build_dir}/\\1#{ext}") + }, + proc { |file| + get_dependencies(file) + rakedep + } + ] do |t| + run t.name, t.prerequisites.first + end + end + end + + private + def get_dependencies(file) + file = file.ext('d') unless File.extname(file) == '.d' + if File.exist?(file) + File.read(file).gsub("\\\n ", "").scan(/^\S+:\s+(.+)$/).flatten.map {|s| s.split(' ') }.flatten + else + [] + end + [ MRUBY_CONFIG ] + end + end + + class Command::Linker < Command + attr_accessor :flags, :library_paths, :flags_before_libraries, :libraries, :flags_after_libraries + attr_accessor :link_options, :option_library, :option_library_path + + def initialize(build) + super + @command = ENV['LD'] || 'ld' + @flags = (ENV['LDFLAGS'] || []) + @flags_before_libraries, @flags_after_libraries = [], [] + @libraries = [] + @library_paths = [] + @option_library = '-l%s' + @option_library_path = '-L%s' + @link_options = "%{flags} -o %{outfile} %{objs} %{flags_before_libraries} %{libs} %{flags_after_libraries}" + end + + def all_flags(_library_paths=[], _flags=[]) + library_path_flags = [library_paths, _library_paths].flatten.map do |f| + if MRUBY_BUILD_HOST_IS_CYGWIN + option_library_path % cygwin_filename(f) + else + option_library_path % filename(f) + end + end + [flags, library_path_flags, _flags].flatten.join(' ') + end + + def library_flags(_libraries) + [libraries, _libraries].flatten.map{ |d| option_library % d }.join(' ') + end + + def run(outfile, objfiles, _libraries=[], _library_paths=[], _flags=[], _flags_before_libraries=[], _flags_after_libraries=[]) + FileUtils.mkdir_p File.dirname(outfile) + library_flags = [libraries, _libraries].flatten.map { |d| option_library % d } + + _pp "LD", outfile.relative_path + if MRUBY_BUILD_HOST_IS_CYGWIN + _run link_options, { :flags => all_flags(_library_paths, _flags), + :outfile => cygwin_filename(outfile) , :objs => cygwin_filename(objfiles).join(' '), + :flags_before_libraries => [flags_before_libraries, _flags_before_libraries].flatten.join(' '), + :flags_after_libraries => [flags_after_libraries, _flags_after_libraries].flatten.join(' '), + :libs => library_flags.join(' ') } + else + _run link_options, { :flags => all_flags(_library_paths, _flags), + :outfile => filename(outfile) , :objs => filename(objfiles).join(' '), + :flags_before_libraries => [flags_before_libraries, _flags_before_libraries].flatten.join(' '), + :flags_after_libraries => [flags_after_libraries, _flags_after_libraries].flatten.join(' '), + :libs => library_flags.join(' ') } + end + end + end + + class Command::Archiver < Command + attr_accessor :archive_options + + def initialize(build) + super + @command = ENV['AR'] || 'ar' + @archive_options = 'rs %{outfile} %{objs}' + end + + def run(outfile, objfiles) + FileUtils.mkdir_p File.dirname(outfile) + _pp "AR", outfile.relative_path + if MRUBY_BUILD_HOST_IS_CYGWIN + _run archive_options, { :outfile => cygwin_filename(outfile), :objs => cygwin_filename(objfiles).join(' ') } + else + _run archive_options, { :outfile => filename(outfile), :objs => filename(objfiles).join(' ') } + end + end + end + + class Command::Yacc < Command + attr_accessor :compile_options + + def initialize(build) + super + @command = 'bison' + @compile_options = '-o %{outfile} %{infile}' + end + + def run(outfile, infile) + FileUtils.mkdir_p File.dirname(outfile) + _pp "YACC", infile.relative_path, outfile.relative_path + _run compile_options, { :outfile => filename(outfile) , :infile => filename(infile) } + end + end + + class Command::Gperf < Command + attr_accessor :compile_options + + def initialize(build) + super + @command = 'gperf' + @compile_options = '-L ANSI-C -C -p -j1 -i 1 -g -o -t -N mrb_reserved_word -k"1,3,$" %{infile} > %{outfile}' + end + + def run(outfile, infile) + FileUtils.mkdir_p File.dirname(outfile) + _pp "GPERF", infile.relative_path, outfile.relative_path + _run compile_options, { :outfile => filename(outfile) , :infile => filename(infile) } + end + end + + class Command::Git < Command + attr_accessor :flags + attr_accessor :clone_options, :pull_options, :checkout_options + + def initialize(build) + super + @command = 'git' + @flags = %w[] + @clone_options = "clone %{flags} %{url} %{dir}" + @pull_options = "pull" + @checkout_options = "checkout %{checksum_hash}" + end + + def run_clone(dir, url, _flags = []) + _pp "GIT", url, dir.relative_path + _run clone_options, { :flags => [flags, _flags].flatten.join(' '), :url => url, :dir => filename(dir) } + end + + def run_pull(dir, url) + root = Dir.pwd + Dir.chdir dir + _pp "GIT PULL", url, dir.relative_path + _run pull_options + Dir.chdir root + end + + def run_checkout(dir, checksum_hash) + root = Dir.pwd + Dir.chdir dir + _pp "GIT CHECKOUT", checksum_hash + _run checkout_options, { :checksum_hash => checksum_hash } + Dir.chdir root + end + end + + class Command::Mrbc < Command + attr_accessor :compile_options + + def initialize(build) + super + @command = nil + @compile_options = "-B%{funcname} -o-" + end + + def run(out, infiles, funcname) + @command ||= @build.mrbcfile + infiles = [infiles].flatten + infiles.each do |f| + _pp "MRBC", f.relative_path, nil, :indent => 2 + end + IO.popen("#{filename @command} #{@compile_options % {:funcname => funcname}} #{filename(infiles).join(' ')}", 'r+') do |io| + out.puts io.read + end + # if mrbc execution fail, drop the file + if $?.exitstatus != 0 + File.delete(out.path) + exit(-1) + end + end + end + + class Command::CrossTestRunner < Command + attr_accessor :runner_options + attr_accessor :verbose_flag + attr_accessor :flags + + def initialize(build) + super + @command = nil + @runner_options = '%{flags} %{infile}' + @verbose_flag = '' + @flags = [] + end + + def run(testbinfile) + puts "TEST for " + @build.name + _run runner_options, { :flags => [flags, verbose_flag].flatten.join(' '), :infile => testbinfile } + end + end + +end diff --git a/web/server/h2o/libh2o/deps/mruby/lib/mruby/build/load_gems.rb b/web/server/h2o/libh2o/deps/mruby/lib/mruby/build/load_gems.rb new file mode 100644 index 00000000..b48df651 --- /dev/null +++ b/web/server/h2o/libh2o/deps/mruby/lib/mruby/build/load_gems.rb @@ -0,0 +1,122 @@ +module MRuby + module LoadGems + def gembox(gemboxfile) + gembox = File.expand_path("#{gemboxfile}.gembox", "#{MRUBY_ROOT}/mrbgems") + fail "Can't find gembox '#{gembox}'" unless File.exist?(gembox) + + GemBox.config = self + GemBox.path = gembox + + instance_eval File.read(gembox) + + GemBox.path = nil + end + + def gem(gemdir, &block) + caller_dir = File.expand_path(File.dirname(/^(.*?):\d/.match(caller.first).to_a[1])) + + if gemdir.is_a?(Hash) + gemdir = load_special_path_gem(gemdir) + elsif GemBox.path && gemdir.is_a?(String) + gemdir = File.expand_path(gemdir, File.dirname(GemBox.path)) + else + gemdir = File.expand_path(gemdir, caller_dir) + end + + gemrake = File.join(gemdir, "mrbgem.rake") + + fail "Can't find #{gemrake}" unless File.exist?(gemrake) + Gem.current = nil + load gemrake + return nil unless Gem.current + + Gem.current.dir = gemdir + Gem.current.build = self.is_a?(MRuby::Build) ? self : MRuby::Build.current + Gem.current.build_config_initializer = block + gems << Gem.current + + cxx_srcs = ['src', 'test', 'tools'].map do |subdir| + Dir.glob("#{Gem.current.dir}/#{subdir}/*.{cpp,cxx,cc}") + end.flatten + enable_cxx_exception unless cxx_srcs.empty? + + Gem.current + end + + def load_special_path_gem(params) + if params[:github] + params[:git] = "https://github.com/#{params[:github]}.git" + elsif params[:bitbucket] + if params[:method] == "ssh" + params[:git] = "git@bitbucket.org:#{params[:bitbucket]}.git" + else + params[:git] = "https://bitbucket.org/#{params[:bitbucket]}.git" + end + elsif params[:mgem] + mgem_list_dir = "#{gem_clone_dir}/mgem-list" + mgem_list_url = 'https://github.com/mruby/mgem-list.git' + if File.exist? mgem_list_dir + git.run_pull mgem_list_dir, mgem_list_url if $pull_gems + else + FileUtils.mkdir_p mgem_list_dir + git.run_clone mgem_list_dir, mgem_list_url, "--depth 1" + end + + require 'yaml' + + conf_path = "#{mgem_list_dir}/#{params[:mgem]}.gem" + conf_path = "#{mgem_list_dir}/mruby-#{params[:mgem]}.gem" unless File.exist? conf_path + fail "mgem not found: #{params[:mgem]}" unless File.exist? conf_path + conf = YAML.load File.read conf_path + + fail "unknown mgem protocol: #{conf['protocol']}" if conf['protocol'] != 'git' + params[:git] = conf['repository'] + params[:branch] = conf['branch'] if conf['branch'] + end + + if params[:core] + gemdir = "#{root}/mrbgems/#{params[:core]}" + elsif params[:path] + require 'pathname' + gemdir = Pathname.new(params[:path]).absolute? ? params[:path] : "#{root}/#{params[:path]}" + elsif params[:git] + url = params[:git] + gemdir = "#{gem_clone_dir}/#{url.match(/([-\w]+)(\.[-\w]+|)$/).to_a[1]}" + + # by default the 'master' branch is used + branch = params[:branch] ? params[:branch] : 'master' + + if File.exist?(gemdir) + if $pull_gems + git.run_pull gemdir, url + else + gemdir + end + else + options = [params[:options]] || [] + options << "--recursive" + options << "--branch \"#{branch}\"" + options << "--depth 1" unless params[:checksum_hash] + FileUtils.mkdir_p "#{gem_clone_dir}" + git.run_clone gemdir, url, options + end + + if params[:checksum_hash] + # Jump to the specified commit + git.run_checkout gemdir, params[:checksum_hash] + else + # Jump to the top of the branch + git.run_checkout gemdir, branch if $pull_gems + end + else + fail "unknown gem option #{params}" + end + + gemdir + end + + def enable_gems? + !@gems.empty? + end + end # LoadGems +end # MRuby diff --git a/web/server/h2o/libh2o/deps/mruby/lib/mruby/gem.rb b/web/server/h2o/libh2o/deps/mruby/lib/mruby/gem.rb new file mode 100644 index 00000000..27a1d358 --- /dev/null +++ b/web/server/h2o/libh2o/deps/mruby/lib/mruby/gem.rb @@ -0,0 +1,459 @@ +require 'pathname' +require 'forwardable' +require 'tsort' +require 'shellwords' + +module MRuby + module Gem + class << self + attr_accessor :current + end + LinkerConfig = Struct.new(:libraries, :library_paths, :flags, :flags_before_libraries, :flags_after_libraries) + + class Specification + include Rake::DSL + extend Forwardable + def_delegators :@build, :filename, :objfile, :libfile, :exefile + + attr_accessor :name, :dir, :build + alias mruby build + attr_accessor :build_config_initializer + attr_accessor :mrblib_dir, :objs_dir + + attr_accessor :version + attr_accessor :description, :summary + attr_accessor :homepage + attr_accessor :licenses, :authors + alias :license= :licenses= + alias :author= :authors= + + attr_accessor :rbfiles, :objs + attr_accessor :test_objs, :test_rbfiles, :test_args + attr_accessor :test_preload + + attr_accessor :bins + + attr_accessor :requirements + attr_reader :dependencies, :conflicts + + attr_accessor :export_include_paths + + attr_reader :generate_functions + + attr_block MRuby::Build::COMMANDS + + def initialize(name, &block) + @name = name + @initializer = block + @version = "0.0.0" + @mrblib_dir = "mrblib" + @objs_dir = "src" + MRuby::Gem.current = self + end + + def setup + MRuby::Gem.current = self + MRuby::Build::COMMANDS.each do |command| + instance_variable_set("@#{command}", @build.send(command).clone) + end + @linker = LinkerConfig.new([], [], [], [], []) + + @rbfiles = Dir.glob("#{@dir}/#{@mrblib_dir}/**/*.rb").sort + @objs = Dir.glob("#{@dir}/#{@objs_dir}/*.{c,cpp,cxx,cc,m,asm,s,S}").map do |f| + objfile(f.relative_path_from(@dir).to_s.pathmap("#{build_dir}/%X")) + end + + @test_rbfiles = Dir.glob("#{dir}/test/**/*.rb") + @test_objs = Dir.glob("#{dir}/test/*.{c,cpp,cxx,cc,m,asm,s,S}").map do |f| + objfile(f.relative_path_from(dir).to_s.pathmap("#{build_dir}/%X")) + end + @custom_test_init = !@test_objs.empty? + @test_preload = nil # 'test/assert.rb' + @test_args = {} + + @bins = [] + + @requirements = [] + @dependencies, @conflicts = [], [] + @export_include_paths = [] + @export_include_paths << "#{dir}/include" if File.directory? "#{dir}/include" + + instance_eval(&@initializer) + + @generate_functions = !(@rbfiles.empty? && @objs.empty?) + @objs << objfile("#{build_dir}/gem_init") if @generate_functions + + if !name || !licenses || !authors + fail "#{name || dir} required to set name, license(s) and author(s)" + end + + build.libmruby << @objs + + instance_eval(&@build_config_initializer) if @build_config_initializer + end + + def setup_compilers + compilers.each do |compiler| + compiler.define_rules build_dir, "#{dir}" + compiler.defines << %Q[MRBGEM_#{funcname.upcase}_VERSION=#{version}] + compiler.include_paths << "#{dir}/include" if File.directory? "#{dir}/include" + end + + define_gem_init_builder if @generate_functions + end + + def add_dependency(name, *requirements) + default_gem = requirements.last.kind_of?(Hash) ? requirements.pop : nil + requirements = ['>= 0.0.0'] if requirements.empty? + requirements.flatten! + @dependencies << {:gem => name, :requirements => requirements, :default => default_gem} + end + + def add_test_dependency(*args) + add_dependency(*args) if build.test_enabled? + end + + def add_conflict(name, *req) + @conflicts << {:gem => name, :requirements => req.empty? ? nil : req} + end + + def self.bin=(bin) + @bins = [bin].flatten + end + + def build_dir + "#{build.build_dir}/mrbgems/#{name}" + end + + def test_rbireps + "#{build_dir}/gem_test.c" + end + + def search_package(name, version_query=nil) + package_query = name + package_query += " #{version_query}" if version_query + _pp "PKG-CONFIG", package_query + escaped_package_query = Shellwords.escape(package_query) + if system("pkg-config --exists #{escaped_package_query}") + cc.flags += [`pkg-config --cflags #{escaped_package_query}`.strip] + cxx.flags += [`pkg-config --cflags #{escaped_package_query}`.strip] + linker.flags_before_libraries += [`pkg-config --libs #{escaped_package_query}`.strip] + true + else + false + end + end + + def funcname + @funcname ||= @name.gsub('-', '_') + end + + def compilers + MRuby::Build::COMPILERS.map do |c| + instance_variable_get("@#{c}") + end + end + + def define_gem_init_builder + file objfile("#{build_dir}/gem_init") => [ "#{build_dir}/gem_init.c", File.join(dir, "mrbgem.rake") ] + file "#{build_dir}/gem_init.c" => [build.mrbcfile, __FILE__] + [rbfiles].flatten do |t| + FileUtils.mkdir_p build_dir + generate_gem_init("#{build_dir}/gem_init.c") + end + end + + def generate_gem_init(fname) + open(fname, 'w') do |f| + print_gem_init_header f + build.mrbc.run f, rbfiles, "gem_mrblib_irep_#{funcname}" unless rbfiles.empty? + f.puts %Q[void mrb_#{funcname}_gem_init(mrb_state *mrb);] + f.puts %Q[void mrb_#{funcname}_gem_final(mrb_state *mrb);] + f.puts %Q[] + f.puts %Q[void GENERATED_TMP_mrb_#{funcname}_gem_init(mrb_state *mrb) {] + f.puts %Q[ int ai = mrb_gc_arena_save(mrb);] + f.puts %Q[ mrb_#{funcname}_gem_init(mrb);] if objs != [objfile("#{build_dir}/gem_init")] + unless rbfiles.empty? + f.puts %Q[ mrb_load_irep(mrb, gem_mrblib_irep_#{funcname});] + f.puts %Q[ if (mrb->exc) {] + f.puts %Q[ mrb_print_error(mrb);] + f.puts %Q[ exit(EXIT_FAILURE);] + f.puts %Q[ }] + end + f.puts %Q[ mrb_gc_arena_restore(mrb, ai);] + f.puts %Q[}] + f.puts %Q[] + f.puts %Q[void GENERATED_TMP_mrb_#{funcname}_gem_final(mrb_state *mrb) {] + f.puts %Q[ mrb_#{funcname}_gem_final(mrb);] if objs != [objfile("#{build_dir}/gem_init")] + f.puts %Q[}] + end + end # generate_gem_init + + def print_gem_comment(f) + f.puts %Q[/*] + f.puts %Q[ * This file is loading the irep] + f.puts %Q[ * Ruby GEM code.] + 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[ */] + end + + def print_gem_init_header(f) + print_gem_comment(f) + f.puts %Q[#include <stdlib.h>] unless rbfiles.empty? + f.puts %Q[#include <mruby.h>] + f.puts %Q[#include <mruby/irep.h>] unless rbfiles.empty? + end + + def print_gem_test_header(f) + print_gem_comment(f) + f.puts %Q[#include <stdio.h>] + f.puts %Q[#include <stdlib.h>] + f.puts %Q[#include <mruby.h>] + f.puts %Q[#include <mruby/irep.h>] + f.puts %Q[#include <mruby/variable.h>] + f.puts %Q[#include <mruby/hash.h>] unless test_args.empty? + end + + def test_dependencies + [@name] + end + + def custom_test_init? + @custom_test_init + end + + def version_ok?(req_versions) + req_versions.map do |req| + cmp, ver = req.split + cmp_result = Version.new(version) <=> Version.new(ver) + case cmp + when '=' then cmp_result == 0 + when '!=' then cmp_result != 0 + when '>' then cmp_result == 1 + when '<' then cmp_result == -1 + when '>=' then cmp_result >= 0 + when '<=' then cmp_result <= 0 + when '~>' + Version.new(version).twiddle_wakka_ok?(Version.new(ver)) + else + fail "Comparison not possible with '#{cmp}'" + end + end.all? + end + end # Specification + + class Version + include Comparable + include Enumerable + + def <=>(other) + ret = 0 + own = to_enum + + other.each do |oth| + begin + ret = own.next <=> oth + rescue StopIteration + ret = 0 <=> oth + end + + break unless ret == 0 + end + + ret + end + + # ~> compare algorithm + # + # Example: + # ~> 2.2 means >= 2.2.0 and < 3.0.0 + # ~> 2.2.0 means >= 2.2.0 and < 2.3.0 + def twiddle_wakka_ok?(other) + gr_or_eql = (self <=> other) >= 0 + still_minor = (self <=> other.skip_minor) < 0 + gr_or_eql and still_minor + end + + def skip_minor + a = @ary.dup + a.slice!(-1) + a[-1] = a[-1].succ + a + end + + def initialize(str) + @str = str + @ary = @str.split('.').map(&:to_i) + end + + def each(&block); @ary.each(&block); end + def [](index); @ary[index]; end + def []=(index, value) + @ary[index] = value + @str = @ary.join('.') + end + def slice!(index) + @ary.slice!(index) + @str = @ary.join('.') + end + end # Version + + class List + include Enumerable + + def initialize + @ary = [] + end + + def each(&b) + @ary.each(&b) + end + + def <<(gem) + unless @ary.detect {|g| g.dir == gem.dir } + @ary << gem + else + # GEM was already added to this list + end + end + + def empty? + @ary.empty? + end + + def generate_gem_table build + gem_table = @ary.reduce({}) { |res,v| res[v.name] = v; res } + + default_gems = [] + each do |g| + g.dependencies.each do |dep| + unless gem_table.key? dep[:gem] + if dep[:default]; default_gems << dep + elsif File.exist? "#{MRUBY_ROOT}/mrbgems/#{dep[:gem]}" # check core + default_gems << { :gem => dep[:gem], :default => { :core => dep[:gem] } } + else # fallback to mgem-list + default_gems << { :gem => dep[:gem], :default => { :mgem => dep[:gem] } } + end + end + end + end + + until default_gems.empty? + def_gem = default_gems.pop + + spec = build.gem def_gem[:default] + fail "Invalid gem name: #{spec.name} (Expected: #{def_gem[:gem]})" if spec.name != def_gem[:gem] + spec.setup + + spec.dependencies.each do |dep| + unless gem_table.key? dep[:gem] + if dep[:default]; default_gems << dep + else default_gems << { :gem => dep[:gem], :default => { :mgem => dep[:gem] } } + end + end + end + gem_table[spec.name] = spec + end + + each do |g| + g.dependencies.each do |dep| + name = dep[:gem] + req_versions = dep[:requirements] + dep_g = gem_table[name] + + # check each GEM dependency against all available GEMs + if dep_g.nil? + fail "The GEM '#{g.name}' depends on the GEM '#{name}' but it could not be found" + end + unless dep_g.version_ok? req_versions + fail "#{name} version should be #{req_versions.join(' and ')} but was '#{dep_g.version}'" + end + end + + cfls = g.conflicts.select { |c| + cfl_g = gem_table[c[:gem]] + cfl_g and cfl_g.version_ok?(c[:requirements] || ['>= 0.0.0']) + }.map { |c| "#{c[:gem]}(#{gem_table[c[:gem]].version})" } + fail "Conflicts of gem `#{g.name}` found: #{cfls.join ', '}" unless cfls.empty? + end + + gem_table + end + + def tsort_dependencies ary, table, all_dependency_listed = false + unless all_dependency_listed + left = ary.dup + until left.empty? + v = left.pop + table[v].dependencies.each do |dep| + left.push dep[:gem] + ary.push dep[:gem] + end + end + end + + ary.uniq! + table.instance_variable_set :@root_gems, ary + class << table + include TSort + def tsort_each_node &b + @root_gems.each &b + end + + def tsort_each_child(n, &b) + fetch(n).dependencies.each do |v| + b.call v[:gem] + end + end + end + + begin + table.tsort.map { |v| table[v] } + rescue TSort::Cyclic => e + fail "Circular mrbgem dependency found: #{e.message}" + end + end + + def check(build) + gem_table = generate_gem_table build + + @ary = tsort_dependencies gem_table.keys, gem_table, true + + each(&:setup_compilers) + + each do |g| + import_include_paths(g) + end + end + + def import_include_paths(g) + gem_table = @ary.reduce({}) { |res,v| res[v.name] = v; res } + g.dependencies.each do |dep| + dep_g = gem_table[dep[:gem]] + # We can do recursive call safely + # as circular dependency has already detected in the caller. + import_include_paths(dep_g) + + dep_g.export_include_paths.uniq! + g.compilers.each do |compiler| + compiler.include_paths += dep_g.export_include_paths + g.export_include_paths += dep_g.export_include_paths + compiler.include_paths.uniq! + g.export_include_paths.uniq! + end + end + end + end # List + end # Gem + + GemBox = Object.new + class << GemBox + attr_accessor :path + + def new(&block); block.call(self); end + def config=(obj); @config = obj; end + def gem(gemdir, &block); @config.gem(gemdir, &block); end + end # GemBox +end # MRuby diff --git a/web/server/h2o/libh2o/deps/mruby/lib/mruby/source.rb b/web/server/h2o/libh2o/deps/mruby/lib/mruby/source.rb new file mode 100644 index 00000000..5819a322 --- /dev/null +++ b/web/server/h2o/libh2o/deps/mruby/lib/mruby/source.rb @@ -0,0 +1,30 @@ +require "pathname" + +module MRuby + module Source + # MRuby's source root directory + ROOT = Pathname.new(File.expand_path('../../../',__FILE__)) + + # Reads a constant defined at version.h + MRUBY_READ_VERSION_CONSTANT = Proc.new { |name| ROOT.join('include','mruby','version.h').read.match(/^#define #{name} +"?([\w\. ]+)"?$/)[1] } + + MRUBY_RUBY_VERSION = MRUBY_READ_VERSION_CONSTANT['MRUBY_RUBY_VERSION'] + MRUBY_RUBY_ENGINE = MRUBY_READ_VERSION_CONSTANT['MRUBY_RUBY_ENGINE'] + + MRUBY_RELEASE_MAJOR = Integer(MRUBY_READ_VERSION_CONSTANT['MRUBY_RELEASE_MAJOR']) + MRUBY_RELEASE_MINOR = Integer(MRUBY_READ_VERSION_CONSTANT['MRUBY_RELEASE_MINOR']) + MRUBY_RELEASE_TEENY = Integer(MRUBY_READ_VERSION_CONSTANT['MRUBY_RELEASE_TEENY']) + + MRUBY_VERSION = [MRUBY_RELEASE_MAJOR,MRUBY_RELEASE_MINOR,MRUBY_RELEASE_TEENY].join('.') + MRUBY_RELEASE_NO = (MRUBY_RELEASE_MAJOR * 100 * 100 + MRUBY_RELEASE_MINOR * 100 + MRUBY_RELEASE_TEENY) + + MRUBY_RELEASE_YEAR = Integer(MRUBY_READ_VERSION_CONSTANT['MRUBY_RELEASE_YEAR']) + MRUBY_RELEASE_MONTH = Integer(MRUBY_READ_VERSION_CONSTANT['MRUBY_RELEASE_MONTH']) + MRUBY_RELEASE_DAY = Integer(MRUBY_READ_VERSION_CONSTANT['MRUBY_RELEASE_DAY']) + MRUBY_RELEASE_DATE = [MRUBY_RELEASE_YEAR,MRUBY_RELEASE_MONTH,MRUBY_RELEASE_DAY].join('.') + + MRUBY_BIRTH_YEAR = Integer(MRUBY_READ_VERSION_CONSTANT['MRUBY_BIRTH_YEAR']) + + MRUBY_AUTHOR = MRUBY_READ_VERSION_CONSTANT['MRUBY_AUTHOR'] + end +end |