#!/usr/bin/env ruby

require './rakelib/configure'

require './rakelib/release'

require './rakelib/build_signature'

require 'rbconfig'

require 'tempfile'

require 'fileutils'

require 'stringio'

require 'date'

require 'digest/md5'

require 'digest/sha2'

require 'net/http'

module Rubinius

BUILD_CONFIG = {}

end

root = File.expand_path File.dirname(__FILE__)

require File.join(root, "core", "options")

class Configure

# Default settings only. All code that may depend on user-selected options

# must run after options are processed.

def initialize(root)

@log = Logger.new "configure.log"

@command_line = ARGV.dup

@log.log "Command line: #{@command_line.join(" ").inspect}"

@features = {}

@defines = []

@config = File.join(root, "build/config/config.rb")

# Platform settings

@host = `sh -c ./build/bin/config.guess`.chomp

@cpu = nil

@vendor = nil

@os = nil

@windows = nil

@darwin = nil

@bsd = nil

@linux = nil

@little_endian = false

@sizeof = {}

@gc_stack_check = false

@log_concurrent_update = false

@raise_concurrent_update = false

# Build tools

@cc = nil

@cxx = nil

@make = nil

@rake = nil

@tar = nil

@bzip = nil

@perl = nil

@gem = nil

# LLVM settings

@llvm_path = nil

@llvm_system_name = get_system_name

@llvm_configure = nil

@llvm_version = nil

@llvm_api_version = nil

@llvm_shared = false

@llvm_shared_objs = nil

@llvm_cxxflags = ""

@llvm_ldflags = ""

# System settings

@libc = nil

@x86_64 = false

@aarch64 = false

@dtrace = false

@dtrace_const = false

@have_lchmod = false

@have_lchown = false

@have_mkfifo = false

@debug_build = false

@include_dirs = []

@lib_dirs = []

# File system paths

@sourcedir = root

@prefixdir = nil

@bindir = nil

@appdir = nil

@libdir = nil

@encdir = nil

@runtimedir = nil

@codedbdir = nil

@codetoolsdir = nil

@stdlibdir = nil

@coredir = nil

@sitedir = nil

@archdir = nil

@vendordir = nil

@mandir = nil

@gemsdir = nil

@includedir = nil

@build_libdir = nil

@builddir = nil

@scriptdir = nil

@capi_includedir = "#{@sourcedir}/machine/include/capi"

@bootstrap_gems_dir = nil

@vm_release_h = File.join(root, "/machine/release.h")

@preserve_prefix = false

@program_name = "rbx"

@bin_links = ["rbx", "ruby", "rake", "gem", "irb", "rdoc", "ri", "erb"]

@use_bin_links = true

# List of all gems to pre-install.

@gems_list = File.join(root, "gems_list.txt")

@gem_files = File.readlines(@gems_list).map { |x| x.chomp }

@gem_names = @gem_files.map { |x| /(.*)-\d+\.\d+(\.\d+)?\.gem$/.match(x)[1] }

@installed_gems = [

"bundler-1.16.1.gem",

"minitest-5.11.1.gem",

"racc-1.4.14.gem",

"rake-12.3.0.gem",

"rdoc-5.1.0.gem",

"rb-readline-0.5.5.gem",

"test-unit-3.2.7.gem",

]

# Default cache directory, can be overwritten by the user.

@gems_cache = File.expand_path "../build/libraries/cache", __FILE__

# Vendored library settings

@build_libdir = File.join(root, "/build/libraries")

# Ruby compatibility version

@ruby_version = "10.0"

@ruby_libversion = @ruby_version.split(/\./)[0..1].join.to_i

@build_bin = "#{@sourcedir}/build/bin"

# Configure settings

@release_build = !in_git?

end

# Set up system commands to run in cmd.exe on Windows. Either Windows

# or MRI on Windows has issues with subprocesses where the invocation

# of the subprocess will return before the subprocess has finished.

# This manifests in configure when uncompressing LLVM source returns

# but attempting to move the directory fails sporadically with an access

# exception. Adding the, essentially no-op, 'sleep 0' resolves this.

def msys_system(cmd)

old_system %[cmd.exe /C "#{cmd} && sleep 0"]

end

def msys_backquote(cmd)

old_backquote %[cmd.exe /C "#{cmd}"]

end

def expand(path)

File.expand_path(path)

end

def expand_install_dir(dir)

dir = expand dir

if !@preserve_prefix and File.directory?(dir) and dir !~ /(rubinius|rbx).*\/?$/

original = dir

dir += "/rubinius/#{@libversion}"

@log.write "The directory #{original} already exists, installing to #{dir}"

end

dir

end

def set_host

/([^-]+)-([^-]+)-(.*)/ =~ @host

@cpu, @vendor, @os = $1, $2, $3

# TODO: For better cross-compiling support, it may be necessary to

# use the feature facility to check for a define in the compiler.

@windows = (@host =~ /mingw|mswin/) != nil

@darwin = (@host =~ /darwin/) != nil

@bsd = (@host =~ /bsd/) != nil

@linux = (@host =~ /linux/) != nil

end

def set_system_commands

# Set up system commands to run in cmd.exe on Windows.

if @windows

alias :old_system :system

alias :old_backquote :`

alias :system :msys_system

alias :` :msys_backquote

end

end

def set_filesystem_paths

@prefixdir = @prefixdir ? expand_install_dir(@prefixdir) : @sourcedir

if @appdir

dir = expand_install_dir @appdir

@libdir = dir + "/library"

@runtimedir = dir + "/runtime"

@codedbdir = dir + "/codedb"

@coredir = dir + "/core"

@sitedir = dir + "/site"

@archdir = dir + "/site/#{@cpu}-#{@os}"

@encdir = dir + "/site/#{@cpu}-#{@os}/encoding/converter"

@vendordir = dir + "/vendor"

end

@bindir = @prefixdir + "/bin" unless @bindir

@libdir = @prefixdir + "/library" unless @libdir

@runtimedir = @prefixdir + "/runtime" unless @runtimedir

@codedbdir = @prefixdir + "/codedb" unless @codedbdir

@coredir = @prefixdir + "/core" unless @coredir

@sitedir = @prefixdir + "/site" unless @sitedir

@archdir = @prefixdir + "/site/#{@cpu}-#{@os}" unless @archdir

@encdir = @prefixdir + "/site/#{@cpu}-#{@os}/encoding/converter" unless @encdir

@vendordir = @prefixdir + "/vendor" unless @vendordir

@mandir = @prefixdir + "/man" unless @mandir

@gemsdir = @prefixdir + "/gems" unless @gemsdir

@includedir = @prefixdir + "/machine/include/capi" unless @includedir

dirs = [@bindir, @libdir, @runtimedir, @codedbdir, @coredir, @sitedir,

@archdir, @vendordir, @mandir, @gemsdir, @includedir, @encdir]

parts = dirs.map { |d| d.split "/" }

i = 0

total = parts[0].size

prefix = []

while i < total

part = parts[0][i]

break unless parts.all? { |p| p[i] == part }

prefix << part

i += 1

end

@prefixdir = prefix.join "/"

size = @prefixdir.size

dirs.each { |d| d.replace d[size..-1] }

@scriptdir = "#{@sourcedir}/build/scripts"

@builddir = "#{@sourcedir}/build/rubinius" unless @builddir

stat = File.stat @builddir if File.exist? @builddir

if stat and stat.owned? and not @builddir.empty? and @builddir != "/"

FileUtils.rm_r @builddir

end

if @preserve_prefix

@builddir = File.expand_path "#{@builddir}/#{@prefixdir}"

end

FileUtils.mkdir_p @builddir

@bootstrap_gems_dir ||= "#{@sourcedir}/build/libraries/gems"

@codetoolsdir = "#{@sourcedir}/build/codetools"

@stdlibdir = "#{@sourcedir}/build/stdlib"

end

def add_opt_dir(dir)

@include_dirs << "#{dir}/include"

@lib_dirs << "#{dir}/lib" << "#{dir}/lib64"

end

def options

@options = Rubinius::Options.new "Usage: configure [options]", 30

o = @options

o.left_align

o.doc " Configure settings"

o.on "--log-file", "NAME", "Write log to file NAME" do |name|

old_log = @log.path

@log = Logger.new name, false

@log.replace old_log

end

o.on "--make", "NAME", "Use NAME as 'make' during build" do |name|

@make = name

end

o.on "--rake", "NAME", "Use NAME as 'rake' during build" do |name|

@rake = name

end

o.on "--tar", "NAME", "Use NAME as 'tar'" do |name|

@tar = name

end

o.on "--bzip", "NAME", "Use NAME as 'bzip'" do |name|

@bzip = name

end

o.on "--perl", "NAME", "Use NAME as 'perl' during build" do |name|

@perl = name

end

o.on "--gem", "NAME", "Use NAME as 'gem' during build" do |name|

@gem = name

end

o.on "--debug-build", "Disable C++ optimizations and retain debugging symbols" do

@debug_build = true

end

o.on "--sanitize", "SANITIZER", "Enable the Clang sanitizer: 'memory', 'address', 'undefined'" do |sanitizer|

if ["address", "memory", "undefined"].include?(sanitizer)

@debug_build = true

(@system_cxxflags ||= "") << " -fsanitize=#{sanitizer} -fno-omit-frame-pointer -fno-optimize-sibling-calls "

@system_cxxflags << " -fsanitize-address-use-after-scope " if sanitizer == "address"

@system_cxxflags << " -fsanitize-memory-track-origins " if sanitizer == "memory"

(@system_ldflags ||= "") << " -g -fsanitize=#{sanitizer} "

end

end

o.on "--release-build", "Build from local files instead of accessing the network" do

@release_build = true

end

o.on "--no-release-build", "Build from the network instead of local files" do

@release_build = false

end

o.on "--gc-stack-check", "Emit stack trace for all threads on pause for GC" do

@gc_stack_check = true

end

o.on "--log-concurrent-update", "Log when T2 updates an object created by T1" do

@log_concurrent_update = true

end

o.on "--raise-concurrent-update", "Raise a RuntimeError when T2 updates an object created by T1" do

@raise_concurrent_update = true

end

o.doc "\n Compiler settings"

o.on "--cc", "COMPILER", "Compiler to use for C code (eg clang)" do |cc|

@cc = cc

end

o.on "--cxx", "COMPILER", "Compiler to use for C++ code (eg clang++)" do |cxx|

@cxx = cxx

end

o.doc "\n LLVM settings"

o.on "--system-name", "NAME", "Name of OS (eg fedora-8, ubuntu-10.04)" do |name|

@llvm_system_name = name

end

o.on "--llvm-path", "PATH", "File system path to the directory containing LLVM" do |dir|

@llvm_path = dir.dup

end

o.on "--llvm-config", "PROGRAM", "File system path to the llvm-config program" do |program|

@llvm_configure = program

end

o.on "--llvm-shared", "Link to shared LLVM library" do

@llvm_shared = true

end

o.doc "\n System settings"

o.on "--with-include-dir", "DIR", "Add DIR to the default include search paths" do |dir|

dir.split(File::PATH_SEPARATOR).each do |d|

@include_dirs << d

end

end

o.on "--with-lib-dir", "DIR", "Add DIR to the default library search paths" do |dir|

dir.split(File::PATH_SEPARATOR).each do |d|

@lib_dirs << d

end

end

o.on "--with-opt-dir", "DIR", "Add DIR/include and DIR/lib to include and library search paths" do |dir|

dir.split(File::PATH_SEPARATOR).each do |d|

add_opt_dir(d)

end

end

o.on "--libc", "NAME", "Use NAME as the libc for FFI" do |name|

@libc = name

end

o.on "--host", "HOST", "Override guessed platform with HOST specification" do |host|

@log.write "------------------------------------------------------"

@log.write "\nChanging the platform specification can cause Rubinius"

@log.write "to malfunction. The current platform specification is:"

@log.write "\n#{@host}"

@log.write "\n------------------------------------------------------"

@host = host

end

o.doc "\n Program names"

o.on "--program-name", "NAME", "Build Rubinius executable as NAME" do |name|

@program_name = name

end

o.on "--bin-link", "NAME", "Create NAME as binary symlink to program name" do |name|

@bin_links << name

end

o.on "--no-bin-links", "Do not create any symlinks to program name" do

@use_bin_links = false

end

o.doc "\n File system paths for installing Rubinius"

o.on "-P", "--prefix", "PATH", "Install Rubinius in subdirectories of PATH" do |dir|

warn_prefix dir

@prefixdir = dir.dup

end

o.on "-B", "--bindir", "PATH", "Install Rubinius executable in PATH" do |dir|

@bindir = expand dir

end

o.on "-I", "--includedir", "PATH", "Install Rubinius C-API include files in PATH" do |dir|

@includedir = expand dir

end

o.on "-A", "--appdir", "PATH", "Install Ruby runtime and libraries in PATH" do |dir|

@appdir = dir.dup

end

o.on "-L", "--libdir", "PATH", "Install Rubinius shared library in PATH" do |dir|

@libdir = dir.dup

end

o.on "-M", "--mandir", "PATH", "Install man pages in PATH" do |dir|

@mandir = expand dir

end

o.on "-G", "--gemsdir", "PATH", "Install gems in PATH" do |dir|

@gemsdir = expand dir

end

o.on "--gems-cache", "PATH", "Cache Gems in PATH during compilation" do |dir|

@gems_cache = expand dir

end

o.on "--sitedir", "PATH", "Install site-specific Ruby code in PATH" do |dir|

@sitedir = expand dir

end

o.on "--archdir", "PATH", "Install arch-specific native extensions in PATH" do |dir|

@archdir = expand dir

end

o.on "--vendordir", "PATH", "Install vendor-specific Ruby code in PATH" do |dir|

@vendordir = expand dir

end

o.on "--preserve-prefix", "Use the configure prefix for staging Rubinius to install" do

@preserve_prefix = true

end

o.on "--stagingdir", "PATH", "Use PATH to build and prepare all files for install" do |dir|

@builddir = expand dir

end

o.doc "\n Optional features"

feature "execinfo", true

feature "vendor-zlib", false

feature "vendor-libsodium", true

feature "alloc-tracking", false

feature "dtrace", false

feature "rpath", false

o.doc "\n Help!"

o.on "--show", "Print the current configuration and exit" do

print_debug

exit 0

end

o.on "-V", "--verbose", "Print additional info" do

@verbose = true

end

o.help

o.doc ""

end

def feature(name, default_value=true)

@features[name] = ConfigurationToggle.new default_value

@options.on "--with-#{name}", "Enable #{name}" do

@features[name].configured = true

end

@options.on "--without-#{name}", "Disable #{name}" do

@features[name].configured = false

end

end

def parse(ary)

@options.parse ary

end

def md5_checksum(md5_path, full_path)

return Digest::MD5.file(full_path).hexdigest == File.read(md5_path).strip.split(" ").first

end

def download(url, full_path, follows=0)

begin

dir = File.dirname full_path

Dir.mkdir dir unless File.exist? dir

uri = url.kind_of?(URI) ? url : URI(url)

if ENV['http_proxy']

protocol, userinfo, p_host, p_port = URI::split(ENV['http_proxy'])

p_user, p_pass = userinfo.split(/:/) if userinfo

http = Net::HTTP.new(uri.host, uri.port, p_host, p_port, p_user, p_pass)

else

http = Net::HTTP.new(uri.host, uri.port)

end

http.use_ssl = true if uri.scheme == 'https'

request = Net::HTTP::Get.new(uri.request_uri)

http.request(request) do |res|

case res

when Net::HTTPNotFound

@log.write " #{url} not found."

return false

when Net::HTTPMovedPermanently,

Net::HTTPFound,

Net::HTTPSeeOther,

Net::HTTPTemporaryRedirect

if follows > 3

@log.write " ERROR: too many redirects: #{url}"

return false

end

return download URI.parse(res['Location']), full_path, follows + 1

when Net::HTTPClientError

@log.write " ERROR: #{res.inspect}"

return false

end

size = 0

total = res.header['Content-Length'].to_i

@log.write " Downloading #{File.basename(full_path)}..."

File.open full_path, "wb" do |f|

res.read_body do |chunk|

f << chunk

size += chunk.size

print "\r [ %d%% (%d of %d) ]" % [(size * 100) / total, size, total]

end

end

@log.write ": done!"

end

rescue Interrupt

File.unlink full_path if File.exist?(full_path)

raise

rescue StandardError => e

File.unlink full_path if File.exist?(full_path)

@log.write " ERROR: #{e.message}"

return false

end

return true

end

def setup_llvm

@log.print " Checking for 'llvm-config': "

config = @llvm_configure

if !config

which = ENV['PATH'].split(":").find do |path|

File.exist? File.join(path, "llvm-config")

end

if which

config = File.join(which, "llvm-config")

elsif @darwin

if macports?

config = macports_llvm_config

else

out = brew "--prefix llvm"

config = "#{out}/bin/llvm-config" if $?.success?

end

end

end

if config

config_cmd = llvm_config_cmd config

begin

version = `#{config_cmd} --version`.strip

# Ruby 1.8 returns an empty string

failed = true if version.empty?

rescue Errno::ENOENT

# Ruby 1.9 raises this error

failed = true

end

unless failed

parts = version.sub(/svn$/, "").split(".").map { |i| i.to_i }

api_version = ("%d%02d" % parts[0..1]).to_i

if api_version < 306

@log.write "only LLVM 3.6+ is supported"

else

@log.write "found! (version #{version} - api: #{api_version})"

@llvm = :config

@llvm_configure = config_cmd

@llvm_version = version

@llvm_api_version = api_version

check_llvm_flags

if @llvm_shared

setup_llvm_shared

end

return true

end

else

@log.write "executing #{config_cmd.inspect} failed"

end

else

@log.write "not found"

end

failure "ABORT: unable to set up LLVM"

end

def setup_llvm_shared

@log.print " Checking for LLVM shared libs: "

src = <<-EOP

#include <llvm/IR/LLVMContext.h>

using namespace llvm;

int main() { LLVMContext &Context = getGlobalContext(); }

EOP

common_args = "`#{@llvm_configure} --cppflags` #{@llvm_cxxflags} #{@llvm_ldflags}".strip.split(/\s+/)

shared_configs = {

"libLLVM-#{@llvm_version}" => ["-lLLVM-#{@llvm_version}"],

"#{@llvm_configure} --libs" => `#{@llvm_configure} --libs`.strip.split(/\s+/)

}

shared_configs.each do |desc, objs|

status = check_program(false, *(common_args + objs)) do |f|

f.puts src

@log.log src

end

if status == 0

@log.write "found! (using #{desc})"

@llvm_shared_objs = objs

return true

end

end

@log.write "not found"

false

end

def check_llvm_flags

flags = '--ldflags'

# Starting with LLVM 3.5 the --system-libs option is required in order to

# link against libraries such as zlib. Prior to 3.5 this was handled by

# --ldflags.

flags << ' --system-libs'

# Generate the actual flags. For whatever reason llvm-config also includes

# newlines in the output, so lets get rid of those while we're at it.

@llvm_ldflags = `#{@llvm_configure} #{flags}`.strip.gsub("\n", ' ')

end

def env(which)

ENV[which] || ""

end

def default_link_libs

libs = []

unless @host =~ /haiku/

libs << "m"

end

libs

end

def failure(message=nil)

@log.error message if message

STDERR.puts "\nRunning 'configure' failed. Please check configure.log for more details."

exit 1

end

def supported_compiler(name)

failure <<-EOM

Unable to find #{name} compiler. Support for compilers other than #{name}

compiler was deprecated 1 Jun 2016 and has been removed. If your platform does

not support #{name} compiler, please email contact@rubinius.com

EOM

end

def default_cc

return 'clang' if `clang --version > /dev/null 2>&1` && $?.success?

supported_compiler "clang C"

end

def default_cxx

return 'clang++' if `clang++ --version > /dev/null 2>&1` && $?.success?

supported_compiler "clang++ C++"

end

def check_tools

@cc ||= ENV['CC'] || default_cc

@cxx ||= ENV['CXX'] || default_cxx

check_tool_version @cc, '-dumpversion', [4, 1]

check_tool_version @cxx, '-dumpversion', [4, 1]

supported_compiler "clang C" unless @cc =~ /clang|ccc-analyzer/

supported_compiler "clang++ C++" unless @cxx =~ /clang\+\+|c\+\+\-analyzer/

if File.exist? @build_bin

if !File.directory? @build_bin

fail "#{@build_bin} already exists and is not a directory"

end

else

FileUtils.mkdir_p @build_bin

end

if @cc != "cc"

cc = "#{@build_bin}/cc"

File.symlink `which #{@cc}`.chomp, cc unless File.exist? cc

end

if @cxx != "c++"

cxx = "#{@build_bin}/c++"

File.symlink `which #{@cxx}`.chomp, cxx unless File.exist? cxx

end

@make ||= ENV['MAKE'] || 'make'

@rake ||= ENV['RAKE'] || 'rake'

@tar ||= ENV['TAR'] || (@windows ? 'bsdtar' : 'tar')

@bzip ||= ENV['BZIP'] || 'bzip2'

@perl ||= ENV['PERL'] || 'perl'

@gem ||= ENV['GEM'] || 'gem'

@gcc_major = `#{@cc} -dumpversion`.strip.split(".")[0,2].join(".")

if @host == "i686-pc-linux-gnu" || @host == "x86_64-unknown-linux-gnu"

@llvm_generic_prebuilt = "llvm-#{@llvm_version}-#{@host}-#{@gcc_major}.tar.bz2"

else

@llvm_generic_prebuilt = "llvm-#{@llvm_version}-#{@host}.tar.bz2"

end

@system_cflags ||= ""

(@system_cxxflags ||= "") << "-std=c++14 "

@system_cppflags ||= ""

@system_incflags ||= ""

@system_ldflags ||= ""

@user_cflags = ENV['CFLAGS']

@user_cxxflags = ENV['CXXFLAGS']

@user_cppflags = ENV['CPPFLAGS']

@user_incflags = ENV['INCFLAGS']

@user_ldflags = ENV['LDFLAGS']

setup_platform

end

def setup_platform

@ldsharedxx = "#{@cxx} -shared"

@ldshared = "#{@cc} -shared"

@include_dirs.each do |d|

@system_incflags << "-I#{d} "

end

@lib_dirs.each do |d|

@system_ldflags << "-L#{d} "

end

case RUBY_PLATFORM

when /mswin/i, /mingw/i, /bccwin32/i

# TODO: discovery helpers

#check_heads(%w[windows.h winsock.h], true)

#check_libs(%w[kernel32 rpcrt4 gdi32], true)

unless RUBY_PLATFORM =~ /mingw/

@system_cflags << "-EHs -GR"

end

@system_ldflags << "-lws2_32"

@features["rpath"].configured = false

when /solaris/i

# GNU CHAIN only supported

@ldsharedxx = "#{@cxx} -shared -G -fPIC -lstdc++"

@ldshared = "#{@cc} -shared -G -fPIC"

@system_cflags << "-fPIC -Wno-strict-aliasing"

@system_ldflags << "-lsocket -lnsl -fPIC"

@features["rpath"].configured = false

@make = "gmake"

when /freebsd/i

@ldsharedxx = "#{@cxx} -shared -fPIC"

@ldshared = "#{@cc} -shared -fPIC"

@system_cflags << "-fPIC"

@system_ldflags << "-lcrypt -pthread -rdynamic"

@make = "gmake"

when /openbsd/i

# OpenBSD branch contributed by Guillaume Sellier.

# on Unix we need a g++ link, not gcc. On OpenBSD, linking against

# libstdc++ have to be explicitly done for shared libs

@ldsharedxx = "#{@cxx} -shared -lstdc++ -fPIC"

@ldshared = "#{@cc} -shared -fPIC"

@system_cflags << "-fPIC"

@system_ldflags << "-pthread -rdynamic -Wl,--export-dynamic"

@make = "gmake"

when /netbsd/i

@ldsharedxx = "#{@cxx} -shared -lstdc++ -fPIC"

@ldshared = "#{@cc} -shared -fPIC"

@system_cflags << "-fPIC"

@system_ldflags << "-lcrypt -pthread -rdynamic -Wl,--export-dynamic"

@make = "gmake"

when /darwin/i

# on Unix we need a g++ link, not gcc.

# Ff line contributed by Daniel Harple.

@ldsharedxx = "#{@cxx} -bundle -undefined suppress -flat_namespace"

@ldshared = "#{@cc} -bundle -undefined suppress -flat_namespace"

@system_cflags << "-fPIC -D_DARWIN_USE_64_BIT_INODE"

@features["rpath"].configured = false

when /haiku/i

@system_cflags << "-fPIC"

@system_ldflags << "-ldl -lnetwork"

@features["rpath"].configured = false

when /aix/i

@ldsharedxx = "#{@cxx} -shared -Wl,-G -Wl,-brtl"

@ldshared = "#{@cc} -shared -Wl,-G -Wl,-brtl"

@features["rpath"].configured = false

when /linux/i

@system_cflags << "-fPIC"

@system_ldflags << "-Wl,--export-dynamic -lrt -lcrypt -ldl -lpthread"

else

# on Unix we need a g++ link, not gcc.

@system_cflags << "-fPIC"

@system_ldflags << "-ldl -lpthread"

end

if @features["rpath"].value

@lib_dirs.each do |d|

@system_ldflags << " -Wl,-rpath=#{d}"

end

end

end

def check_program(run=true, *arguments)

begin

basename = "rbx-configure-test"

source = basename + ".cpp"

File.open source, "wb" do |f|

yield f

end

File.open source, "rb" do |f|

@log.log f.read

end

libs = default_link_libs.map { |l| "-l#{l}" }.join(" ")

args = arguments.join(" ")

cmd = "#{@cxx} #{@user_cppflags} #{@user_cflags} #{@user_cxxflags} #{@user_incflags} #{@user_ldflags} -o #{basename} #{source} #{@system_cppflags} #{@system_cflags} #{@system_cxxflags} #{@system_incflags} #{@system_ldflags} #{libs} #{args} >>#{@log.path} 2>&1"

@log.log cmd

system cmd

return $?.exitstatus unless run

unless $?.exitstatus == 0

@log.log msg = "Compiling configure test program failed."

raise RuntimeError, msg

end

system expand("./#{basename}")

return $?.exitstatus

rescue => e

@log.log "Error in check_program: #{e.class} #{e.message}\n #{e.backtrace.join("\n ")}"

raise e

ensure

FileUtils.rm_r(Dir["#{basename}*"])

end

end

def write_have_defines(f)

f.puts

@defines.each { |d| f.puts "#define #{d.ljust(20)} 1" }

end

def write_have_sizeof_defines(f)

f.puts

@sizeof.keys.sort.each { |k| f.puts "#define HAVE_#{k}".ljust(30) + "1" }

end

def write_sizeof_defines(f)

f.puts

@sizeof.keys.sort.each { |k| f.puts "#define SIZEOF_#{k}".ljust(30) + @sizeof[k].to_s }

end

def sizeof_typename(type)

if type =~ /(\*+)$/

name = "#{type[0...-$1.size]}#{"p" * $1.size}"

else

name = type

end

name.gsub(/\W/, "_").upcase

end

def sizeof(type)

@sizeof[sizeof_typename(type)] or failure("Unknown type: '#{type}'.")

end

def assert_sizeof

@log.print "Checking sizeof(intptr_t) == sizeof(int64_t): "

status = check_program do |f|

src = <<-EOP

#include <stdint.h>

int main(int argc, char* argv[]) {

return sizeof(intptr_t) == sizeof(int64_t);

}

EOP

f.puts src

@log.log src

end

if status == 1

@log.write "yes"

else

@log.write "no"

failure "\nRubinius requires that sizeof(intptr_t) == sizeof(int64_t)"

end

end

def detect_sizeof(type, includes=[])

@log.print "Checking sizeof(#{type}): "

size = check_program do |f|

src = includes.map { |include| "#include <#{include}>\n" }.join

src += <<-EOP

#include <stddef.h>

#include <stdint.h>

int main() { return sizeof(#{type}); }

EOP

f.puts src

@log.log src

end

@sizeof[sizeof_typename(type)] = size

@log.write "#{size} bytes"

end

def detect_endian

@log.print "Checking platform endianness: "

status = check_program do |f|

src = "int main() { int one = 1; return (*((char*)&one)) == 1 ? 0 : 1; }"

f.puts src

@log.log src

end

@little_endian = (status == 0)

@log.write @little_endian ? "little endian" : "big endian"

end

def detect_tr1

@log.print "Checking for tr1: "

status = check_program(false) do |f|

src = <<-EOP

#include <tr1/unordered_map>

typedef std::tr1::unordered_map<int, void*> X;