module MakeMakefile

Module MakeMakefile 用于 Ruby C 扩展，以生成一个 Makefile，该 Makefile 可以正确地编译和链接 C 扩展到 Ruby 和第三方库。

Constants

ASSEMBLE_C

在生成的 Makefile 中将 C 文件转换为汇编源文件的命令

ASSEMBLE_CXX

在生成的 Makefile 中将 C++ 文件转换为汇编源文件的命令

CLEANINGS

清理扩展构建目录的 Makefile 规则

COMMON_HEADERS

Ruby C 扩展的通用头文件

COMMON_LIBS

Ruby C 扩展的通用库

COMPILE_C

在生成的 Makefile 中编译 C 文件的命令

COMPILE_CXX

在生成的 Makefile 中编译 C++ 文件的命令

COMPILE_RULES

make 编译规则

CONFIG

使用 Ruby 构建时的默认值的 Makefile 配置。

CXX_EXT

使用 C++ 编译器编译的文件的扩展名

C_EXT

使用 C 编译器编译的文件的扩展名

EXPORT_PREFIX

自动添加到导出符号的前缀

HDR_EXT

头文件的扩展名

LANGUAGE

此模块所用的语言

LIBARG

将库添加到链接器的参数

LIBPATHFLAG

将库路径添加到链接器的参数

LINK_SO

链接共享库的命令

MAIN_DOES_NOTHING

一个不做任何工作的 C main 函数

ORIG_LIBPATH

保存的 LIB 环境变量的原始值

RPATHFLAG

将运行时库路径添加到链接器的参数

RULE_SUBST

NMake 规则中的替换

RbConfig

在构建时存储 Ruby 解释器配置的模块。

此文件由 mkconfig.rb 在 ruby 构建时创建。它包含 ruby 的构建信息，例如 mkmf 用于构建兼容的本地扩展。对该文件的任何更改将在下次构建 ruby 时丢失。

SRC_EXT

源文件的扩展名

TRY_LINK

用于编译程序以测试链接库的命令

UNIVERSAL_INTS

convertible_int 的类型名称

Public Class Methods

[] (name)

Source

# File lib/mkmf.rb, line 2990
def self.[](name)
  @lang.fetch(name)
end

检索 name 语言的模块。

[]= (name, mod)

Source

# File lib/mkmf.rb, line 2996
def self.[]=(name, mod)
  @lang[name] = mod
end

定义 name 语言的模块。

rm_f (*files)

Source

# File lib/mkmf.rb, line 270
def rm_f(*files)
  opt = (Hash === files.last ? [files.pop] : [])
  FileUtils.rm_f(Dir[*files.flatten], *opt)
end

删除 files。

rm_rf (*files)

Source

# File lib/mkmf.rb, line 277
def rm_rf(*files)
  opt = (Hash === files.last ? [files.pop] : [])
  FileUtils.rm_rf(Dir[*files.flatten], *opt)
end

递归删除 files。

Public Instance Methods

append_cflags (flags, **opts)

Source

# File lib/mkmf.rb, line 1106
def append_cflags(flags, **opts)
  Array(flags).each do |flag|
    if checking_for("whether #{flag} is accepted as CFLAGS") {
         try_cflags(flag, **opts)
       }
      $CFLAGS << " " << flag
    end
  end
end

检查每个给定的 C 编译器标志是否可接受，如果可接受则将其追加到 $CFLAGS。

flags: C 编译器标志，可以是 String 或它们的 Array

append_ldflags (flags, **opts)

Source

# File lib/mkmf.rb, line 762
def append_ldflags(flags, **opts)
  Array(flags).each do |flag|
    if checking_for("whether #{flag} is accepted as LDFLAGS") {
         try_ldflags(flag, **opts)
       }
      $LDFLAGS << " " << flag
    end
  end
end

检查每个给定的链接器标志是否可接受，如果可接受则将其追加到 $LDFLAGS。

flags: 链接器标志，可以是 String 或它们的 Array

check_signedness (type, headers = nil, opts = nil, &b)

Source

# File lib/mkmf.rb, line 1509
def check_signedness(type, headers = nil, opts = nil, &b)
  typedef, member, prelude = typedef_expr(type, headers)
  signed = nil
  checking_for("signedness of #{type}", STRING_OR_FAILED_FORMAT) do
    signed = try_signedness(typedef, member, [prelude], opts, &b) or next nil
    $defs.push("-DSIGNEDNESS_OF_%s=%+d" % [type.tr_cpp, signed])
    signed < 0 ? "signed" : "unsigned"
  end
  signed
end

返回给定 type 的符号性。您还可以选择指定额外的 headers 来搜索 type。

如果找到 type 并且它是一个数值类型，则通过预处理器常量将一个宏传递给编译器，该宏使用大写的 type 名称，前面加上 SIGNEDNESS_OF_，后面跟着 type 名称，最后是 =X，其中“X”如果 type 是无符号的则为正整数，如果 type 是有符号的则为负整数。

例如，如果 size_t 定义为 unsigned，则 check_signedness('size_t') 将返回 +1，并且 SIGNEDNESS_OF_SIZE_T=+1 预处理器宏将被传递给编译器。对于 check_signedness('int')，将设置 SIGNEDNESS_OF_INT=-1 宏。

check_sizeof (type, headers = nil, opts = "", &b)

Source

# File lib/mkmf.rb, line 1480
def check_sizeof(type, headers = nil, opts = "", &b)
  typedef, member, prelude = typedef_expr(type, headers)
  prelude << "#{typedef} *rbcv_ptr_;\n"
  prelude = [prelude]
  expr = "sizeof((*rbcv_ptr_)#{"." << member if member})"
  fmt = STRING_OR_FAILED_FORMAT
  checking_for checking_message("size of #{type}", headers), fmt do
    if size = try_constant(expr, prelude, opts, &b)
      $defs.push(format("-DSIZEOF_%s=%s", type.tr_cpp, size))
      size
    end
  end
end

返回给定 type 的大小。您还可以选择指定额外的 headers 来搜索 type。

如果找到，则通过预处理器常量将一个宏传递给编译器，该宏使用大写的类型名称，前面加上 SIZEOF_，后面跟着类型名称，最后是 =X，其中“X”是实际大小。

例如，如果 check_sizeof('mystruct') 返回 12，则 SIZEOF_MYSTRUCT=12 预处理器宏将被传递给编译器。

conftest_source ()

Source

# File lib/mkmf.rb, line 488
def conftest_source
  CONFTEST_C
end

返回用于配置检查的依赖于语言的源文件名。

convertible_int (type, headers = nil, opts = nil, &b)

Source

# File lib/mkmf.rb, line 1544
def convertible_int(type, headers = nil, opts = nil, &b)
  type, macname = *type
  checking_for("convertible type of #{type}", STRING_OR_FAILED_FORMAT) do
    if UNIVERSAL_INTS.include?(type)
      type
    else
      typedef, member, prelude = typedef_expr(type, headers, &b)
      if member
        prelude << "static rbcv_typedef_ rbcv_var;"
        compat = UNIVERSAL_INTS.find {|t|
          try_static_assert("sizeof(rbcv_var.#{member}) == sizeof(#{t})", [prelude], opts, &b)
        }
      else
        next unless signed = try_signedness(typedef, member, [prelude])
        u = "unsigned " if signed > 0
        prelude << "extern rbcv_typedef_ foo();"
        compat = UNIVERSAL_INTS.find {|t|
          try_compile([prelude, "extern #{u}#{t} foo();"].join("\n"), opts, werror: true, &b)
        }
      end
      if compat
        macname ||= type.sub(/_(?=t\z)/, '').tr_cpp
        conv = (compat == "long long" ? "LL" : compat.upcase)
        compat = "#{u}#{compat}"
        typename = type.tr_cpp
        $defs.push(format("-DSIZEOF_%s=SIZEOF_%s", typename, compat.tr_cpp))
        $defs.push(format("-DTYPEOF_%s=%s", typename, compat.quote))
        $defs.push(format("-DPRI_%s_PREFIX=PRI_%s_PREFIX", macname, conv))
        conv = (u ? "U" : "") + conv
        $defs.push(format("-D%s2NUM=%s2NUM", macname, conv))
        $defs.push(format("-DNUM2%s=NUM2%s", macname, conv))
        compat
      end
    end
  end
end

返回给定 type 的可转换整数类型。您还可以选择指定额外的 headers 来搜索 type。convertible 实际上意味着相同的类型，或者由相同类型 typedef 而来。

如果 type 是整数类型并且找到了 *convertible* 类型，则以下宏将作为预处理器常量传递给编译器，使用大写的 type 名称。

TYPEOF_，后面跟着 type 名称，然后是 =X，其中“X”是找到的 *convertible* 类型名称。
TYP2NUM 和 NUM2TYP，其中 TYP 是大写的 type 名称，将 _t 后缀替换为“T”，后面跟着 =X，其中“X”是将 type 转换为 Integer 对象的宏名称，反之亦然。

例如，如果 foobar_t 定义为 unsigned long，则 convertible_int("foobar_t") 将返回“unsigned long”，并定义这些宏

#define TYPEOF_FOOBAR_T unsigned long
#define FOOBART2NUM ULONG2NUM
#define NUM2FOOBART NUM2ULONG

create_header (header = "extconf.h")

Source

# File lib/mkmf.rb, line 1840
def create_header(header = "extconf.h")
  message "creating %s\n", header
  sym = header.tr_cpp
  hdr = ["#ifndef #{sym}\n#define #{sym}\n"]
  for line in $defs
    case line
    when /^-D([^=]+)(?:=(.*))?/
      hdr << "#define #$1 #{$2 ? Shellwords.shellwords($2)[0].gsub(/(?=\t+)/, "\\\n") : 1}\n"
    when /^-U(.*)/
      hdr << "#undef #$1\n"
    end
  end
  hdr << "#endif\n"
  hdr = hdr.join("")
  log_src(hdr, "#{header} is")
  unless (File.read(header) == hdr rescue false)
    File.open(header, "wb") do |hfile|
      hfile.write(hdr)
    end
  end
  $extconf_h = header
end

生成一个头文件，其中包含其他方法（如 have_func 和 have_header）生成的各种宏定义。然后，这些宏被包装在一个自定义的 ifndef 中，该 ifndef 基于 header 文件名，默认为“extconf.h”。

例如

# extconf.rb
require 'mkmf'
have_func('realpath')
have_header('sys/utime.h')
create_header
create_makefile('foo')

上面的脚本将生成以下 extconf.h 文件

#ifndef EXTCONF_H
#define EXTCONF_H
#define HAVE_REALPATH 1
#define HAVE_SYS_UTIME_H 1
#endif

鉴于 create_header 方法根据您的 extconf.rb 文件早期设置的定义生成文件，您可能希望将其作为您脚本中最后调用的方法之一。

create_makefile (target, srcprefix = nil) { |conf| ... }

Source

# File lib/mkmf.rb, line 2396
  def create_makefile(target, srcprefix = nil)
    $target = target
    libpath = $DEFLIBPATH|$LIBPATH
    message "creating Makefile\n"
    MakeMakefile.rm_f "#{CONFTEST}*"
    if CONFIG["DLEXT"] == $OBJEXT
      for lib in libs = $libs.split(' ')
        lib.sub!(/-l(.*)/, %%"lib\\1.#{$LIBEXT}"%)
      end
      $defs.push(format("-DEXTLIB='%s'", libs.join(",")))
    end

    if target.include?('/')
      target_prefix, target = File.split(target)
      target_prefix[0,0] = '/'
    else
      target_prefix = ""
    end

    srcprefix ||= "$(srcdir)/#{srcprefix}".chomp('/')
    RbConfig.expand(srcdir = srcprefix.dup)

    ext = ".#{$OBJEXT}"
    orig_srcs = Dir[File.join(srcdir, "*.{#{SRC_EXT.join(%q{,})}}")]
    if not $objs
      srcs = $srcs || orig_srcs
      $objs = []
      objs = srcs.inject(Hash.new {[]}) {|h, f|
        h.key?(o = File.basename(f, ".*") << ext) or $objs << o
        h[o] <<= f
        h
      }
      unless objs.delete_if {|b, f| f.size == 1}.empty?
        dups = objs.map {|b, f|
          "#{b[/.*\./]}{#{f.collect {|n| n[/([^.]+)\z/]}.join(',')}}"
        }
        abort "source files duplication - #{dups.join(", ")}"
      end
    else
      $objs.collect! {|o| File.basename(o, ".*") << ext} unless $OBJEXT == "o"
      srcs = $srcs || $objs.collect {|o| o.chomp(ext) << ".c"}
    end
    $srcs = srcs

    hdrs = Dir[File.join(srcdir, "*.{#{HDR_EXT.join(%q{,})}}")]

    target = nil if $objs.empty?

    if target and EXPORT_PREFIX
      if File.exist?(File.join(srcdir, target + '.def'))
        deffile = "$(srcdir)/$(TARGET).def"
        unless EXPORT_PREFIX.empty?
          makedef = %{$(RUBY) -pe "$$_.sub!(/^(?=\\w)/,'#{EXPORT_PREFIX}') unless 1../^EXPORTS$/i" #{deffile}}
        end
      else
        makedef = %{(echo EXPORTS && echo $(TARGET_ENTRY))}
      end
      if makedef
        $cleanfiles << '$(DEFFILE)'
        origdef = deffile
        deffile = "$(TARGET)-$(arch).def"
      end
    end
    origdef ||= ''

    if $extout and $INSTALLFILES
      $cleanfiles.concat($INSTALLFILES.collect {|files, dir|File.join(dir, files.delete_prefix('./'))})
      $distcleandirs.concat($INSTALLFILES.collect {|files, dir| dir})
    end

    if $extmk and $static
      $defs << "-DRUBY_EXPORT=1"
    end

    if $extmk and not $extconf_h
      create_header
    end

    libpath = libpathflag(libpath)

    dllib = target ? "$(TARGET).#{CONFIG['DLEXT']}" : ""
    staticlib = target ? "$(TARGET).#$LIBEXT" : ""
    conf = configuration(srcprefix)
    conf << "\
libpath = #{($DEFLIBPATH|$LIBPATH).join(" ")}
LIBPATH = #{libpath}
DEFFILE = #{deffile}

CLEANFILES = #{$cleanfiles.join(' ')}
DISTCLEANFILES = #{$distcleanfiles.join(' ')}
DISTCLEANDIRS = #{$distcleandirs.join(' ')}

extout = #{$extout && $extout.quote}
extout_prefix = #{$extout_prefix}
target_prefix = #{target_prefix}
LOCAL_LIBS = #{$LOCAL_LIBS}
LIBS = #{$LIBRUBYARG} #{$libs} #{$LIBS}
ORIG_SRCS = #{orig_srcs.collect(&File.method(:basename)).join(' ')}
SRCS = $(ORIG_SRCS) #{(srcs - orig_srcs).collect(&File.method(:basename)).join(' ')}
OBJS = #{$objs.join(" ")}
HDRS = #{hdrs.map{|h| '$(srcdir)/' + File.basename(h)}.join(' ')}
LOCAL_HDRS = #{$headers.join(' ')}
TARGET = #{target}
TARGET_NAME = #{target && target[/\A\w+/]}
TARGET_ENTRY = #{EXPORT_PREFIX || ''}Init_$(TARGET_NAME)
DLLIB = #{dllib}
EXTSTATIC = #{$static || ""}
STATIC_LIB = #{staticlib unless $static.nil?}
#{!$extout && defined?($installed_list) ? %[INSTALLED_LIST = #{$installed_list}\n] : ""}
TIMESTAMP_DIR = #{$extout && $extmk ? '$(extout)/.timestamp' : '.'}
" #"
    # TODO: fixme
    install_dirs.each {|d| conf << ("%-14s= %s\n" % d) if /^[[:upper:]]/ =~ d[0]}
    sodir = $extout ? '$(TARGET_SO_DIR)' : '$(RUBYARCHDIR)'
    n = '$(TARGET_SO_DIR)$(TARGET)'
    cleanobjs = ["$(OBJS)"]
    cleanlibs = []
    if $extmk
      %w[bc i s].each {|ex| cleanobjs << "$(OBJS:.#{$OBJEXT}=.#{ex})"}
    end
    if target
      config_string('cleanobjs') {|t| cleanobjs << t.gsub(/\$\*/, "$(TARGET)#{deffile ? '-$(arch)': ''}")}
      cleanlibs << '$(TARGET_SO)'
    end
    config_string('cleanlibs') {|t| cleanlibs << t.gsub(/\$\*/) {n}}
    conf << "\
TARGET_SO_DIR =#{$extout ? " $(RUBYARCHDIR)/" : ''}
TARGET_SO     = $(TARGET_SO_DIR)$(DLLIB)
CLEANLIBS     = #{cleanlibs.join(' ')}
CLEANOBJS     = #{cleanobjs.join(' ')} *.bak
TARGET_SO_DIR_TIMESTAMP = #{timestamp_file(sodir, target_prefix)}
" #"

    conf = yield(conf) if block_given?
    mfile = File.open("Makefile", "wb")
    mfile.puts(conf)
    mfile.print "
all:    #{$extout ? "install" : target ? "$(DLLIB)" : "Makefile"}
static: #{$extmk && !$static ? "all" : %[$(STATIC_LIB)#{$extout ? " install-rb" : ""}]}
.PHONY: all install static install-so install-rb
.PHONY: clean clean-so clean-static clean-rb
" #"
    mfile.print CLEANINGS
    fsep = config_string('BUILD_FILE_SEPARATOR') {|s| s unless s == "/"}
    if fsep
      sep = ":/=#{fsep}"
      fseprepl = proc {|s|
        s = s.gsub("/", fsep)
        s = s.gsub(/(\$\(\w+)(\))/) {$1+sep+$2}
        s.gsub(/(\$\{\w+)(\})/) {$1+sep+$2}
      }
      rsep = ":#{fsep}=/"
    else
      fseprepl = proc {|s| s}
      sep = ""
      rsep = ""
    end
    dirs = []
    mfile.print "install: install-so install-rb\n\n"
    dir = sodir.dup
    mfile.print("install-so: ")
    if target
      f = "$(DLLIB)"
      dest = "$(TARGET_SO)"
      stamp = '$(TARGET_SO_DIR_TIMESTAMP)'
      if $extout
        mfile.puts dest
        mfile.print "clean-so::\n"
        mfile.print "\t-$(Q)$(RM) #{fseprepl[dest]} #{fseprepl[stamp]}\n"
        mfile.print "\t-$(Q)$(RM_RF) #{fseprepl['$(CLEANLIBS)']}\n"
        mfile.print "\t-$(Q)$(RMDIRS) #{fseprepl[dir]}#{$ignore_error}\n"
      else
        mfile.print "#{f} #{stamp}\n"
        mfile.print "\t$(INSTALL_PROG) #{fseprepl[f]} #{dir}\n"
        if defined?($installed_list)
          mfile.print "\t@echo #{dir}/#{File.basename(f)}>>$(INSTALLED_LIST)\n"
        end
      end
      mfile.print "clean-static::\n"
      mfile.print "\t-$(Q)$(RM) $(STATIC_LIB)\n"
    else
      mfile.puts "Makefile"
    end
    mfile.print("install-rb: pre-install-rb do-install-rb install-rb-default\n")
    mfile.print("install-rb-default: pre-install-rb-default do-install-rb-default\n")
    mfile.print("pre-install-rb: Makefile\n")
    mfile.print("pre-install-rb-default: Makefile\n")
    mfile.print("do-install-rb:\n")
    mfile.print("do-install-rb-default:\n")
    for sfx, i in [["-default", [["lib/**/*.rb", "$(RUBYLIBDIR)", "lib"]]], ["", $INSTALLFILES]]
      files = install_files(mfile, i, nil, srcprefix) or next
      for dir, *files in files
        unless dirs.include?(dir)
          dirs << dir
          mfile.print "pre-install-rb#{sfx}: #{timestamp_file(dir, target_prefix)}\n"
        end
        for f in files
          dest = "#{dir}/#{File.basename(f)}"
          mfile.print("do-install-rb#{sfx}: #{dest}\n")
          mfile.print("#{dest}: #{f} #{timestamp_file(dir, target_prefix)}\n")
          mfile.print("\t$(Q) $(#{$extout ? 'COPY' : 'INSTALL_DATA'}) #{f} $@\n")
          if defined?($installed_list) and !$extout
            mfile.print("\t@echo #{dest}>>$(INSTALLED_LIST)\n")
          end
          if $extout
            mfile.print("clean-rb#{sfx}::\n")
            mfile.print("\t-$(Q)$(RM) #{fseprepl[dest]}\n")
          end
        end
      end
      mfile.print "pre-install-rb#{sfx}:\n"
      if files.empty?
        mfile.print("\t@$(NULLCMD)\n")
      else
        q = "$(MAKE) -q do-install-rb#{sfx}"
        if $nmake
          mfile.print "!if \"$(Q)\" == \"@\"\n\t@#{q} || \\\n!endif\n\t"
        else
          mfile.print "\t$(Q1:0=@#{q} || )"
        end
        mfile.print "$(ECHO1:0=echo) installing#{sfx.sub(/^-/, " ")} #{target} libraries\n"
      end
      if $extout
        dirs.uniq!
        unless dirs.empty?
          mfile.print("clean-rb#{sfx}::\n")
          for dir in dirs.sort_by {|d| -d.count('/')}
            stamp = timestamp_file(dir, target_prefix)
            mfile.print("\t-$(Q)$(RM) #{fseprepl[stamp]}\n")
            mfile.print("\t-$(Q)$(RMDIRS) #{fseprepl[dir]}#{$ignore_error}\n")
          end
        end
      end
    end
    if target and !dirs.include?(sodir)
      mfile.print "$(TARGET_SO_DIR_TIMESTAMP):\n\t$(Q) $(MAKEDIRS) $(@D) #{sodir}\n\t$(Q) $(TOUCH) $@\n"
    end
    dirs.each do |d|
      t = timestamp_file(d, target_prefix)
      mfile.print "#{t}:\n\t$(Q) $(MAKEDIRS) $(@D) #{d}\n\t$(Q) $(TOUCH) $@\n"
    end

    mfile.print <<-SITEINSTALL

site-install: site-install-so site-install-rb
site-install-so: install-so
site-install-rb: install-rb

    SITEINSTALL

    return unless target

    mfile.print ".SUFFIXES: .#{(SRC_EXT + [$OBJEXT, $ASMEXT]).compact.join(' .')}\n"
    mfile.print "\n"

    compile_command = "\n\t$(ECHO) compiling $(<#{rsep})\n\t$(Q) %s\n\n"
    command = compile_command % COMPILE_CXX
    asm_command = compile_command.sub(/compiling/, 'translating') % ASSEMBLE_CXX
    CXX_EXT.each do |e|
      each_compile_rules do |rule|
        mfile.printf(rule, e, $OBJEXT)
        mfile.print(command)
        mfile.printf(rule, e, $ASMEXT)
        mfile.print(asm_command)
      end
    end
    command = compile_command % COMPILE_C
    asm_command = compile_command.sub(/compiling/, 'translating') % ASSEMBLE_C
    C_EXT.each do |e|
      each_compile_rules do |rule|
        mfile.printf(rule, e, $OBJEXT)
        mfile.print(command)
        mfile.printf(rule, e, $ASMEXT)
        mfile.print(asm_command)
      end
    end

    mfile.print "$(TARGET_SO): "
    mfile.print "$(DEFFILE) " if makedef
    mfile.print "$(OBJS) Makefile"
    mfile.print " $(TARGET_SO_DIR_TIMESTAMP)" if $extout
    mfile.print "\n"
    mfile.print "\t$(ECHO) linking shared-object #{target_prefix.sub(/\A\/(.*)/, '\1/')}$(DLLIB)\n"
    mfile.print "\t-$(Q)$(RM) $(@#{sep})\n"
    link_so = LINK_SO.gsub(/^/, "\t$(Q) ")
    if srcs.any?(&%r"\.(?:#{CXX_EXT.join('|')})\z".method(:===))
      link_so = link_so.sub(/\bLDSHARED\b/, '\&XX')
    end
    mfile.print link_so, "\n\n"
    unless $static.nil?
      mfile.print "$(STATIC_LIB): $(OBJS)\n\t-$(Q)$(RM) $(@#{sep})\n\t"
      mfile.print "$(ECHO) linking static-library $(@#{rsep})\n\t$(Q) "
      mfile.print "$(AR) #{config_string('ARFLAGS') || 'cru '}$@ $(OBJS)"
      config_string('RANLIB') do |ranlib|
        mfile.print "\n\t-$(Q)#{ranlib} $(@)#{$ignore_error}"
      end
    end
    mfile.print "\n\n"
    if makedef
      mfile.print "$(DEFFILE): #{origdef}\n"
      mfile.print "\t$(ECHO) generating $(@#{rsep})\n"
      mfile.print "\t$(Q) #{makedef} > $@\n\n"
    end

    depend = File.join(srcdir, "depend")
    if File.exist?(depend)
      mfile.print("###\n", *depend_rules(File.read(depend)))
    else
      mfile.print "$(OBJS): $(HDRS) $(ruby_headers)\n"
    end

    $makefile_created = true
  ensure
    mfile.close if mfile
  end

为您的扩展生成 Makefile，传递您可能通过其他方法生成的任何选项和预处理器常量。

target 名称应对应于 C 扩展中定义的全局函数名称，不包括 Init_。例如，如果您的 C 扩展定义为 Init_foo，则您的 target 仅仅是“foo”。

如果 target 名称中存在任何“/”字符，则只有最后一个名称被解释为 target 名称，其余的被视为顶层目录名称，并且生成的 Makefile 将相应地修改以遵循该目录结构。

例如，如果您将“test/foo”作为 target 名称传递，您的扩展将安装在“test”目录下。这意味着为了在后续的 Ruby 程序中加载该文件，需要遵循该目录结构，例如 require 'test/foo'。

srcprefix 应在源文件与构建脚本不在同一目录时使用。这不仅消除了您手动将源文件复制到与构建脚本相同目录的需要，而且还在生成的 Makefile 中设置了正确的 target_prefix。

设置 target_prefix 将在生成 Makefile 时，通过 make install 命令将生成的二进制文件安装在 RbConfig::CONFIG['sitearchdir'] 下的一个模仿您本地文件系统的目录中。

例如，给定以下文件树

ext/
  extconf.rb
  test/
    foo.c

并给定以下代码

create_makefile('test/foo', 'test')

这将把生成的 Makefile 中的 target_prefix 设置为“test”。然后，通过 make install 命令安装时，将创建以下文件树

/path/to/ruby/sitearchdir/test/foo.so

建议您使用此方法生成 makefile，而不是手动复制文件，因为某些第三方库可能依赖于正确设置 target_prefix。

srcprefix 参数可用于覆盖默认源目录（即当前目录）。它作为 VPATH 的一部分，并添加到 INCFLAGS 列表中。

如果提供了块，则将 Makefile 的配置部分作为字符串数组屈服。返回的值将用作新的配置部分。

create_makefile('foo') {|conf|
  [
    *conf,
    "MACRO_YOU_NEED = something",
  ]
}

如果源目录中存在“depend”文件，其内容将包含在生成的 makefile 中，并由 depend_rules 方法格式化。

create_tmpsrc (src) { |src| ... }

Source

# File lib/mkmf.rb, line 495
def create_tmpsrc(src)
  src = "#{COMMON_HEADERS}\n#{src}"
  src = yield(src) if block_given?
  src.gsub!(/[ \t]+$/, '')
  src.gsub!(/\A\n+|^\n+$/, '')
  src.sub!(/[^\n]\z/, "\\&\n")
  count = 0
  begin
    File.open(conftest_source, "wb") do |cfile|
      cfile.print src
    end
  rescue Errno::EACCES
    if (count += 1) < 5
      sleep 0.2
      retry
    end
  end
  src
end

从 COMMON_HEADERS 和 src 创建临时源文件。如果提供了块，则屈服创建的源字符串并使用返回的字符串作为源代码。

depend_rules (depend)

Source

# File lib/mkmf.rb, line 2268
def depend_rules(depend)
  suffixes = []
  depout = []
  cont = implicit = nil
  impconv = proc do
    each_compile_rules {|rule| depout << (rule % implicit[0]) << implicit[1]}
    implicit = nil
  end
  ruleconv = proc do |line|
    if implicit
      if /\A\t/ =~ line
        implicit[1] << line
        next
      else
        impconv[]
      end
    end
    if m = /\A\.(\w+)\.(\w+)(?:\s*:)/.match(line)
      suffixes << m[1] << m[2]
      implicit = [[m[1], m[2]], [m.post_match]]
      next
    elsif RULE_SUBST and /\A(?!\s*\w+\s*=)[$\w][^#]*:/ =~ line
      line.sub!(/\s*\#.*$/, '')
      comment = $&
      line.gsub!(%r"(\s)(?!\.)([^$(){}+=:\s\\,]+)(?=\s|\z)") {$1 + RULE_SUBST % $2}
      line = line.chomp + comment + "\n" if comment
    end
    depout << line
  end
  depend.each_line do |line|
    line.gsub!(/\.o\b/, ".#{$OBJEXT}")
    line.gsub!(/\{\$\(VPATH\)\}/, "") unless $nmake
    line.gsub!(/\$\((?:hdr|top)dir\)\/config.h/, $config_h)
    if $nmake && /\A\s*\$\(RM|COPY\)/ =~ line
      line.gsub!(%r"[-\w\./]{2,}"){$&.tr("/", "\\")}
      line.gsub!(/(\$\((?!RM|COPY)[^:)]+)(?=\))/, '\1:/=\\')
    end
    if /(?:^|[^\\])(?:\\\\)*\\$/ =~ line
      (cont ||= []) << line
      next
    elsif cont
      line = (cont << line).join
      cont = nil
    end
    ruleconv.call(line)
  end
  if cont
    ruleconv.call(cont.join)
  elsif implicit
    impconv.call
  end
  unless suffixes.empty?
    depout.unshift(".SUFFIXES: ." + suffixes.uniq.join(" .") + "\n\n")
  end
  if $extconf_h
    depout.unshift("$(OBJS): $(RUBY_EXTCONF_H)\n\n")
    depout.unshift("$(OBJS): $(hdrdir)/ruby/win32.h\n\n") if $mswin or $mingw
  end
  depout.flatten!
  depout
end

处理“depend”文件的内容。该文件的每一行都应为一个文件名。

返回 Makefile 格式的查找结果。

dir_config(target)

dir_config(target, prefix)

dir_config(target, idefault, ldefault)

Source

# File lib/mkmf.rb, line 1890
def dir_config(target, idefault=nil, ldefault=nil)
  key = [target, idefault, ldefault].compact.join("\0")
  if conf = $config_dirs[key]
    return conf
  end

  if dir = with_config(target + "-dir", (idefault unless ldefault))
    defaults = Array === dir ? dir : dir.split(File::PATH_SEPARATOR)
    idefault = ldefault = nil
  end

  idir = with_config(target + "-include", idefault)
  if conf = $arg_config.assoc("--with-#{target}-include")
    conf[1] ||= "${#{target}-dir}/include"
  end
  ldir = with_config(target + "-lib", ldefault)
  if conf = $arg_config.assoc("--with-#{target}-lib")
    conf[1] ||= "${#{target}-dir}/#{_libdir_basename}"
  end

  idirs = idir ? Array === idir ? idir.dup : idir.split(File::PATH_SEPARATOR) : []
  if defaults
    idirs.concat(defaults.collect {|d| d + "/include"})
    idir = ([idir] + idirs).compact.join(File::PATH_SEPARATOR)
  end
  unless idirs.empty?
    idirs.collect! {|d| "-I" + d}
    idirs -= Shellwords.shellwords($CPPFLAGS)
    unless idirs.empty?
      $CPPFLAGS = (idirs.quote << $CPPFLAGS).join(" ")
    end
  end

  ldirs = ldir ? Array === ldir ? ldir.dup : ldir.split(File::PATH_SEPARATOR) : []
  if defaults
    ldirs.concat(defaults.collect {|d| "#{d}/#{_libdir_basename}"})
    ldir = ([ldir] + ldirs).compact.join(File::PATH_SEPARATOR)
  end
  $LIBPATH = ldirs | $LIBPATH

  $config_dirs[key] = [idir, ldir]
end

设置一个 target 名称，用户可以使用该名称通过命令行使用各种“with”选项进行配置。例如，如果 target 设置为“foo”，则用户可以使用 --with-foo-dir=prefix、--with-foo-include=dir 和 --with-foo-lib=dir 命令行选项来指定在哪里搜索头/库文件。

您可以传递额外的参数来指定默认值。如果提供了一个参数，则将其视为默认的 prefix；如果提供了两个参数，则按顺序将其视为“include”和“lib”的默认值。

在任何情况下，返回值都将是一个确定的“include”和“lib”目录的数组，如果未提供相应的命令行选项且未指定默认值，则其中任何一个都可以为 nil。

请注意，dir_config 仅添加到搜索库和包含文件的列表。它不会将库链接到您的应用程序。

dummy_makefile (srcdir)

Source

# File lib/mkmf.rb, line 2237
  def dummy_makefile(srcdir)
    configuration(srcdir) << <<RULES << CLEANINGS
CLEANFILES = #{$cleanfiles.join(' ')}
DISTCLEANFILES = #{$distcleanfiles.join(' ')}

all install static install-so install-rb: Makefile
        @$(NULLCMD)
.PHONY: all install static install-so install-rb
.PHONY: clean clean-so clean-static clean-rb

RULES
  end

创建存根 Makefile。

egrep_cpp (pat, src, opt = "", &b)

Source

# File lib/mkmf.rb, line 923
def egrep_cpp(pat, src, opt = "", &b)
  src = create_tmpsrc(src, &b)
  xpopen(cpp_command('', opt)) do |f|
    if Regexp === pat
      puts("    ruby -ne 'print if #{pat.inspect}'")
      f.grep(pat) {|l|
        puts "#{f.lineno}: #{l}"
        return true
      }
      false
    else
      puts("    egrep '#{pat}'")
      begin
        stdin = $stdin.dup
        $stdin.reopen(f)
        system("egrep", pat)
      ensure
        $stdin.reopen(stdin)
      end
    end
  end
ensure
  MakeMakefile.rm_f "#{CONFTEST}*"
  log_src(src)
end

返回 src 是否可以被 C 预处理器预处理并与 pat 匹配。

如果提供了块，则在编译之前用源文件调用它。您可以在块中修改源文件。

pat: 一个 Regexp 或 String
src: 一个包含 C 源的 String
opt: 一个包含预处理器选项的 String

注意：当 pat 是 Regexp 时，匹配将在进程中进行检查，否则将调用 egrep(1) 来检查。

enable_config (config, default=nil) { |config, default| ... }

Source

# File lib/mkmf.rb, line 1802
def enable_config(config, default=nil)
  if arg_config("--enable-"+config)
    true
  elsif arg_config("--disable-"+config)
    false
  elsif block_given?
    yield(config, default)
  else
    return default
  end
end

测试是否存在 --enable-config 或 --disable-config 选项。如果给定了 enable 选项，则返回 true；如果给定了 disable 选项，则返回 false；否则返回默认值。

这对于添加自定义定义（例如调试信息）很有用。

示例

if enable_config("debug")
   $defs.push("-DOSSL_DEBUG") unless $defs.include? "-DOSSL_DEBUG"
end

find_header (header, *paths)

Source

# File lib/mkmf.rb, line 1290
def find_header(header, *paths)
  message = checking_message(header, paths)
  header = cpp_include(header)
  checking_for message do
    if try_header(header)
      true
    else
      found = false
      paths.each do |dir|
        opt = "-I#{dir}".quote
        if try_header(header, opt)
          $INCFLAGS << " " << opt
          found = true
          break
        end
      end
      found
    end
  end
end

指示 mkmf 在提供的任何 paths 中搜索给定的 header，并返回是否在该路径中找到它。

如果找到头文件，则找到它的路径将被添加到传递给编译器的包含目录列表中（通过 -I 开关）。

find_library (lib, func, *paths, &b)

Source

# File lib/mkmf.rb, line 1164
def find_library(lib, func, *paths, &b)
  dir_config(lib)
  lib = with_config(lib+'lib', lib)
  paths = paths.flat_map {|path| path.split(File::PATH_SEPARATOR)}
  checking_for checking_message(func && func.funcall_style, LIBARG%lib) do
    libpath = $LIBPATH
    libs = append_library($libs, lib)
    begin
      until r = try_func(func, libs, &b) or paths.empty?
        $LIBPATH = libpath | [paths.shift]
      end
      if r
        $libs = libs
        libpath = nil
      end
    ensure
      $LIBPATH = libpath if libpath
    end
    r
  end
end

返回是否可以在 paths 数组指定的 lib 中的入口点 func 中找到。如果 func 为 nil，则使用 main() 函数作为入口点。

如果找到 lib，则找到它的路径将被添加到搜索和链接的库路径列表中。

have_framework (fw, &b)

Source

# File lib/mkmf.rb, line 1261
def have_framework(fw, &b)
  if Array === fw
    fw, header = *fw
  else
    header = "#{fw}.h"
  end
  checking_for fw do
    src = cpp_include("#{fw}/#{header}") << "\n" "int main(void){return 0;}"
    opt = " -framework #{fw}"
    if try_link(src, opt, &b) or (objc = try_link(src, "-ObjC#{opt}", &b))
      $defs.push(format("-DHAVE_FRAMEWORK_%s", fw.tr_cpp))
      # TODO: non-worse way than this hack, to get rid of separating
      # option and its argument.
      $LDFLAGS << " -ObjC" if objc and /(\A|\s)-ObjC(\s|\z)/ !~ $LDFLAGS
      $LIBS << opt
      true
    else
      false
    end
  end
end

返回您的系统上是否可以找到给定的 framework。如果找到，则通过预处理器常量将一个宏传递给编译器，该宏使用大写的框架名称，前面加上 HAVE_FRAMEWORK_。

例如，如果 have_framework('Ruby') 返回 true，则 HAVE_FRAMEWORK_RUBY 预处理器宏将被传递给编译器。

如果 fw 是框架名称及其头文件名对，则检查该头文件，而不是通常使用的与框架同名的头文件。

have_func (func, headers = nil, opt = "", &b)

Source

# File lib/mkmf.rb, line 1198
def have_func(func, headers = nil, opt = "", &b)
  checking_for checking_message(func.funcall_style, headers, opt) do
    if try_func(func, $libs, headers, opt, &b)
      $defs << "-DHAVE_#{func.sans_arguments.tr_cpp}"
      true
    else
      false
    end
  end
end

返回是否可以在通用头文件中，或者在您提供的任何 headers 中找到函数 func。如果找到，则通过预处理器常量将一个宏传递给编译器，该宏使用大写的函数名称，前面加上 HAVE_。

要检查附加库中的函数，您需要先使用 have_library() 检查该库。func 应该是纯函数名或带参数的函数名。

例如，如果 have_func('foo') 返回 true，则 HAVE_FOO 预处理器宏将被传递给编译器。

have_header (header, preheaders = nil, opt = "", &b)

Source

# File lib/mkmf.rb, line 1238
def have_header(header, preheaders = nil, opt = "", &b)
  dir_config(header[/.*?(?=\/)|.*?(?=\.)/])
  checking_for header do
    if try_header(cpp_include(preheaders)+cpp_include(header), opt, &b)
      $defs.push(format("-DHAVE_%s", header.tr_cpp))
      true
    else
      false
    end
  end
end

返回您的系统上是否可以找到给定的 header 文件。如果找到，则通过预处理器常量将一个宏传递给编译器，该宏使用大写的头文件名，前面加上 HAVE_。

例如，如果 have_header('foo.h') 返回 true，则 HAVE_FOO_H 预处理器宏将被传递给编译器。

have_library (lib, func = nil, headers = nil, opt = "", &b)

Source

# File lib/mkmf.rb, line 1138
def have_library(lib, func = nil, headers = nil, opt = "", &b)
  dir_config(lib)
  lib = with_config(lib+'lib', lib)
  checking_for checking_message(func && func.funcall_style, LIBARG%lib, opt) do
    if COMMON_LIBS.include?(lib)
      true
    else
      libs = append_library($libs, lib)
      if try_func(func, libs, headers, opt, &b)
        $libs = libs
        true
      else
        false
      end
    end
  end
end

返回是否可以在 lib 中找到给定的入口点 func。如果 func 为 nil，则默认使用 main() 入口点。如果找到，它会将库添加到链接您的扩展时要使用的库列表中。

如果提供了 headers，它将在搜索 func 时包含这些头文件。

要链接的库的实际名称可以通过 --with-FOOlib 配置选项进行更改。

have_macro (macro, headers = nil, opt = "", &b)

Source

# File lib/mkmf.rb, line 1121
def have_macro(macro, headers = nil, opt = "", &b)
  checking_for checking_message(macro, headers, opt) do
    macro_defined?(macro, cpp_include(headers), opt, &b)
  end
end

返回 macro 是否在通用头文件中或您提供的任何 headers 中定义。

您传递给 opt 的任何选项都将被传递给编译器。

have_struct_member (type, member, headers = nil, opt = "", &b)

Source

# File lib/mkmf.rb, line 1326
  def have_struct_member(type, member, headers = nil, opt = "", &b)
    checking_for checking_message("#{type}.#{member}", headers) do
      if try_compile(<<"SRC", opt, &b)
#{cpp_include(headers)}
/*top*/
int s = (char *)&((#{type}*)0)->#{member} - (char *)0;
#{MAIN_DOES_NOTHING}
SRC
        $defs.push(format("-DHAVE_%s_%s", type.tr_cpp, member.tr_cpp))
        $defs.push(format("-DHAVE_ST_%s", member.tr_cpp)) # backward compatibility
        true
      else
        false
      end
    end
  end

返回结构体类型 type 是否包含 member。如果结构体不存在或找不到结构体类型，则返回 false。您可以选择指定额外的 headers 来查找结构体（除了通用头文件）。

如果找到，则通过预处理器常量将一个宏传递给编译器，该宏使用大写的类型名称和成员名称，前面加上 HAVE_。

例如，如果 have_struct_member('struct foo', 'bar') 返回 true，则 HAVE_STRUCT_FOO_BAR 预处理器宏将被传递给编译器。

为了向后兼容，还定义了 HAVE_ST_BAR。

have_var (var, headers = nil, opt = "", &b)

Source

# File lib/mkmf.rb, line 1220
def have_var(var, headers = nil, opt = "", &b)
  checking_for checking_message(var, headers, opt) do
    if try_var(var, headers, opt, &b)
      $defs.push(format("-DHAVE_%s", var.tr_cpp))
      true
    else
      false
    end
  end
end

返回是否可以在通用头文件中，或者在您提供的任何 headers 中找到变量 var。如果找到，则通过预处理器常量将一个宏传递给编译器，该宏使用大写的变量名称，前面加上 HAVE_。

要检查附加库中的变量，您需要先使用 have_library() 检查该库。

例如，如果 have_var('foo') 返回 true，则 HAVE_FOO 预处理器宏将被传递给编译器。

log_src (src, heading="checked program was")

Source

# File lib/mkmf.rb, line 472
  def log_src(src, heading="checked program was")
    src = src.split(/^/)
    fmt = "%#{src.size.to_s.size}d: %s"
    Logging::message <<"EOM"
#{heading}:
/* begin */
EOM
    src.each_with_index {|line, no| Logging::message fmt, no+1, line}
    Logging::message <<"EOM"
/* end */

EOM
  end

记录 src

modified? (target, times)

Source

# File lib/mkmf.rb, line 285
def modified?(target, times)
  (t = File.mtime(target)) rescue return nil
  Array === times or times = [times]
  t if times.all? {|n| n <= t}
end

如果 target 文件存在且比所有 times 都新或相等，则返回 target 文件的的时间戳。

pkg_config (pkg, *options)

Source

# File lib/mkmf.rb, line 1952
def pkg_config(pkg, *options)
  fmt = "not found"
  def fmt.%(x)
    x ? x.inspect : self
  end

  checking_for "pkg-config for #{pkg}", fmt do
    _, ldir = dir_config(pkg)
    if ldir
      pkg_config_path = "#{ldir}/pkgconfig"
      if File.directory?(pkg_config_path)
        Logging.message("PKG_CONFIG_PATH = %s\n", pkg_config_path)
        envs = ["PKG_CONFIG_PATH"=>[pkg_config_path, ENV["PKG_CONFIG_PATH"]].compact.join(File::PATH_SEPARATOR)]
      end
    end
    if pkgconfig = with_config("#{pkg}-config") and find_executable0(pkgconfig)
    # if and only if package specific config command is given
    elsif ($PKGCONFIG ||=
           (pkgconfig = with_config("pkg-config") {config_string("PKG_CONFIG") || ENV["PKG_CONFIG"] || "pkg-config"}) &&
           find_executable0(pkgconfig) && pkgconfig) and
         xsystem([*envs, $PKGCONFIG, "--exists", pkg])
      # default to pkg-config command
      pkgconfig = $PKGCONFIG
      args = [pkg]
    elsif find_executable0(pkgconfig = "#{pkg}-config")
    # default to package specific config command, as a last resort.
    else
      pkgconfig = nil
    end
    if pkgconfig
      get = proc {|opts|
        opts = Array(opts).map { |o| "--#{o}" }
        opts = xpopen([*envs, pkgconfig, *opts, *args], err:[:child, :out], &:read)
        Logging.open {puts opts.each_line.map{|s|"=> #{s.inspect}"}}
        if $?.success?
          opts = opts.strip
          libarg, libpath = LIBARG, LIBPATHFLAG.strip
          opts = opts.shellsplit.map { |s|
            if s.start_with?('-l')
              libarg % s[2..]
            elsif s.start_with?('-L')
              libpath % s[2..]
            else
              s
            end
          }.quote.join(" ")
          opts
        end
      }
    end
    orig_ldflags = $LDFLAGS
    if get and !options.empty?
      get[options]
    elsif get and try_ldflags(ldflags = get['libs'])
      if incflags = get['cflags-only-I']
        $INCFLAGS << " " << incflags
        cflags = get['cflags-only-other']
      else
        cflags = get['cflags']
      end
      libs = get['libs-only-l']
      if cflags
        $CFLAGS += " " << cflags
        $CXXFLAGS += " " << cflags
      end
      if libs
        ldflags = (Shellwords.shellwords(ldflags) - Shellwords.shellwords(libs)).quote.join(" ")
      else
        libs, ldflags = Shellwords.shellwords(ldflags).partition {|s| s =~ /-l([^ ]+)/ }.map {|l|l.quote.join(" ")}
      end
      $libs += " " << libs

      $LDFLAGS = [orig_ldflags, ldflags].join(' ')
      Logging::message "package configuration for %s\n", pkg
      Logging::message "incflags: %s\ncflags: %s\nldflags: %s\nlibs: %s\n\n",
                       incflags, cflags, ldflags, libs
      [[incflags, cflags].join(' '), ldflags, libs]
    else
      Logging::message "package configuration for %s is not found\n", pkg
      nil
    end
  end
end

通过使用在以下命令中首先找到的命令，返回已安装库的编译/链接信息，格式为 [cflags, ldflags, libs] 的元组

如果通过命令行选项给出了 --with-{pkg}-config={command}： {command} {options}
{pkg}-config {options}
pkg-config {options} {pkg}

其中 options 是没有连字符的选项名称，例如 "cflags" 用于 --cflags 标志。

获得的值将追加到 $INCFLAGS、$CFLAGS、$LDFLAGS 和 $libs。

如果给出了一个或多个 options 参数，则使用这些选项调用 config 命令，并返回一个剥离的输出字符串，而不修改上述任何全局值。

what_type? (type, member = nil, headers = nil, &b)

Source

# File lib/mkmf.rb, line 1624
def what_type?(type, member = nil, headers = nil, &b)
  m = "#{type}"
  var = val = "*rbcv_var_"
  func = "rbcv_func_(void)"
  if member
    m << "." << member
  else
    type, member = type.split('.', 2)
  end
  if member
    val = "(#{var}).#{member}"
  end
  prelude = [cpp_include(headers).split(/^/)]
  prelude << ["typedef #{type} rbcv_typedef_;\n",
              "extern rbcv_typedef_ *#{func};\n",
              "rbcv_typedef_ #{var};\n",
             ]
  type = "rbcv_typedef_"
  fmt = member && !(typeof = have_typeof?) ? "seems %s" : "%s"
  if typeof
    var = "*rbcv_member_"
    func = "rbcv_mem_func_(void)"
    member = nil
    type = "rbcv_mem_typedef_"
    prelude[-1] << "typedef #{typeof}(#{val}) #{type};\n"
    prelude[-1] << "extern #{type} *#{func};\n"
    prelude[-1] << "#{type} #{var};\n"
    val = var
  end
  def fmt.%(x)
    x ? super : "unknown"
  end
  checking_for checking_message(m, headers), fmt do
    if scalar_ptr_type?(type, member, prelude, &b)
      if try_static_assert("sizeof(*#{var}) == 1", prelude)
        return "string"
      end
      ptr = "*"
    elsif scalar_type?(type, member, prelude, &b)
      unless member and !typeof or try_static_assert("(#{type})-1 < 0", prelude)
        unsigned = "unsigned"
      end
      ptr = ""
    else
      next
    end
    type = UNIVERSAL_INTS.find do |t|
      pre = prelude
      unless member
        pre += [["#{unsigned} #{t} #{ptr}#{var};\n",
                 "extern #{unsigned} #{t} #{ptr}*#{func};\n"]]
      end
      try_static_assert("sizeof(#{ptr}#{val}) == sizeof(#{unsigned} #{t})", pre)
    end
    type or next
    [unsigned, type, ptr].join(" ").strip
  end
end

返回一个表示 type 的类型的字符串，或者如果 member 不是 nil，则返回 type 的 member。

with_config (config, default=nil) { |config, default| ... }

Source

# File lib/mkmf.rb, line 1767
def with_config(config, default=nil)
  config = config.sub(/^--with[-_]/, '')
  val = arg_config("--with-"+config) do
    if arg_config("--without-"+config)
      false
    elsif block_given?
      yield(config, default)
    else
      break default
    end
  end
  case val
  when "yes"
    true
  when "no"
    false
  else
    val
  end
end

测试是否存在 --with-config 或 --without-config 选项。如果给出了 with 选项，则返回 true；如果给出了 without 选项，则返回 false；否则返回默认值。

这对于添加自定义定义（例如调试信息）很有用。

示例

if with_config("debug")
   $defs.push("-DOSSL_DEBUG") unless $defs.include? "-DOSSL_DEBUG"
end

with_cppflags (flags) { || ... }

Source

# File lib/mkmf.rb, line 695
def with_cppflags(flags)
  cppflags = $CPPFLAGS
  $CPPFLAGS = flags.dup
  ret = yield
ensure
  $CPPFLAGS = cppflags unless ret
end

将 $CPPFLAGS 设置为 flags 并屈服。如果块返回假值，则 $CPPFLAGS 将重置为先前的值，否则保持为 flags。

flags: C 预处理器标志，可以是 String

xpopen (command, *mode, &block)

Source

# File lib/mkmf.rb, line 457
def xpopen command, *mode, &block
  env, commands = expand_command(command)
  command = [env_quote(env), command].join(' ')
  Logging::open do
    case mode[0]
    when nil, Hash, /^r/
      puts "#{command} |"
    else
      puts "| #{command}"
    end
    IO.popen(env, commands, *mode, &block)
  end
end

执行 command 类似于 xsystem，但屈服打开的管道。

xsystem(command, werror: false) → true or false

Source

# File lib/mkmf.rb, line 438
def xsystem(command, werror: false)
  env, command = expand_command(command)
  Logging::open do
    puts [env_quote(env), command.quote].join(' ')
    if werror
      result = nil
      Logging.postpone do |log|
        output = IO.popen(env, command, &:read)
        result = ($?.success? and File.zero?(log.path))
        output
      end
      result
    else
      system(env, *command)
    end
  end
end

执行 command 并展开变量，并返回退出状态，类似于 Kernel#system。如果 werror 为 true 且错误输出不为空，则返回 false。输出将被记录。

私有实例方法

rm_f (*files)

Source

# File lib/mkmf.rb, line 270
def rm_f(*files)
  opt = (Hash === files.last ? [files.pop] : [])
  FileUtils.rm_f(Dir[*files.flatten], *opt)
end

删除 files。

rm_rf (*files)

Source

# File lib/mkmf.rb, line 277
def rm_rf(*files)
  opt = (Hash === files.last ? [files.pop] : [])
  FileUtils.rm_rf(Dir[*files.flatten], *opt)
end

递归删除 files。