Object

 
               # File extmk.rb, line 522
def initialize(src)
  super("#{src}.c", "#{src}.#{$OBJEXT}")
end
            

 
               # File extmk.rb, line 302
def compiled?(target)
  $compiled[target]
end
            

 
               # File extmk.rb, line 120
def extmake(target)
  unless $configure_only || verbose?
    print "#{$message} #{target}\n"
    $stdout.flush
  end

  FileUtils.mkpath target unless File.directory?(target)
  begin
    dir = Dir.pwd
    FileUtils.mkpath target unless File.directory?(target)
    Dir.chdir target
    top_srcdir = $top_srcdir
    topdir = $topdir
    hdrdir = $hdrdir
    prefix = "../" * (target.count("/")+1)
    $top_srcdir = relative_from(top_srcdir, prefix)
    $hdrdir = relative_from(hdrdir, prefix)
    $topdir = prefix + $topdir
    $target = target
    $mdir = target
    $srcdir = File.join($top_srcdir, "ext", $mdir)
    $preload = nil
    $objs = []
    $srcs = []
    $compiled[target] = false
    makefile = "./Makefile"
    static = $static
    $static = nil if noinstall = File.fnmatch?("-*", target)
    ok = File.exist?(makefile)
    unless $ignore
      rbconfig0 = RbConfig::CONFIG
      mkconfig0 = CONFIG
      rbconfig = {
        "hdrdir" => $hdrdir,
        "srcdir" => $srcdir,
        "topdir" => $topdir,
      }
      mkconfig = {
        "hdrdir" => ($hdrdir == top_srcdir) ? top_srcdir : "$(top_srcdir)/include",
        "srcdir" => "$(top_srcdir)/ext/#{$mdir}",
        "topdir" => $topdir,
      }
      rbconfig0.each_pair {|key, val| rbconfig[key] ||= val.dup}
      mkconfig0.each_pair {|key, val| mkconfig[key] ||= val.dup}
      RbConfig.module_eval {
        remove_const(:CONFIG)
        const_set(:CONFIG, rbconfig)
        remove_const(:MAKEFILE_CONFIG)
        const_set(:MAKEFILE_CONFIG, mkconfig)
      }
      MakeMakefile.class_eval {
        remove_const(:CONFIG)
        const_set(:CONFIG, mkconfig)
      }
      begin
        $extconf_h = nil
        ok &&= extract_makefile(makefile)
        old_objs = $objs
        old_cleanfiles = $distcleanfiles
        conf = ["#{$srcdir}/makefile.rb", "#{$srcdir}/extconf.rb"].find {|f| File.exist?(f)}
        if (!ok || ($extconf_h && !File.exist?($extconf_h)) ||
            !(t = modified?(makefile, MTIMES)) ||
            [conf, "#{$srcdir}/depend"].any? {|f| modified?(f, [t])})
        then
          ok = false
          if $configure_only
            if verbose?
              print "#{conf}\n" if conf
            else
              print "#{$message} #{target}\n"
            end
            $stdout.flush
          end
          init_mkmf
          Logging::logfile 'mkmf.log'
          rm_f makefile
          if conf
            Logging.open do
              unless verbose?
                $stderr.reopen($stdout.reopen(@null))
              end
              load $0 = conf
            end
          else
            create_makefile(target)
          end
          $defs << "-DRUBY_EXPORT" if $static
          ok = File.exist?(makefile)
        end
      rescue SystemExit
        # ignore
      rescue => error
        ok = false
      ensure
        rm_f "conftest*"
        $0 = $PROGRAM_NAME
      end
    end
    ok &&= File.open(makefile){|f| !f.gets[DUMMY_SIGNATURE]}
    ok = yield(ok) if block_given?
    if ok
      open(makefile, "r+") do |f|
        s = f.read.sub!(/^(static:)\s.*/, '\1 all')
        f.rewind
        f.print(s)
        f.truncate(f.pos)
      end
    else
      open(makefile, "w") do |f|
        f.puts "# " + DUMMY_SIGNATURE
        f.print(*dummy_makefile(CONFIG["srcdir"]))
      end

      mess = "Failed to configure #{target}. It will not be installed.\n"
      if error
        mess = "#{error}\n#{mess}"
      end

      Logging::message(mess) if Logging.log_opened?
      print(mess)
      $stdout.flush
      return true
    end
    args = sysquote($mflags)
    unless $destdir.to_s.empty? or $mflags.defined?("DESTDIR")
      args += [sysquote("DESTDIR=" + relative_from($destdir, "../"+prefix))]
    end
    if $static and ok and !$objs.empty? and !noinstall
      args += ["static"] unless $clean
      $extlist.push [$static, target, $target, $preload]
    end
    FileUtils.rm_f(old_cleanfiles - $distcleanfiles)
    FileUtils.rm_f(old_objs - $objs)
    unless $configure_only or system($make, *args)
      $ignore or $continue or return false
    end
    $compiled[target] = true
    if $clean
      FileUtils.rm_f("mkmf.log")
      if $clean != true
        FileUtils.rm_f([makefile, $extconf_h || "extconf.h"])
      end
    end
    if $static
      $extflags ||= ""
      $extlibs ||= []
      $extpath ||= []
      unless $mswin
        $extflags = split_libs($extflags, $DLDFLAGS, $LDFLAGS).uniq.join(" ")
      end
      $extlibs = merge_libs($extlibs, split_libs($libs), split_libs($LOCAL_LIBS))
      $extpath |= $LIBPATH
    end
  ensure
    Logging::log_close
    unless $ignore
      RbConfig.module_eval {
        remove_const(:CONFIG)
        const_set(:CONFIG, rbconfig0)
        remove_const(:MAKEFILE_CONFIG)
        const_set(:MAKEFILE_CONFIG, mkconfig0)
      }
      MakeMakefile.class_eval {
        remove_const(:CONFIG)
        const_set(:CONFIG, mkconfig0)
      }
    end
    $top_srcdir = top_srcdir
    $topdir = topdir
    $hdrdir = hdrdir
    $static = static
    Dir.chdir dir
  end
  begin
    Dir.rmdir target
    target = File.dirname(target)
  rescue SystemCallError
    break
  end while true
  true
end
            

 
               # File extmk.rb, line 70
def extract_makefile(makefile, keep = true)
  m = File.read(makefile)
  if !(target = m[/^TARGET[ \t]*=[ \t]*(\S*)/, 1])
    return keep
  end
  installrb = {}
  m.scan(/^install-rb-default:.*[ \t](\S+)(?:[ \t].*)?\n\1:[ \t]*(\S+)/) {installrb[$2] = $1}
  oldrb = installrb.keys.sort
  newrb = install_rb(nil, "").collect {|d, *f| f}.flatten.sort
  if target_prefix = m[/^target_prefix[ \t]*=[ \t]*\/(.*)/, 1]
    target = "#{target_prefix}/#{target}"
  end
  unless oldrb == newrb
    if $extout
      newrb.each {|f| installrb.delete(f)}
      unless installrb.empty?
        config = CONFIG.dup
        install_dirs(target_prefix).each {|var, val| config[var] = val}
        FileUtils.rm_f(installrb.values.collect {|f| RbConfig.expand(f, config)},
                       :verbose => verbose?)
      end
    end
    return false
  end
  srcs = Dir[File.join($srcdir, "*.{#{SRC_EXT.join(%q{,})}}")].map {|fn| File.basename(fn)}.sort
  if !srcs.empty?
    old_srcs = m[/^ORIG_SRCS[ \t]*=[ \t](.*)/, 1] or return false
    old_srcs.split.sort == srcs or return false
  end
  $target = target
  $extconf_h = m[/^RUBY_EXTCONF_H[ \t]*=[ \t]*(\S+)/, 1]
  if $static.nil?
    $static ||= m[/^EXTSTATIC[ \t]*=[ \t]*(\S+)/, 1] || false
    /^STATIC_LIB[ \t]*=[ \t]*\S+/ =~ m or $static = false
  end
  $preload = Shellwords.shellwords(m[/^preload[ \t]*=[ \t]*(.*)/, 1] || "")
  $DLDFLAGS += " " + (m[/^dldflags[ \t]*=[ \t]*(.*)/, 1] || "")
  if s = m[/^LIBS[ \t]*=[ \t]*(.*)/, 1]
    s.sub!(/^#{Regexp.quote($LIBRUBYARG)} */, "")
    s.sub!(/ *#{Regexp.quote($LIBS)}$/, "")
    $libs = s
  end
  $objs = (m[/^OBJS[ \t]*=[ \t](.*)/, 1] || "").split
  $srcs = (m[/^SRCS[ \t]*=[ \t](.*)/, 1] || "").split
  $distcleanfiles = (m[/^DISTCLEANFILES[ \t]*=[ \t](.*)/, 1] || "").split
  $LOCAL_LIBS = m[/^LOCAL_LIBS[ \t]*=[ \t]*(.*)/, 1] || ""
  $LIBPATH = Shellwords.shellwords(m[/^libpath[ \t]*=[ \t]*(.*)/, 1] || "") - %w[$(libdir) $(topdir)]
  true
end
            

 
               # File extmk.rb, line 306
def parse_args()
  $mflags = []
  $makeflags = [] # for make command to build ruby, so quoted

  $optparser ||= OptionParser.new do |opts|
    opts.on('-n') {$dryrun = true}
    opts.on('--[no-]extension [EXTS]', Array) do |v|
      $extension = (v == false ? [] : v)
    end
    opts.on('--[no-]extstatic [STATIC]', Array) do |v|
      if ($extstatic = v) == false
        $extstatic = []
      elsif v
        $force_static = true if $extstatic.delete("static")
        $extstatic = nil if $extstatic.empty?
      end
    end
    opts.on('--dest-dir=DIR') do |v|
      $destdir = v
    end
    opts.on('--extout=DIR') do |v|
      $extout = (v unless v.empty?)
    end
    opts.on('--make=MAKE') do |v|
      $make = v || 'make'
    end
    opts.on('--make-flags=FLAGS', '--mflags', Shellwords) do |v|
      v.grep(/\A([-\w]+)=(.*)/) {$configure_args["--#{$1}"] = $2}
      if arg = v.first
        arg.insert(0, '-') if /\A[^-][^=]*\Z/ =~ arg
      end
      $makeflags.concat(v.reject {|arg2| /\AMINIRUBY=/ =~ arg2}.quote)
      $mflags.concat(v)
    end
    opts.on('--message [MESSAGE]', String) do |v|
      $message = v
    end
    opts.on('--command-output=FILE', String) do |v|
      $command_output = v
    end
  end
  begin
    $optparser.parse!(ARGV)
  rescue OptionParser::InvalidOption => e
    retry if /^--/ =~ e.args[0]
    $optparser.warn(e)
    abort $optparser.to_s
  end

  $destdir ||= ''

  $make, *rest = Shellwords.shellwords($make)
  $mflags.unshift(*rest) unless rest.empty?

  def $mflags.set?(flag)
    grep(/\A-(?!-).*#{flag.chr}/) { return true }
    false
  end
  def $mflags.defined?(var)
    grep(/\A#{var}=(.*)/) {return $1}
    false
  end

  if $mflags.set?(n)
    $dryrun = true
  else
    $mflags.unshift '-n' if $dryrun
  end

  $continue = $mflags.set?(k)
  if $extout
    $extout = '$(topdir)/'+$extout
    RbConfig::CONFIG["extout"] = CONFIG["extout"] = $extout
    $extout_prefix = $extout ? "$(extout)$(target_prefix)/" : ""
    $mflags << "extout=#$extout" << "extout_prefix=#$extout_prefix"
  end
end
            

 
               # File extmk.rb, line 50
def sysquote(x)
  @quote ||= /os2/ =~ (CROSS_COMPILING || RUBY_PLATFORM)
  @quote ? x.quote : x
end
            

 
               # File extmk.rb, line 59
def system(*args)
  if verbose?
    if args.size == 1
      puts args
    else
      puts Shellwords.join(args)
    end
  end
  super
end
            

 
               # File extmk.rb, line 55
def verbose?
  $mflags.defined?("V") == "1"
end