tioga 1.11 → 1.13

data/split/mkmf2.rb

@@ -1,1623 +0,0 @@
-require 'rbconfig'
-require 'fileutils'
-
-# some global variables: 
-$LOCAL_LIBS = ""
-
-# A string extension from old mkmf.rb
-class String
-  def quote
-    /\s/ =~ self ? "\"#{self}\"" : self
-  end
-
-  # and a new function, that can come in useful in several places:
-  def sanitize
-    return self.tr("a-z./\055", "A-Z___")
-  end
-end
-
-# An array extension from old mkmf.rb
-class Array
-  def quote
-    map {|s| s.quote}
-  end
-end
-
-
-=begin rdoc
-:title: Mkmf2: a better replacement for mkmf
-=end 
-
-=begin rdoc
-
-=Mkmf2: a drop-in replacement for mkmf
-
-Mkmf2 aims at replacing the functionnality of the old mkmf, with a better and
-cleaner code. It hopefully will keep all the previous mkmf files working,
-while providing 
-* better control over the Makefiles produced;
-* installation to <tt>$HOME</tt>;
-* uninstallation;
-* more flexibility.
-
-==Background
-
-Mkmf2 was written to supplement a missing feature on the old +mkmf.rb+: it is
-not possible to install include files along with the library, and not easy
-to make several libraries, that link each other, and install them... So here
-comes mkmf2.rb !
-
-
-==Bugs
-
-There are probably a huge number of bugs, or missing features, or
-misleading features. In case you find one, please file a request
-in the mkmf2 project on rubyforge, at the address
-http://rubyforge.org/tracker/?group_id=1391
-
-But before, please, check out the latest cvs version at
-http://rubyforge.org/scm/?group_id=1391
-and make sure the bug is still there...
-
-==Note to anyone who wishes to contribute
-
-Please, document any code you add, and keep the
-changelog up to date...
-
-==Copyright
-
-This module is copyright 2006 by Vincent Fourmond. You can use and
-redistribute it under the terms of the General Public License version 2.
-As a special exception, you can distribute any verbatim copy along with
-a program, provided that this program depends on mkmf2 to install.
-
-=end
-
-module Mkmf2
-
-  include Config
-
-  # The CVS tag used for the release.
-  CVS_TAG = '$Name:  $'
-
-  # The module version; it is computed from CVS_TAG
-  VERSION = CVS_TAG.match(/\D+(.*?)\s*\$?$/)[1].tr('_-','..')
-
-  # The entities: a list of Mkmf2::MfEntity representing what
-  # we are currently building.
-  @@entities = []
-
-  # User-defined rules:
-  @@user_rules = []
-
-
-  # we first start the module with a whole bunch of small subclasses
-  # that will come in really useful later.
-
-  # This class provides a crude functionnality for defining a rule
-  # in a Makefile.
-  class MfRule
-    attr_accessor :name, :rule, :dependencies
-
-    # converts this rule to a string that can be readily printed to
-    # the Makefile
-    def to_s
-      return "#{@name}: #{@dependencies.join ' '}" + 
-        if @rule.empty? # we don't need a second line
-          "\n" 
-        else
-          "\n\t#{@rule.join "\n\t"}\n" 
-        end 
-    end
-    
-    # +name+:: the name of the rule.
-    # +rule+::
-    #   a string or an array of lines; strings are split if necessary
-    # +deps+:: a string or an array of dependencies
-    def initialize(name, rule = nil, deps = nil)
-      @name = name 
-
-      if rule.is_a? Array
-        @rule = rule
-      elsif rule.nil?
-        @rule = []
-      else
-        @rule = rule.split /\s*\n\t?\s*/
-      end
-
-      if deps.is_a? Array
-        @dependencies = deps
-      elsif deps.nil?
-        @dependencies = []
-      else
-        @dependencies = deps.split /\s+/
-      end
-    end
-    
-  end 
-
-  # A small class to include comments into the Makefile, just to help anyone
-  # who has to debug something. And it annoys me not to be able to clearly
-  # read the output of the test.rb script !
-  class MfComment < MfRule
-    
-    # The actual text of the comment.
-    attr_accessor :text
-
-    # +str+ is the text meant to be displayed in the makefile. If it is nil
-    # the rule just ends up being a blank line, to allow for easy separation
-    # of the rules.
-    def initialize(str = nil)
-      @text = str
-    end
-
-    def to_s
-      if @text.nil?
-        return "\n"
-      else
-        lines = @text.to_s.split '\n'
-        lines.unshift ""
-        return "#{lines.join "\n# "}\n" 
-      end
-    end
-    
-  end
-    
-
-
-  # An MfEntity object reprensents something that is part of the package.
-  # In this way, it needs to provide:
-  # 
-  # * a way to *install* itself;
-  # * a way to *uninstall* itself;
-  # * a way to *clean* the source directory;
-  # * and, possibly, a way to *build* itself.
-  #
-  # This class should be subclassed for objects that need building.
-  # It should be enough though for many simple objects.
-  #
-  # The module will hold a list of all the MfEntities, and use them in turn
-  # to create the Makefile. 
-  class MfEntity
-
-    # +install_files+ is a hash that associates files in the building
-    # tree to files where the installation is done. To be more precise
-    # the install path for the files is expressed relative to
-    # +install_path+
-    attr_accessor :install_files
-
-    # This name has to be registered by Mkmf2.register_name. Its lowercase
-    # version will be used to name the targets (install_#{name}), etc.), and
-    # it's uppercase version can be used as a prefix to name Makefile
-    # variables, that we can for instance depend on.
-    attr_accessor :name
-
-    # It represents the type of the entity. It should be a valid entry
-    # for Mkmf2.install_path.
-    attr_accessor :kind
-
-    # It is used to ask Mkmf2.install_files for the right rule for
-    # installing files (they can be data, scripts, programs, and so on...)
-    attr_accessor :install_rule
-
-    # The +name+ parameter is turned into a unique name and ends up as
-    # an identifier for the stuffs related to this element in the Makefile.
-    # The +install+ parameter directly becomes install_files.
-    # The +kind+ parameter describes the kind of thing we're going
-    # to install. See Mkmf2.install_path.
-
-    def initialize(name, install, kind = 'lib',
-                   install_rule = 'install_data')
-
-      # we append kind to avoid overlaps in case of
-      # a malchosen name (even if this is guaranteed by register_name),
-      # it will look better.
-      @name = Mkmf2::register_name(kind + "_" + name)
-      @install_files = install.dup
-      @kind = kind
-      @install_rule = install_rule
-    end
-
-    # Returns the install path for the current object. The implementation
-    # should call Mkmf2.install_path with an appropriate argument.
-    def install_path
-      return Mkmf2::install_path(@kind)
-    end
-
-    
-    # Returns an array containing
-    # * a string as the first element which should be appendended
-    #   as a dependency for the install target
-    # * a set of MfRules, describing what need to be done
-    #   for that peculiar install.
-
-    def install_rules
-      rules = ["install_#{@name.downcase}"]
-
-      rules.push MfComment.new("installation rules for #{name}")
-
-      rules.push MfRule.new("install_#{@name.downcase}",
-                            Mkmf2.install_files_rules(@install_rule,
-                                                      install_path,
-                                                      @install_files),
-                            ["$(#{@name.upcase}_SOURCE_FILES)",
-                             "$(#{@name.upcase}_INSTALL_DIRS)"] 
-                            )
-    end
-
-    # Rules for uninstalling the entity.
-    # See install_rules for the return values.
-    def uninstall_rules
-      rules = ["uninstall_#{@name.downcase}"]
-
-      rules.push MfComment.new("uninstallation rules for #{name}")
-      files = [] # the rules to remove the installed files
-      dirs = [] # the directories created during install
-      @install_files.each_value do |v|
-        dest = File.join(install_path,v)
-        files.push Mkmf2.rule('remove',dest)
-        dirs << File.dirname(dest)
-      end
-      dirs.uniq!
-      for dir in dirs
-        files << Mkmf2.rule('remove_path',dir)
-      end
-      rules.push MfRule.new("uninstall_#{@name.downcase}",
-                            files)
-    end
-
-    # Rules for cleaning the source directory. See #install_rules for
-    # an explanation about return values. This implementation does
-    # nothing, as there is nothing to be built.
-    def clean_rules
-      return []
-    end
-      
-    # Rules for building the entity. See #install_rules for
-    # an explanation about return values.
-    def build_rules
-      return []
-    end
-    
-    # Returns all the variables that should be added to the Makefile.
-    # It should return a simple hash containing the values.
-    def variables
-      # we need to define this variable:
-      ret = {}
-      install = []
-      source = []
-      dirs = []
-      @install_files.each do |k,f|
-        file = File.join(install_path,f)
-        install << file
-        source << k
-        dirs << File.dirname(file) + "/"
-      end
-      dirs.uniq! 
-      ret["#{@name.upcase}_INSTALL_FILES"] = 
-        Mkmf2.pretty_print_list(install,"#{@name.upcase}_INSTALL_FILES=")
-      ret["#{@name.upcase}_INSTALL_DIRS"] = 
-        Mkmf2.pretty_print_list(dirs,"#{@name.upcase}_INSTALL_DIRS=")
-      ret["#{@name.upcase}_SOURCE_FILES"] = 
-        Mkmf2.pretty_print_list(source,"#{@name.upcase}_SOURCE_FILES=")
-      return ret
-    end
-  end
-
-  # The class to create libraries that need to be built (that is basically
-  # why I wrote the whole stuff !).
-  class MfBinaryLibEntity < MfEntity
-
-    # The source files of the library.
-    attr_accessor :sources
-
-    # The object files for the library
-    attr_accessor :objects
-
-    # The name of the file produced in the source directory.
-    attr_accessor :target_file
-
-    # The libraries on which the linking does depend
-    attr_accessor :lib_depends
-
-    # Supplementary command-line arguments for the linking step.
-    # It will be used for instance to store library info.
-    attr_accessor :suppl_args
-
-    # +name+::  of the binary library produce, for instance "Biniou/Bidule"
-    # +sources+:: sources of the files, defaults to all the potential
-    #             +C+/+C\+\++ in the current directory.
-    #             The sources are further expanded with Dir.glob.
-    #             If you give then name of a directory, it will be
-    #             expanded 
-    # +target_file+:: how the files built in the current directory
-    #                 will be called. Defaults to the same file name
-    #                 as +name+.
-    # +lib_depends+:: an array of objects, which designate ruby binary
-    #                 libraries that this library does depend on;
-
-    def initialize(name, sources = nil, target_file = nil,
-                   lib_depends = nil)
-      if sources.nil?
-        sources = ["."]
-      end
-
-      @sources = []
-      add_sources(sources)
-
-
-      if target_file.nil?
-        @target_file = File.basename(name) + ".#{CONFIG["DLEXT"]}"
-      else
-        @target_file = target_file
-      end
-
-      install_hash = { @target_file => name + ".#{CONFIG["DLEXT"]}" }
-      # Then, we call the function of the parent
-      super(name, install_hash,'bin_lib','install_bin')
-      @suppl_args = ""
-    end
-
-    # Adds source files to the library. Can come in useful inside a block
-    def add_sources(*sources)
-      # we flatten the array, just to make sure everything is top-level
-      sources.flatten!
-      
-      # We expand directory into the files in them
-      # (no subdirs)
-      sources.collect! do |f|
-        if File.directory?(f)
-          temp = []
-          for ext in Mkmf2.source_files_extensions
-            temp << File.join(f,"*.#{ext}")
-          end
-          temp
-        else
-          f
-        end
-      end
-
-      # Then, we expand the files:
-      for f in sources
-        files = Dir.glob(f)
-        if files.empty?
-          @sources << f
-        else
-          @sources += files
-        end
-      end
-
-      # and we update the list of current object files
-      @objects = @sources.collect do |f|
-        f.gsub(/\.[^.]+$/, ".#{CONFIG["OBJEXT"]}")
-      end
-      
-    end
-    # 
-    def build_rules
-      return [#"build_#{@name.downcase}",
-              @target_file,
-              # better to write this way... more clear on the
-              # zsh command-line completion ;-) !
-              MfRule.new(@target_file,
-                         Mkmf2.rule('build_library', 
-                                    "$(#{name.upcase}_OBJS)", 
-                                    @suppl_args),
-                         "$(#{name.upcase}_OBJS)")
-             ]
-    end
-
-    # This removes the object files for the target...
-    def clean_rules
-      rules = ["clean_#{@name.downcase}"]
-
-      rules.push MfComment.new("cleaning rules for #{name}")
-      files = [] # the rules to clean the files
-      @objects.each do |v|
-        files.push Mkmf2.rule('remove',v)
-      end
-
-      files.push Mkmf2.rule('remove', @target_file)
-      rules.push MfRule.new("clean_#{@name.downcase}",
-                            files)
-      return rules
-    end
-
-    def variables
-      vars = super
-      # We add the object list variable
-      vars["#{name.upcase}_OBJS"] = 
-        Mkmf2.pretty_print_list(@objects,"#{name.upcase}_OBJS=")
-      return vars
-    end
-    
-  end
-
-  # Returns a list of the potential source files extensions.
-  def Mkmf2.source_files_extensions
-    return Mkmf2.cpp_files_extensions + 
-      Mkmf2.c_files_extensions
-  end 
-
-  # Return the extensions for C++ files.
-  def Mkmf2.cpp_files_extensions
-    return %w{cpp cc cxx}
-  end 
-
-  # Return extensions for C files.
-  def Mkmf2.c_files_extensions
-    return %w{c}
-  end 
-
-
-  # This function declares a shared binary library that will be built
-  # and installed using the appropriate functions.
-  #
-  # +libname+ is what is usually passed as an argument to the
-  # +create_makefile+ function of the old 
-  #
-  # +sources+ is the source files. They are processed using Dir.glob, so
-  # they can contain wildcards.
-  #
-  # This function contends itselfs to *declare* the library, it does not
-  # *build* it, as this will be done by +make+.
-
-  def declare_binary_library(libname, *sources, &b)
-    add_entity(MfBinaryLibEntity.new(libname, sources), &b)
-  end
-  
-  def add_entity(entity)
-    yield entity if block_given?
-    @@entities << entity
-    return entity
-  end
-
-  # This function declares a Ruby library, namely files that want
-  # to be installed directly in the rubylibdir (or equivalent, depending
-  # on the user settings).
-  # +target_dir+:: the target directory, relative to the installation
-  #                directory;
-  # +files+:: the files to install. Defaults to "lib/**.rb"
-  #
-  # For instance,
-  #  declare_library("Biniou", "toto.rb")
-  # will install the file "Biniou/toto.rb" in the common library
-  # directory. 
-              
-  def declare_library(target_dir,*files, &b)
-    if files.empty?
-      files << "lib/**/*.rb" 
-    end
-    declare_file_set(target_dir, files, 'lib', false, &b)
-  end
-
-  # Declares a set of files that should be executed directly be the user.
-  def declare_exec(*files, &b)
-    # No need for a target directory.
-    declare_file_set("", files, 'exec', true, 'install_script',&b)
-  end
-
-  # Declares a documentation that doesn't need to be built. For the arguments,
-  # see #declare_library.
-  def declare_doc(target_dir, *files,&b)
-    if files.empty?
-      files << "doc/**/*"
-    end
-    declare_file_set(target_dir, files, 'doc', false,&b)
-  end
-
-  # Declares a set of include files to be installed. Defaults to
-  # all the files in the include subdirectory.
-  def declare_includes(target_dir,*files,&b)
-    if files.empty?
-      files << "include/**/*.h" 
-    end
-    declare_file_set(target_dir, files, 'include', true,&b)
-  end
-    
-    
-
-  # The main place for declaring files to be installed.
-  # +target_dir+:: the target directory relative to the install path
-  #                if it is nil or empty, then just install in the
-  #                base directory.
-  # +files+:: the source files
-  # +kind+:: the kind of target (see again and again install_path)
-  # +basename+:: wether or not to strip the leading directories ?
-  # +skip+:: a regular expression (or whatever object that has a ===
-  #          method that matches strings) saying wich files should
-  #          be excluded. Defaults to /~$/.
-  # _base_dir_:: a source base directory to be stripped from the target
-  #              name
-
-  def declare_file_set(target_dir, files, kind = 'lib', 
-                       basename = true, 
-                       rule = 'install_data',
-                       skip = /~$/, delete = /((^.*\/)?lib\/)?/,
-                       base_dir = false, &b)
-    source_files = []
-    for glob in files
-      # If glob looks like a glob, we use Dir.glob, else we add it
-      # without modification
-      if glob =~ /\*|\[|\?/
-        source_files += Dir[glob]
-      else
-        source_files << glob
-      end
-    end
-    install_hash = {}
-    for f in source_files
-      next if skip === f
-      next if File.directory? f
-      filename = if basename 
-                   File.basename(f)
-                 else
-                   f.dup
-                 end
-      filename.gsub!(delete, '')
-      
-      if target_dir.nil? or target_dir.empty?
-        install_hash[f] = filename
-      else
-        install_hash[f] = File.join(target_dir, filename) 
-      end
-    end
-    add_entity(MfEntity.new(target_dir, install_hash, 
-                            kind, rule), &b)
-  end
-  
-  @@model = "local"
-
-  # Sets the model for directory installation. There are for now 
-  # three values:
-  # local:: for a standard installation (like the default in mkmf.rb)
-  # dist:: to use in a packageing system
-  # home:: to install to a home directory (basically, prefix= <tt>$HOME</tt>)
-  #
-  # Please do not modify @@model directly.
-
-  def Mkmf2.set_model(model = "local")
-    @@model = model
-  end
-
-  # Sets up a whole bunch of variables necessary for installation, depending
-  # on the current value of the @@model parameter. This is the place where we
-  # setup the variables used by the installation process, namely:
-  # +RUBYLIB_INSTALL_DIR+:: the directory where the text libraries
-  #                         are to be installed;
-  # +RUBYARCHLIB_INSTALL_DIR+:: the directory where architecture
-  #                             dependent libraries are installed;
-  # +INCLUDE_INSTALL_DIR+:: the directory where include files should go
-  #                         if necessary;
-  # And for now, that is all.
-  def setup_model
-    case @@model
-    when "home"
-      # I made a mistake for the home scheme.
-      # we ensure the prefix is set to $HOME 
-      MAKEFILE_CONFIG["RUBYLIB_INSTALL_DIR"] = 
-        "$(DESTDIR)$(HOME)/lib/ruby"
-      # For the HOME scheme, binaries and .rb files go
-      # to the same directory.
-      MAKEFILE_CONFIG["RUBYARCHLIB_INSTALL_DIR"] = 
-        "$(DESTDIR)$(HOME)/lib/ruby"
-      MAKEFILE_CONFIG["INCLUDE_INSTALL_DIR"] = 
-        "$(DESTDIR)$(HOME)/include"
-      MAKEFILE_CONFIG["EXEC_INSTALL_DIR"] = 
-        "$(DESTDIR)$(HOME)/bin"
-        
-    when "dist"
-      # shares some code with the previous item, don't forget to
-      # update *BOTH* !
-      MAKEFILE_CONFIG["RUBYLIB_INSTALL_DIR"] = 
-        "$(DESTDIR)$(rubylibdir)"
-      MAKEFILE_CONFIG["RUBYARCHLIB_INSTALL_DIR"] = 
-        "$(DESTDIR)$(archdir)"
-      MAKEFILE_CONFIG["INCLUDE_INSTALL_DIR"] = 
-        "$(DESTDIR)$(includedir)"
-      MAKEFILE_CONFIG["EXEC_INSTALL_DIR"] = 
-        File.join("$(DESTDIR)$(prefix)", "bin")
-
-    when "local"
-      MAKEFILE_CONFIG["RUBYLIB_INSTALL_DIR"] = 
-        "$(sitelibdir)"
-      MAKEFILE_CONFIG["RUBYARCHLIB_INSTALL_DIR"] = 
-        "$(sitearchdir)"
-
-      # To make the base directory for installation, I propose
-      # to strip all the directories containing ruby from the
-      # $(sitedir) directory and strip one more directory.
-
-      basedir = MAKEFILE_CONFIG["sitedir"]
-      while File.basename(basedir) =~ /ruby/
-        basedir = File.dirname(basedir)
-      end
-      # Strip one more:
-      basedir = File.dirname(basedir)
-      MAKEFILE_CONFIG["basedir"] = basedir
-      MAKEFILE_CONFIG["INCLUDE_INSTALL_DIR"] = 
-        "$(basedir)/include"
-      MAKEFILE_CONFIG["EXEC_INSTALL_DIR"] = 
-        "$(basedir)/bin"
-    end
-
-  end
-
-
-  # Returns the installation path for a given thing (+what+). This function
-  # basically returns a simple MAKEFILE_CONFIG variable, which has otherwise
-  # been setup by setup_model. What is available for now:
-  # +lib+:: where to install .rb library
-  # +bin_lib+:: where to install binary libs
-  # +include+:: include files
-
-  def Mkmf2.install_path(what)
-    # we should definitely append a $(DESTDIR) to every single
-    # directory we return, since it will make debugging
-    
-    case what
-    when 'lib'
-      return Mkmf2.config_var('RUBYLIB_INSTALL_DIR')
-    when 'exec'
-      return Mkmf2.config_var('EXEC_INSTALL_DIR')
-    when 'bin_lib'
-      return Mkmf2.config_var('RUBYARCHLIB_INSTALL_DIR')
-    when 'include'
-      return Mkmf2.config_var('INCLUDE_INSTALL_DIR')
-    else
-      raise "Unkown installation directory specification: #{what}"
-    end 
-  end
-
-  @@registered_names = {} # a hash containing already registered names
-  # to avoid namespace clobbering.
-  
-  # Register a new name, making sure the name returned is unique.
-  def Mkmf2.register_name(name)
-    # first, transform all that is not letter into underscore
-    name.gsub!(/[^a-zA-Z]/,'_')
-    # pretty-print a bit
-    name.gsub!(/^_|_$/,'')
-    name.gsub!(/_+/, '_')
-    name.downcase!
-    # then, increment the number
-    if @@registered_names[name]
-      i = 1
-      while @@registered_names["#{name}_#{i}"]
-        i += 1
-      end
-      name = "#{name}_#{i}"
-    end
-    @@registered_names[name] = true
-    return name
-  end
-  
-
-  # Stores which configuration variables are used
-  @@config_variables_used = []
-  # Returns the given config key, that will be used to write a rule
-  # in the Makefile. For better output, the function does store a list of
-  # all the config variables which are in use, and simply outputs 
-  # +$(VARIABLE)+. 
-  def Mkmf2.config_var(str)
-    @@config_variables_used << str
-    return "$(#{str})"
-  end
-
-  # This hash says which of the "CONFIG" variables we should make available
-  # as a global variable -- and use it back to output the variables. If non
-  # nil, the second part says which name it should have as global variable.
-  MKMF_GLOBAL_VARIABLES =   {
-    "CFLAGS" => nil, 
-    "CXXFLAGS" => nil, 
-    "LDFLAGS" => nil, 
-    "DLDFLAGS" => nil,
-    "CPPFLAGS" => nil,
-    "LIBS" => nil,
-    "LIBRUBYARG" => nil,
-    "LOCAL_LIBS" => nil,
-    "libs" => nil,
-  }
-                           
-
-  # Takes the config variables, turn them into global variables.
-  def config_to_global
-    for var,name in MKMF_GLOBAL_VARIABLES 
-      name = var if name.nil?
-      value = MAKEFILE_CONFIG[var].to_s # make sure its a string
-      # in case it doesn't exist there...
-      # Nice trick to get around quoting...
-      block = eval "proc {|x| $#{name} = x}"
-      block.call(value)
-    end
-    $LIBRUBYARG = "" # seems the default in mkmf.rb
-  end
-
-  # Takes the global variables taken from the config, and put them back into
-  # the config hash.
-  def global_to_config
-    for var,name in MKMF_GLOBAL_VARIABLES 
-      name = var if name.nil?
-      value = eval "$#{name}"
-      MAKEFILE_CONFIG[var] = value
-    end
-  end
-
-
-
-  # A constant to get a configuration variable
-  MAKE_VARIABLE = /\$\((\w+)\)/
-
-  # List config variables referenced to by the string _str_. If
-  # hash is specified, only config variables that are keys of this hash
-  # will be listed.
-  def subvars(str, hash = nil)
-    vars = []
-    str.gsub(MAKE_VARIABLE) { |k|
-      # we add the key to the list only if it exists, else the
-      # environment variable gets overridden by what is written
-      # in the Makefile (for $HOME, for instance)
-      vars << $1 if ( hash.nil? || hash.key?($1) )
-    }
-    return vars
-  end
-
-  # A way to deal with compound make variables (that is,
-  # make variables that get more than just themselves on the output)
-
-  COMPOUND_MAKE_VARIABLES = {
-    "CFLAGS" => "$(CFLAGS) $(ARCH_FLAG)", 
-    "DLDFLAGS" => "$(DLDFLAGS) $(ARCH_FLAG)",
-    "LIBS" => "$(LIBRUBYARG) $(libs) $(LIBS)",
-  }
-
-
-  # Returns the contents of a "compound" variable.
-  def compound_var_expand(var, value = nil, hash = MAKEFILE_CONFIG)
-    if value.nil?
-      value = MAKEFILE_CONFIG[var]
-    end
-    COMPOUND_MAKE_VARIABLES[var].gsub("$(#{var})",value)
-  end
-
-
-  # Returns a string containing all the configuration variables. We
-  # use the MAKEFILE_CONFIG for more flexibility in the Makefile: the
-  # variables can then be redefined on the make command-line.
-  def output_config_variables
-    str = ""
-    keys = @@config_variables_used.uniq
-    global_to_config
-    new_keys = []
-    begin 
-      # we merge the new keys with the old
-      keys += new_keys
-      keys.uniq!
-      new_keys = []
-      keys.each do |k|
-        if MAKEFILE_CONFIG.key? k
-          new_keys += subvars(MAKEFILE_CONFIG[k], MAKEFILE_CONFIG)
-        end
-        if COMPOUND_MAKE_VARIABLES.key? k
-          new_keys += subvars(COMPOUND_MAKE_VARIABLES[k], MAKEFILE_CONFIG)
-        end
-      end
-    end until (keys + new_keys).uniq.length == keys.length
-    
-    for var in keys.uniq.sort
-      # We output the variable only if it is not empty: makes
-      # it a lot easier to modify them from outside...
-      if COMPOUND_MAKE_VARIABLES.key?(var)
-        str += "#{var}=#{compound_var_expand(var)}\n"
-      elsif MAKEFILE_CONFIG[var] =~ /\S/
-        str += "#{var}=#{MAKEFILE_CONFIG[var]}\n"
-      end
-    end
-    return str
-  end
-    
-
-  # This hash contains replacements for basic filesystem functions
-  # based on ruby and FileUtils. They are used only if the corresponding
-  # element is missing in CONFIG. They also contains some other default
-  # values for possibly missing CONFIG keys.
-  CONFIG_DEFAULTS = {
-    # first, a short for the rest...
-    "RB_FILE_UTILS" => "$(RUBY_INSTALL_NAME) -r fileutils", 
-    "INSTALL_SCRIPT" => 
-    "$(RB_FILE_UTILS) -e 'FileUtils.install(ARGV[0],ARGV[1],:mode => 0755)'",
-    "INSTALL_DATA" => 
-    "$(RB_FILE_UTILS) -e 'FileUtils.install(ARGV[0],ARGV[1],:mode => 0644)'",
-    "INSTALL_PROGRAM" =>  "$(INSTALL_SCRIPT) ",
-    "MAKEDIRS" => 
-    "$(RB_FILE_UTILS) -e 'FileUtils.makedirs(ARGV)'",
-    "RM" => 
-    "$(RB_FILE_UTILS) -e 'FileUtils.rm(ARGV)'",
-    "RM_PATH" => # a trick to remove a path
-    "$(RB_FILE_UTILS) -e 'd = ARGV[0]; begin ;while FileUtils.rmdir d, :verbose=>true; d = File.dirname(d);end; rescue ; end;'",
-    "DEFINES" => "",
-    "LIBARG" => "-l%s",
-    "LIBS_SUP" => "", 
-  } 
-  
-  # This functions checks for missing features in the CONFIG hash and 
-  # supplements them using the FILE_UTILS_COMMAND hash if necessary.
-  def check_missing_features
-    CONFIG.delete("INSTALL_SCRIPT")   # Not consistent, it's better to use
-    # the Fileutils stuff
-    for key, val in CONFIG_DEFAULTS 
-      if CONFIG.key?(key) and CONFIG[key] =~ /\w/
-        # everything is fine
-      else
-        # we supplement the feature.
-        MAKEFILE_CONFIG[key] = val
-      end
-    end
-  end
-
-  # Takes a list of CONFIG variables and returns them joined by spaces. 
-  def Mkmf2.config_join(*vars)
-    return vars.collect { |v|
-      Mkmf2.config_var(v)
-    }.join(' ')
-  end
-    
-
-  # Returns the way to represent the dependencies of a rule in the
-  # Makefile.
-  def Mkmf2.mf_deps
-    return " $(@D)"
-  end
-
-  # Returns the way to represent the current target in the Makefile.
-  def Mkmf2.mf_target
-    return " $@"
-  end
-
-  # A small helper function to write quickly rules, based on a configuration
-  # item.
-  def Mkmf2.mf_rule(cfg,*args)
-    if args.empty?
-      return Mkmf2.config_var(cfg) + 
-        Mkmf2.mf_deps + Mkmf2.mf_target
-    else
-      return Mkmf2.config_var(cfg) + ' ' + args.join(' ')
-    end
-  end
-
-  # This function returns the common build rules for C and C++ files.
-  def Mkmf2.common_build_rules
-    rules = []
-    for ext in Mkmf2.c_files_extensions
-      rules << MfRule.new(".#{ext}.#{CONFIG["OBJEXT"]}",
-                          Mkmf2.config_join("CC",
-                                            "CFLAGS",
-                                            "CPPFLAGS",
-                                            "INCLUDEDIRS",
-                                            "DEFINES") +
-                          " -c $< #{CONFIG["OUTFLAG"]} $@" 
-                          ) 
-    end 
-
-    # The same, but with C++:
-    for ext in Mkmf2.cpp_files_extensions
-      rules << MfRule.new(".#{ext}.#{CONFIG["OBJEXT"]}",
-                          Mkmf2.config_join("CXX",
-                                            "CXXFLAGS",
-                                            "CPPFLAGS",
-                                            "INCLUDEDIRS",
-                                            "DEFINES") +
-                          " -c $< #{CONFIG["OUTFLAG"]} $@" 
-                          ) 
-    end 
-    # A simple rule for making directories:
-    rules << MfRule.new("%/",
-                        Mkmf2.config_join("MAKEDIRS") + " $@")
-    return rules
-  end 
-
-  # Now, the infrastructure for dealing with include and library
-  # directories:
-  if CONFIG.key?('rubyhdrdir')
-    @@include_path = [
-                      Mkmf2.config_var("rubyhdrdir")+"/ruby",
-                      Mkmf2.config_var("rubyhdrdir"),
-                      Mkmf2.config_var("rubyhdrdir") + "/" + 
-                      Mkmf2.config_var("arch")
-                     ] 
-  else
-    @@include_path = [ Mkmf2.config_var("rubylibdir") ]
-  end
-
-  @@include_path += [
-                    Mkmf2.config_var("archdir"),
-                    '.',
-                    File.join('.','include')
-                   ]
-
-  
-  # Adds one or more +paths+ to the current include path.
-  def add_include_path(*paths)
-    @@include_path += paths.flatten
-  end
-
-  def output_include_path
-    return @@include_path.collect {|v|
-      "-I#{v}"
-    }.join(' ')
-  end
-
-  @@library_path = []
-
-  # Adds one or more +paths+ to the current library path.
-  def add_library_path(*paths)
-    @@library_path += paths.flatten
-  end
-
-  def output_library_path
-    return @@library_path.collect {|v|
-      "-L#{v}"
-    }.join(' ')
-  end
-
-  # I know this is bad design, but that's the best I think of for now.
-  # This function better be called before using MAKEFILE_CONFIG directly.
-  def update_makefile_config
-    global_to_config
-    setup_paths_variables
-  end
-
-  # Sets up the various variables pertaining to include
-  # and library paths.
-  def setup_paths_variables
-    MAKEFILE_CONFIG["INCLUDEDIRS"] = output_include_path
-    MAKEFILE_CONFIG["LIBDIRS"] = output_library_path
-  end
-
-  # A recommandation for line size in the Makefile
-  MAKEFILE_LINE_SIZE = 40
-  
-  # Returns a string where all the elements are joined together. The lines
-  # will break if they exceed +line_size+, but the elements themselves
-  # will not be broken. They will be indented
-  def Mkmf2.pretty_print_list(list, indent = 0,
-                              line_size = MAKEFILE_LINE_SIZE)
-    if indent.is_a? String
-      indent = indent.length
-    end
-    lines = []
-    for elem in list
-      if lines.last.nil? || 
-          (lines.last + elem).length > line_size
-        lines << elem.dup # necessary to force ruby to create
-      else
-        lines.last.concat(' ' + elem)
-      end
-    end
-    return lines.join("\\\n#{' ' * indent}")
-  end
-
-  
-  # Returns the string corresponding to a rule, given by the string +rule+,
-  # which can take the following values:
-  # +install_data+::   returns the rule for installing a data file to a
-  #                    given place
-  # +install_script+:: the rule for installing code at a given place
-  # +remove+::         to remove files
-  # +directory+:: to create a directory
-  # +build_library+:: to build a library; in that case, the first argument
-  #                   is the name of the target, and the ones after
-  #                   the objects.
-  #
-  # the optional arguments are the arguments to the rule, if they exist. Else,
-  # they default to $(@D) $@ (or something like that).
-  
-  def Mkmf2.rule(rule, *args)
-    case rule
-    when 'install_data'
-      return Mkmf2.mf_rule("INSTALL_DATA",args)
-    when 'install_script'
-      return Mkmf2.mf_rule("INSTALL_SCRIPT",args)
-    when 'install_bin'
-      return Mkmf2.mf_rule("INSTALL_PROGRAM",args)
-    when 'remove'
-      return "-" + Mkmf2.mf_rule("RM",args)
-    when 'remove_path'
-      return "-" + Mkmf2.mf_rule("RM_PATH", args)
-    when 'directory' # to create a directory
-      return Mkmf2.mf_rule("MAKEDIRS", args)
-    when 'build_library' 
-      return Mkmf2.mf_rule("LDSHARED",
-                           Mkmf2.config_join("DLDFLAGS",
-                                             "LIBDIRS"),
-                           CONFIG["OUTFLAG"],
-                           "$@", # the target,
-                           args, # and the source
-                           # The libraries should better come in the end,
-                           # since for instance the standard linux ld
-                           # does only link with the symbols that have been
-                           # reported missing in the previous files.
-                           Mkmf2.config_join("LIBRUBYARG_SHARED", 
-                                             # we shouldn't forget this one !!
-                                             "LOCAL_LIBS",
-                                             "LIBS",
-                                             # and then, the global libraries
-                                             # that have been added using
-                                             # have_library
-                                             "LIBS_SUP")
-                           )
-    end
-  end
-  
-  @@directories = {}
-  # Register a directory that we might need to create. Make sure that
-  # the rules don't appear twice.
-  def Mkmf2.register_dir(dir)
-    if ! @@directories.key?(dir)
-      @@directories[dir] = true
-    end
-  end
-
-  # Return the rules to create the necessary directories
-  def directory_rules
-    rules = []
-    for dir in @@directories.keys 
-      rules << MfRule.new(dir, Mkmf2.rule('directory',dir))
-    end
-    return rules
-  end
-
-
-  # A small helper function to extract the install directory name
-  # for one file. +file+ is the file, +install_dir+ where we want to
-  # install it. This should take care of messy dots.
-  def Mkmf2.dest_dir(file, install_dir)
-      dir = File::dirname(file)
-      if dir == "."
-        return install_dir
-      else
-        return File.join(install_dir,dir)
-      end
-  end
-
-  # A helper function for MfEntity instances that will have to install
-  # files into directories.
-  # +rule+:: the rule to use, see Mkmf2::rule
-  # +install_path+:: the installation path
-  # +files+:: a hash containing original -> destination pairs.
-
-  def Mkmf2.install_files(rule, install_path,files)
-    rules = []
-    files.each do |k,v|
-      destdir = Mkmf2.dest_dir(v, install_path)
-      Mkmf2.register_dir(destdir)
-      rules.push(MfRule.new(File.join(install_path,v),
-                            Mkmf2::rule(rule, k,
-                                        File.join(install_path,v)),
-                            [k,destdir])) 
-      # depends on both the file
-      # that will be installed and the directory where to install it.
-    end
-
-    return rules
-  end
-
-  # The companion of install_files, returning a list of strings
-  # rather than MfRules. Bascially behaves the same way. It is probably
-  # a better thing to use this function now.
-  def Mkmf2.install_files_rules(rule, install_path,files)
-    rules = []
-    files.each do |k,v|
-      dir = File::dirname(v)
-      Mkmf2.register_dir(Mkmf2.dest_dir(v,install_path))
-      rules.push Mkmf2::rule(rule, k, File.join(install_path,v))
-      
-      # depends on both the file
-      # that will be installed and the directory where to install it.
-    end
-
-    return rules
-  end
-
-  # Small helper function for write_makefile. +target+ is
-  # a hash containing a "deps" array and a "rules" array
-  # which are created in case of need.
-  def unwrap_rules(target, source)
-    # we first make sure that the keys exist, even if we don't
-    # have anything to append to them.
-    if ! target.has_key? "deps"
-      target["deps"] = []
-    end
-    if ! target.has_key? "rules"
-      target["rules"] = []
-    end
-
-    return if source.empty?
-    target["deps"] << source.shift
-    target["rules"] += source
-  end
-
-  # Writes the Makefile using @@entities -- and others...
-  def write_makefile(file_name = "Makefile")
-    puts "Writing #{file_name}"
-    
-    install = {}
-    uninstall = {}
-    build = {}
-    clean = {}
-    vars = []
-
-
-
-    for entity in @@entities
-      t = entity.install_rules
-      unwrap_rules(install,t)
-
-      t = entity.uninstall_rules
-      unwrap_rules(uninstall,t)
-      
-      t = entity.build_rules
-      unwrap_rules(build,t)
-
-      t = entity.clean_rules
-      unwrap_rules(clean,t)
-
-      vars << entity.variables
-    end
-
-    # Common rules: 
-    common = Mkmf2.common_build_rules()
-    
-    # Setup the path variables:
-    setup_paths_variables
-    dir_rules = directory_rules()
-
-    # OK, now, everything is prepared, we just need to create the
-    # makefile and output everything into it...
-
-    f = open(file_name, File::WRONLY|File::CREAT|File::TRUNC)
-
-
-    # First, the variables in use:
-    f.puts "# Configurations variables, from rbconfig.rb"
-    f.puts output_config_variables
-
-    # build has to be the first target so that simply
-    # invoking make does the building, but not the installing.
-    # now, the main rules
-    f.puts "\n\n# main rules"
-    # we force the dependence on build for install so that
-    # ruby library files don't get installed before the c code is
-    # compiled...
-    # build is output first so that invoking make without
-    # arguments builds.
-    f.print MfRule.new("build", nil, build["deps"]).to_s
-    f.print MfRule.new("install", nil, ["build"] + install["deps"]).to_s
-    f.print MfRule.new("uninstall", nil, uninstall["deps"]).to_s
-    f.print MfRule.new("clean", 
-                       [Mkmf2.rule('remove',"**/*~")], # remove archive files
-                       # by default in the clean target.
-                       clean["deps"]).to_s
-
-    # Add a distclean rule, to make debuild happy.
-    f.print <<"EOR"
-distclean: clean 
-\t@-$(RM) Makefile extconf.h conftest.* mkmf2.log
-\t@-$(RM) core ruby$(EXEEXT) *~ $(DISTCLEANFILES) 
-EOR
-
-    # Phony targets:
-    f.puts ".PHONY: build install uninstall"
-
-    f.puts "\n\n# Common rules:"
-    common.each {|v|
-      f.print v.to_s
-    }
-
-    
-    # We write the variables:
-    f.puts "\n\n# entities-dependent variables"
-    for v in vars 
-      v.each do |k,v|
-        f.print "#{k}=#{v}\n"
-      end
-    end
-
-    f.puts "\n\n# Rules to make directories"
-
-    # directory rules
-    for rule in dir_rules
-      f.print rule.to_s
-    end
-
-    f.puts "\n\n# entities-dependent rules"
-    # We write the rules
-    for rule in (install['rules'] + 
-                 uninstall['rules'] +
-                 build['rules'] + clean['rules'])
-      f.print rule.to_s
-    end
-
-    if @@user_rules.length > 0
-      f.puts "\n\n# User-defined rules"
-      for rule in @@user_rules
-        f.puts rule.to_s
-      end
-    end
-
-
-    f.close # not necessary, but good practice ;-) ?? 
-
-  end
-
-  # Adds a custom rule to the Makefile. If only the first argument
-  # is specified, it is written as is to the Makefile. If at least the
-  # second or the third is non-nil, a MfRule is created with the arguments
-  # and written to the Makefile.
-  def custom_rule(str, rule = nil, deps = nil)
-    if rule || deps 
-      @@user_rules  << MfRule.new(str, rule, deps)
-    else
-      @@user_rules << str
-    end
-  end
-
-  # *The* compatibility function with the mkmf.rb !
-  def create_makefile(target)
-    declare_library(File.dirname(target))
-    declare_binary_library(target, "**/*.c")
-
-    write_makefile
-  end
-
-  # A function to ease the task of producing several libraries from the
-  # same source tree. It sets up a library context for one directory,
-  # adding it to the include path, and taking care of the files in:
-  # +lib/+:: the ruby library files;
-  # +include/+:: the include files
-  #
-  # +dir+ is the directory in the source, +target_dir+ the base directory
-  # for target files. It is pretty rudimentary, but should do the job
-  # for many cases (and especially Tioga ;-) !). +name+ is the name
-  # of the binary library. If nil, doesn't try to build a binary library.
-  # +include_dir+ is the target name for includes. If +nil+, doesn't
-  # try to install them.
-  #
-  # You can use either the return value or a block to change somehow the
-  # behavior of the different objects produced (like adding a binary library
-  # for instance).
-  
-  def setup_dir(dir, target_dir, bin_name = nil,
-                include_dir = nil)
-    add_include_path(dir, File.join(dir, 'include'))
-
-    lib = declare_library(target_dir, "#{dir}/lib/**/*.rb")
-    binlib = declare_binary_library(bin_name, 
-                                    "#{dir}/**/*.c") if ! bin_name.nil?
-    include = declare_includes(include_dir, 
-                     "#{dir}/include/**/*.h") if ! include_dir.nil?
-    yield lib, binlib, include if block_given?
-    [lib, binlib, include]
-  end
-
-  # the module variable that will hold the command-line arguments:
-  # even with a similar name, the contents of this variable will
-  # be quite different from the old $configure_args
-  @@configure_args = {}
-
-  # Parses command-line arguments, wiping the ones that we understood.
-  def parse_cmdline
-    $*.delete_if do |arg|
-      if arg =~ /^--(.*)/ # does look like a command-line argument...
-        case $1
-        when "local" # installation to sitedir
-          Mkmf2.set_model("local")
-          true
-        when "dist"
-          Mkmf2.set_model("dist")
-          true
-        when "home"
-          Mkmf2.set_model("home")
-          true
-        when /^--with(.*)/ # this is my understanding of the
-          # with-config stuff. It is a complete rewrite, I don't like
-          # much the old code
-          rhs = $1 # right-hand side
-          case rhs
-          when /-([\w-]+)=(.*)/
-            @@configure_args[$1] = $2
-          when /out-([\w-]+)$/
-            @@configure_args[$1] = false
-          when /-([\w-]+)$/
-            @@configure_args[$1] = true
-          else
-            raise "Argument #{arg} not understood"
-          end
-        else
-          false
-        end
-      else
-        false
-      end
-    end
-  end
-
-  # This function is a try at reproducing the functionnality of the
-  # old mkmf.rb's dir_config. It is not a copy, and might not work
-  # well in all situations. Basically, if --with-target-dir has been
-  # specified, use dir/include dir/lib. If --with-target-(include|lib)
-  # have been specified, use them !
-  def dir_config(target)
-    ldir = nil
-    idir = nil
-    if @@configure_args.key?("#{target}-lib") 
-      ldir = @@configure_args["#{target}-lib"]
-    elsif @@configure_args.key?("#{target}-dir") 
-      ldir = File::join(@@configure_args["#{target}-dir"], "lib")
-    end
-    if ldir
-      add_library_path(ldir.split(File::PATH_SEPARATOR))
-    end
-
-    if @@configure_args.key?("#{target}-include") 
-      idir = @@configure_args["#{target}-include"]
-    elsif @@configure_args.key?("#{target}-dir") 
-      idir = File::join(@@configure_args["#{target}-dir"], "include")
-    end
-    if idir
-      add_include_path(idir.split(File::PATH_SEPARATOR))
-    end
-    return [idir, ldir]
-  end
-
-  ###########################################################################
-  # This module is copied verbatim from the old mkmf.rb code. It comes dead #
-  # useful for logging things. I hope it will not cause licence conflicts.  #
-  ###########################################################################
-
-  module Logging
-    @log = nil
-    @logfile = 'mkmf2.log'
-    @orgerr = $stderr.dup
-    @orgout = $stdout.dup
-    @postpone = 0
-    
-    def self::open
-      @log ||= File::open(@logfile, 'w')
-      @log.sync = true
-      $stderr.reopen(@log)
-    $stdout.reopen(@log)
-      yield
-    ensure
-      $stderr.reopen(@orgerr)
-      $stdout.reopen(@orgout)
-    end
-    
-    def self::message(*s)
-      @log ||= File::open(@logfile, 'w')
-      @log.sync = true
-      @log.printf(*s)
-    end
-    
-    def self::logfile file
-      @logfile = file
-      if @log and not @log.closed?
-        @log.flush
-        @log.close
-        @log = nil
-      end
-    end
-    
-    def self::postpone
-      tmplog = "mkmftmp#{@postpone += 1}.log"
-      open do
-        log, *save = @log, @logfile, @orgout, @orgerr
-        @log, @logfile, @orgout, @orgerr = nil, tmplog, log, log
-        begin
-          log.print(open {yield})
-          @log.close
-          File::open(tmplog) {|t| FileUtils.copy_stream(t, log)}
-        ensure
-          @log, @logfile, @orgout, @orgerr = log, *save
-          @postpone -= 1
-          rm_f tmplog
-        end
-      end
-    end
-  end
-
-  # Also from old mkmf.rb
-  CONFTEST_C = "conftest.c"
-
-  def xsystem(command)
-    Logging::open do
-      puts command.quote
-      system(command)
-    end
-  end
-  
-  # Also from old mkmf.rb
-  def log_src(src)
-    Logging::message <<"EOM", src
-checked program was:
-/* begin */
-%s/* end */
-
-EOM
-  end
-  
-  # Also from old mkmf.rb
-  def create_tmpsrc(src)
-    src = yield(src) if block_given?
-    src = src.sub(/[^\n]\z/, "\\&\n")
-    open(CONFTEST_C, "wb") do |cfile|
-      cfile.print src
-    end
-    src
-  end
-  
-  # Also from old mkmf.rb
-  def try_do(src, command, &b)
-    src = create_tmpsrc(src, &b)
-    xsystem(command)
-  ensure
-    log_src(src)
-  end
-
-  # Also from old mkmf.rb
-  def checking_for(m, fmt = nil)
-    f = caller[0][/in `(.*)'$/, 1] and f << ": " #` for vim
-    m = "checking for #{m}... "
-    print m
-    a = r = nil
-    Logging::postpone do
-      r = yield
-      a = (fmt ? fmt % r : r ? "yes" : "no") << "\n"
-      "#{f}#{m}-------------------- #{a}\n"
-    end
-    puts a
-    $stdout.flush
-    Logging::message "--------------------\n\n"
-    r
-  end
-
-  # also taken straight from mkmf.rb
-  def rm_f(*files)
-    FileUtils.rm_f(Dir[files.join("\0")])
-  end
-
-  # A small wrapper around Config::expand which diminishes the size of the code
-  # and makes sure the MAKEFILE_CONFIG hash is updated.
-  def expand_vars(str)
-    update_makefile_config
-    string = Config::expand(str,MAKEFILE_CONFIG)
-    # then, we need to turn all the remaining $(THING) into $THING, so that
-    # the shell doesn't spawn subshells ? 
-    return string.gsub(/\$\((\w+)\)/) { "$#$1" }
-  end
-
-  # Add defines to the build
-  def add_define(d)
-        MAKEFILE_CONFIG["DEFINES"] += 
-          " -D_#{d}"
-  end
-
-  # This is a compatibility function with the previous mkmf.rb. It does check
-  # for the presence of a header in the current include directories. If found,
-  # it returns true and sets the define HAVE_...
-  def have_header(header, &b)
-    checking_for header do
-      if try_do("#include <#{header}>",
-                expand_vars("$(CPP) $(INCLUDEDIRS) " \
-                            "$(CPPFLAGS) $(CFLAGS) $(DEFINES) "\
-                            "#{CONFTEST_C} $(CPPOUTFILE)"),&b)
-        add_define("HAVE_#{header.sanitize}")
-        true
-      else
-        false
-      end
-    end
-  ensure
-    rm_f("conftest*")
-  end
-
-  # The same as have_header, but fails if the header is not found...
-  def require_header(header, message = nil ,&b)
-    if ! have_header(header,&b)
-      if message
-        puts message
-      end
-      raise "Header #{header} not found, stopping\n"
-    end
-  end
-
-  def mkmf2_init
-    check_missing_features
-    parse_cmdline
-    setup_model
-    config_to_global
-  end
-
-  def headers(header)
-    headers = ""
-    if header
-      if header.is_a?(Array) 
-        header.each {|h|
-          headers += "#include <#{h.to_s}>\n"
-        }
-      else
-        headers += "#include <#{header.to_s}>\n"
-      end
-    end
-    return headers
-  end
-
-  # Tries to link the given code with the extra flags given
-  def try_link(code, extras = "")
-    return try_do(code,
-                expand_vars("$(CC) $(OUTFLAG)conftest $(INCFLAGS) " +
-                            "#{CONFTEST_C} " + 
-                            " -I$(hdrdir) $(CPPFLAGS) $(CFLAGS) $(src)" + 
-                            " $(LIBPATH) $(LDFLAGS) $(ARCH_FLAG) " +
-                            " $(LOCAL_LIBS) $(LIBS) $(LIBS_SUP) #{extras}"
-                            )
-                )
-  ensure
-    rm_f("conftest*")
-  end
-
-  def try_func(func, extra, h)
-    headers = headers(h)
-
-    try_link(<<"SRC", extra) or try_link(<<"SRC", extra)
-#{headers}
-/*top*/
-int main() { return 0; }
-int t() { #{func}(); return 0; }
-SRC
-#{headers}
-/*top*/
-int main() { return 0; }
-int t() { void ((*volatile p)()); p = (void ((*)()))#{func}; return 0; }
-SRC
-end
-
-
-  # Compatibility function from mkmf.rb. Checks if the compiler
-  # can find the given function in the given library. If the function
-  # is not given, we look for main but it's definitely not a good idea.
-  # +header+ is a header that can be included to get the prototype for
-  # this function. It can possibly be an array, in which case it is
-  # interpreted as a list of headers that should be included.
-
-  def have_library(lib, func = nil, header=nil, &b)
-    if func.nil?
-      func = "main"
-    end
-    libarg = "#{MAKEFILE_CONFIG["LIBARG"]%lib}"
-    checking_for "#{func}() in #{libarg}" do
-      if try_func(func, libarg, header)
-        add_define("HAVE_#{lib.sanitize}")
-        MAKEFILE_CONFIG["LIBS_SUP"] += " #{libarg}" 
-        true
-      else
-        false
-      end
-    end
-  end
-  
-  # Returns true if a function could be found
-  def have_func(func, header = nil)
-    checking_for "#{func}() " do
-      if try_func(func, "", header)
-        add_define("HAVE_#{func.sanitize}")
-        true
-      else
-        false
-      end
-    end
-  end
-end
-
-include Mkmf2
-mkmf2_init