# mkmf.rb

Path: | mkmf.rb
Last Update: | Thu Dec 04 21:22:53 GMT+10:00 2003

module to create Makefile for extension modules invoke like: ruby -r mkmf extconf.rb

## Required files

rbconfig fileutils shellwords

## Methods

append_library arg_config cc_command check_sizeof checking_for config_string configuration cpp_command cpp_include create_header create_makefile create_tmpsrc dir_config dir_re dummy_makefile egrep_cpp enable_config find_executable find_executable0 find_library have_func have_header have_library have_struct_member have_type init_mkmf install_files install_rb libpathflag link_command log_src macro_defined? map_dir message modified? pkg_config rm_f try_compile try_constant try_cpp try_do try_func try_link try_link0 try_run try_static_assert winsep with_config with_destdir xpopen xsystem

## Constants

CONFIG | = | Config::MAKEFILE_CONFIG
ORIG_LIBPATH | = | ENV['LIB']
SRC_EXT | = | ["c", "cc", "m", "cxx", "cpp", "C"]
INSTALL_DIRS | = | [ [dir_re('commondir'), "$(RUBYCOMMONDIR)"], [dir_re("sitedir"), "$(RUBYCOMMONDIR)"], [dir_re('rubylibdir'), "$(RUBYLIBDIR)"], [dir_re('archdir'), "$(RUBYARCHDIR)"], [dir_re('sitelibdir'), "$(RUBYLIBDIR)"], [dir_re('sitearchdir'), "$(RUBYARCHDIR)"]
OUTFLAG | = | CONFIG['OUTFLAG']
CPPOUTFILE | = | CONFIG['CPPOUTFILE']
CONFTEST_C | = | "conftest.c"
EXPORT_PREFIX | = | config_string('EXPORT_PREFIX') {|s| s.strip}
COMMON_HEADERS | = | (hdr.join("\n") unless hdr.empty?)
COMMON_LIBS | = | config_string('COMMON_LIBS', &split) || []
COMPILE_RULES | = | config_string('COMPILE_RULES', &split) || %w[.%s.%s:]
COMPILE_C | = | config_string('COMPILE_C') || '$(CC) $(CFLAGS) $(CPPFLAGS) -c $<'
COMPILE_CXX | = | config_string('COMPILE_CXX') || '$(CXX) $(CXXFLAGS) $(CPPFLAGS) -c $<'
TRY_LINK | = | config_string('TRY_LINK') || "$(CC) #{OUTFLAG}conftest $(INCFLAGS) -I$(hdrdir) $(CPPFLAGS) " \
LINK_SO | = | config_string('LINK_SO') || if CONFIG["DLEXT"] == $OBJEXT

## Classes and Modules

Module Logging
Class Array
Class String

## Public Instance methods

config_string(key, config = CONFIG) {|s| ...}

[Source]

    # File mkmf.rb, line 58
    def config_string(key, config = CONFIG)
      s = config[key] and !s.empty? and block_given? ? yield(s) : s
    end

dir_re(dir)

[Source]

    # File mkmf.rb, line 62
    def dir_re(dir)
      Regexp.new('\$(?:\('+dir+'\)|\{'+dir+'\})(?:\$\(target_prefix\)|\{target_prefix\})?')
    end

map_dir(dir, map = nil)

[Source]

    # File mkmf.rb, line 75
    def map_dir(dir, map = nil)
      map ||= INSTALL_DIRS
      map.inject(dir) {|dir, (orig, new)| dir.gsub(orig, new)}
    end

rm_f(*files)

[Source]

    # File mkmf.rb, line 106
    def rm_f(*files)
      FileUtils.rm_f(Dir[files.join("\0")])
    end

modified?(target, times)

[Source]

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

xsystem(command)

[Source]

    # File mkmf.rb, line 165
    def xsystem command
      Config.expand(command)
      Logging::open do
        puts command.quote
        system(command)
      end
    end

xpopen(command, *mode, &block)

[Source]

    # File mkmf.rb, line 173
    def xpopen command, *mode, &block
      Config.expand(command)
      Logging::open do
        case mode[0]
        when nil, /^r/
          puts "#{command} |"
        else
          puts "| #{command}"
        end
        IO.popen(command, *mode, &block)
      end
    end

log_src(src)

[Source]

    # File mkmf.rb, line 186
    def log_src(src)
      Logging::message "checked program was:\n/* begin */\n%s/* end */\n\n", src
    end

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

[Source]

    # File mkmf.rb, line 196
    def create_tmpsrc(src)
      src = yield(src) if block_given?
      src = src.sub(/[^\n]\z/, "\\&\n")
      open(CONFTEST_C, "w") do |cfile|
        cfile.print src
      end
      src
    end

try_do(src, command, &b)

[Source]

    # File mkmf.rb, line 205
    def try_do(src, command, &b)
      src = create_tmpsrc(src, &b)
      xsystem(command)
    ensure
      log_src(src)
    end

link_command(ldflags, opt="", libpath=$LIBPATH)

[Source]

    # File mkmf.rb, line 212
    def link_command(ldflags, opt="", libpath=$LIBPATH)
      Config::expand(TRY_LINK.dup,
                     'hdrdir' => $hdrdir,
                     'src' => CONFTEST_C,
                     'INCFLAGS' => $INCFLAGS,
                     'CPPFLAGS' => $CPPFLAGS,
                     'CFLAGS' => "#$CFLAGS",
                     'ARCH_FLAG' => "#$ARCH_FLAG",
                     'LDFLAGS' => "#$LDFLAGS #{ldflags}",
                     'DLDFLAGS' => "#$DLDFLAGS",
                     'LIBPATH' => libpathflag(libpath),
                     'LOCAL_LIBS' => "#$LOCAL_LIBS #$libs",
                     'LIBS' => "#$LIBRUBYARG_STATIC #{opt} #$LIBS")
    end

cc_command(opt="")

[Source]

    # File mkmf.rb, line 227
    def cc_command(opt="")
      "$(CC) -c #$INCFLAGS -I#{$hdrdir} " \
      "#$CPPFLAGS #$CFLAGS #$ARCH_FLAG #{opt} #{CONFTEST_C}"
    end

cpp_command(outfile, opt="")

[Source]

    # File mkmf.rb, line 232
    def cpp_command(outfile, opt="")
      "$(CPP) #$INCFLAGS -I#{$hdrdir} " \
      "#$CPPFLAGS #$CFLAGS #{opt} #{CONFTEST_C} #{outfile}"
    end

libpathflag(libpath=$LIBPATH)

[Source]

    # File mkmf.rb, line 237
    def libpathflag(libpath=$LIBPATH)
      libpath.map{|x|
        (x == "$(topdir)" ? LIBPATHFLAG : LIBPATHFLAG+RPATHFLAG) % %["#{x}"]
      }.join
    end

try_link0(src, opt="", &b)

[Source]

    # File mkmf.rb, line 243
    def try_link0(src, opt="", &b)
      try_do(src, link_command("", opt), &b)
    end

try_link(src, opt="", &b)

[Source]

    # File mkmf.rb, line 247
    def try_link(src, opt="", &b)
      try_link0(src, opt, &b)
    ensure
      rm_f "conftest*", "c0x32*"
    end

try_compile(src, opt="", &b)

[Source]

    # File mkmf.rb, line 253
    def try_compile(src, opt="", &b)
      try_do(src, cc_command(opt), &b)
    ensure
      rm_f "conftest*"
    end

try_cpp(src, opt="", &b)

[Source]

    # File mkmf.rb, line 259
    def try_cpp(src, opt="", &b)
      try_do(src, cpp_command(CPPOUTFILE, opt), &b)
    ensure
      rm_f "conftest*"
    end

cpp_include(header)

[Source]

    # File mkmf.rb, line 265
    def cpp_include(header)
      if header
        header = [header] unless header.kind_of? Array
        header.map {|h| "#include <#{h}>\n"}.join
      else
        ""
      end
    end

try_static_assert(expr, headers = nil, opt = "", &b)

[Source]

    # File mkmf.rb, line 274
    def try_static_assert(expr, headers = nil, opt = "", &b)
      headers = cpp_include(headers)
      try_compile("\#{COMMON_HEADERS}\n\#{headers}\n/*top*/\nint tmp[(\#{expr}) ? 1 : -1];\n", opt, &b)
    end

try_constant(const, headers = nil, opt = "", &b)

[Source]

    # File mkmf.rb, line 285
    def try_constant(const, headers = nil, opt = "", &b)
      headers = cpp_include(headers)
      if CROSS_COMPILING
        unless try_compile("\#{COMMON_HEADERS}\n\#{headers}\n/*top*/\nint tmp = \#{const};\n", opt, &b)
          return nil
        end
        if try_static_assert("#{const} < 0", headers, opt)
          neg = true
          const = "-(#{const})"
        elsif try_static_assert("#{const} == 0", headers, opt)
          return 0
        end
        upper = 1
        until try_static_assert("#{const} < #{upper}", headers, opt)
          lower = upper
          upper <<= 1
        end
        return nil unless lower
        until try_static_assert("#{const} == #{upper}", headers, opt)
          if try_static_assert("#{const} > #{(upper+lower)/2}", headers, opt)
            lower = (upper+lower)/2
          else
            upper = (upper+lower)/2
          end
        end
        upper = -upper if neg
        return upper
      else
        src = %{#{COMMON_HEADERS}
    #{headers}
    #include <stdio.h>
    /*top*/
    int main() {printf("%d\\n", (int)(#{const})); return 0;}
    }
        if try_link0(src, opt, &b)
          xpopen("./conftest") do |f|
            return Integer(f.gets)
          end
        end
      end
      nil
    end

try_func(func, libs, headers = nil, &b)

[Source]

    # File mkmf.rb, line 334
    def try_func(func, libs, headers = nil, &b)
      headers = cpp_include(headers)
      try_link("\#{headers}\n/*top*/\nint main() { return 0; }\nint t() { \#{func}(); return 0; }\n", libs, &b) or try_link("\#{COMMON_HEADERS}\n\#{headers}\n/*top*/\nint main() { return 0; }\nint t() { void ((*volatile p)()); p = (void ((*)()))\#{func}; return 0; }\n", libs, &b)
    end

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

[Source]

    # File mkmf.rb, line 352
    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
      rm_f "conftest*"
      log_src(src)
    end

macro_defined?(macro, src, opt = "", &b)

[Source]

    # File mkmf.rb, line 378
    def macro_defined?(macro, src, opt = "", &b)
      src = src.sub(/[^\n]\z/, "\\&\n")
      try_cpp(src + "/*top*/\n\#ifndef \#{macro}\n\# error\n\#endif\n", opt, &b)
    end

try_run(src, opt = "", &b)

[Source]

    # File mkmf.rb, line 389
    def try_run(src, opt = "", &b)
      if try_link0(src, opt, &b)
        xsystem("./conftest")
      else
        nil
      end
    ensure
      rm_f "conftest*"
    end

install_files(mfile, ifiles, map = nil, srcprefix = nil)

[Source]

    # File mkmf.rb, line 399
    def install_files(mfile, ifiles, map = nil, srcprefix = nil)
      ifiles or return
      srcprefix ||= '$(srcdir)'
      Config::expand(srcdir = srcprefix.dup)
      dirs = []
      path = Hash.new {|h, i| h[i] = dirs.push([i])[-1]}
      ifiles.each do |files, dir, prefix|
        dir = map_dir(dir, map)
        prefix = %|\A#{Regexp.quote(prefix)}/?| if prefix
        if( files[0,2] == "./" )
          # install files which are in current working directory.

          files = files[2..-1]
          len = nil
        else
          # install files which are under the $(srcdir).

          files = File.join(srcdir, files)
          len = srcdir.size
        end
        f = nil
        Dir.glob(files) do |f|
          f[0..len] = "" if len
          d = File.dirname(f)
          d.sub!(prefix, "") if prefix
          d = (d.empty? || d == ".") ? dir : File.join(dir, d)
          f = File.join(srcprefix, f) if len
          path[d] << f
        end
        unless len or f
          d = File.dirname(files)
          d.sub!(prefix, "") if prefix
          d = (d.empty? || d == ".") ? dir : File.join(dir, d)
          path[d] << files
        end
      end
      dirs
    end

install_rb(mfile, dest, srcdir = nil)

[Source]

    # File mkmf.rb, line 436
    def install_rb(mfile, dest, srcdir = nil)
      install_files(mfile, [["lib/**/*.rb", dest, "lib"]], nil, srcdir)
    end

append_library(libs, lib)

[Source]

    # File mkmf.rb, line 440
    def append_library(libs, lib)
      format(LIBARG, lib) + " " + libs
    end

message(*s)

[Source]

    # File mkmf.rb, line 444
    def message(*s)
      unless $extmk and not $VERBOSE
        printf(*s)
        $stdout.flush
      end
    end

checking_for(m) {|| ...}

[Source]

    # File mkmf.rb, line 451
    def checking_for(m)
      f = caller[0][/in `(.*)'$/, 1] and f << ": " #` for vim

      m = "checking for #{m}... "
      message "%s", m
      a = r = nil
      Logging::postpone do
        r = yield
        a = r ? "yes\n" : "no\n"
        "#{f}#{m}-------------------- #{a}\n"
      end
      message(a)
      Logging::message "--------------------\n\n"
      r
    end

have_library(lib, func = nil, &b)

[Source]

    # File mkmf.rb, line 466
    def have_library(lib, func = nil, &b)
      func = "main" if !func or func.empty?
      lib = with_config(lib+'lib', lib)
      checking_for "#{func}() in #{LIBARG%lib}" do
        if COMMON_LIBS.include?(lib)
          true
        else
          libs = append_library($libs, lib)
          if try_func(func, libs, &b)
            $libs = libs
            true
          else
            false
          end
        end
      end
    end

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

[Source]

    # File mkmf.rb, line 484
    def find_library(lib, func, *paths, &b)
      func = "main" if !func or func.empty?
      lib = with_config(lib+'lib', lib)
      checking_for "#{func}() in #{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

have_func(func, headers = nil, &b)

[Source]

    # File mkmf.rb, line 505
    def have_func(func, headers = nil, &b)
      checking_for "#{func}()" do
        if try_func(func, $libs, headers, &b)
          $defs.push(format("-DHAVE_%s", func.upcase))
          true
        else
          false
        end
      end
    end

have_header(header, &b)

[Source]

    # File mkmf.rb, line 516
    def have_header(header, &b)
      checking_for header do
        if try_cpp(cpp_include(header), &b)
          $defs.push(format("-DHAVE_%s", header.tr("a-z./\055", "A-Z___")))
          true
        else
          false
        end
      end
    end

have_struct_member(type, member, header = nil, &b)

[Source]

    # File mkmf.rb, line 527
    def have_struct_member(type, member, header = nil, &b)
      checking_for "#{type}.#{member}" do
        if try_compile("\#{COMMON_HEADERS}\n\#{cpp_include(header)}\n/*top*/\nint main() { return 0; }\nint s = (char *)&((\#{type}*)0)->\#{member} - (char *)0;\n", &b)
          $defs.push(format("-DHAVE_ST_%s", member.upcase))
          true
        else
          false
        end
      end
    end

have_type(type, header = nil, opt = "", &b)

[Source]

    # File mkmf.rb, line 545
    def have_type(type, header = nil, opt = "", &b)
      checking_for type do
        header = cpp_include(header)
        if try_compile("\#{COMMON_HEADERS}\n\#{header}\n/*top*/\nstatic \#{type} t;\n", opt, &b) or try_compile("\#{COMMON_HEADERS}\n\#{header}\n/*top*/\nstatic \#{type} *t;\n", opt, &b)
          $defs.push(format("-DHAVE_TYPE_%s", type.upcase))
          true
        else
          false
        end
      end
    end

check_sizeof(type, header = nil, &b)

[Source]

    # File mkmf.rb, line 569
    def check_sizeof(type, header = nil, &b)
      expr = "sizeof(#{type})"
      m = "checking size of #{type}... "
      message "%s", m
      Logging::message "check_sizeof: %s--------------------\n", m
      if size = try_constant(expr, header, &b)
        $defs.push(format("-DSIZEOF_%s", type.upcase))
      end
      message(a = size ? "#{size}\n" : "failed\n")
      Logging::message "-------------------- %s\n", a
      r
    end

find_executable0(bin, path = nil)

[Source]

    # File mkmf.rb, line 582
    def find_executable0(bin, path = nil)
      path = (path || ENV['PATH']).split(File::PATH_SEPARATOR)
      ext = config_string('EXEEXT')
      file = nil
      path.each do |dir|
        return file if File.executable?(file = File.join(dir, bin))
        return file if ext and File.executable?(file << ext)
      end
      nil
    end

find_executable(bin, path = nil)

[Source]

    # File mkmf.rb, line 593
    def find_executable(bin, path = nil)
      checking_for bin do
        find_executable0(bin, path)
      end
    end

arg_config(config, default=nil)

[Source]

    # File mkmf.rb, line 599
    def arg_config(config, default=nil)
      $configure_args.fetch(config, default)
    end

with_config(config, default=nil)

[Source]

    # File mkmf.rb, line 603
    def with_config(config, default=nil)
      unless /^--with-/ =~ config
        config = '--with-' + config
      end
      arg_config(config, default)
    end

enable_config(config, default=nil)

[Source]

    # File mkmf.rb, line 610
    def enable_config(config, default=nil)
      if arg_config("--enable-"+config)
        true
      elsif arg_config("--disable-"+config)
        false
      else
        default
      end
    end

create_header(header = "extconf.h")

[Source]

    # File mkmf.rb, line 620
    def create_header(header = "extconf.h")
      message "creating %s\n", header
      if $defs.length > 0
        sym = header.tr("a-z./\055", "A-Z___")
        open(header, "w") do |hfile|
          hfile.print "#ifndef #{sym}\n#define #{sym}\n"
          for line in $defs
            case line
            when /^-D(.*)(?:=(.*))?/
              hfile.print "#define #$1 #{$2 || 1}\n"
            when /^-U(.*)/
              hfile.print "#undef #$1\n"
            end
          end
          hfile.print "#endif\n"
        end
      end
    end

dir_config(target, idefault=nil, ldefault=nil)

[Source]

    # File mkmf.rb, line 639
    def dir_config(target, idefault=nil, ldefault=nil)
      if dir = with_config(target + "-dir", (idefault unless ldefault))
        defaults = dir.split(File::PATH_SEPARATOR)
        idefault = ldefault = nil
      end

      idir = with_config(target + "-include", idefault)
      ldir = with_config(target + "-lib", ldefault)

    #  idirs = idir ? idir.split(File::PATH_SEPARATOR) : []

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

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

      [idir, ldir]
    end

pkg_config(pkg)

[Source]

    # File mkmf.rb, line 672
    def pkg_config(pkg)
      unless defined?($PKGCONFIG)
        if pkgconfig = with_config("pkg-config", !CROSS_COMPILING && "pkg-config")
          find_executable0(pkgconfig) or pkgconfig = nil
        end
        $PKGCONFIG = pkgconfig
      end
      if $PKGCONFIG and system("#{$PKGCONFIG} --exists #{pkg}")
        cflags = `#{$PKGCONFIG} --cflags #{pkg}`.chomp
        ldflags = `#{$PKGCONFIG} --libs #{pkg}`.chomp
        libs = `#{$PKGCONFIG} --libs-only-l #{pkg}`.chomp
        ldflags = (Shellwords.shellwords(ldflags) - Shellwords.shellwords(libs)).quote.join(" ")
        $CFLAGS += " " << cflags
        $LDFLAGS += " " << ldflags
        $libs += " " << libs
        Logging::message "package configuration for %s\n", pkg
        Logging::message "cflags: %s\nldflags: %s\nlibs: %s\n\n",
                         cflags, ldflags, libs
        [cflags, ldflags, libs]
      end
    end

with_destdir(dir)

[Source]

    # File mkmf.rb, line 694
    def with_destdir(dir)
      /^\$[\(\{]/ =~ dir ? dir : "$(DESTDIR)"+dir
    end

winsep(s)

[Source]

    # File mkmf.rb, line 698
    def winsep(s)
      s.tr('/', '\\')
    end

configuration(srcdir)

[Source]

    # File mkmf.rb, line 702
    def configuration(srcdir)
      mk = []
      mk << %{
    SHELL = /bin/sh

    #### Start of system configuration section. ####

    srcdir = #{srcdir}
    topdir = #{$topdir}
    hdrdir = #{$hdrdir}
    VPATH = #{$mingw && CONFIG['build_os'] == 'cygwin' ? '$(shell cygpath -u $(srcdir))' : '$(srcdir)'}
    }
      drive = File::PATH_SEPARATOR == ';' ? /\A\w:/ : /\A/
      if destdir = CONFIG["prefix"].scan(drive)[0] and !destdir.empty?
        mk << "\nDESTDIR = #{destdir}\n"
      end
      CONFIG.each do |key, var|
        next unless /prefix$/ =~ key
        mk << "#{key} = #{with_destdir(var.sub(drive, ''))}\n"
      end
      CONFIG.each do |key, var|
        next if /^abs_/ =~ key
        next unless /^(?:src|top|(.*))dir$/ =~ key and $1
        mk << "#{key} = #{with_destdir(var.sub(drive, ''))}\n"
      end
      mk << %{
    CC = #{CONFIG['CC']}
    LIBRUBY = #{CONFIG['LIBRUBY']}
    LIBRUBY_A = #{CONFIG['LIBRUBY_A']}
    LIBRUBYARG_SHARED = #$LIBRUBYARG_SHARED
    LIBRUBYARG_STATIC = #$LIBRUBYARG_STATIC

    CFLAGS   = #{CONFIG['CCDLFLAGS'] unless $static} #$CFLAGS #$ARCH_FLAG
    CPPFLAGS = -I. -I$(topdir) -I$(hdrdir) -I$(srcdir) #{$defs.join(" ")} #{$CPPFLAGS}
    CXXFLAGS = $(CFLAGS) #{CONFIG['CXXFLAGS']}
    DLDFLAGS = #$LDFLAGS #$DLDFLAGS #$ARCH_FLAG
    LDSHARED = #{CONFIG['LDSHARED']}
    AR = #{CONFIG['AR']}
    EXEEXT = #{CONFIG['EXEEXT']}

    RUBY_INSTALL_NAME = #{CONFIG['RUBY_INSTALL_NAME']}
    RUBY_SO_NAME = #{CONFIG['RUBY_SO_NAME']}
    arch = #{CONFIG['arch']}
    sitearch = #{CONFIG['sitearch']}
    ruby_version = #{Config::CONFIG['ruby_version']}
    RUBY = #{$ruby}
    RM = $(RUBY) -run -e rm -- -f
    MAKEDIRS = $(RUBY) -run -e mkdir -- -p
    INSTALL_PROG = $(RUBY) -run -e install -- -vpm 0755
    INSTALL_DATA = $(RUBY) -run -e install -- -vpm 0644

    #### End of system configuration section. ####

    }
      if $nmake == ?b
        mk.each do |x|
          x.gsub!(/^(MAKEDIRS|INSTALL_(?:PROG|DATA))+\s*=.*\n/) do
            "!ifndef " + $1 + "\n" +
            $& +
            "!endif\n"
          end
        end
      end
      mk
    end

dummy_makefile(srcdir)

[Source]

    # File mkmf.rb, line 768
    def dummy_makefile(srcdir)
      configuration(srcdir) << "all install: Makefile\n" << CLEANINGS
    end

create_makefile(target, srcprefix = nil)

[Source]

    # File mkmf.rb, line 772
    def create_makefile(target, srcprefix = nil)
      $target = target
      libpath = $LIBPATH
      message "creating Makefile\n"
      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)'
      Config::expand(srcdir = srcprefix.dup)

      unless $objs then
        $objs = []
        for f in Dir[File.join(srcdir, "*.{#{SRC_EXT.join(%q{,})}}")]
          $objs.push(File.basename(f, ".*") << "." << $OBJEXT)
        end
      else
        for i in $objs
          i.sub!(/\.o\z/, ".#{$OBJEXT}")
        end
      end
      $objs = $objs.join(" ")

      target = nil if $objs == ""

      if target and EXPORT_PREFIX
        origdef = target + '.def'
        deffile = EXPORT_PREFIX + origdef
        unless File.exist? deffile
          if File.exist? File.join(srcdir, deffile)
            deffile = File.join(srcdir, deffile)
          elsif !EXPORT_PREFIX.empty? and File.exist?(origdef = File.join(srcdir, origdef))
            open(origdef) do |d|
              open(deffile, 'wb') do |f|
                d.each do |l|
                  f.print l
                  break if /^EXPORTS$/i =~ l
                end
                d.each do |l|
                  f.print l.sub(/\S/, EXPORT_PREFIX+'\&')
                end
              end
            end
          else
            open(deffile, 'wb') do |f|
              f.print "EXPORTS\n", EXPORT_PREFIX, "Init_", target, "\n"
            end
          end
        end
        $distcleanfiles << deffile unless deffile == origdef
      end

      libpath = libpathflag(libpath)

      dllib = target ? "$(TARGET).#{CONFIG['DLEXT']}" : ""
      staticlib = target ? "$(TARGET).#$LIBEXT" : ""
      mfile = open("Makefile", "wb")
      mfile.print configuration(srcdir)
      mfile.print %{
    LIBPATH = #{libpath}
    DEFFILE = #{deffile}

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

    target_prefix = #{target_prefix}
    LOCAL_LIBS = #{$LOCAL_LIBS}
    LIBS = #{$LIBRUBYARG} #{$libs} #{$LIBS}
    OBJS = #{$objs}
    TARGET = #{target}
    DLLIB = #{dllib}
    STATIC_LIB = #{staticlib}
    }
      if $extmk
        mfile.print %{
    RUBYCOMMONDIR = $(rubylibdir)
    RUBYLIBDIR    = $(rubylibdir)$(target_prefix)
    RUBYARCHDIR   = $(archdir)$(target_prefix)
    }
      else
        mfile.print %{
    RUBYCOMMONDIR = $(sitedir)$(target_prefix)
    RUBYLIBDIR    = $(sitelibdir)$(target_prefix)
    RUBYARCHDIR   = $(sitearchdir)$(target_prefix)
    }
      end
      mfile.print %{
    CLEANLIBS     = "$(TARGET).{lib,exp,il?,tds,map}" $(DLLIB)
    CLEANOBJS     = "*.{#{$OBJEXT},#{$LIBEXT},s[ol],pdb,bak}"

    all:            #{target ? "$(DLLIB)" : "Makefile"}
    static:         $(STATIC_LIB)
    }
      mfile.print CLEANINGS
      dirs = []
      if not $static and target
        dirs << (dir = "$(RUBYARCHDIR)")
        mfile.print("install: #{dir}\n")
        f = "$(DLLIB)"
        dest = "#{dir}/#{f}"
        mfile.print "install: #{dest}\n"
        mfile.print "#{dest}: #{f} #{dir}\n\t@$(INSTALL_PROG) #{f} #{dir}\n"
      end
      for i in [[["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("install: #{dir}\n")
          end
          files.each do |f|
            dest = "#{dir}/#{File.basename(f)}"
            mfile.print("install: #{dest}\n")
            mfile.print("#{dest}: #{f} #{dir}\n\t@$(INSTALL_DATA) #{f} #{dir}\n")
          end
        end
      end
      if dirs.empty?
        mfile.print("install:\n")
      else
        dirs.each {|dir| mfile.print "#{dir}:\n\t@$(MAKEDIRS) #{dir}\n"}
      end

      mfile.print "\nsite-install: install\n\n"

      return unless target

      mfile.print ".SUFFIXES: .#{SRC_EXT.join(' .')} .#{$OBJEXT}\n"
      mfile.print "\n"

      %[cc cpp cxx C].each do |ext|
        COMPILE_RULES.each do |rule|
          mfile.printf(rule, ext, $OBJEXT)
          mfile.printf("\n\t%s\n\n", COMPILE_CXX)
        end
      end
      %[c].each do |ext|
        COMPILE_RULES.each do |rule|
          mfile.printf(rule, ext, $OBJEXT)
          mfile.printf("\n\t%s\n\n", COMPILE_C)
        end
      end

      mfile.print "$(DLLIB): $(OBJS)\n\t"
      mfile.print "@-$(RM) $@\n\t"
      mfile.print "@-$(RM) $(TARGET).lib\n\t" if $mswin
      mfile.print LINK_SO, "\n\n"
      mfile.print "$(STATIC_LIB): $(OBJS)\n\t"
      mfile.print "$(AR) #{config_string('ARFLAGS') || 'cru '}$@ $(OBJS)"
      if ranlib = config_string('RANLIB')
        mfile.print "\n\t@-#{ranlib} $(DLLIB) 2> /dev/null || true"
      end
      mfile.print "\n\n"

      depend = File.join(srcdir, "depend")
      if File.exist?(depend)
        open(depend, "r") do |dfile|
          mfile.printf "###\n"
          while line = dfile.gets()
            line.gsub!(/\.o\b/, ".#{$OBJEXT}")
            line.gsub!(/(\s)([^\s\/]+\.[ch])/, '\1{$(srcdir)}\2') if $nmake
            line.gsub!(/\$\(hdrdir\)\/config.h/, $config_h) if $config_h
            mfile.print line
          end
        end
      end
    ensure
      mfile.close if mfile
    end

init_mkmf(config = CONFIG)

[Source]

    # File mkmf.rb, line 953
    def init_mkmf(config = CONFIG)
      $enable_shared = config['ENABLE_SHARED'] == 'yes'
      $defs = []
      $CFLAGS = with_config("cflags", arg_config("CFLAGS", config["CFLAGS"])).dup
      $ARCH_FLAG = with_config("arch_flag", arg_config("ARCH_FLAG", config["ARCH_FLAG"])).dup
      $CPPFLAGS = with_config("cppflags", arg_config("CPPFLAGS", config["CPPFLAGS"])).dup
      $LDFLAGS = (with_config("ldflags") || "").dup
      $INCFLAGS = "-I#{$topdir}"
      $DLDFLAGS = with_config("dldflags", arg_config("DLDFLAGS", config["DLDFLAGS"])).dup
      $LIBEXT = config['LIBEXT'].dup
      $OBJEXT = config["OBJEXT"].dup
      $LIBS = "#{config['LIBS']} #{config['DLDLIBS']}"
      $LIBRUBYARG = ""
      $LIBRUBYARG_STATIC = config['LIBRUBYARG_STATIC']
      $LIBRUBYARG_SHARED = config['LIBRUBYARG_SHARED']
      $LIBPATH = CROSS_COMPILING ? [] : ["$(libdir)"]
      $LIBPATH.unshift("$(topdir)") if $extmk
      $INSTALLFILES = nil

      $objs = nil
      $libs = ""
      if $enable_shared or Config.expand(config["LIBRUBY"].dup) != Config.expand(config["LIBRUBY_A"].dup)
        $LIBRUBYARG = config['LIBRUBYARG']
      end

      $LOCAL_LIBS = ""

      $cleanfiles = []
      $distcleanfiles = []

      dir_config("opt")
    end

[Validate]