зеркало из https://github.com/github/ruby.git
4343 строки
140 KiB
Plaintext
4343 строки
140 KiB
Plaintext
dnl Process this file with autoconf to produce a configure script.
|
|
AC_INIT
|
|
{
|
|
AC_CONFIG_AUX_DIR(tool)
|
|
|
|
AC_PREREQ(2.67)
|
|
|
|
tooldir="$srcdir/tool"
|
|
|
|
AC_DISABLE_OPTION_CHECKING
|
|
|
|
m4_include([tool/m4/_colorize_result_prepare.m4])dnl
|
|
m4_include([tool/m4/ac_msg_result.m4])dnl
|
|
m4_include([tool/m4/colorize_result.m4])dnl
|
|
m4_include([tool/m4/ruby_append_option.m4])dnl
|
|
m4_include([tool/m4/ruby_append_options.m4])dnl
|
|
m4_include([tool/m4/ruby_check_builtin_func.m4])dnl
|
|
m4_include([tool/m4/ruby_check_builtin_setjmp.m4])dnl
|
|
m4_include([tool/m4/ruby_check_printf_prefix.m4])dnl
|
|
m4_include([tool/m4/ruby_check_setjmp.m4])dnl
|
|
m4_include([tool/m4/ruby_check_signedness.m4])dnl
|
|
m4_include([tool/m4/ruby_check_sizeof.m4])dnl
|
|
m4_include([tool/m4/ruby_check_sysconf.m4])dnl
|
|
m4_include([tool/m4/ruby_cppoutfile.m4])dnl
|
|
m4_include([tool/m4/ruby_decl_attribute.m4])dnl
|
|
m4_include([tool/m4/ruby_default_arch.m4])dnl
|
|
m4_include([tool/m4/ruby_define_if.m4])dnl
|
|
m4_include([tool/m4/ruby_defint.m4])dnl
|
|
m4_include([tool/m4/ruby_dtrace_available.m4])dnl
|
|
m4_include([tool/m4/ruby_dtrace_postprocess.m4])dnl
|
|
m4_include([tool/m4/ruby_func_attribute.m4])dnl
|
|
m4_include([tool/m4/ruby_mingw32.m4])dnl
|
|
m4_include([tool/m4/ruby_prepend_option.m4])dnl
|
|
m4_include([tool/m4/ruby_prog_gnu_ld.m4])dnl
|
|
m4_include([tool/m4/ruby_replace_funcs.m4])dnl
|
|
m4_include([tool/m4/ruby_replace_type.m4])dnl
|
|
m4_include([tool/m4/ruby_rm_recursive.m4])dnl
|
|
m4_include([tool/m4/ruby_setjmp_type.m4])dnl
|
|
m4_include([tool/m4/ruby_stack_grow_direction.m4])dnl
|
|
m4_include([tool/m4/ruby_try_cflags.m4])dnl
|
|
m4_include([tool/m4/ruby_try_cxxflags.m4])dnl
|
|
m4_include([tool/m4/ruby_try_ldflags.m4])dnl
|
|
m4_include([tool/m4/ruby_universal_arch.m4])dnl
|
|
m4_include([tool/m4/ruby_werror_flag.m4])dnl
|
|
|
|
AC_ARG_VAR([cflags], [additional CFLAGS (ignored when CFLAGS is given)])dnl
|
|
AC_ARG_VAR([cppflags], [additional CPPFLAGS (ignored when CPPFLAGS is given)])dnl
|
|
AC_ARG_VAR([cxxflags], [additional CXXFLAGS (ignored when CXXFLAGS is given)])dnl
|
|
|
|
: "environment section" && {
|
|
HAVE_BASERUBY=yes
|
|
BASERUBY_VERSION=
|
|
AC_ARG_WITH(baseruby,
|
|
AS_HELP_STRING([--with-baseruby=RUBY], [use RUBY as baseruby; RUBY is the pathname of ruby]),
|
|
[AS_CASE(["$withval"],
|
|
[*ruby*],[BASERUBY=$withval],
|
|
[no],[HAVE_BASERUBY=no],
|
|
[AC_MSG_ERROR(need ruby)])
|
|
],
|
|
[
|
|
AC_PATH_PROG([BASERUBY], [ruby], [false])
|
|
])
|
|
AS_IF([test "$HAVE_BASERUBY" != no -a "`RUBYOPT=- $BASERUBY --disable=gems -e 'print 42 if RUBY_VERSION > "2.2"' 2>/dev/null`" = 42], [
|
|
BASERUBY="$BASERUBY --disable=gems"
|
|
BASERUBY_VERSION=`$BASERUBY -v`
|
|
$BASERUBY -C "$srcdir" tool/downloader.rb -d tool -e gnu config.guess config.sub >&AS_MESSAGE_FD
|
|
], [
|
|
BASERUBY="echo executable host ruby is required. use --with-baseruby option.; false"
|
|
HAVE_BASERUBY=no
|
|
])
|
|
AC_SUBST(BASERUBY)
|
|
AC_SUBST(HAVE_BASERUBY)
|
|
|
|
: ${GIT=git}
|
|
HAVE_GIT=yes
|
|
AC_ARG_WITH(git,
|
|
AS_HELP_STRING([--without-git], [never use git]),
|
|
[AS_CASE([$withval],
|
|
[no], [GIT=never-use HAVE_GIT=no],
|
|
[yes], [],
|
|
[GIT=$withval])])
|
|
AS_IF([test x"$HAVE_GIT" = xyes], [command -v "$GIT" > /dev/null || HAVE_GIT=no])
|
|
AC_SUBST(GIT)
|
|
AC_SUBST(HAVE_GIT)
|
|
|
|
eval `sed -n -e ['s/^@%:@define RUBY_[A-Z_]*VERSION_\([A-Z][A-Z][A-Z_0-9]*\) \([0-9][0-9]*\)$/\1=\2/p'] \
|
|
-e ['s/^@%:@define \(RUBY_PATCHLEVEL\) \(.*\)/\1=\2/p'] \
|
|
$srcdir/include/ruby/version.h $srcdir/version.h`
|
|
for v in MAJOR MINOR TEENY; do
|
|
AS_IF([eval "test \"\$$v\" = ''"], [
|
|
AC_MSG_ERROR(could not determine $v number from version.h)
|
|
])
|
|
done
|
|
AC_SUBST(MAJOR)
|
|
AC_SUBST(MINOR)
|
|
AC_SUBST(TEENY)
|
|
AC_SUBST(RUBY_API_VERSION, '$(MAJOR).$(MINOR)')
|
|
AC_SUBST(RUBY_PROGRAM_VERSION, '$(MAJOR).$(MINOR).$(TEENY)')
|
|
|
|
AS_IF([test "$program_prefix" = NONE], [
|
|
program_prefix=
|
|
])
|
|
AS_IF([test "$prefix" -ef .], [
|
|
AC_MSG_ERROR(--prefix cannot be the current working directory.)
|
|
])
|
|
RUBY_BASE_NAME=`echo ruby | sed "$program_transform_name"`
|
|
RUBYW_BASE_NAME=`echo rubyw | sed "$program_transform_name"`
|
|
AC_SUBST(RUBY_BASE_NAME)
|
|
AC_SUBST(RUBYW_BASE_NAME)
|
|
AC_SUBST(RUBY_VERSION_NAME, '${RUBY_BASE_NAME}-${ruby_version}')
|
|
|
|
dnl checks for alternative programs
|
|
AC_CANONICAL_BUILD
|
|
AC_CANONICAL_HOST
|
|
AC_CANONICAL_TARGET
|
|
AS_CASE(["$target_cpu-$target_os"],
|
|
[aarch64-darwin*], [
|
|
target_cpu=arm64
|
|
AS_CASE(["$target_vendor"], [unknown], [target_vendor=apple target=${target/-unknown-/-apple-}])
|
|
target="${target/aarch64/arm64}"
|
|
target_alias="${target_alias/aarch64/arm64}"
|
|
])
|
|
|
|
AC_ARG_PROGRAM
|
|
RUBY_RM_RECURSIVE
|
|
AC_ARG_WITH(gcc,
|
|
AS_HELP_STRING([--without-gcc], [never use gcc]),
|
|
[
|
|
AS_CASE([$withval],
|
|
[no], [: ${CC=cc}],
|
|
[yes], [: ${CC=gcc}],
|
|
[CC=$withval])])
|
|
dnl If the user switches compilers, we can't believe the cache
|
|
AS_IF([test ! -z "$ac_cv_prog_CC" -a ! -z "$CC" -a "$CC" != "$ac_cv_prog_CC"], [
|
|
AC_MSG_ERROR(cached CC is different -- throw away $cache_file
|
|
(it is also a good idea to do 'make clean' before compiling))
|
|
])
|
|
AS_CASE(["${build_os}"],
|
|
[linux*|cygwin*|msys*], [
|
|
# Naruse prefers GCC on Linux
|
|
AC_CHECK_TOOLS([CC], [gcc clang cc])
|
|
],
|
|
[solaris*], [
|
|
# Clang on Solaris is largely untested.
|
|
# https://bugs.ruby-lang.org/issues/17949
|
|
AC_CHECK_TOOLS([CC], [cc gcc])
|
|
], [
|
|
# OpenBSD wants to prefer cc over gcc.
|
|
# See https://github.com/ruby/ruby/pull/2443
|
|
AC_CHECK_TOOLS([CC], [cl.exe clang cc gcc c99 /usr/ucb/cc])
|
|
])
|
|
|
|
AC_ARG_VAR([AR], [Archiver command])
|
|
AC_ARG_VAR([AS], [Assembler command])
|
|
AC_ARG_VAR([CC], [C compiler command])
|
|
AC_ARG_VAR([CXX], [C++ compiler command])
|
|
AC_ARG_VAR([LD], [Linker command])
|
|
AC_ARG_VAR([NM], [Symbol list command])
|
|
AC_ARG_VAR([OBJCOPY], [Objcopy command])
|
|
AC_ARG_VAR([OBJDUMP], [Objdump command])
|
|
AC_ARG_VAR([RANLIB], [Ranlib command])
|
|
AC_ARG_VAR([STRIP], [Strip command])
|
|
|
|
# We don't want to bother things like `ccache gcc`, `clang -shared-libgcc`, ...
|
|
set rb_dummy ${CC}
|
|
rb_CC=$2
|
|
AS_CASE(["/${rb_CC} "],
|
|
[*@<:@\ /@:>@"cc "*], [
|
|
# Don't try g++/clang++ when CC=cc
|
|
AC_CHECK_TOOLS([CXX], [cl.exe CC c++])
|
|
],
|
|
[*icc*], [
|
|
# Intel C++ has interprocedural optimizations. It tends to come with its
|
|
# own linker etc.
|
|
AC_CHECK_TOOL([AR], [`echo "${rb_CC}" | sed s/icc/xiar/`])
|
|
AC_CHECK_TOOL([CXX], [`echo "${rb_CC}" | sed s/icc/icpc/`])
|
|
AC_CHECK_TOOL([LD], [`echo "${rb_CC}" | sed s/icc/xild/`])
|
|
],
|
|
[*gcc*], [
|
|
# Dito for GCC.
|
|
AC_CHECK_TOOL([LD], [`echo "${rb_CC}" | sed s/gcc/ld/`])
|
|
AC_CHECK_TOOL([AR], [`echo "${rb_CC}" | sed s/gcc/gcc-ar/`])
|
|
AC_CHECK_TOOL([CXX], [`echo "${rb_CC}" | sed s/gcc/g++/`])
|
|
AC_CHECK_TOOL([NM], [`echo "${rb_CC}" | sed s/gcc/gcc-nm/`])
|
|
AC_CHECK_TOOL([RANLIB], [`echo "${rb_CC}" | sed s/gcc/gcc-ranlib/`])
|
|
],
|
|
[*clang*], [
|
|
# Dito for LLVM. Note however that llvm-as is a LLVM-IR to LLVM bitcode
|
|
# assembler that does not target your machine native binary.
|
|
: ${LD:="${CC}"} # ... try -fuse-ld=lld ?
|
|
AC_CHECK_TOOL([AR], [`echo "${rb_CC}" | sed s/clang/llvm-ar/`])
|
|
# AC_CHECK_TOOL([AS], [`echo "${rb_CC}" | sed s/clang/llvm-as/`])
|
|
AC_CHECK_TOOL([CXX], [`echo "${rb_CC}" | sed s/clang/clang++/`])
|
|
AC_CHECK_TOOL([NM], [`echo "${rb_CC}" | sed s/clang/llvm-nm/`])
|
|
AC_CHECK_TOOL([OBJCOPY], [`echo "${rb_CC}" | sed s/clang/llvm-objcopy/`])
|
|
AC_CHECK_TOOL([OBJDUMP], [`echo "${rb_CC}" | sed s/clang/llvm-objdump/`])
|
|
AC_CHECK_TOOL([RANLIB], [`echo "${rb_CC}" | sed s/clang/llvm-ranlib/`])
|
|
AC_CHECK_TOOL([STRIP], [`echo "${rb_CC}" | sed s/clang/llvm-strip/`])
|
|
])
|
|
AS_UNSET(rb_CC)
|
|
AS_UNSET(rb_dummy)
|
|
|
|
AS_CASE(["${build_os}"],
|
|
[solaris*], [
|
|
AC_PATH_TOOL([LD], [ld], [/usr/ccs/bin/ld], [/usr/ccs/bin:$PATH])
|
|
],
|
|
[aix*], [
|
|
AC_PATH_TOOL([NM], [nm], [/usr/ccs/bin/nm], [/usr/ccs/bin:$PATH])
|
|
])
|
|
AS_CASE(["${target_os}"],
|
|
[cygwin*|msys*|mingw*], [
|
|
ac_cv_prog_ac_ct_OBJCOPY=":"
|
|
])
|
|
|
|
rb_test_CFLAGS=${CFLAGS+yes}
|
|
rb_test_CXXFLAGS=${CXXFLAGS+yes}
|
|
|
|
# BSD's ports and MacPorts prefix GNU binutils with 'g'
|
|
|
|
dnl Seems necessarily in order to add -std=gnu99 option for gcc 4.9.
|
|
m4_version_prereq([2.70], [AC_PROG_CC], [AC_PROG_CC_C99])
|
|
|
|
AC_PROG_CXX
|
|
AC_PROG_CPP
|
|
AC_PROG_RANLIB
|
|
AC_CHECK_TOOLS([AR], [gar ar])
|
|
AC_CHECK_TOOLS([AS], [gas as])
|
|
AC_CHECK_TOOLS([LD], [gld ld]) # ... try gold ?
|
|
AC_CHECK_TOOLS([NM], [gnm nm])
|
|
AC_CHECK_TOOLS([OBJCOPY], [gobjcopy objcopy])
|
|
AC_CHECK_TOOLS([OBJDUMP], [gobjdump objdump])
|
|
AC_CHECK_TOOLS([STRIP], [gstrip strip], [:])
|
|
|
|
AS_IF([test ! $rb_test_CFLAGS], [AS_UNSET(CFLAGS)]); AS_UNSET(rb_test_CFLAGS)
|
|
AS_IF([test ! $rb_test_CXXFLAGS], [AS_UNSET(CXXFLAGS)]); AS_UNSET(rb_save_CXXFLAGS)
|
|
|
|
AS_IF([test "${CXX}" = "g++" -a -z "${GXX}"], [
|
|
# AC_PROG_CXX sets $CXX to "g++" when it purposefully finds that there is
|
|
# _no_ g++. This brain-damaged design must be worked around. Thankfully,
|
|
# similar thing doesn't happen for AC_PROG_CC.
|
|
rb_there_is_in_fact_no_gplusplus_but_autoconf_is_cheating_us=true
|
|
])
|
|
|
|
test x"$target_alias" = x &&
|
|
target_os=`echo $target_os | sed 's/linux-gnu$/linux/;s/linux-gnu/linux-/'`
|
|
ac_install_sh='' # unusable for extension libraries.
|
|
|
|
AC_ARG_WITH(os-version-style,
|
|
AS_HELP_STRING([--with-os-version-style=TYPE],
|
|
[OS version number for target and target_os [[full]]]
|
|
[(full|teeny|minor+0|minor|major+0|major|none)]),
|
|
[os_version_style=$withval],
|
|
[os_version_style=full
|
|
AS_CASE($target_os, [[*[0-9].*]],
|
|
[AS_CASE([`/usr/bin/ruby -e 'puts RUBY_PLATFORM' 2>/dev/null`],
|
|
[[*-*[0-9].*.0]], [os_version_style=minor+0],
|
|
[[*-*[0-9].*.*]], [os_version_style=full],
|
|
[[*-*[0-9].0] ], [os_version_style=major+0],
|
|
[[*-*[0-9].*] ], [os_version_style=minor],
|
|
[[*-*[0-9]] ], [os_version_style=major],
|
|
)])
|
|
])
|
|
os_version_style_transform=
|
|
AS_CASE("${os_version_style}",
|
|
[full|teeny], [],
|
|
[minor+0], [os_version_style_transform=['s/\([0-9]\.[0-9][0-9]*\)\.[0-9][.0-9]*$/\1.0/']],
|
|
[minor], [os_version_style_transform=['s/\([0-9]\.[0-9][0-9]*\)\.[0-9][.0-9]*$/\1/']],
|
|
[major+0], [os_version_style_transform=['s/\([0-9]\)\.[0-9][.0-9]*$/\1.0/']],
|
|
[major], [os_version_style_transform=['s/\([0-9]\)\.[0-9][.0-9]*$/\1/']],
|
|
[none], [os_version_style_transform=['s/[0-9]*\.[0-9][.0-9]*$//']],
|
|
[AC_MSG_ERROR(unknown --with-os-version-style: $withval)])
|
|
AS_IF([test -z "$target_alias" -a -n "$os_version_style_transform"],
|
|
[
|
|
target=`echo ${target} | sed "$os_version_style_transform"`
|
|
target_os=`echo ${target_os} | sed "$os_version_style_transform"`
|
|
])
|
|
|
|
AC_ARG_WITH(arch,
|
|
AS_HELP_STRING([--with-arch=ARCHS],
|
|
[build an Apple/NeXT Multi Architecture Binary (MAB);
|
|
ARCHS is a comma-delimited list of architectures for
|
|
which to build; if this option is disabled or omitted
|
|
entirely, then the package will be built only for the
|
|
target platform]),
|
|
[target_archs="$withval"], [unset target_archs])
|
|
|
|
AC_ARG_ENABLE(load-relative,
|
|
AS_HELP_STRING([--enable-load-relative], [resolve load paths at run time]),
|
|
[load_relative=$enableval])
|
|
|
|
# checks for UNIX variants that set C preprocessor variables
|
|
AC_USE_SYSTEM_EXTENSIONS
|
|
|
|
dnl Checks for programs.
|
|
|
|
cflagspat=
|
|
test -z "$optflags" ||
|
|
cflagspat="$cflagspat;s|"`eval echo '"'"${optflags}"'"' | sed 's/[[][|.*]]/\\&/g;s/^ */ /;s/ *$/ /'`'| |g'
|
|
test -z "$debugflags" ||
|
|
cflagspat="$cflagspat;s|"`eval echo '"'"${debugflags}"'"' | sed 's/[[][|.*]]/\\&/g;s/^ */ /;s/ *$/ /'`'| |g'
|
|
test -z "$warnflags" ||
|
|
cflagspat="$cflagspat;s|"`eval echo '"'"${warnflags}"'"' | sed 's/[[][|.*]]/\\&/g;s/^ */ /;s/ *$/ /'`'| |g'
|
|
AS_IF([test -z "${CFLAGS+set}"], [
|
|
cflags=`echo " $cflags " | sed "$cflagspat;s/^ *//;s/ *$//"`
|
|
orig_cflags="$cflags"
|
|
cflags="$cflags "'${optflags} ${debugflags} ${warnflags}'
|
|
])
|
|
dnl AS_IF([test -z "${CXXFLAGS+set}"], [
|
|
dnl cxxflags=`echo " $cxxflags " | sed "$cflagspat;s/^ *//;s/ *$//"`
|
|
dnl orig_cxxflags="$cxxflags"
|
|
dnl cxxflags="$cxxflags "'${optflags} ${debugflags} ${warnflags}'
|
|
dnl ])
|
|
|
|
AS_CASE(["$host_os:$build_os"],
|
|
[darwin*:darwin*], [
|
|
# Following Apple deployed clang are broken
|
|
# clang version 1.0 (http://llvm.org/svn/llvm-project/cfe/tags/Apple/clang-23 exported)
|
|
# Apple clang version 2.0 (tags/Apple/clang-137) (based on LLVM 2.9svn)
|
|
# Apple clang version 2.1 (tags/Apple/clang-163.7.1) (based on LLVM 3.0svn)
|
|
AC_PREPROC_IFELSE(
|
|
[AC_LANG_PROGRAM([
|
|
@%:@if defined __APPLE_CC__ && defined __clang_major__ && __clang_major__ < 3
|
|
@%:@error premature clang
|
|
@%:@endif
|
|
])],
|
|
[],
|
|
[AC_MSG_ERROR([clang version 3.0 or later is required])])
|
|
])
|
|
|
|
AS_CASE(["$target_os"],
|
|
[darwin*], [
|
|
AC_MSG_CHECKING(if minimum required OS X version is supported)
|
|
AC_PREPROC_IFELSE([AC_LANG_SOURCE([[@%:@include <AvailabilityMacros.h>
|
|
@%:@if MAC_OS_X_VERSION_MIN_REQUIRED < __MAC_10_5
|
|
@%:@error pre OS X 10.5
|
|
[!<===== pre OS X 10.5 =====>]
|
|
@%:@endif
|
|
]])],
|
|
[macosx_min_required=yes],
|
|
[AC_MSG_RESULT(no)
|
|
AC_MSG_ERROR([Unsupported OS X version is required])])
|
|
AC_MSG_RESULT(${macosx_min_required})
|
|
])
|
|
|
|
RUBY_MINGW32
|
|
AC_SUBST(GCC)
|
|
AC_SUBST(LD)
|
|
AS_IF([test "$GCC" = yes], [
|
|
linker_flag=-Wl,
|
|
: ${optflags=-O3}
|
|
gcc_major=`echo =__GNUC__ | $CC -E -xc - | sed '/^=/!d;s///'`
|
|
gcc_minor=`echo =__GNUC_MINOR__ | $CC -E -xc - | sed '/^=/!d;s///'`
|
|
test -n "$gcc_major" || gcc_major=0
|
|
test -n "$gcc_minor" || gcc_minor=0
|
|
icc_version=`echo =__ICC | $CC -E -xc - | sed '/^=/!d;s///;/^__ICC/d'`
|
|
test -n "$icc_version" || icc_version=0
|
|
# RUBY_APPEND_OPTIONS(XCFLAGS, ["-include ruby/config.h" "-include ruby/missing.h"])
|
|
], [
|
|
linker_flag=
|
|
])
|
|
|
|
AS_IF([test "$GCC" = yes -a "$gcc_major" -lt 3 ], [
|
|
AC_MSG_ERROR([too old GCC])
|
|
])
|
|
|
|
RUBY_PROG_GNU_LD
|
|
RUBY_CPPOUTFILE
|
|
|
|
: ${OUTFLAG='-o '}
|
|
: ${COUTFLAG=${OUTFLAG}}
|
|
: ${CSRCFLAG=''}
|
|
AC_SUBST(OUTFLAG)
|
|
AC_SUBST(COUTFLAG)
|
|
AC_SUBST(CSRCFLAG)
|
|
|
|
: ${MJIT_CC=$CC}
|
|
AS_IF([test "x$cross_compiling" = xno], [
|
|
AC_PATH_PROG([MJIT_CC], ${MJIT_CC})
|
|
|
|
# if $CC is in /usr/lib/ccache/$CC, search original $CC (disable ccache)
|
|
AS_IF([echo $RUBY_DEBUG | grep ci > /dev/null &&
|
|
echo $MJIT_CC | grep ^/usr/lib/ccache > /dev/null], [
|
|
PATH=`echo $PATH | sed "s/\/usr\/lib\/ccache://"` MJIT_CC=`which $CC`])
|
|
|
|
AS_CASE([$target_os],
|
|
[*mingw*], [command -v cygpath > /dev/null && MJIT_CC=`cygpath -ma $MJIT_CC`])
|
|
shift 2
|
|
MJIT_CC="$MJIT_CC${1+ }$*"
|
|
])
|
|
|
|
AS_CASE(["$build_os"],
|
|
[darwin1*.*], [
|
|
# Xcode linker warns for deprecated architecture and wrongly
|
|
# installed TBD files.
|
|
CC_WRAPPER=""
|
|
echo 'int main(void) {return 0;}' > conftest.c
|
|
AS_IF([$CC -framework Foundation -o conftest conftest.c 2>&1 |
|
|
grep '^ld: warning: text-based stub file' >/dev/null], [
|
|
CC_WRAPPER=`cd -P "${tooldir}" && pwd`/darwin-cc
|
|
CC="$CC_WRAPPER $CC"
|
|
])
|
|
rm -fr conftest*
|
|
])
|
|
|
|
cc_version=
|
|
for option in --version -v -V -qversion; do
|
|
cc_version_message=`$CC $option 2>&1`
|
|
cc_version_status=$?
|
|
AS_CASE($cc_version_status, [0], [:], [continue])
|
|
AS_CASE($cc_version_message, [*Warning*], [continue])
|
|
cc_version='$(CC) '$option
|
|
break
|
|
done
|
|
AC_SUBST(CC_VERSION, $cc_version)
|
|
AC_SUBST(CC_VERSION_MESSAGE, $cc_version_message)
|
|
|
|
: ${DLDFLAGS="$LDFLAGS"}
|
|
|
|
RUBY_UNIVERSAL_ARCH
|
|
AS_IF([test "$target_cpu" != "$host_cpu" -a "$GCC" = yes -a "$cross_compiling" = no -a "${universal_binary:-no}" = no], [
|
|
RUBY_DEFAULT_ARCH("$target_cpu")
|
|
])
|
|
host_os=$target_os
|
|
host_vendor=$target_vendor
|
|
host_cpu=$target_cpu
|
|
host=$target
|
|
host_alias=$target_alias
|
|
|
|
AC_CACHE_CHECK([for $AR flags], [rb_cv_arflags], [
|
|
AS_IF([$AR rcD conftest.a > /dev/null 2>&1 && rm conftest.a],
|
|
[rb_cv_arflags=rcD], [rb_cv_arflags=rcu])
|
|
])
|
|
AC_SUBST(ARFLAGS, ["$rb_cv_arflags "])
|
|
AC_SUBST(ASFLAGS)
|
|
|
|
AS_CASE(["$target_os"],
|
|
[cygwin*|msys*|mingw*], [
|
|
AC_CHECK_TOOL(WINDRES, windres)
|
|
AC_CHECK_TOOL(DLLWRAP, dllwrap)
|
|
target=`echo $target | sed "s/^$target_cpu-/-/"`
|
|
target_alias=`echo $target_alias | sed "s/^$target_cpu-/-/"`
|
|
target_cpu=`echo $target_cpu | sed s/i.86/i386/`
|
|
AS_CASE(["$target"], [-*], [ target="$target_cpu${target}"])
|
|
AS_CASE(["$target_alias"], [-*], [ target_alias="$target_cpu${target_alias}"])
|
|
AS_CASE(["$target_os"],
|
|
[mingw*], [
|
|
test "$rb_cv_msvcrt" = "" && unset rb_cv_msvcrt
|
|
AC_CACHE_CHECK(for mingw32 runtime DLL, rb_cv_msvcrt, [
|
|
AC_LINK_IFELSE([AC_LANG_PROGRAM([[@%:@include <stdio.h>]],
|
|
[[FILE* volatile f = stdin; return 0;]])],
|
|
[rb_cv_msvcrt=`$OBJDUMP -p conftest$ac_exeext |
|
|
tr A-Z a-z |
|
|
sed -n '/^[[ ]]*dll name: \(msvc.*\)\.dll$/{s//\1/p;q;};
|
|
/^[[ ]]*dll name: \(ucrtbase\|api-ms-win-crt-.*\)\.dll$/{s//ucrt/p;q;}'`],
|
|
[rb_cv_msvcrt=msvcrt])
|
|
test "$rb_cv_msvcrt" = "" && rb_cv_msvcrt=msvcrt])
|
|
RT_VER=`echo "$rb_cv_msvcrt" | tr -cd [0-9]`
|
|
test "$RT_VER" = "" && RT_VER=60
|
|
test "$rb_cv_msvcrt" = "ucrt" && RT_VER=140
|
|
AC_DEFINE_UNQUOTED(RUBY_MSVCRT_VERSION, $RT_VER)
|
|
sysconfdir=
|
|
])
|
|
: ${enable_shared=yes}
|
|
],
|
|
[hiuxmpp*], [AC_DEFINE(__HIUX_MPP__)]) # by TOYODA Eizi <toyoda@npd.kishou.go.jp>
|
|
|
|
AC_PROG_LN_S
|
|
AC_PROG_MAKE_SET
|
|
AC_PROG_INSTALL
|
|
AC_PROG_MKDIR_P
|
|
AS_IF([test "x$MKDIR_P" = "x -d"], [
|
|
AS_IF([test x"$as_mkdir_p" != xfalse], [
|
|
MKDIR_P='mkdir -p'
|
|
echo "use 'mkdir -p' as MKDIR_P"
|
|
], [
|
|
AC_MSG_ERROR([mkdir -p is required])
|
|
])
|
|
])
|
|
MAKEDIRS="$MKDIR_P"
|
|
AC_SUBST(MAKEDIRS)
|
|
|
|
AC_CHECK_PROG([DTRACE], [${ac_tool_prefix}dtrace], [${ac_tool_prefix}dtrace])
|
|
AS_IF([test "$cross_compiling:$ac_cv_prog_DTRACE" = no: -a -n "$ac_tool_prefix"], [
|
|
AC_CHECK_PROG([DTRACE], [dtrace], [dtrace])
|
|
])
|
|
|
|
AC_CHECK_PROGS(DOT, dot)
|
|
AC_CHECK_PROGS(DOXYGEN, doxygen)
|
|
|
|
for prog in ${ac_tool_prefix:+${ac_tool_prefix}pkg-config} pkg-config; do
|
|
AC_CHECK_PROG(PKG_CONFIG, $prog, [$prog], [], [],
|
|
[`"$as_dir/$ac_word$ac_exec_ext" --print-errors --version > /dev/null 2>&1 || echo "$as_dir/$ac_word$ac_exec_ext"`])
|
|
test -z "${PKG_CONFIG}" || break
|
|
done
|
|
|
|
AC_MSG_CHECKING([whether it is Android])
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
|
|
@%:@ifndef __ANDROID__
|
|
@%:@error Not android
|
|
@%:@endif
|
|
]], [[]])],
|
|
[
|
|
AC_MSG_RESULT(yes)
|
|
target_os=${target_os}-android
|
|
AS_IF([test "x$cross_compiling" = xno], [
|
|
AC_MSG_CHECKING([for Android API version])
|
|
# hacky workaround: https://github.com/termux/termux-packages/issues/6176
|
|
rb_android_api=`getprop ro.build.version.sdk`
|
|
AC_MSG_RESULT($rb_android_api)
|
|
RUBY_APPEND_OPTIONS(CPPFLAGS, -D__ANDROID_API__=$rb_android_api -Wno-macro-redefined)
|
|
])
|
|
],
|
|
[AC_MSG_RESULT(no)])
|
|
|
|
AC_SUBST(RM, ['rm -f'])
|
|
AC_SUBST(CP, ['cp'])
|
|
RMDIRS='$(top_srcdir)/tool/rmdirs'
|
|
RMDIR=rmdir
|
|
mkdir "rmdirs_$$_test" "rmdirs_$$_test/a"
|
|
rmdir --ignore-fail-on-non-empty "rmdirs_$$_test" 2>/dev/null &&
|
|
RMDIR='rmdir --ignore-fail-on-non-empty'
|
|
$RMDIR -p "rmdirs_$$_test/a" 2>/dev/null &&
|
|
{ test -d "rmdirs_$$_test" || RMDIRS="$RMDIR -p"; }
|
|
rmdir "rmdirs_$$_test/a" "rmdirs_$$_test" 2>/dev/null
|
|
AC_SUBST(RMDIR)
|
|
AC_SUBST(RMDIRS)
|
|
AC_SUBST(RMALL, ['rm -fr'])
|
|
|
|
AC_MSG_CHECKING([for cd using physical directory])
|
|
rm -fr conf$$.dir
|
|
mkdir conf$$.dir &&
|
|
(cd conf$$.dir && mkdir src build && cd src &&
|
|
$as_ln_s ../build . > /dev/null 2>&1 && cd build &&
|
|
for chdir in 'cd -P' 'PWD= cd'; do
|
|
/bin/sh -c "$chdir ../src && echo '$chdir' > cdcmd" 2> /dev/null && break
|
|
done)
|
|
AS_IF([test -f conf$$.dir/src/cdcmd], [
|
|
read CHDIR < conf$$.dir/src/cdcmd 2> /dev/null
|
|
], [
|
|
CHDIR=cd
|
|
])
|
|
rm -fr conf$$.dir
|
|
AC_MSG_RESULT([$CHDIR])
|
|
AC_SUBST(CHDIR)
|
|
}
|
|
|
|
: "compiler section" && {
|
|
RUBY_WERROR_FLAG([
|
|
AC_MSG_CHECKING([whether CFLAGS is valid])
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])],
|
|
[AC_MSG_RESULT(yes)],
|
|
[
|
|
AC_MSG_RESULT(no)
|
|
AC_MSG_ERROR([something wrong with CFLAGS="$CFLAGS"])
|
|
]
|
|
)
|
|
|
|
AC_MSG_CHECKING([whether LDFLAGS is valid])
|
|
{
|
|
mkdir tmp.$$.try_link &&
|
|
cd tmp.$$.try_link &&
|
|
cp ../confdefs.h . &&
|
|
echo '<?xml?><plist><dict><key>CFBundleIdentifier</key><string></string></dict></plist>' > Info.plist &&
|
|
:
|
|
} || AC_MSG_ERROR([failed to make temporary directory])
|
|
AC_LINK_IFELSE([AC_LANG_PROGRAM([[]], [[]])],
|
|
[AC_MSG_RESULT(yes)],
|
|
[
|
|
cd .. && rm -fr tmp.$$.try_link
|
|
AC_MSG_RESULT(no)
|
|
AC_MSG_ERROR([something wrong with LDFLAGS="$LDFLAGS"])
|
|
]
|
|
)
|
|
cd .. && rm -fr tmp.$$.try_link
|
|
])
|
|
|
|
: ${RPATHFLAG=''}
|
|
rpathflag=''
|
|
AS_IF([test x"${RPATHFLAG}" = x], [
|
|
AS_CASE(["$target_os"],
|
|
[hpux*], [AS_IF([test "$rb_cv_prog_gnu_ld" = no], [rpathflag='+b '])],
|
|
[aix*], [rpathflag='-blibpath:'],
|
|
[for rpathflag in -R "-rpath "; do
|
|
AS_CASE("$rpathflag",
|
|
[*" "], [AS_CASE(["${linker_flag}"],
|
|
[*,], [rpathflag=`echo "$rpathflag" | tr ' ' ,`])])
|
|
rpathflag="${linker_flag}${rpathflag}"
|
|
RUBY_TRY_LDFLAGS([${rpathflag}.], [], [rpathflag=])
|
|
AS_IF([test "x${rpathflag}" != x], [])
|
|
done])
|
|
], [
|
|
rpathflag=`echo "$RPATHFLAG" | sed 's/%.*//'`
|
|
])
|
|
|
|
RUBY_TRY_LDFLAGS(-fdeclspec, [fdeclspec=yes], [fdeclspec=no])
|
|
AS_IF([test "$fdeclspec" = yes], [
|
|
RUBY_APPEND_OPTIONS(CFLAGS, -fdeclspec)
|
|
RUBY_APPEND_OPTIONS(cflags, -fdeclspec)
|
|
RUBY_APPEND_OPTIONS(orig_cflags, -fdeclspec)
|
|
])
|
|
RUBY_TRY_CXXFLAGS(-fdeclspec, [fdeclspec=yes], [fdeclspec=no])
|
|
AS_IF([test "$fdeclspec" = yes], [
|
|
RUBY_APPEND_OPTIONS(CXXFLAGS, -fdeclspec)
|
|
])
|
|
|
|
AS_CASE([$RUBY_PATCHLEVEL], [-*],
|
|
[RUBY_DEVEL=yes], [RUBY_DEVEL=no])
|
|
particular_werror_flags=$RUBY_DEVEL
|
|
AC_ARG_ENABLE(werror,
|
|
AS_HELP_STRING([--disable-werror],
|
|
[don't make warnings into errors
|
|
even if a compiler support -Werror feature
|
|
[[disabled by default unless development version]]]),
|
|
[particular_werror_flags=$enableval])
|
|
|
|
rb_cv_warnflags="$warnflags"
|
|
AS_CASE(["$GCC:${warnflags+set}:${extra_warnflags:+set}:"],
|
|
[yes::*|yes:*:set:], [# GCC && (!warnflags || extra_warnflags)
|
|
AS_IF([test $gcc_major -ge 4], [
|
|
extra_warnflags="$extra_warnflags -Werror=extra-tokens"
|
|
])
|
|
AS_IF([test $gcc_major -ge 5 -a $gcc_major -le 6], [
|
|
extra_warnflags="$extra_warnflags -Wno-maybe-uninitialized"
|
|
])
|
|
# ICC doesn't support -Werror=
|
|
AS_IF([test $icc_version -gt 0], [
|
|
particular_werror_flags=no
|
|
])
|
|
for wflag in \
|
|
-Werror=deprecated-declarations \
|
|
-Werror=division-by-zero \
|
|
-Werror=duplicated-cond \
|
|
-Werror=implicit-function-declaration \
|
|
-Werror=implicit-int \
|
|
-Werror=misleading-indentation \
|
|
-Werror=pointer-arith \
|
|
-Werror=shorten-64-to-32 \
|
|
-Werror=write-strings \
|
|
-Wimplicit-fallthrough=0 \
|
|
-Wmissing-noreturn \
|
|
-Wno-cast-function-type \
|
|
-Wno-constant-logical-operand \
|
|
-Wno-long-long \
|
|
-Wno-missing-field-initializers \
|
|
-Wno-overlength-strings \
|
|
-Wno-packed-bitfield-compat \
|
|
-Wno-parentheses-equality \
|
|
-Wno-self-assign \
|
|
-Wno-tautological-compare \
|
|
-Wno-unused-parameter \
|
|
-Wno-unused-value \
|
|
-Wsuggest-attribute=format \
|
|
-Wsuggest-attribute=noreturn \
|
|
-Wunused-variable \
|
|
-diag-disable=175,188,1684,2259,2312 \
|
|
$extra_warnflags \
|
|
; do
|
|
AS_IF([test "$particular_werror_flags" != yes], [
|
|
wflag=`echo x$wflag | sed 's/^x-Werror=/-W/;s/^x//'`
|
|
])
|
|
ok=no
|
|
RUBY_TRY_CFLAGS($wflag, [
|
|
RUBY_APPEND_OPTIONS(warnflags, $wflag)
|
|
ok=yes
|
|
])
|
|
AS_CASE([$ok:$wflag], [no:-Werror=*], [
|
|
wflag=`echo x$wflag | sed 's/^x-Werror=/-W/'`
|
|
RUBY_TRY_CFLAGS($wflag, [
|
|
RUBY_APPEND_OPTIONS(warnflags, $wflag)
|
|
particular_werror_flags=no
|
|
])
|
|
])
|
|
done
|
|
AS_IF([test "$particular_werror_flags" = "yes"], [
|
|
wflag=-Werror=undef
|
|
], [
|
|
wflag=-Wundef
|
|
])
|
|
RUBY_TRY_CFLAGS($wflag, [
|
|
RUBY_APPEND_OPTIONS(warnflags, $wflag)
|
|
], [], [
|
|
@%:@if !defined(RUBY_CONFIG_TEST_NEVER_DEFINED_SYMBOL)
|
|
@%:@elif RUBY_CONFIG_TEST_NEVER_DEFINED_SYMBOL
|
|
@%:@endif
|
|
])
|
|
AS_CASE([" $warnflags "],[*" -Wno-missing-field-initializers "*], [wflag="-Wall -Wextra"],
|
|
[wflag=-Wall])
|
|
RUBY_TRY_CFLAGS($wflag, [warnflags="$wflag${warnflags+ $warnflags}"])
|
|
# Disable warnflags while conftest. -Werror=* flags might make bad OS capability guess.
|
|
rb_cv_warnflags="$warnflags"
|
|
warnflags=
|
|
])
|
|
RUBY_TRY_CFLAGS(-Qunused-arguments, [RUBY_APPEND_OPTIONS(rb_cv_wsuppress_flags, -Qunused-arguments)])
|
|
AC_COMPILE_IFELSE([
|
|
AC_LANG_PROGRAM([
|
|
@%:@if !(defined(__SUNPRO_C)||defined(__SUNPRO_CC))
|
|
@%:@error not sunpro
|
|
@%:@endif],[])], [
|
|
for e in \
|
|
E_STATEMENT_NOT_REACHED \
|
|
E_INIT_SIGN_EXTEND \
|
|
E_INIT_DOES_NOT_FIT \
|
|
E_INITIALIZATION_TYPE_MISMATCH
|
|
do
|
|
RUBY_TRY_CFLAGS([-erroff=${e}], [
|
|
RUBY_APPEND_OPTIONS(rb_cv_warnflags, [-erroff=${e}])
|
|
])
|
|
done
|
|
])
|
|
|
|
AC_ARG_WITH(compress-debug-sections,
|
|
AS_HELP_STRING([--with-compress-debug-sections=type],
|
|
[enable debug section compression]),
|
|
[compress_debug_sections=$withval], [compress_debug_sections=])
|
|
|
|
AS_IF([test "$GCC" = yes], [
|
|
# -D_FORTIFY_SOURCE
|
|
# When defined _FORTIFY_SOURCE, glibc enables some additional sanity
|
|
# argument check. The performance drop is very little and Ubuntu enables
|
|
# _FORTIFY_SOURCE=2 by default. So, let's support it for protecting us from
|
|
# a mistake of silly C extensions.
|
|
|
|
# TODO: check if link succeeds with _FORTIFY_SOURCE=2.
|
|
AS_CASE(["$target_os"],
|
|
[mingw*], [
|
|
fortify_source=no
|
|
])
|
|
AC_ARG_ENABLE(fortify_source,
|
|
AS_HELP_STRING([--disable-fortify-source],
|
|
[disable -D_FORTIFY_SOURCE=2 option, which causes link error on mingw]),
|
|
[fortify_source=$enableval])
|
|
AS_IF([test "x$fortify_source" != xno], [
|
|
RUBY_TRY_CFLAGS([$optflags -D_FORTIFY_SOURCE=2], [RUBY_APPEND_OPTION(XCFLAGS, -D_FORTIFY_SOURCE=2)], [],
|
|
[@%:@include <stdio.h>])
|
|
])
|
|
|
|
: ${MJIT_HEADER_FLAGS='-P -dD'}
|
|
|
|
# -fstack-protector
|
|
AS_CASE(["$target_os"],
|
|
[mingw*|emscripten*], [
|
|
stack_protector=no
|
|
])
|
|
AS_IF([test -z "${stack_protector+set}"], [
|
|
AS_FOR(option, opt, [-fstack-protector-strong -fstack-protector], [
|
|
RUBY_TRY_CFLAGS(option, [stack_protector=yes])
|
|
AS_IF([test "x$stack_protector" = xyes], [
|
|
RUBY_TRY_LDFLAGS(option, [], [stack_protector=])
|
|
])
|
|
AS_IF([test "x$stack_protector" = xyes], [stack_protector=option; break])
|
|
])
|
|
])
|
|
AS_CASE(["$stack_protector"], [-*], [
|
|
RUBY_APPEND_OPTION(XCFLAGS, $stack_protector)
|
|
RUBY_APPEND_OPTION(XLDFLAGS, $stack_protector)
|
|
RUBY_APPEND_OPTION(LDFLAGS, $stack_protector)
|
|
])
|
|
|
|
AS_CASE("${compress_debug_sections:-zlib}",
|
|
[none|no], [], [
|
|
RUBY_TRY_LDFLAGS(${linker_flag}--compress-debug-sections=${compress_debug_sections:-zlib},
|
|
[compress_debug_sections=${compress_debug_sections:-zlib}],
|
|
[compress_debug_sections=no])
|
|
])
|
|
AS_IF([test "x$compress_debug_sections" != xno], [
|
|
RUBY_APPEND_OPTION(DLDFLAGS, ${linker_flag}--compress-debug-sections=$compress_debug_sections)
|
|
])
|
|
|
|
AS_CASE(["$target_os"],[mingw*], [
|
|
# On Windows platforms, system provided headers are VC++
|
|
# optimized. That is, C++ habits are often contaminated into
|
|
# various headers. Most frequent situation is the use of //
|
|
# comments. We bypass ANSI C mode for them. Otherwise
|
|
# extension libs cannot include those headers.
|
|
|
|
# Since math.h in some mingw64 wrongly declares frexp and modf
|
|
# to be pure, the variables pointed by the second arguments are
|
|
# considered uninitialized unexpectedly.
|
|
AC_CACHE_CHECK([whether frexp and modf are broken],
|
|
rb_cv_mingw64_broken_frexp_modf,
|
|
[
|
|
save_CFLAGS="$CFLAGS"
|
|
AS_IF([test "$particular_werror_flags" = "yes"], [
|
|
CFLAGS="$CFLAGS -Werror=uninitialized"
|
|
], [
|
|
CFLAGS="$CFLAGS -Werror -Wuninitialized"
|
|
])
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[@%:@include <math.h>
|
|
int foo(double x)
|
|
{
|
|
int exp;
|
|
frexp(x, &exp);
|
|
return exp;
|
|
}]], [[if (foo(0.0)) return 1;]])],
|
|
[rb_cv_mingw64_broken_frexp_modf=no],
|
|
[rb_cv_mingw64_broken_frexp_modf=yes])
|
|
CFLAGS="$save_CFLAGS"
|
|
])
|
|
AS_IF([test "$rb_cv_mingw64_broken_frexp_modf" = yes], [
|
|
AC_DEFINE(RUBY_MINGW64_BROKEN_FREXP_MODF)
|
|
])
|
|
],
|
|
[cygwin*|msys*|darwin*|netbsd*], [
|
|
# need lgamma_r()
|
|
])
|
|
|
|
# ANSI (no XCFLAGS because this is C only)
|
|
AS_CASE(["$target_os"],
|
|
[solaris*], [
|
|
# Because "-std=gnu99" affects existence of functions on Solaris,
|
|
# "-std=gnu99" will be appended to CPPFLAGS.
|
|
for ansi_options in -std=gnu99; do
|
|
RUBY_TRY_CFLAGS(${ansi_options}, [
|
|
RUBY_APPEND_OPTIONS(CPPFLAGS, ${ansi_options})
|
|
], [ansi_options=])
|
|
test "x${ansi_options}" = x || break
|
|
done
|
|
],
|
|
[
|
|
# ANSI (no XCFLAGS because this is C only)
|
|
rb_tmp_std_check=`echo $CC $CFLAGS $optflags $warnflags $debugflags | fgrep std= | tr -d '\015'`
|
|
AS_IF([test "x$rb_tmp_std_check" = "x"],
|
|
[
|
|
for ansi_options in -std=gnu99; do
|
|
RUBY_TRY_CFLAGS(${ansi_options}, [
|
|
RUBY_APPEND_OPTIONS(warnflags, ${ansi_options})
|
|
RUBY_APPEND_OPTIONS(strict_warnflags, ${ansi_options})
|
|
], [ansi_options=])
|
|
test "x${ansi_options}" = x || break
|
|
done
|
|
])
|
|
])
|
|
|
|
# suppress annoying -Wstrict-overflow warnings
|
|
RUBY_TRY_CFLAGS(-fno-strict-overflow, [RUBY_APPEND_OPTION(XCFLAGS, -fno-strict-overflow)])
|
|
|
|
test "${debugflags+set}" || {RUBY_TRY_CFLAGS(-ggdb3, [debugflags=-ggdb3])}
|
|
test "${debugflags+set}" || {RUBY_TRY_CFLAGS(-ggdb, [debugflags=-ggdb])}
|
|
test "${debugflags+set}" || {RUBY_TRY_CFLAGS(-g3, [debugflags=-g3])}
|
|
])
|
|
test $ac_cv_prog_cc_g = yes && : ${debugflags=-g}
|
|
AS_IF([test "x$RUBY_DEVEL" = xyes], [RUBY_APPEND_OPTION(XCFLAGS, -DRUBY_DEVEL=1)])
|
|
|
|
AS_IF([test "$GCC" = ""], [
|
|
AS_CASE(["$target_os"],[aix*],[warnflags="$warnflags -qinfo=por" rb_cv_warnflags="$rb_cv_warnflags -qinfo=por"])
|
|
])
|
|
AS_IF([test "$GCC" = yes], [
|
|
AS_IF([test "$gcc_major" -ge 4], [
|
|
RUBY_TRY_CFLAGS(-fvisibility=hidden, [visibility_option=yes], [visibility_option=no])
|
|
])
|
|
AC_SUBST(WERRORFLAG, "-Werror")
|
|
AS_IF([test "$visibility_option" = yes], [
|
|
RUBY_APPEND_OPTION(XCFLAGS, -fvisibility=hidden)
|
|
AC_DEFINE(RUBY_SYMBOL_EXPORT_BEGIN, [_Pragma("GCC visibility push(default)")])
|
|
AC_DEFINE(RUBY_SYMBOL_EXPORT_END, [_Pragma("GCC visibility pop")])
|
|
], [
|
|
RUBY_TRY_LDFLAGS([-Wl,-unexported_symbol,_Init_*], [visibility_option=ld], [visibility_option=no])
|
|
])
|
|
test "$visibility_option" = no || OBJCOPY=:
|
|
])
|
|
|
|
AS_IF([test "$GCC" = yes], [
|
|
# optflags
|
|
|
|
AS_CASE(["$target_os"], [mingw*], [
|
|
RUBY_TRY_CFLAGS(-fno-omit-frame-pointer, [optflags="${optflags+$optflags }-fno-omit-frame-pointer"])
|
|
RUBY_TRY_CFLAGS(-static-libgcc, [static_libgcc=yes], [static_libgcc=no])
|
|
AS_IF([test "$static_libgcc" = yes], [
|
|
RUBY_APPEND_OPTION(EXTLDFLAGS, -static-libgcc)
|
|
])
|
|
])
|
|
|
|
# disable fast-math
|
|
for oflag in -fno-fast-math; do
|
|
RUBY_TRY_CFLAGS($oflag, [RUBY_APPEND_OPTION(optflags, $oflag)])
|
|
done
|
|
for oflag in -fexcess-precision=standard -fp-model\ precise; do
|
|
RUBY_TRY_CFLAGS($oflag, [RUBY_APPEND_OPTION(XCFLAGS, $oflag)])
|
|
done
|
|
])
|
|
|
|
AS_CASE(["$target_cpu"], [[i[3-6]86*]], [
|
|
AC_CACHE_CHECK([for __sync_val_compare_and_swap], [rb_cv_gcc_compiler_cas], [
|
|
AC_LINK_IFELSE([AC_LANG_PROGRAM([[unsigned long atomic_var;]],
|
|
[[__sync_val_compare_and_swap(&atomic_var, 0, 1);]])],
|
|
[rb_cv_gcc_compiler_cas=yes],
|
|
[
|
|
save_CFLAGS="$CFLAGS" CFLAGS="$CFLAGS -march=i486"
|
|
AC_LINK_IFELSE([AC_LANG_PROGRAM([[unsigned long atomic_var;]],
|
|
[[__sync_val_compare_and_swap(&atomic_var, 0, 1);]])],
|
|
[rb_cv_gcc_compiler_cas=i486],
|
|
[rb_cv_gcc_compiler_cas=no])
|
|
CFLAGS="$save_CFLAGS"
|
|
])
|
|
])
|
|
AS_IF([test "$rb_cv_gcc_compiler_cas" = i486], [ARCH_FLAG="-march=i486"])
|
|
])
|
|
|
|
AC_ARG_WITH(opt-dir,
|
|
AS_HELP_STRING([--with-opt-dir=DIR-LIST],
|
|
[add optional headers and libraries directories separated by $PATH_SEPARATOR]),
|
|
[
|
|
val=`echo "$PATH_SEPARATOR$withval" | sed "s|$PATH_SEPARATOR\([[^$PATH_SEPARATOR]*]\)| -I\1/include|g;s/^ //"`
|
|
CPPFLAGS="$CPPFLAGS $val"
|
|
val=`echo "$PATH_SEPARATOR$withval" | sed "s|$PATH_SEPARATOR\([[^$PATH_SEPARATOR]*]\)| -L\1/lib${rpathflag:+ $rpathflag\\\\1/lib}|g;s/^ //"`
|
|
LDFLAGS="$LDFLAGS $val"
|
|
LDFLAGS_OPTDIR="$val"
|
|
OPT_DIR="$withval"
|
|
], [OPT_DIR=])
|
|
|
|
test -z "${ac_env_CFLAGS_set}" -a -n "${cflags+set}" && eval CFLAGS="\"$cflags $ARCH_FLAG\""
|
|
test -z "${ac_env_CXXFLAGS_set}" -a -n "${cxxflags+set}" && eval CXXFLAGS="\"$cxxflags $ARCH_FLAG\""
|
|
}
|
|
|
|
AC_CACHE_CHECK([whether compiler has statement and declarations in expressions],
|
|
rb_cv_have_stmt_and_decl_in_expr,
|
|
[AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]],[[ __extension__ ({ int a = 0; a; }); ]])],
|
|
[rb_cv_have_stmt_and_decl_in_expr=yes],
|
|
[rb_cv_have_stmt_and_decl_in_expr=no])])
|
|
AS_IF([test "$rb_cv_have_stmt_and_decl_in_expr" = yes], [
|
|
AC_DEFINE(HAVE_STMT_AND_DECL_IN_EXPR)
|
|
])
|
|
|
|
: "header and library section" && {
|
|
AC_ARG_WITH(winnt-ver,
|
|
AS_HELP_STRING([--with-winnt-ver=0xXXXX], [target Windows NT version (default to 0x0600)]),
|
|
[with_winnt_ver="$withval"], [with_winnt_ver="0x0600"])
|
|
AS_CASE(["$target_os"],
|
|
[mingw*], [
|
|
RUBY_APPEND_OPTION(CPPFLAGS, -D_WIN32_WINNT=$with_winnt_ver)
|
|
RUBY_APPEND_OPTION(CPPFLAGS, -D__MINGW_USE_VC2005_COMPAT)
|
|
])
|
|
|
|
AS_CASE(["$target_os"],
|
|
[freebsd*], [
|
|
AC_CACHE_CHECK([whether pthread should be enabled by default],
|
|
rb_cv_enable_pthread_default,
|
|
[AC_PREPROC_IFELSE([AC_LANG_SOURCE([[
|
|
#include <osreldate.h>
|
|
#if __FreeBSD_version < 502102
|
|
#error pthread should be disabled on this platform
|
|
#endif
|
|
]])],
|
|
rb_cv_enable_pthread_default=yes,
|
|
rb_cv_enable_pthread_default=no)])
|
|
enable_pthread=$rb_cv_enable_pthread_default
|
|
],
|
|
[mingw*], [
|
|
enable_pthread=no
|
|
],
|
|
[
|
|
enable_pthread=yes
|
|
])
|
|
|
|
dnl Checks for libraries.
|
|
AS_CASE(["$target_os"],[*bsd*|dragonfly*],[],[ac_cv_func_daemon=no])
|
|
|
|
AS_CASE(["$target_os"], [*android*], [
|
|
AS_CASE(["$target_cpu"], [arm*], [
|
|
ac_cv_func___builtin_setjmp=no
|
|
])
|
|
])
|
|
|
|
AS_UNSET(ORIG_LIBS)
|
|
POSTLINK=:
|
|
AC_SUBST(POSTLINK)
|
|
cleanlibs=
|
|
AC_SUBST(cleanlibs)
|
|
AS_CASE(["$target_os"],
|
|
[nextstep*], [ ],
|
|
[openstep*], [ ],
|
|
[rhapsody*], [ ],
|
|
[darwin*], [
|
|
ORIG_LIBS="$LIBS"
|
|
RUBY_PREPEND_OPTION(LIBS, -lobjc)
|
|
RUBY_APPEND_OPTIONS(CPPFLAGS, -D_XOPEN_SOURCE -D_DARWIN_C_SOURCE -D_DARWIN_UNLIMITED_SELECT -D_REENTRANT)
|
|
AC_CACHE_CHECK([whether syscall(2) is deprecated], rb_cv_syscall_deprecated,
|
|
[RUBY_WERROR_FLAG([
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[@%:@include <unistd.h>]],
|
|
[[if (syscall(0)) return 1;]])],
|
|
[rb_cv_syscall_deprecated=no],
|
|
[rb_cv_syscall_deprecated=yes])])])
|
|
AS_IF([test $rb_cv_syscall_deprecated = yes], [
|
|
ac_cv_func___syscall=no
|
|
ac_cv_func_syscall=no
|
|
ac_cv_header_sys_syscall_h=no
|
|
ac_cv_header_syscall_h=no
|
|
])
|
|
ac_cv_func_getcontext=no
|
|
ac_cv_func_setcontext=no
|
|
incs=`$CC -v -E -xc - < /dev/null 2>&1 | sed ['1,/^@%:@include </d;s/^ *//;s|[^./][^/]*/\.\./||g;/\/include$/!d;s||/lib|;/\/usr\/lib/d']`
|
|
for d in `$CC -print-search-dirs | sed -e '/^libraries: */!d;s///' | tr : '\012' | fgrep -v /../ | sed -n 's|^\(/.*/lib\)/$|\1|p'`; do
|
|
incs=`echo "$incs" | fgrep -v "$d"`
|
|
done
|
|
for d in $incs; do
|
|
test -d "$d" && RUBY_APPEND_OPTIONS(LDFLAGS, "-L$d")
|
|
done
|
|
ac_cv_type_getgroups=gid_t # getgroups() on Rosetta fills garbage
|
|
ac_cv_lib_crypt_crypt=no
|
|
ac_cv_func_fdatasync=no # Mac OS X wrongly reports it has fdatasync()
|
|
ac_cv_func_vfork=no
|
|
AS_IF([test $gcc_major -lt 4 -o \( $gcc_major -eq 4 -a $gcc_minor -lt 3 \)], [
|
|
ac_cv_func___builtin_setjmp=no
|
|
])
|
|
with_setjmp_type=sigsetjmp # to hijack SIGCHLD handler
|
|
AC_CACHE_CHECK(for broken crypt with 8bit chars, rb_cv_broken_crypt,
|
|
[AC_RUN_IFELSE([AC_LANG_SOURCE([[
|
|
#include <stdio.h>
|
|
#include <unistd.h>
|
|
#include <string.h>
|
|
|
|
void
|
|
broken_crypt(const char *salt, const char *buf1, const char *buf2)
|
|
{
|
|
#if 0
|
|
printf("%.2x%.2x: %s -> %s\n", (unsigned char)salt[0], (unsigned char)salt[1],
|
|
buf1+2, buf2+2);
|
|
#endif
|
|
}
|
|
|
|
int
|
|
main()
|
|
{
|
|
int i;
|
|
char salt[2], buf[256], *s;
|
|
for (i = 0; i < 128*128; i++) {
|
|
salt[0] = 0x80 | (i & 0x7f);
|
|
salt[1] = 0x80 | (i >> 7);
|
|
strcpy(buf, crypt("", salt));
|
|
if (strcmp(buf, s = crypt("", salt))) {
|
|
broken_crypt(salt, buf, s);
|
|
return 1;
|
|
}
|
|
}
|
|
salt[0] = salt[1] = ' ';
|
|
strcpy(buf, crypt("", salt));
|
|
salt[0] = salt[1] = 0x80 | ' ';
|
|
if (strcmp(buf, s = crypt("", salt))) {
|
|
broken_crypt(salt, buf, s);
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
]])],
|
|
rb_cv_broken_crypt=no,
|
|
rb_cv_broken_crypt=yes,
|
|
rb_cv_broken_crypt=yes)])
|
|
AS_IF([test "$rb_cv_broken_crypt" = yes], [
|
|
AC_DEFINE(BROKEN_CRYPT, 1)
|
|
])
|
|
POSTLINK=""
|
|
AC_CHECK_PROGS(codesign, codesign)
|
|
AC_CHECK_PROGS(dsymutil, dsymutil)
|
|
AS_IF([test -n "$codesign"], [
|
|
POSTLINK="{ test -z '\$(RUBY_CODESIGN)' || $codesign -s '\$(RUBY_CODESIGN)' -f \$@; }${POSTLINK:+; $POSTLINK}"
|
|
])
|
|
AS_IF([test -n "$dsymutil"], [
|
|
POSTLINK="$dsymutil \$@${POSTLINK:+; $POSTLINK}"
|
|
])
|
|
AS_IF([test -n "${POSTLINK}"], [
|
|
LINK_SO="$LINK_SO
|
|
\$(POSTLINK)"
|
|
])
|
|
AC_CHECK_HEADERS(crt_externs.h, [], [], [
|
|
#include <crt_externs.h>
|
|
])
|
|
cleanlibs='$(TARGET_SO).dSYM'
|
|
],
|
|
[hpux*], [ LIBS="-lm $LIBS"
|
|
ac_cv_c_inline=no],
|
|
[solaris*], [ LIBS="-lm $LIBS"
|
|
ac_cv_func_vfork=no
|
|
AC_MSG_CHECKING(whether _XOPEN_SOURCE is already given)
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <unistd.h>
|
|
#ifndef _XOPEN_SOURCE
|
|
#error _XOPEN_SOURCE is not defined
|
|
#endif
|
|
]], [[]])],
|
|
[given_xopen_source=yes], [given_xopen_source=no])
|
|
AC_MSG_RESULT($given_xopen_source)
|
|
AS_IF([test $given_xopen_source = no], [
|
|
AC_MSG_CHECKING(appropriate _XOPEN_SOURCE value to define)
|
|
define_xopen_source=""
|
|
for tmp_xpg in 7 6 5; do
|
|
AS_IF([test x"$define_xopen_source" != x], [
|
|
break
|
|
])
|
|
RUBY_WERROR_FLAG([AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
|
|
#define _XOPEN_SOURCE ${tmp_xpg}00
|
|
#include <unistd.h>
|
|
#ifndef _XPG${tmp_xpg}
|
|
#error _XPG${tmp_xpg} should be defined by _XOPEN_SOURCE=${tmp_xpg}00
|
|
#endif
|
|
]], [[]])],
|
|
[define_xopen_source=${tmp_xpg}00], [])
|
|
])
|
|
done
|
|
AS_IF([test x"$define_xopen_source" = x], [
|
|
define_xopen_source=no
|
|
])
|
|
AC_MSG_RESULT($define_xopen_source)
|
|
AS_IF([test x"$define_xopen_source" != xno], [
|
|
RUBY_APPEND_OPTIONS(CPPFLAGS, -D_XOPEN_SOURCE=$define_xopen_source)
|
|
# _XOPEN_SOURCE should not be defined for C++ on Solaris.
|
|
RUBY_APPEND_OPTIONS(CXXFLAGS, -U_XOPEN_SOURCE)
|
|
])
|
|
])
|
|
],
|
|
[haiku*], [
|
|
LIBS="$LIBS" # m lib is include in root
|
|
],
|
|
[cygwin*|msys*], [
|
|
ac_cv_header_langinfo_h=yes
|
|
RUBY_APPEND_OPTIONS(CPPFLAGS, -D_XOPEN_SOURCE -D_GNU_SOURCE)
|
|
AC_CHECK_FUNCS(cygwin_conv_path)
|
|
AC_LIBOBJ([langinfo])
|
|
],
|
|
[mingw*], [ LIBS="-lshell32 -lws2_32 -liphlpapi -limagehlp -lshlwapi -lbcrypt $LIBS"
|
|
ac_cv_header_pwd_h=no
|
|
ac_cv_header_utime_h=no
|
|
ac_cv_header_sys_ioctl_h=no
|
|
ac_cv_header_sys_param_h=no
|
|
ac_cv_header_sys_resource_h=no
|
|
ac_cv_header_sys_select_h=no
|
|
ac_cv_header_sys_time_h=no
|
|
ac_cv_header_sys_times_h=no
|
|
ac_cv_header_sys_socket_h=no
|
|
ac_cv_func_lstat=yes
|
|
ac_cv_func_times=yes
|
|
ac_cv_func_waitpid=yes
|
|
ac_cv_func_fsync=yes
|
|
ac_cv_func_seekdir=yes
|
|
ac_cv_func_telldir=yes
|
|
ac_cv_func_lchown=yes
|
|
ac_cv_func_link=yes
|
|
ac_cv_func_readlink=yes
|
|
ac_cv_func_symlink=yes
|
|
ac_cv_lib_crypt_crypt=no
|
|
ac_cv_func_getpgrp_void=no
|
|
ac_cv_func_memcmp_working=yes
|
|
ac_cv_lib_dl_dlopen=no
|
|
rb_cv_binary_elf=no
|
|
rb_cv_negative_time_t=yes
|
|
ac_cv_func_fcntl=yes
|
|
ac_cv_func_flock=yes
|
|
ac_cv_func_gmtime_r=yes
|
|
rb_cv_large_fd_select=yes
|
|
ac_cv_type_struct_timeval=yes
|
|
ac_cv_func_clock_gettime=yes
|
|
ac_cv_func_clock_getres=yes
|
|
ac_cv_func_malloc_usable_size=no
|
|
ac_cv_type_off_t=yes
|
|
ac_cv_sizeof_off_t=8
|
|
AS_IF([test "$target_cpu" = x64], [
|
|
ac_cv_func___builtin_setjmp=yes
|
|
ac_cv_func_round=no
|
|
coroutine_type=yes
|
|
])
|
|
ac_cv_func_tgamma=no
|
|
AC_CHECK_TYPE([NET_LUID], [], [],
|
|
[@%:@include <winsock2.h>
|
|
@%:@include <iphlpapi.h>])
|
|
AS_IF([test x"$ac_cv_type_NET_LUID" = xyes], [
|
|
AC_DEFINE(HAVE_TYPE_NET_LUID, 1)
|
|
])
|
|
AC_CHECK_FUNCS(_gmtime64_s)
|
|
AC_CHECK_FUNCS(_wfreopen_s)
|
|
AC_LIBOBJ([langinfo])
|
|
],
|
|
[bsdi*], [ LIBS="-lm $LIBS"
|
|
AC_DEFINE(BROKEN_SETREUID, 1)
|
|
AC_DEFINE(BROKEN_SETREGID, 1)
|
|
ac_cv_sizeof_rlim_t=8],
|
|
[freebsd*], [ LIBS="-lm $LIBS"
|
|
ac_cv_func_getpeername=no
|
|
ac_cv_func_getsockname=no
|
|
ac_cv_func_shutdown=no
|
|
ac_cv_func_close=no
|
|
],
|
|
[netbsd*], [ LIBS="-lm $LIBS"
|
|
],
|
|
[dragonfly*], [ LIBS="-lm $LIBS"
|
|
],
|
|
[aix*],[ LIBS="-lm $LIBS"
|
|
ac_cv_func_round=no
|
|
ac_cv_func___builtin_setjmp=no
|
|
],
|
|
[linux*],[ LIBS="-lm $LIBS"
|
|
# __builtin_longjmp in ppc64* Linux does not restore
|
|
# the TOC register (r2), which is problematic
|
|
# when a global exit happens from JITted .so code.
|
|
AS_CASE(["$target_cpu"], [powerpc64*], [
|
|
ac_cv_func___builtin_setjmp=no
|
|
])
|
|
# With gcc-8's -fcf-protection, MJIT's __builtin_longjmp fails.
|
|
AS_CASE(["$CC $CFLAGS "], [*" -fcf-protection "*], [cf_protection=yes], [cf_protection=no])
|
|
AS_IF([test "$cf_protection" = yes], [
|
|
ac_cv_func___builtin_setjmp=no
|
|
])
|
|
],
|
|
[emscripten*], [LIBS="-lm -lc $LIBS"
|
|
RUBY_APPEND_OPTIONS(LDFLAGS, "-sALLOW_MEMORY_GROWTH=1")
|
|
RUBY_APPEND_OPTIONS(LDFLAGS, "-sASYNCIFY")
|
|
RUBY_APPEND_OPTIONS(LDFLAGS, "-sFORCE_FILESYSTEM=1")
|
|
],
|
|
[ LIBS="-lm $LIBS"])
|
|
: ${ORIG_LIBS=$LIBS}
|
|
|
|
AS_IF([test -n "${rb_there_is_in_fact_no_gplusplus_but_autoconf_is_cheating_us}"], [
|
|
AC_MSG_NOTICE([Test skipped due to lack of a C++ compiler.])
|
|
],
|
|
[test -n "${CXX}"], [
|
|
RUBY_WERROR_FLAG([
|
|
AC_MSG_CHECKING([whether CXXFLAGS is valid])
|
|
AC_LANG_PUSH(C++)
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[@%:@include <cstdio>]], [[]])],
|
|
[AC_MSG_RESULT(yes)],[
|
|
AC_MSG_RESULT(no)
|
|
# The message mentions CXXFLAGS, but CPPFLAGS might also affects.
|
|
AC_MSG_WARN([something wrong with CXXFLAGS="$CXXFLAGS"])
|
|
CXX=false
|
|
])
|
|
AC_LANG_POP(C++)
|
|
])
|
|
])
|
|
|
|
AC_CHECK_LIB(crypt, crypt) # glibc (GNU/Linux, GNU/Hurd, GNU/kFreeBSD)
|
|
AC_CHECK_LIB(dl, dlopen) # Dynamic linking for SunOS/Solaris and SYSV
|
|
AC_CHECK_LIB(dld, shl_load) # Dynamic linking for HP-UX
|
|
AC_CHECK_LIB(socket, shutdown) # SunOS/Solaris
|
|
|
|
dnl Checks for header files.
|
|
AC_HEADER_DIRENT
|
|
dnl AC_HEADER_STDC has been checked in AC_USE_SYSTEM_EXTENSIONS
|
|
AC_HEADER_STDBOOL
|
|
AC_HEADER_SYS_WAIT
|
|
|
|
AC_CHECK_HEADERS(atomic.h)
|
|
AC_CHECK_HEADERS(copyfile.h)
|
|
AC_CHECK_HEADERS(direct.h)
|
|
AC_CHECK_HEADERS(grp.h)
|
|
AC_CHECK_HEADERS(fcntl.h)
|
|
AC_CHECK_HEADERS(float.h)
|
|
AC_CHECK_HEADERS(ieeefp.h)
|
|
AC_CHECK_HEADERS(intrinsics.h)
|
|
AC_CHECK_HEADERS(langinfo.h)
|
|
AC_CHECK_HEADERS(limits.h)
|
|
AC_CHECK_HEADERS(locale.h)
|
|
AC_CHECK_HEADERS(malloc.h)
|
|
AC_CHECK_HEADERS(malloc/malloc.h)
|
|
AC_CHECK_HEADERS(malloc_np.h)
|
|
AC_CHECK_HEADERS(net/socket.h)
|
|
AC_CHECK_HEADERS(process.h)
|
|
AC_CHECK_HEADERS(pwd.h)
|
|
AC_CHECK_HEADERS(sanitizer/asan_interface.h)
|
|
AC_CHECK_HEADERS(sanitizer/msan_interface.h)
|
|
AC_CHECK_HEADERS(setjmpex.h)
|
|
AC_CHECK_HEADERS(stdalign.h)
|
|
AC_CHECK_HEADERS(sys/attr.h)
|
|
AC_CHECK_HEADERS(sys/eventfd.h)
|
|
AC_CHECK_HEADERS(sys/fcntl.h)
|
|
AC_CHECK_HEADERS(sys/file.h)
|
|
AC_CHECK_HEADERS(sys/id.h)
|
|
AC_CHECK_HEADERS(sys/ioctl.h)
|
|
AC_CHECK_HEADERS(sys/mkdev.h)
|
|
AC_CHECK_HEADERS(sys/param.h)
|
|
AC_CHECK_HEADERS(sys/prctl.h)
|
|
AC_CHECK_HEADERS(sys/random.h)
|
|
AC_CHECK_HEADERS(sys/resource.h)
|
|
AC_CHECK_HEADERS(sys/select.h)
|
|
AC_CHECK_HEADERS(sys/sendfile.h)
|
|
AC_CHECK_HEADERS(sys/socket.h)
|
|
AC_CHECK_HEADERS(sys/syscall.h)
|
|
AC_CHECK_HEADERS(sys/sysmacros.h)
|
|
AC_CHECK_HEADERS(sys/time.h)
|
|
AC_CHECK_HEADERS(sys/times.h)
|
|
AC_CHECK_HEADERS(sys/uio.h)
|
|
AC_CHECK_HEADERS(sys/utime.h)
|
|
AC_CHECK_HEADERS(syscall.h)
|
|
AC_CHECK_HEADERS(time.h)
|
|
AC_CHECK_HEADERS(ucontext.h)
|
|
AC_CHECK_HEADERS(utime.h)
|
|
AS_CASE("$target_cpu", [x64|x86_64|i[3-6]86*], [
|
|
AC_CHECK_HEADERS(x86intrin.h)
|
|
])
|
|
RUBY_UNIVERSAL_CHECK_HEADER([x86_64, i386], x86intrin.h)
|
|
|
|
AC_ARG_WITH([gmp],
|
|
[AS_HELP_STRING([--without-gmp],
|
|
[disable GNU GMP to accelerate Bignum operations])],
|
|
[],
|
|
[with_gmp=yes])
|
|
AS_IF([test "x$with_gmp" != xno],
|
|
[AC_CHECK_HEADERS(gmp.h)
|
|
AS_IF([test "x$ac_cv_header_gmp_h" != xno],
|
|
AC_SEARCH_LIBS([__gmpz_init], [gmp],
|
|
[AC_DEFINE(HAVE_LIBGMP, 1)]))])
|
|
|
|
AC_ARG_WITH([jemalloc],
|
|
[AS_HELP_STRING([--with-jemalloc],[use jemalloc allocator])],
|
|
[with_jemalloc=$withval], [with_jemalloc=no])
|
|
AS_IF([test "x$with_jemalloc" != xno],[
|
|
# find jemalloc header first
|
|
malloc_header=
|
|
AC_CHECK_HEADER(jemalloc/jemalloc.h, [malloc_header=jemalloc/jemalloc.h], [
|
|
AC_CHECK_HEADER(jemalloc.h, [malloc_header=jemalloc.h])
|
|
])
|
|
AS_IF([test "$malloc_header" != ""], [
|
|
AC_DEFINE_UNQUOTED(RUBY_ALTERNATIVE_MALLOC_HEADER, [<$malloc_header>])
|
|
])
|
|
save_LIBS="$LIBS"
|
|
AC_CACHE_CHECK([for jemalloc library], rb_cv_jemalloc_library, [
|
|
rb_cv_jemalloc_library=no
|
|
# try [with mangle, without mangle] x [no more additional
|
|
# libraries, adding jemalloc] combination, using the jemalloc
|
|
# header found above.
|
|
for mangle in '' mangle; do
|
|
for lib in '' -ljemalloc; do
|
|
LIBS="${lib:+$lib }$LIBS"
|
|
AC_LINK_IFELSE([AC_LANG_PROGRAM([${mangle:+@%:@define JEMALLOC_MANGLE 1}
|
|
@%:@include <stdio.h>
|
|
@%:@ifdef RUBY_ALTERNATIVE_MALLOC_HEADER
|
|
@%:@include RUBY_ALTERNATIVE_MALLOC_HEADER
|
|
@%:@else
|
|
extern const char *malloc_conf;
|
|
@%:@endif],
|
|
[/* access at runtime not to be optimized away */
|
|
if (malloc_conf) printf("malloc_conf=%s\n", malloc_conf);])],
|
|
[rb_cv_jemalloc_library="${lib:-none required}${mangle:+ with mangle}"])
|
|
LIBS="$save_LIBS"
|
|
test "${rb_cv_jemalloc_library}" = no || break 2
|
|
done
|
|
done
|
|
])
|
|
with_jemalloc=${rb_cv_jemalloc_library}
|
|
AS_CASE(["$with_jemalloc"],
|
|
[no],
|
|
[AC_MSG_ERROR([jemalloc requested but not found])],
|
|
[-l*], [
|
|
set dummy $with_jemalloc
|
|
LIBS="$2 $LIBS"
|
|
])
|
|
AS_CASE(["$with_jemalloc"],
|
|
[*" with mangle"], [
|
|
AC_DEFINE(JEMALLOC_MANGLE)
|
|
])
|
|
AC_DEFINE(HAVE_MALLOC_CONF)
|
|
ac_cv_func_malloc_usable_size=yes
|
|
]) # with_jemalloc
|
|
|
|
dnl check for large file stuff
|
|
mv confdefs.h confdefs1.h
|
|
: > confdefs.h
|
|
AC_SYS_LARGEFILE
|
|
# On 32-bit Solaris, it is safe to define _LARGEFILE_SOURCE
|
|
# which is not added by AC_SYS_LARGEFILE.
|
|
AS_IF([test x"$enable_largefile" != xno], [
|
|
AS_CASE(["$target_os"], [solaris*], [
|
|
AC_MSG_CHECKING([wheather _LARGEFILE_SOURCE should be defined])
|
|
AS_CASE(["${ac_cv_sys_file_offset_bits}:${ac_cv_sys_large_files}"],
|
|
["64:"|"64:no"|"64:unknown"], [
|
|
# insert _LARGEFILE_SOURCE before _FILE_OFFSET_BITS line
|
|
# that is the same order as "getconf LFS_CFLAGS" output
|
|
mv confdefs.h largefile0.h
|
|
: > confdefs.h
|
|
AC_DEFINE(_LARGEFILE_SOURCE)
|
|
cat largefile0.h >> confdefs.h
|
|
rm largefile0.h
|
|
AC_MSG_RESULT([yes])
|
|
], [AC_MSG_RESULT([no])])
|
|
])
|
|
])
|
|
mv confdefs.h largefile.h
|
|
mv confdefs1.h confdefs.h
|
|
cat largefile.h >> confdefs.h
|
|
|
|
AS_CASE(["$target_os"],
|
|
[aix*], [
|
|
AS_CASE(["$target_cpu:$ac_cv_sys_large_files"],
|
|
[ppc64:*|powerpc64:*], [],
|
|
[*:no|*:unknown], [],
|
|
[
|
|
# AIX currently does not support a 32-bit call to posix_fadvise()
|
|
# if _LARGE_FILES is defined.
|
|
ac_cv_func_posix_fadvise=no
|
|
])
|
|
])
|
|
|
|
AC_C_BIGENDIAN([], [], [], [AC_DEFINE(AC_APPLE_UNIVERSAL_BUILD, 1)])
|
|
AC_C_CONST
|
|
AC_C_CHAR_UNSIGNED
|
|
AC_C_INLINE
|
|
AC_C_VOLATILE
|
|
AC_C_TYPEOF
|
|
AC_C_RESTRICT
|
|
|
|
AS_CASE(":$ac_cv_c_const:$ac_cv_c_volatile:",
|
|
[*:no:*], [AC_MSG_ERROR(ANSI C-conforming const and volatile are mandatory)])
|
|
|
|
AC_CHECK_TYPES([long long, off_t])
|
|
|
|
AC_CACHE_CHECK([char bit], [rb_cv_char_bit],
|
|
[test "$universal_binary" = yes && cross_compiling=yes
|
|
AC_COMPUTE_INT([rb_cv_char_bit], [CHAR_BIT],
|
|
[AC_INCLUDES_DEFAULT([@%:@include <limits.h>])], [rb_cv_char_bit=8])
|
|
test "$universal_binary" = yes && cross_compiling=$real_cross_compiling])
|
|
|
|
RUBY_CHECK_SIZEOF(int, [], [ILP])
|
|
RUBY_CHECK_SIZEOF(short)
|
|
RUBY_CHECK_SIZEOF(long, [int], [ILP LP])
|
|
RUBY_CHECK_SIZEOF(long long)
|
|
RUBY_CHECK_SIZEOF(__int64, [8], [ILP LP])
|
|
RUBY_CHECK_SIZEOF(__int128, [16], [ILP LP])
|
|
RUBY_CHECK_SIZEOF(off_t)
|
|
RUBY_CHECK_SIZEOF(void*, [int long "long long"], [ILP LP LLP])
|
|
RUBY_CHECK_SIZEOF(float)
|
|
RUBY_CHECK_SIZEOF(double)
|
|
RUBY_CHECK_SIZEOF(time_t, [long "long long"], [], [@%:@include <time.h>])
|
|
RUBY_CHECK_SIZEOF(clock_t, [], [], [@%:@include <time.h>])
|
|
|
|
AC_CACHE_CHECK(packed struct attribute, rb_cv_packed_struct,
|
|
[rb_cv_packed_struct=no
|
|
for mac in \
|
|
"__pragma(pack(push, 1)) x __pragma(pack(pop))" \
|
|
"x __attribute__((packed))" \
|
|
; do
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[@%:@define PACKED_STRUCT(x) $mac
|
|
PACKED_STRUCT(struct { int a; });]], [[]])],
|
|
[rb_cv_packed_struct=$mac; break])
|
|
done])
|
|
AS_IF([test "$rb_cv_packed_struct" != no], [
|
|
AC_DEFINE_UNQUOTED([PACKED_STRUCT(x)], [$rb_cv_packed_struct])
|
|
RUBY_TRY_CFLAGS(-Wno-address-of-packed-member, [AC_DEFINE(USE_UNALIGNED_MEMBER_ACCESS)])
|
|
], [
|
|
AC_DEFINE_UNQUOTED([PACKED_STRUCT(x)], x)
|
|
])
|
|
|
|
AS_IF([test "x$ac_cv_type_long_long" = xyes], [
|
|
RUBY_CHECK_PRINTF_PREFIX(long long, ll I64, LL)
|
|
], [test "x$ac_cv_type___int64" = xyes], [
|
|
RUBY_CHECK_PRINTF_PREFIX(__int64, ll I64, LL)
|
|
])
|
|
|
|
RUBY_REPLACE_TYPE(pid_t, int, PIDT)
|
|
RUBY_REPLACE_TYPE(uid_t, int, UIDT)
|
|
RUBY_REPLACE_TYPE(gid_t, int, GIDT)
|
|
RUBY_REPLACE_TYPE(time_t, [], TIMET, [@%:@include <time.h>])
|
|
RUBY_REPLACE_TYPE(dev_t, [int long "long long"], DEVT)
|
|
RUBY_REPLACE_TYPE(mode_t, ["unsigned short" "unsigned int" long], MODET, [@%:@include <sys/stat.h>])
|
|
RUBY_REPLACE_TYPE(rlim_t, [int long "long long"], RLIM, [
|
|
@%:@ifdef HAVE_SYS_TYPES_H
|
|
@%:@include <sys/types.h>
|
|
@%:@endif
|
|
@%:@ifdef HAVE_SYS_TYPES_H
|
|
@%:@include <sys/time.h>
|
|
@%:@endif
|
|
@%:@include <sys/resource.h>
|
|
])
|
|
RUBY_REPLACE_TYPE(off_t, [], OFFT)
|
|
RUBY_REPLACE_TYPE(clockid_t, [], CLOCKID, [@%:@ifdef HAVE_TIME_H
|
|
@%:@ include <time.h>
|
|
@%:@endif
|
|
@%:@ifdef HAVE_SYS_TIME_H
|
|
@%:@ include <sys/time.h>
|
|
@%:@endif])
|
|
|
|
# __VA_ARGS__ is also tested in AC_PROG_CC_C99 since autoconf 2.60a (around
|
|
# 2006). The check below is redundant and should always success. Remain not
|
|
# deleted for backward compat.
|
|
AC_CACHE_CHECK(for variable length macro, rb_cv_va_args_macro,
|
|
[AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
|
|
int foo(const char*);
|
|
@%:@define FOO(...) foo(@%:@__VA_ARGS__)
|
|
]], [[FOO(1);FOO(1,2);FOO(1,2,3);]])],
|
|
rb_cv_va_args_macro=yes,
|
|
rb_cv_va_args_macro=no)])
|
|
AS_IF([test "$rb_cv_va_args_macro" = yes], [
|
|
AC_DEFINE(HAVE_VA_ARGS_MACRO)
|
|
])
|
|
|
|
# We want C11's `_Alignof`. GCC (and alike) have `__alignof__`, which behave
|
|
# slightly differently than the C11's. We cannot use `__alignof__` for our
|
|
# purpose. The problem is, however, that old gcc and old clang had both
|
|
# implemented `_Alignof` as a synonym of `__alignof__`. They are not what we
|
|
# want. We have to check sanity.
|
|
#
|
|
# See also: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=52023
|
|
# See also: https://bugs.llvm.org/show_bug.cgi?id=26547
|
|
AC_CACHE_CHECK([if _Alignof() works], rb_cv_have__alignof,[
|
|
rb_cv_have__alignof=no
|
|
RUBY_WERROR_FLAG([
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
|
|
@%:@ifdef HAVE_STDALIGN_H
|
|
@%:@include <stdalign.h>
|
|
@%:@endif
|
|
@%:@ifdef STDC_HEADERS
|
|
@%:@include <stddef.h>
|
|
@%:@endif
|
|
@%:@ifndef __GNUC__
|
|
@%:@define __extension__
|
|
@%:@endif
|
|
]], [[
|
|
typedef struct conftest_tag {
|
|
char _;
|
|
double d;
|
|
} T;
|
|
static int conftest_ary@<:@
|
|
offsetof(T, d) == __extension__ _Alignof(double)
|
|
? 1 : -1
|
|
@:>@;
|
|
return conftest_ary@<:@0@:>@;
|
|
]])],[
|
|
rb_cv_have__alignof=yes
|
|
],[])
|
|
])
|
|
])
|
|
AS_IF([test "$rb_cv_have__alignof" != no], [
|
|
AC_DEFINE(HAVE__ALIGNOF)
|
|
])
|
|
|
|
RUBY_FUNC_ATTRIBUTE(__const__, CONSTFUNC)
|
|
RUBY_FUNC_ATTRIBUTE(__pure__, PUREFUNC)
|
|
RUBY_FUNC_ATTRIBUTE(__noreturn__, NORETURN)
|
|
RUBY_FUNC_ATTRIBUTE(__deprecated__, DEPRECATED)
|
|
RUBY_FUNC_ATTRIBUTE(__deprecated__("by "@%:@n), DEPRECATED_BY(n,x), rb_cv_func_deprecated_by)
|
|
RUBY_FUNC_ATTRIBUTE(__noinline__, NOINLINE)
|
|
RUBY_FUNC_ATTRIBUTE(__always_inline__, ALWAYS_INLINE)
|
|
RUBY_FUNC_ATTRIBUTE(__no_sanitize__(san), NO_SANITIZE(san, x), rb_cv_func_no_sanitize)
|
|
RUBY_FUNC_ATTRIBUTE(__no_sanitize_address__, NO_SANITIZE_ADDRESS)
|
|
RUBY_FUNC_ATTRIBUTE(__no_address_safety_analysis__, NO_ADDRESS_SAFETY_ANALYSIS)
|
|
RUBY_FUNC_ATTRIBUTE(__warn_unused_result__, WARN_UNUSED_RESULT)
|
|
RUBY_FUNC_ATTRIBUTE(__unused__, MAYBE_UNUSED)
|
|
RUBY_FUNC_ATTRIBUTE(__error__ mesg, ERRORFUNC(mesg,x), rb_cv_func___error__)
|
|
RUBY_FUNC_ATTRIBUTE(__warning__ mesg, WARNINGFUNC(mesg,x), rb_cv_func___warning__)
|
|
RUBY_FUNC_ATTRIBUTE(__weak__, WEAK, rb_cv_func_weak)
|
|
AS_IF([test "$rb_cv_func_weak" != x], [
|
|
AC_DEFINE(HAVE_FUNC_WEAK)
|
|
])
|
|
|
|
AC_CACHE_CHECK([for __attribute__((__depreacted__(msg))) in C++],
|
|
rb_cv_CentOS6_CXX_workaround,
|
|
RUBY_WERROR_FLAG([
|
|
AC_LANG_PUSH([C++])
|
|
AC_COMPILE_IFELSE(
|
|
[AC_LANG_PROGRAM(
|
|
[],
|
|
[__attribute__((__deprecated__("message"))) int conftest(...);])],
|
|
[rb_cv_CentOS6_CXX_workaround=yes],
|
|
[rb_cv_CentOS6_CXX_workaround=no])
|
|
AC_LANG_POP()]))
|
|
AS_IF([test "$rb_cv_CentOS6_CXX_workaround" != no],[
|
|
AC_DEFINE([RUBY_CXX_DEPRECATED(msg)],
|
|
[__attribute__((__deprecated__(msg)))])])
|
|
|
|
AC_CACHE_CHECK([for std::nullptr_t], rb_cv_CXX_nullptr, [
|
|
AC_LANG_PUSH([C++])
|
|
AC_COMPILE_IFELSE(
|
|
[AC_LANG_PROGRAM(
|
|
[@%:@include <cstddef>],
|
|
[static std::nullptr_t const *const conftest = nullptr;])],
|
|
[rb_cv_CXX_nullptr=yes],
|
|
[rb_cv_CXX_nullptr=no])
|
|
AC_LANG_POP()])
|
|
AS_IF([test "$rb_cv_CXX_nullptr" != no],[AC_DEFINE(HAVE_NULLPTR)])
|
|
|
|
if_i386=${universal_binary+[defined __i386__]}
|
|
RUBY_FUNC_ATTRIBUTE(__stdcall__, FUNC_STDCALL, rb_cv_func_stdcall, ${if_i386})
|
|
RUBY_FUNC_ATTRIBUTE(__cdecl__, FUNC_CDECL, rb_cv_func_cdecl, ${if_i386})
|
|
RUBY_FUNC_ATTRIBUTE(__fastcall__, FUNC_FASTCALL, rb_cv_func_fastcall, ${if_i386})
|
|
RUBY_FUNC_ATTRIBUTE(__optimize__("O0"), FUNC_UNOPTIMIZED, rb_cv_func_unoptimized)
|
|
RUBY_FUNC_ATTRIBUTE(__optimize__("-Os","-fomit-frame-pointer"), FUNC_MINIMIZED, rb_cv_func_minimized)
|
|
|
|
AS_IF([test "$GCC" = yes], [
|
|
AC_CACHE_CHECK([for function alias], [rb_cv_gcc_function_alias],
|
|
[rb_cv_gcc_function_alias=no
|
|
for a in alias weak,alias; do
|
|
AC_LINK_IFELSE([AC_LANG_PROGRAM([[void foo(void) {}
|
|
void bar(void) __attribute__(($a("foo")));]], [[bar()]])],
|
|
[rb_cv_gcc_function_alias=$a; break])
|
|
done])
|
|
AS_IF([test "$rb_cv_gcc_function_alias" != no], [
|
|
AC_DEFINE(HAVE_ATTRIBUTE_FUNCTION_ALIAS)
|
|
AC_DEFINE_UNQUOTED([RUBY_ALIAS_FUNCTION_TYPE(type, prot, name, args)],
|
|
[type prot __attribute__(($rb_cv_gcc_function_alias(@%:@name)));])
|
|
AC_DEFINE_UNQUOTED([RUBY_ALIAS_FUNCTION_VOID(prot, name, args)],
|
|
[RUBY_ALIAS_FUNCTION_TYPE(void, prot, name, args)])
|
|
])
|
|
])
|
|
|
|
{
|
|
AC_CACHE_CHECK([for __atomic builtins], [rb_cv_gcc_atomic_builtins], [
|
|
AC_LINK_IFELSE([AC_LANG_PROGRAM([[unsigned int atomic_var;]],
|
|
[[
|
|
__atomic_exchange_n(&atomic_var, 0, __ATOMIC_SEQ_CST);
|
|
__atomic_exchange_n(&atomic_var, 1, __ATOMIC_SEQ_CST);
|
|
__atomic_fetch_add(&atomic_var, 1, __ATOMIC_SEQ_CST);
|
|
__atomic_fetch_sub(&atomic_var, 1, __ATOMIC_SEQ_CST);
|
|
__atomic_or_fetch(&atomic_var, 1, __ATOMIC_SEQ_CST);
|
|
]])],
|
|
[rb_cv_gcc_atomic_builtins=yes],
|
|
[rb_cv_gcc_atomic_builtins=no])])
|
|
AS_IF([test "$rb_cv_gcc_atomic_builtins" = yes], [
|
|
AC_DEFINE(HAVE_GCC_ATOMIC_BUILTINS)
|
|
])
|
|
|
|
AC_CACHE_CHECK([for __sync builtins], [rb_cv_gcc_sync_builtins], [
|
|
AC_LINK_IFELSE([AC_LANG_PROGRAM([[unsigned int atomic_var;]],
|
|
[[
|
|
__sync_lock_test_and_set(&atomic_var, 0);
|
|
__sync_lock_test_and_set(&atomic_var, 1);
|
|
__sync_fetch_and_add(&atomic_var, 1);
|
|
__sync_fetch_and_sub(&atomic_var, 1);
|
|
__sync_or_and_fetch(&atomic_var, 1);
|
|
__sync_val_compare_and_swap(&atomic_var, 0, 1);
|
|
]])],
|
|
[rb_cv_gcc_sync_builtins=yes],
|
|
[rb_cv_gcc_sync_builtins=no])])
|
|
AS_IF([test "$rb_cv_gcc_sync_builtins" = yes], [
|
|
AC_DEFINE(HAVE_GCC_SYNC_BUILTINS)
|
|
])
|
|
|
|
AC_CACHE_CHECK(for __builtin_unreachable, rb_cv_func___builtin_unreachable,
|
|
[RUBY_WERROR_FLAG(
|
|
[AC_LINK_IFELSE([AC_LANG_PROGRAM([[volatile int zero;]],
|
|
[[if (zero) __builtin_unreachable();]])],
|
|
[rb_cv_func___builtin_unreachable=yes],
|
|
[rb_cv_func___builtin_unreachable=no])
|
|
])
|
|
])
|
|
AS_IF([test "$rb_cv_func___builtin_unreachable" = yes], [
|
|
AC_DEFINE_UNQUOTED(UNREACHABLE, [__builtin_unreachable()])
|
|
])
|
|
}
|
|
|
|
AC_CACHE_CHECK(for exported function attribute, rb_cv_func_exported, [
|
|
rb_cv_func_exported=no
|
|
RUBY_WERROR_FLAG([
|
|
for mac in '__attribute__ ((__visibility__("default")))' '__declspec(dllexport)'; do
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[@%:@define RUBY_FUNC_EXPORTED $mac extern
|
|
RUBY_FUNC_EXPORTED void conftest_attribute_check(void);]], [[]])],
|
|
[rb_cv_func_exported="$mac"; break])
|
|
done
|
|
])])
|
|
AS_IF([test "$rb_cv_func_exported" != no], [
|
|
AC_DEFINE_UNQUOTED(RUBY_FUNC_EXPORTED, [$rb_cv_func_exported extern])
|
|
])
|
|
RUBY_DECL_ATTRIBUTE([__nonnull__(n)], [RUBY_FUNC_NONNULL(n,x)], [rb_cv_func_nonnull],
|
|
[], [function], [
|
|
@%:@define x int conftest_attribute_check(void *p)
|
|
@%:@define n 1
|
|
])
|
|
|
|
RUBY_APPEND_OPTION(XCFLAGS, -DRUBY_EXPORT)
|
|
|
|
AC_ARG_ENABLE(mathn,
|
|
AS_HELP_STRING([--enable-mathn], [enable canonicalization for mathn]),
|
|
[AC_MSG_ERROR([mathn support has been dropped])])
|
|
|
|
AC_CACHE_CHECK(for function name string predefined identifier,
|
|
rb_cv_function_name_string,
|
|
[AS_CASE(["$target_os"],[openbsd*],[
|
|
rb_cv_function_name_string=__func__
|
|
],[
|
|
rb_cv_function_name_string=no
|
|
RUBY_WERROR_FLAG([
|
|
for func in __func__ __FUNCTION__; do
|
|
AC_LINK_IFELSE([AC_LANG_PROGRAM([[@%:@include <stdio.h>]],
|
|
[[puts($func);]])],
|
|
[rb_cv_function_name_string=$func
|
|
break])
|
|
done
|
|
])])]
|
|
)
|
|
AS_IF([test "$rb_cv_function_name_string" != no], [
|
|
AC_DEFINE_UNQUOTED(RUBY_FUNCTION_NAME_STRING, [$rb_cv_function_name_string])
|
|
])
|
|
|
|
AC_CACHE_CHECK(if enum over int is allowed, rb_cv_enum_over_int, [
|
|
rb_cv_enum_over_int=no
|
|
AS_IF([test "x$ac_cv_type_long_long" = xyes], [
|
|
type="unsigned long long" max="ULLONG_MAX"
|
|
], [
|
|
type="unsigned long" max="ULONG_MAX"
|
|
])
|
|
RUBY_WERROR_FLAG([
|
|
AC_COMPILE_IFELSE([
|
|
AC_LANG_BOOL_COMPILE_TRY([
|
|
@%:@include <limits.h>
|
|
enum {conftest_max = $max};
|
|
], [
|
|
(conftest_max == $max) &&
|
|
(sizeof(conftest_max) == sizeof($type))
|
|
]
|
|
)],
|
|
[rb_cv_enum_over_int=yes],
|
|
[rb_cv_enum_over_int=no]
|
|
)
|
|
])
|
|
])
|
|
AS_IF([test $rb_cv_enum_over_int = yes], [
|
|
AC_DEFINE(ENUM_OVER_INT, 1)
|
|
])
|
|
|
|
dnl Check whether we need to define sys_nerr locally
|
|
AC_CHECK_DECLS([sys_nerr], [], [], [$ac_includes_default
|
|
@%:@include <errno.h>])
|
|
|
|
AC_CHECK_DECLS([getenv])
|
|
|
|
AS_CASE(["$target_cpu"],
|
|
[alpha*|sh4|sh4el|sh4eb], [AS_CASE(["$target_os"::"$GCC"],
|
|
[*::yes], # gcc
|
|
[CFLAGS="-mieee $CFLAGS"],
|
|
[osf*], # ccc
|
|
[CFLAGS="-ieee $CFLAGS"],
|
|
)],
|
|
[sparc*], [AC_LIBOBJ([sparc])])
|
|
|
|
ac_cv_header_net_socket_h=${ac_cv_header_net_socket_h=no}
|
|
AS_IF([test "$ac_cv_header_net_socket_h" = yes], [
|
|
ac_cv_header_sys_socket_h=${ac_cv_header_sys_socket_h=no}
|
|
], [
|
|
ac_cv_header_sys_socket_h=${ac_cv_header_sys_socket_h=yes}
|
|
])
|
|
|
|
|
|
AC_TYPE_SIZE_T
|
|
RUBY_CHECK_SIGNEDNESS(size_t, [AC_MSG_ERROR(size_t is signed)], [],
|
|
[@%:@include <sys/types.h>])
|
|
RUBY_CHECK_SIZEOF(size_t, [int long void*], [], [@%:@include <sys/types.h>])
|
|
RUBY_CHECK_SIZEOF(ptrdiff_t, size_t, [], [@%:@include <stddef.h>])
|
|
RUBY_CHECK_SIZEOF(dev_t)
|
|
RUBY_CHECK_PRINTF_PREFIX(size_t, z)
|
|
RUBY_CHECK_PRINTF_PREFIX(ptrdiff_t, t)
|
|
AC_CHECK_MEMBERS([struct stat.st_blksize])
|
|
AC_CHECK_MEMBERS([struct stat.st_blocks])
|
|
AC_CHECK_MEMBERS([struct stat.st_rdev])
|
|
RUBY_CHECK_SIZEOF([struct stat.st_size], [off_t int long "long long"], [], [@%:@include <sys/stat.h>])
|
|
AS_IF([test "$ac_cv_member_struct_stat_st_blocks" = yes], [
|
|
RUBY_CHECK_SIZEOF([struct stat.st_blocks], [off_t int long "long long"], [], [@%:@include <sys/stat.h>])
|
|
])
|
|
RUBY_CHECK_SIZEOF([struct stat.st_ino], [long "long long"], [], [@%:@include <sys/stat.h>])
|
|
RUBY_CHECK_SIZEOF([struct stat.st_dev], [dev_t int long "long long"], [], [@%:@include <sys/stat.h>])
|
|
AS_IF([test "$ac_cv_member_struct_stat_st_rdev" = yes], [
|
|
RUBY_CHECK_SIZEOF([struct stat.st_rdev], [dev_t int long "long long"], [], [@%:@include <sys/stat.h>])
|
|
])
|
|
AC_CHECK_MEMBERS([struct stat.st_atim])
|
|
AC_CHECK_MEMBERS([struct stat.st_atimespec])
|
|
AC_CHECK_MEMBERS([struct stat.st_atimensec])
|
|
AC_CHECK_MEMBERS([struct stat.st_mtim])
|
|
AC_CHECK_MEMBERS([struct stat.st_mtimespec])
|
|
AC_CHECK_MEMBERS([struct stat.st_mtimensec])
|
|
AC_CHECK_MEMBERS([struct stat.st_ctim])
|
|
AC_CHECK_MEMBERS([struct stat.st_ctimespec])
|
|
AC_CHECK_MEMBERS([struct stat.st_ctimensec])
|
|
AC_CHECK_MEMBERS([struct stat.st_birthtimespec])
|
|
AS_IF([test "x$ac_cv_member_struct_stat_st_birthtimespec" != xyes],
|
|
[AC_CHECK_MEMBERS([struct statx.stx_btime])])
|
|
|
|
AC_CHECK_TYPES([struct timeval], [], [], [@%:@ifdef HAVE_TIME_H
|
|
@%:@include <time.h>
|
|
@%:@endif
|
|
@%:@ifdef HAVE_SYS_TIME_H
|
|
@%:@include <sys/time.h>
|
|
@%:@endif])
|
|
|
|
AS_IF([test "${ac_cv_type_struct_timeval}" = yes], [
|
|
RUBY_CHECK_SIZEOF([struct timeval.tv_sec], [time_t long "long long"], [],
|
|
[@%:@ifdef HAVE_TIME_H
|
|
@%:@include <time.h>
|
|
@%:@endif
|
|
@%:@ifdef HAVE_SYS_TIME_H
|
|
@%:@include <sys/time.h>
|
|
@%:@endif])
|
|
AS_CASE(${ac_cv_sizeof_struct_timeval_tv_sec},
|
|
[SIZEOF_INT], [t=int],
|
|
[SIZEOF_LONG], [t=long],
|
|
[SIZEOF_LONG_LONG], [t=LONG_LONG],
|
|
[t=])
|
|
AS_IF([test "${t}" != ""], [
|
|
AC_DEFINE_UNQUOTED(TYPEOF_TIMEVAL_TV_SEC, [$t])
|
|
])
|
|
])
|
|
|
|
AC_CHECK_TYPES([struct timespec], [], [], [@%:@ifdef HAVE_TIME_H
|
|
@%:@include <time.h>
|
|
@%:@endif
|
|
@%:@ifdef HAVE_SYS_TIME_H
|
|
@%:@include <sys/time.h>
|
|
@%:@endif])
|
|
|
|
AC_CHECK_TYPES([struct timezone], [], [], [@%:@ifdef HAVE_TIME_H
|
|
@%:@ include <time.h>
|
|
@%:@endif
|
|
@%:@ifdef HAVE_SYS_TIME_H
|
|
@%:@ include <sys/time.h>
|
|
@%:@endif])
|
|
|
|
AC_CACHE_VAL([rb_cv_large_fd_select],
|
|
[AC_CHECK_TYPE(fd_mask, [rb_cv_large_fd_select=yes], [rb_cv_large_fd_select=no], [AC_INCLUDES_DEFAULT([])
|
|
@%:@ifdef HAVE_SYS_SELECT_H
|
|
@%:@ include <sys/select.h>
|
|
@%:@endif])])
|
|
AS_IF([test "$rb_cv_large_fd_select" = yes], [
|
|
AC_DEFINE(HAVE_RB_FD_INIT, 1)
|
|
])
|
|
|
|
RUBY_DEFINT(int8_t, 1)
|
|
RUBY_DEFINT(uint8_t, 1, unsigned)
|
|
RUBY_DEFINT(int16_t, 2)
|
|
RUBY_DEFINT(uint16_t, 2, unsigned)
|
|
RUBY_DEFINT(int32_t, 4)
|
|
RUBY_DEFINT(uint32_t, 4, unsigned)
|
|
RUBY_DEFINT(int64_t, 8)
|
|
RUBY_DEFINT(uint64_t, 8, unsigned)
|
|
RUBY_DEFINT(int128_t, 16)
|
|
RUBY_DEFINT(uint128_t, 16, unsigned)
|
|
RUBY_DEFINT(intptr_t, void*)
|
|
RUBY_DEFINT(uintptr_t, void*, unsigned)
|
|
AS_IF([test "x$rb_cv_type_intptr_t" != xno], [
|
|
RUBY_CHECK_PRINTF_PREFIX(intptr_t, '' ll I64 l, PTR)
|
|
])
|
|
RUBY_DEFINT(ssize_t, size_t, [], [@%:@include <sys/types.h>]) dnl may differ from int, so not use AC_TYPE_SSIZE_T.
|
|
AS_IF([test "x$rb_cv_type_int64_t" != xno], [
|
|
RUBY_CHECK_PRINTF_PREFIX(int64_t, ll I64 l, 64)
|
|
])
|
|
|
|
AC_CACHE_CHECK(for stack end address, rb_cv_stack_end_address,
|
|
[rb_cv_stack_end_address=no
|
|
AC_LINK_IFELSE([AC_LANG_PROGRAM(
|
|
[[extern void *__libc_stack_end;]],
|
|
[[if (!__libc_stack_end) return 1;]])],
|
|
[rb_cv_stack_end_address="__libc_stack_end"])
|
|
])
|
|
AS_IF([test $rb_cv_stack_end_address != no], [
|
|
AC_DEFINE_UNQUOTED(STACK_END_ADDRESS, $rb_cv_stack_end_address)
|
|
])
|
|
|
|
dnl Checks for library functions.
|
|
AC_TYPE_GETGROUPS
|
|
AS_CASE(["${target_cpu}-${target_os}:${target_archs}"],
|
|
[powerpc-darwin*], [
|
|
AC_LIBSOURCES(alloca.c)
|
|
AC_SUBST([ALLOCA], [\${LIBOBJDIR}alloca.${ac_objext}])
|
|
AC_DEFINE(C_ALLOCA)
|
|
AC_DEFINE_UNQUOTED(alloca, alloca)
|
|
],
|
|
[universal-darwin*:*ppc*], [
|
|
AC_LIBSOURCES(alloca.c)
|
|
AC_SUBST([ALLOCA], [\${LIBOBJDIR}alloca.${ac_objext}])
|
|
RUBY_DEFINE_IF([defined __powerpc__], C_ALLOCA, 1)
|
|
RUBY_DEFINE_IF([defined __powerpc__], alloca, alloca)
|
|
],
|
|
[
|
|
AC_FUNC_ALLOCA
|
|
])
|
|
AS_IF([test "x$ALLOCA" = "x"], [
|
|
AC_CACHE_CHECK([for dynamic size alloca], rb_cv_dynamic_alloca, [
|
|
for chk in ok __chkstk; do
|
|
AC_LINK_IFELSE([AC_LANG_PROGRAM([[
|
|
@%:@ifdef HAVE_ALLOCA_H
|
|
@%:@include <alloca.h>
|
|
@%:@endif
|
|
void $chk() {}
|
|
int dynamic_alloca_test;
|
|
int dynamic_alloca_result;]],
|
|
[[dynamic_alloca_result = alloca(dynamic_alloca_test) != 0;]])],
|
|
[rb_cv_dynamic_alloca=$chk; break])
|
|
done])
|
|
AS_IF([test "x$rb_cv_dynamic_alloca" = "x__chkstk"], [
|
|
AC_DEFINE_UNQUOTED(RUBY_ALLOCA_CHKSTK, _$rb_cv_dynamic_alloca)
|
|
AS_CASE("$target_cpu",
|
|
[x64|x86_64], [
|
|
AC_SUBST([ALLOCA], [\${LIBOBJDIR}x86_64-chkstk.${ac_objext}])
|
|
],)
|
|
])
|
|
])
|
|
AC_FUNC_MEMCMP
|
|
|
|
AS_CASE(["$target_os"],[freebsd*],[
|
|
AC_DEFINE(BROKEN_CLOSE)
|
|
AC_REPLACE_FUNCS(close)
|
|
])
|
|
|
|
AC_DEFUN([RUBY_REQUIRE_FUNC], [
|
|
AC_CHECK_FUNCS([$1])
|
|
AS_IF([test "$ac_cv_func_[]AS_TR_SH($1)" = yes], [],
|
|
[AC_MSG_ERROR($1[() must be supported])])
|
|
])
|
|
m4_map_args_w([dup dup2], [RUBY_REQUIRE_FUNC(], [)])
|
|
|
|
AC_REPLACE_FUNCS(acosh)
|
|
AC_REPLACE_FUNCS(cbrt)
|
|
AC_REPLACE_FUNCS(crypt)
|
|
AC_REPLACE_FUNCS(erf)
|
|
AC_REPLACE_FUNCS(explicit_bzero)
|
|
AC_REPLACE_FUNCS(ffs)
|
|
AC_REPLACE_FUNCS(flock)
|
|
AC_REPLACE_FUNCS(hypot)
|
|
AC_REPLACE_FUNCS(lgamma_r)
|
|
AC_REPLACE_FUNCS(memmove)
|
|
AC_REPLACE_FUNCS(nan)
|
|
AC_REPLACE_FUNCS(nextafter)
|
|
AC_REPLACE_FUNCS(setproctitle)
|
|
AC_REPLACE_FUNCS(strchr)
|
|
AC_REPLACE_FUNCS(strerror)
|
|
AC_REPLACE_FUNCS(strlcat)
|
|
AC_REPLACE_FUNCS(strlcpy)
|
|
AC_REPLACE_FUNCS(strstr)
|
|
AC_REPLACE_FUNCS(tgamma)
|
|
|
|
AC_DEFINE(HAVE_ISFINITE) # C99; backward compatibility
|
|
|
|
# for missing/setproctitle.c
|
|
AS_CASE(["$target_os"],
|
|
[aix* | k*bsd*-gnu | kopensolaris*-gnu | linux* | darwin*], [AC_DEFINE(SPT_TYPE,SPT_REUSEARGV)],
|
|
[hpux*], [AC_DEFINE(SPT_TYPE,SPT_PSTAT) ],
|
|
[])
|
|
AC_CHECK_HEADERS(sys/pstat.h)
|
|
|
|
|
|
AC_DEFINE(HAVE_SIGNBIT) # C99; backward compatibility
|
|
|
|
AC_FUNC_FORK
|
|
|
|
AC_CHECK_FUNCS(__syscall)
|
|
AC_CHECK_FUNCS(_longjmp) # used for AC_ARG_WITH(setjmp-type)
|
|
# we don't use _setjmp if _longjmp doesn't exist.
|
|
test x$ac_cv_func__longjmp = xno && ac_cv_func__setjmp=no
|
|
AC_CHECK_FUNCS(arc4random_buf)
|
|
AC_CHECK_FUNCS(atan2l atan2f)
|
|
AC_CHECK_FUNCS(chroot)
|
|
AC_CHECK_FUNCS(chsize)
|
|
AC_CHECK_FUNCS(clock_gettime)
|
|
AC_CHECK_FUNCS(copy_file_range)
|
|
AC_CHECK_FUNCS(cosh)
|
|
AC_CHECK_FUNCS(crypt_r)
|
|
AC_CHECK_FUNCS(daemon)
|
|
AC_CHECK_FUNCS(dirfd)
|
|
AC_CHECK_FUNCS(dl_iterate_phdr)
|
|
AC_CHECK_FUNCS(dlopen)
|
|
AC_CHECK_FUNCS(dladdr)
|
|
AC_CHECK_FUNCS(dup3)
|
|
AC_CHECK_FUNCS(eaccess)
|
|
AC_CHECK_FUNCS(endgrent)
|
|
AC_CHECK_FUNCS(eventfd)
|
|
AC_CHECK_FUNCS(explicit_memset)
|
|
AC_CHECK_FUNCS(fcopyfile)
|
|
AC_CHECK_FUNCS(fchmod)
|
|
AC_CHECK_FUNCS(fchown)
|
|
AC_CHECK_FUNCS(fcntl)
|
|
AC_CHECK_FUNCS(fdatasync)
|
|
AC_CHECK_FUNCS(fdopendir)
|
|
AC_CHECK_FUNCS(fgetattrlist)
|
|
AC_CHECK_FUNCS(fmod)
|
|
AC_CHECK_FUNCS(fstatat)
|
|
AC_CHECK_FUNCS(fsync)
|
|
AC_CHECK_FUNCS(ftruncate)
|
|
AC_CHECK_FUNCS(ftruncate64) # used for Win32 platform
|
|
AC_CHECK_FUNCS(getattrlist)
|
|
AC_CHECK_FUNCS(getcwd)
|
|
AC_CHECK_FUNCS(getentropy)
|
|
AC_CHECK_FUNCS(getgidx)
|
|
AC_CHECK_FUNCS(getgrnam)
|
|
AC_CHECK_FUNCS(getgrnam_r)
|
|
AC_CHECK_FUNCS(getgroups)
|
|
AC_CHECK_FUNCS(getlogin)
|
|
AC_CHECK_FUNCS(getlogin_r)
|
|
AC_CHECK_FUNCS(getpgid)
|
|
AC_CHECK_FUNCS(getpgrp)
|
|
AC_CHECK_FUNCS(getpriority)
|
|
AC_CHECK_FUNCS(getpwnam)
|
|
AC_CHECK_FUNCS(getpwnam_r)
|
|
AC_CHECK_FUNCS(getpwuid)
|
|
AC_CHECK_FUNCS(getpwuid_r)
|
|
AC_CHECK_FUNCS(getrandom)
|
|
AC_CHECK_FUNCS(getresgid)
|
|
AC_CHECK_FUNCS(getresuid)
|
|
AC_CHECK_FUNCS(getrlimit)
|
|
AC_CHECK_FUNCS(getsid)
|
|
AC_CHECK_FUNCS(gettimeofday) # for making ac_cv_func_gettimeofday
|
|
AC_CHECK_FUNCS(getuidx)
|
|
AC_CHECK_FUNCS(gmtime_r)
|
|
AC_CHECK_FUNCS(grantpt)
|
|
AC_CHECK_FUNCS(initgroups)
|
|
AC_CHECK_FUNCS(ioctl)
|
|
AC_CHECK_FUNCS(isfinite)
|
|
AC_CHECK_FUNCS(issetugid)
|
|
AC_CHECK_FUNCS(killpg)
|
|
AC_CHECK_FUNCS(lchmod)
|
|
AC_CHECK_FUNCS(lchown)
|
|
AC_CHECK_FUNCS(link)
|
|
AC_CHECK_FUNCS(llabs)
|
|
AC_CHECK_FUNCS(lockf)
|
|
AC_CHECK_FUNCS(log2)
|
|
AC_CHECK_FUNCS(lstat)
|
|
AC_CHECK_FUNCS(lutimes)
|
|
AC_CHECK_FUNCS(malloc_usable_size)
|
|
AC_CHECK_FUNCS(malloc_size)
|
|
AC_CHECK_FUNCS(mblen)
|
|
AC_CHECK_FUNCS(memalign)
|
|
AC_CHECK_FUNCS(memset_s)
|
|
AC_CHECK_FUNCS(writev)
|
|
AC_CHECK_FUNCS(memrchr)
|
|
AC_CHECK_FUNCS(memmem)
|
|
AC_CHECK_FUNCS(mkfifo)
|
|
AC_CHECK_FUNCS(mknod)
|
|
AC_CHECK_FUNCS(mktime)
|
|
AC_CHECK_FUNCS(mmap)
|
|
AC_CHECK_FUNCS(openat)
|
|
AC_CHECK_FUNCS(pipe2)
|
|
AC_CHECK_FUNCS(poll)
|
|
AC_CHECK_FUNCS(posix_fadvise)
|
|
AC_CHECK_FUNCS(posix_memalign)
|
|
AC_CHECK_FUNCS(ppoll)
|
|
AC_CHECK_FUNCS(pread)
|
|
AC_CHECK_FUNCS(pwrite)
|
|
AC_CHECK_FUNCS(qsort_r)
|
|
AC_CHECK_FUNCS(qsort_s)
|
|
AC_CHECK_FUNCS(readlink)
|
|
AC_CHECK_FUNCS(realpath)
|
|
AC_CHECK_FUNCS(round)
|
|
AC_CHECK_FUNCS(sched_getaffinity)
|
|
AC_CHECK_FUNCS(seekdir)
|
|
AC_CHECK_FUNCS(select_large_fdset)
|
|
AC_CHECK_FUNCS(sendfile)
|
|
AC_CHECK_FUNCS(setegid)
|
|
AC_CHECK_FUNCS(setenv)
|
|
AC_CHECK_FUNCS(seteuid)
|
|
AC_CHECK_FUNCS(setgid)
|
|
AC_CHECK_FUNCS(setgroups)
|
|
AC_CHECK_FUNCS(setpgid)
|
|
AC_CHECK_FUNCS(setpgrp)
|
|
AC_CHECK_FUNCS(setregid)
|
|
AC_CHECK_FUNCS(setresgid)
|
|
AC_CHECK_FUNCS(setresuid)
|
|
AC_CHECK_FUNCS(setreuid)
|
|
AC_CHECK_FUNCS(setrgid)
|
|
AC_CHECK_FUNCS(setrlimit)
|
|
AC_CHECK_FUNCS(setruid)
|
|
AC_CHECK_FUNCS(setsid)
|
|
AC_CHECK_FUNCS(setuid)
|
|
AC_CHECK_FUNCS(shutdown)
|
|
AC_CHECK_FUNCS(sigaction)
|
|
AC_CHECK_FUNCS(sigaltstack)
|
|
AC_CHECK_FUNCS(sigprocmask)
|
|
AC_CHECK_FUNCS(sinh)
|
|
AC_CHECK_FUNCS(spawnv)
|
|
AC_CHECK_FUNCS(symlink)
|
|
AC_CHECK_FUNCS(syscall)
|
|
AC_CHECK_FUNCS(sysconf)
|
|
AC_CHECK_FUNCS(tanh)
|
|
AC_CHECK_FUNCS(telldir)
|
|
AC_CHECK_FUNCS(timegm)
|
|
AC_CHECK_FUNCS(times)
|
|
AC_CHECK_FUNCS(truncate)
|
|
AC_CHECK_FUNCS(truncate64) # used for Win32
|
|
AC_CHECK_FUNCS(unsetenv)
|
|
AC_CHECK_FUNCS(utimensat)
|
|
AC_CHECK_FUNCS(utimes)
|
|
AC_CHECK_FUNCS(wait4)
|
|
AC_CHECK_FUNCS(waitpid)
|
|
AC_CHECK_FUNCS(__cospi)
|
|
AC_CHECK_FUNCS(__sinpi)
|
|
|
|
AS_IF([test "x$ac_cv_member_struct_statx_stx_btime" = xyes],
|
|
[AC_CHECK_FUNCS(statx)])
|
|
|
|
AS_CASE(["$ac_cv_func_memset_s:$ac_cv_func_qsort_s"], [*yes*],
|
|
[RUBY_DEFINE_IF([!defined __STDC_WANT_LIB_EXT1__], [__STDC_WANT_LIB_EXT1__], 1)])
|
|
|
|
AS_IF([test "$ac_cv_func_getcwd" = yes], [
|
|
AC_CACHE_CHECK(if getcwd allocates buffer if NULL is given, [rb_cv_getcwd_malloc],
|
|
[AC_RUN_IFELSE([AC_LANG_SOURCE([[
|
|
@%:@include <stddef.h>
|
|
@%:@include <stdio.h>
|
|
@%:@ifdef HAVE_UNISTD_H
|
|
@%:@include <unistd.h>
|
|
@%:@endif
|
|
@%:@ifndef EXIT_SUCCESS
|
|
@%:@define EXIT_SUCCESS 0
|
|
@%:@endif
|
|
@%:@ifndef EXIT_FAILURE
|
|
@%:@define EXIT_FAILURE 1
|
|
@%:@endif
|
|
|
|
int
|
|
main(int argc, char **argv)
|
|
{
|
|
if (!getcwd(NULL, 0)) return EXIT_FAILURE;
|
|
return EXIT_SUCCESS;
|
|
}
|
|
]])],
|
|
rb_cv_getcwd_malloc=yes,
|
|
rb_cv_getcwd_malloc=no,
|
|
AS_CASE($target_os,
|
|
[linux*|darwin*|*bsd|cygwin*|msys*|mingw*|mswin*],
|
|
[rb_cv_getcwd_malloc=yes],
|
|
[rb_cv_getcwd_malloc=no]))])
|
|
AS_IF([test "$rb_cv_getcwd_malloc" = no], [AC_DEFINE(NO_GETCWD_MALLOC, 1)])
|
|
])
|
|
|
|
AS_IF([test "$ac_cv_func_crypt_r" = yes],
|
|
[AC_CHECK_HEADERS(crypt.h)])
|
|
AS_IF([test "$ac_cv_func_crypt_r:$ac_cv_header_crypt_h" = yes:yes],
|
|
[AC_CHECK_MEMBERS([struct crypt_data.initialized], [], [],
|
|
[AC_INCLUDES_DEFAULT([@%:@include <crypt.h>])])])
|
|
|
|
RUBY_CHECK_BUILTIN_FUNC(__builtin_alloca_with_align, [__builtin_alloca_with_align(1, 4096)])
|
|
RUBY_CHECK_BUILTIN_FUNC(__builtin_assume_aligned, [__builtin_assume_aligned((void*)32, 32)])
|
|
RUBY_CHECK_BUILTIN_FUNC(__builtin_bswap16, [__builtin_bswap16(0)])
|
|
RUBY_CHECK_BUILTIN_FUNC(__builtin_bswap32, [__builtin_bswap32(0)])
|
|
RUBY_CHECK_BUILTIN_FUNC(__builtin_bswap64, [__builtin_bswap64(0)])
|
|
RUBY_CHECK_BUILTIN_FUNC(__builtin_popcount, [__builtin_popcount(0)])
|
|
RUBY_CHECK_BUILTIN_FUNC(__builtin_popcountll, [__builtin_popcountll(0)])
|
|
RUBY_CHECK_BUILTIN_FUNC(__builtin_clz, [__builtin_clz(0)])
|
|
RUBY_CHECK_BUILTIN_FUNC(__builtin_clzl, [__builtin_clzl(0)])
|
|
RUBY_CHECK_BUILTIN_FUNC(__builtin_clzll, [__builtin_clzll(0)])
|
|
RUBY_CHECK_BUILTIN_FUNC(__builtin_ctz, [__builtin_ctz(0)])
|
|
RUBY_CHECK_BUILTIN_FUNC(__builtin_ctzll, [__builtin_ctzll(0)])
|
|
RUBY_CHECK_BUILTIN_FUNC(__builtin_add_overflow, [int x;__builtin_add_overflow(0,0,&x)])
|
|
RUBY_CHECK_BUILTIN_FUNC(__builtin_sub_overflow, [int x;__builtin_sub_overflow(0,0,&x)])
|
|
RUBY_CHECK_BUILTIN_FUNC(__builtin_mul_overflow, [int x;__builtin_mul_overflow(0,0,&x)])
|
|
RUBY_CHECK_BUILTIN_FUNC(__builtin_mul_overflow_p, [__builtin_mul_overflow_p(0,0,(int)0)])
|
|
RUBY_CHECK_BUILTIN_FUNC(__builtin_constant_p, [__builtin_constant_p(0)])
|
|
RUBY_CHECK_BUILTIN_FUNC(__builtin_choose_expr, [
|
|
[int x[__extension__(__builtin_choose_expr(1, 1, -1))]];
|
|
[int y[__extension__(__builtin_choose_expr(0, -1, 1))]];
|
|
])
|
|
AS_IF([test x$rb_cv_builtin___builtin_choose_expr = xyes], [
|
|
RUBY_CHECK_BUILTIN_FUNC(__builtin_choose_expr_constant_p, [
|
|
[int x[__extension__(__builtin_choose_expr(__builtin_constant_p(1), 1, -1))]];
|
|
[int y[__extension__(__builtin_choose_expr(__builtin_constant_p(foo), -1, 1))]];
|
|
])
|
|
])
|
|
RUBY_CHECK_BUILTIN_FUNC(__builtin_types_compatible_p, [__builtin_types_compatible_p(int, int)])
|
|
RUBY_CHECK_BUILTIN_FUNC(__builtin_trap, [__builtin_trap()])
|
|
RUBY_CHECK_BUILTIN_FUNC(__builtin_expect, [__builtin_expect(0, 0)])
|
|
|
|
AS_IF([test "$ac_cv_func_qsort_r" != no], [
|
|
AC_CACHE_CHECK(whether qsort_r is GNU version, rb_cv_gnu_qsort_r,
|
|
[AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
|
|
@%:@include <stdlib.h>
|
|
void (qsort_r)(void *base, size_t nmemb, size_t size,
|
|
int (*compar)(const void *, const void *, void *),
|
|
void *arg);
|
|
]], [[ ]])],
|
|
[rb_cv_gnu_qsort_r=yes],
|
|
[rb_cv_gnu_qsort_r=no])
|
|
])
|
|
AC_CACHE_CHECK(whether qsort_r is BSD version, rb_cv_bsd_qsort_r,
|
|
[AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
|
|
@%:@include <stdlib.h>
|
|
void (qsort_r)(void *base, size_t nmemb, size_t size,
|
|
void *arg, int (*compar)(void *, const void *, const void *));
|
|
]], [[ ]])],
|
|
[rb_cv_bsd_qsort_r=yes],
|
|
[rb_cv_bsd_qsort_r=no])
|
|
])
|
|
AS_CASE("$rb_cv_gnu_qsort_r:$rb_cv_bsd_qsort_r",
|
|
[yes:no], [
|
|
AC_DEFINE(HAVE_GNU_QSORT_R, 1)
|
|
],
|
|
[no:yes], [
|
|
AC_DEFINE(HAVE_BSD_QSORT_R, 1)
|
|
])
|
|
])
|
|
|
|
AC_CACHE_CHECK(whether atan2 handles Inf as C99, rb_cv_atan2_inf_c99, [
|
|
AS_IF([test $ac_cv_func_atan2f:$ac_cv_func_atan2l = yes:yes], [
|
|
AC_RUN_IFELSE([AC_LANG_SOURCE([[
|
|
@%:@include <math.h>
|
|
@%:@ifdef HAVE_UNISTD_H
|
|
@%:@include <unistd.h>
|
|
@%:@endif
|
|
@%:@ifndef EXIT_SUCCESS
|
|
@%:@define EXIT_SUCCESS 0
|
|
@%:@endif
|
|
@%:@ifndef EXIT_FAILURE
|
|
@%:@define EXIT_FAILURE 1
|
|
@%:@endif
|
|
|
|
int
|
|
main(int argc, char **argv)
|
|
{
|
|
if (fabs(atan2(INFINITY, INFINITY) - M_PI_4) <= 0.01) return EXIT_SUCCESS;
|
|
return EXIT_FAILURE;
|
|
}
|
|
]])],
|
|
[rb_cv_atan2_inf_c99=yes],
|
|
[rb_cv_atan2_inf_c99=no],
|
|
[AS_CASE($target_os, [mingw*|mswin*], [rb_cv_atan2_inf_c99=no], [rb_cv_atan2_inf_c99=yes])]
|
|
)
|
|
], [rb_cv_atan2_inf_c99=no])
|
|
])
|
|
AS_IF([test "x$rb_cv_atan2_inf_c99" = xyes], [AC_DEFINE(ATAN2_INF_C99)])
|
|
|
|
# Some platform need -lrt for clock_gettime, but the other don't.
|
|
AS_IF([test x"$ac_cv_func_clock_gettime" != xyes], [
|
|
# glibc 2.17 moves clock_* functions from librt to the main C library.
|
|
# http://sourceware.org/ml/libc-announce/2012/msg00001.html
|
|
AC_CHECK_LIB(rt, clock_gettime)
|
|
AS_IF([test x"$ac_cv_lib_rt_clock_gettime" = xyes], [
|
|
AC_DEFINE(HAVE_CLOCK_GETTIME, 1)
|
|
])
|
|
])
|
|
AC_CHECK_FUNCS(clock_getres) # clock_getres should be tested after clock_gettime test including librt test.
|
|
AC_CHECK_LIB([rt], [timer_create])
|
|
AC_CHECK_LIB([rt], [timer_settime])
|
|
AS_IF([test x"$ac_cv_lib_rt_timer_create" = xyes], [
|
|
AC_DEFINE(HAVE_TIMER_CREATE, 1)
|
|
])
|
|
AS_IF([test x"$ac_cv_lib_rt_timer_settime" = xyes], [
|
|
AC_DEFINE(HAVE_TIMER_SETTIME, 1)
|
|
])
|
|
|
|
AC_CACHE_CHECK(for unsetenv returns a value, rb_cv_unsetenv_return_value,
|
|
[AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
|
|
#include <stdlib.h>
|
|
]], [[int v = unsetenv("foo");]])],
|
|
rb_cv_unsetenv_return_value=yes,
|
|
rb_cv_unsetenv_return_value=no)])
|
|
AS_IF([test "$rb_cv_unsetenv_return_value" = no], [
|
|
AC_DEFINE(VOID_UNSETENV)
|
|
])
|
|
|
|
# End of setjmp check.
|
|
|
|
AC_ARG_ENABLE(setreuid,
|
|
AS_HELP_STRING([--enable-setreuid], [use setreuid()/setregid() according to need even if obsolete]),
|
|
[use_setreuid=$enableval])
|
|
AS_IF([test "$use_setreuid" = yes], [
|
|
AC_DEFINE(USE_SETREUID)
|
|
AC_DEFINE(USE_SETREGID)
|
|
])
|
|
AC_STRUCT_TIMEZONE
|
|
AC_CACHE_CHECK(for struct tm.tm_gmtoff, rb_cv_member_struct_tm_tm_gmtoff,
|
|
[AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
|
|
@%:@define _BSD_SOURCE
|
|
@%:@define _DEFAULT_SOURCE
|
|
@%:@include <time.h>
|
|
]],
|
|
[[struct tm t; t.tm_gmtoff = 3600;]])],
|
|
[rb_cv_member_struct_tm_tm_gmtoff=yes],
|
|
[rb_cv_member_struct_tm_tm_gmtoff=no])])
|
|
AS_IF([test "$rb_cv_member_struct_tm_tm_gmtoff" = yes], [
|
|
AC_DEFINE(HAVE_STRUCT_TM_TM_GMTOFF)
|
|
])
|
|
AC_CACHE_CHECK(for external int daylight, rb_cv_have_daylight,
|
|
[AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <time.h>
|
|
int i;]],
|
|
[[i = daylight;]])],
|
|
rb_cv_have_daylight=yes,
|
|
rb_cv_have_daylight=no)])
|
|
AS_IF([test "$rb_cv_have_daylight" = yes], [
|
|
AC_DEFINE(HAVE_DAYLIGHT)
|
|
])
|
|
|
|
AC_CACHE_CHECK(for negative time_t for gmtime(3), rb_cv_negative_time_t,
|
|
[AC_RUN_IFELSE([AC_LANG_SOURCE([[
|
|
#include <stdlib.h>
|
|
#include <time.h>
|
|
|
|
void
|
|
check(tm, y, m, d, h, s)
|
|
struct tm *tm;
|
|
int y, m, d, h, s;
|
|
{
|
|
if (!tm ||
|
|
tm->tm_year != y ||
|
|
tm->tm_mon != m-1 ||
|
|
tm->tm_mday != d ||
|
|
tm->tm_hour != h ||
|
|
tm->tm_sec != s) {
|
|
exit(1);
|
|
}
|
|
}
|
|
|
|
int
|
|
main()
|
|
{
|
|
time_t t = -1;
|
|
struct tm *tm;
|
|
|
|
check(gmtime(&t), 69, 12, 31, 23, 59);
|
|
t = ~(time_t)0 << 31;
|
|
check(gmtime(&t), 1, 12, 13, 20, 52);
|
|
return 0;
|
|
}
|
|
]])],
|
|
rb_cv_negative_time_t=yes,
|
|
rb_cv_negative_time_t=no,
|
|
rb_cv_negative_time_t=yes)])
|
|
AS_IF([test "$rb_cv_negative_time_t" = yes], [
|
|
AC_DEFINE(NEGATIVE_TIME_T)
|
|
])
|
|
|
|
# [ruby-dev:40910] overflow of time on FreeBSD
|
|
# http://www.freebsd.org/cgi/query-pr.cgi?pr=145341
|
|
AC_CACHE_CHECK(for localtime(3) overflow correctly, rb_cv_localtime_overflow,
|
|
[AC_RUN_IFELSE([AC_LANG_SOURCE([[
|
|
#include <stdlib.h>
|
|
#include <time.h>
|
|
|
|
void
|
|
check(time_t t1)
|
|
{
|
|
struct tm *tm;
|
|
time_t t2;
|
|
tm = localtime(&t1);
|
|
if (!tm)
|
|
return; /* overflow detected. ok. */
|
|
t2 = mktime(tm);
|
|
if (t1 == t2)
|
|
return; /* round-trip. ok. */
|
|
exit(1);
|
|
}
|
|
|
|
int
|
|
main()
|
|
{
|
|
time_t t;
|
|
if (~(time_t)0 <= 0) {
|
|
t = (((time_t)1) << (sizeof(time_t) * 8 - 2));
|
|
t |= t - 1;
|
|
}
|
|
else {
|
|
t = ~(time_t)0;
|
|
}
|
|
check(t);
|
|
return 0;
|
|
}
|
|
]])],
|
|
rb_cv_localtime_overflow=yes,
|
|
rb_cv_localtime_overflow=no,
|
|
rb_cv_localtime_overflow=no)])
|
|
AS_IF([test "$rb_cv_localtime_overflow" = no], [
|
|
AC_DEFINE(LOCALTIME_OVERFLOW_PROBLEM)
|
|
])
|
|
|
|
AS_IF([test "$ac_cv_func_sigprocmask" = yes && test "$ac_cv_func_sigaction" = yes], [
|
|
AC_DEFINE(POSIX_SIGNAL)
|
|
], [
|
|
AC_CHECK_FUNCS(sigsetmask)
|
|
AC_CACHE_CHECK(for BSD signal semantics, rb_cv_bsd_signal,
|
|
[AC_RUN_IFELSE([AC_LANG_SOURCE([[
|
|
#include <stdio.h>
|
|
#include <signal.h>
|
|
|
|
void
|
|
sig_handler(dummy)
|
|
int dummy;
|
|
{
|
|
}
|
|
|
|
int
|
|
main()
|
|
{
|
|
signal(SIGINT, sig_handler);
|
|
kill(getpid(), SIGINT);
|
|
kill(getpid(), SIGINT);
|
|
return 0;
|
|
}
|
|
]])],
|
|
rb_cv_bsd_signal=yes,
|
|
rb_cv_bsd_signal=no,
|
|
rb_cv_bsd_signal=$ac_cv_func_sigsetmask)])
|
|
AS_IF([test "$rb_cv_bsd_signal" = yes], [
|
|
AC_DEFINE(BSD_SIGNAL)
|
|
])
|
|
])
|
|
|
|
AC_CHECK_TYPES([sig_t],[],[],[@%:@include <signal.h>])
|
|
|
|
AS_IF([test "$ac_cv_func_getpgid" = no], [
|
|
# AC_FUNC_GETPGRP fails when cross-compiling with old autoconf.
|
|
# autoconf is changed between 2.52d and 2.52f?
|
|
# http://lists.gnu.org/archive/html/bug-gnu-utils/2001-09/msg00181.html
|
|
# "autoconf cleanup for AC_FUNC_GETPGRP and GETPGRP_VOID"
|
|
AC_FUNC_GETPGRP
|
|
])
|
|
AS_IF([test "$ac_cv_func_setpgid:$ac_cv_func_setpgrp" = no:yes], [
|
|
# AC_FUNC_SETPGRP fails when cross-compiling. (until autoconf 2.69?)
|
|
# https://lists.gnu.org/archive/html/bug-autoconf/2013-02/msg00002.html
|
|
# "AC_FUNC_SETPGRP fails to work properly when cross-compiling"
|
|
AC_FUNC_SETPGRP
|
|
])
|
|
|
|
AS_IF([test x"$ac_cv_func_dirfd" = xno], [
|
|
AS_CASE(["$target_os"],[solaris*],
|
|
[AC_CHECK_MEMBERS([DIR.d_fd, DIR.dd_fd],,,[
|
|
#include <sys/types.h>
|
|
#include <dirent.h>
|
|
])])
|
|
])
|
|
|
|
AC_CACHE_CHECK(whether right shift preserve sign bit, rb_cv_rshift_sign,
|
|
[AC_COMPILE_IFELSE([AC_LANG_BOOL_COMPILE_TRY([], [(-1==(-1>>1))])],
|
|
rb_cv_rshift_sign=yes,
|
|
rb_cv_rshift_sign=no)])
|
|
AS_IF([test "$rb_cv_rshift_sign" = yes], [
|
|
AC_DEFINE(RSHIFT(x,y), ((x)>>(int)(y)))
|
|
], [
|
|
AC_DEFINE(RSHIFT(x,y), (((x)<0) ? ~((~(x))>>(int)(y)) : (x)>>(int)(y)))
|
|
])
|
|
|
|
AS_IF([test "$ac_cv_func_copy_file_range" = no], [
|
|
AC_CACHE_CHECK([for copy_file_range],
|
|
rb_cv_use_copy_file_range,
|
|
[AC_RUN_IFELSE([AC_LANG_SOURCE([[
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/syscall.h>
|
|
#include <fcntl.h>
|
|
#include <unistd.h>
|
|
|
|
#ifndef O_TMPFILE
|
|
#define O_TMPFILE __O_TMPFILE
|
|
#endif
|
|
|
|
int
|
|
main()
|
|
{
|
|
#ifdef __NR_copy_file_range
|
|
int ret, fd_in, fd_out;
|
|
fd_in = open("/tmp", O_TMPFILE|O_RDWR, S_IRUSR);
|
|
fd_out = open("/tmp", O_TMPFILE|O_WRONLY, S_IWUSR);
|
|
ret = syscall(__NR_copy_file_range, fd_in, NULL, fd_out, NULL, 0, 0);
|
|
close(fd_in);
|
|
close(fd_out);
|
|
if (ret == -1) { return 1; }
|
|
return 0;
|
|
#else
|
|
return 1;
|
|
#endif
|
|
}
|
|
]])],
|
|
[rb_cv_use_copy_file_range=yes],
|
|
[rb_cv_use_copy_file_range=no],
|
|
[rb_cv_use_copy_file_range=no])])
|
|
])
|
|
AS_CASE(["$ac_cv_func_copy_file_range:$rb_cv_use_copy_file_range"], [*yes*], [
|
|
AC_DEFINE(USE_COPY_FILE_RANGE)
|
|
])
|
|
|
|
AS_CASE(["$ac_cv_func_gettimeofday:$ac_cv_func_clock_gettime"],
|
|
[*yes*], [],
|
|
[
|
|
AC_MSG_ERROR(clock_gettime() or gettimeofday() must exist)
|
|
])
|
|
|
|
AS_IF([test "$ac_cv_func_sysconf" = yes], [
|
|
RUBY_CHECK_SYSCONF(CLK_TCK)
|
|
])
|
|
|
|
AS_IF([test "${universal_binary-no}" = yes ], [
|
|
archflagpat=`eval echo '"'"${ARCH_FLAG}"'"' | sed 's/[[][|.*]]/\\&/g'`
|
|
save_CFLAGS="$CFLAGS" new_cflags=`echo "$CFLAGS" | sed "s|$archflagpat"'||'`
|
|
save_LDFLAGS="$LDFLAGS" new_ldflags=`echo "$LDFLAGS" | sed "s|$archflagpat"'||'`
|
|
stack_dir=
|
|
for archs in ${universal_archnames}; do
|
|
archs=`echo $archs | sed 's/=.*//'`
|
|
CFLAGS="$new_cflags -arch $archs"
|
|
LDFLAGS="$new_ldflags -arch $archs"
|
|
RUBY_STACK_GROW_DIRECTION($archs, dir)
|
|
AS_IF([test x$stack_dir = x], [
|
|
stack_dir=$dir
|
|
], [test x$stack_dir != x$dir], [
|
|
stack_dir=no
|
|
])
|
|
done
|
|
CFLAGS="$save_CFLAGS" LDFLAGS="$save_LDFLAGS"
|
|
AS_IF([test x$stack_dir = xno], [
|
|
for archs in ${universal_archnames}; do
|
|
archs=`echo $archs | sed 's/=.*//'`
|
|
eval dir=\$[rb_cv_stack_grow_dir_]AS_TR_SH([$archs])
|
|
RUBY_DEFINE_IF([defined __${archs}__], STACK_GROW_DIRECTION, $dir)
|
|
done
|
|
], [
|
|
AC_DEFINE_UNQUOTED(STACK_GROW_DIRECTION, $stack_dir)
|
|
])
|
|
], [
|
|
RUBY_STACK_GROW_DIRECTION($target_cpu, dir)
|
|
AC_DEFINE_UNQUOTED(STACK_GROW_DIRECTION, $dir)
|
|
])
|
|
|
|
AC_ARG_WITH(coroutine,
|
|
AS_HELP_STRING([--with-coroutine=IMPLEMENTATION], [specify the coroutine implementation to use]),
|
|
[coroutine_type=$withval], [coroutine_type=])
|
|
AS_CASE([$coroutine_type], [yes|''], [
|
|
coroutine_type=
|
|
AS_CASE(["$target_cpu-$target_os"],
|
|
[universal-darwin*], [
|
|
coroutine_type=universal
|
|
],
|
|
[x*64-darwin*], [
|
|
coroutine_type=amd64
|
|
],
|
|
[arm64-darwin*], [
|
|
coroutine_type=arm64
|
|
],
|
|
[x*64-linux*], [
|
|
AS_CASE(["$ac_cv_sizeof_voidp"],
|
|
[8], [ coroutine_type=amd64 ],
|
|
[4], [ coroutine_type=x86 ],
|
|
dnl unknown pointer size, bail out as no Context.h soon.
|
|
)
|
|
],
|
|
[*86-linux*], [
|
|
coroutine_type=x86
|
|
],
|
|
[x64-mingw*], [
|
|
coroutine_type=win64
|
|
],
|
|
[*86-mingw*], [
|
|
coroutine_type=win32
|
|
],
|
|
[arm*-linux*], [
|
|
coroutine_type=arm32
|
|
],
|
|
[aarch64-linux*], [
|
|
coroutine_type=arm64
|
|
],
|
|
[powerpc64le-linux*], [
|
|
coroutine_type=ppc64le
|
|
],
|
|
[riscv64-linux*], [
|
|
coroutine_type=riscv64
|
|
],
|
|
[x86_64-freebsd*], [
|
|
coroutine_type=amd64
|
|
],
|
|
[i386-freebsd*], [
|
|
coroutine_type=x86
|
|
],
|
|
[aarch64-freebsd*], [
|
|
coroutine_type=arm64
|
|
],
|
|
[x86_64-netbsd*], [
|
|
coroutine_type=amd64
|
|
],
|
|
[i386-netbsd*], [
|
|
coroutine_type=x86
|
|
],
|
|
[aarch64-netbsd*], [
|
|
coroutine_type=arm64
|
|
],
|
|
[x86_64-openbsd*], [
|
|
coroutine_type=amd64
|
|
],
|
|
[i386-openbsd*], [
|
|
coroutine_type=x86
|
|
],
|
|
[*-openbsd*], [
|
|
coroutine_type=pthread
|
|
],
|
|
[x86_64-dragonfly*], [
|
|
coroutine_type=amd64
|
|
],
|
|
[*-haiku*], [
|
|
coroutine_type=pthread
|
|
],
|
|
[*-emscripten*], [
|
|
coroutine_type=emscripten
|
|
],
|
|
[
|
|
AC_CHECK_FUNCS([getcontext swapcontext makecontext],
|
|
[coroutine_type=ucontext],
|
|
[coroutine_type=pthread; break]
|
|
)
|
|
]
|
|
)
|
|
AC_MSG_CHECKING(native coroutine implementation for ${target_cpu}-${target_os})
|
|
AC_MSG_RESULT(${coroutine_type})
|
|
])
|
|
COROUTINE_H=coroutine/$coroutine_type/Context.h
|
|
AS_IF([test ! -f "$srcdir/$COROUTINE_H"],
|
|
[AC_MSG_ERROR('$coroutine_type' is not supported as coroutine)])
|
|
COROUTINE_SRC=coroutine/$coroutine_type/Context.c
|
|
AS_IF([test ! -f "$srcdir/$COROUTINE_SRC"],
|
|
[COROUTINE_SRC=coroutine/$coroutine_type/Context.'$(ASMEXT)'])
|
|
AC_DEFINE_UNQUOTED(COROUTINE_H, ["$COROUTINE_H"])
|
|
AC_SUBST(X_COROUTINE_H, [$COROUTINE_H])
|
|
AC_SUBST(X_COROUTINE_SRC, [$COROUTINE_SRC])
|
|
|
|
AS_IF([test x"$enable_pthread" = xyes], [
|
|
for pthread_lib in thr pthread pthreads c c_r root; do
|
|
AC_CHECK_LIB($pthread_lib, pthread_create,
|
|
rb_with_pthread=yes, rb_with_pthread=no)
|
|
AS_IF([test "$rb_with_pthread" = "yes"], [break])
|
|
done
|
|
AS_IF([test x"$rb_with_pthread" = xyes], [
|
|
AC_DEFINE(_REENTRANT)
|
|
AC_DEFINE(_THREAD_SAFE)
|
|
AC_DEFINE(HAVE_LIBPTHREAD)
|
|
AC_CHECK_HEADERS(pthread_np.h, [], [], [@%:@include <pthread.h>])
|
|
AS_CASE(["$pthread_lib:$target_os"],
|
|
[c:*], [],
|
|
[root:*], [],
|
|
[c_r:*|*:openbsd*|*:mirbsd*], [LIBS="-pthread $LIBS"],
|
|
[LIBS="-l$pthread_lib $LIBS"])
|
|
], [
|
|
AC_MSG_WARN("Don't know how to find pthread library on your system -- thread support disabled")
|
|
])
|
|
AC_CACHE_CHECK([whether pthread_t is scalar type], [rb_cv_scalar_pthread_t], [
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
|
|
@%:@include <pthread.h>
|
|
]], [[
|
|
pthread_t thread_id;
|
|
thread_id = 0;
|
|
if (!thread_id) return 0;
|
|
]])],[rb_cv_scalar_pthread_t=yes],[rb_cv_scalar_pthread_t=no])
|
|
])
|
|
AS_IF([test x"$rb_cv_scalar_pthread_t" = xyes], [
|
|
: # RUBY_CHECK_SIZEOF(pthread_t, [void* int long], [], [@%:@include <pthread.h>])
|
|
], [
|
|
AC_DEFINE(NON_SCALAR_THREAD_ID)
|
|
])
|
|
AC_CHECK_FUNCS(sched_yield pthread_attr_setinheritsched \
|
|
pthread_attr_get_np pthread_attr_getstack pthread_attr_getguardsize \
|
|
pthread_get_stackaddr_np pthread_get_stacksize_np \
|
|
thr_stksegment pthread_stackseg_np pthread_getthrds_np \
|
|
pthread_condattr_setclock \
|
|
pthread_setname_np pthread_set_name_np)
|
|
AS_CASE(["$target_os"],[emscripten*],[ac_cv_func_pthread_sigmask=no],[AC_CHECK_FUNCS(pthread_sigmask)])
|
|
AS_CASE(["$target_os"],[aix*],[ac_cv_func_pthread_getattr_np=no],[AC_CHECK_FUNCS(pthread_getattr_np)])
|
|
set_current_thread_name=
|
|
AS_IF([test "$ac_cv_func_pthread_setname_np" = yes], [
|
|
AC_CACHE_CHECK([arguments of pthread_setname_np], [rb_cv_func_pthread_setname_np_arguments],
|
|
[rb_cv_func_pthread_setname_np_arguments=
|
|
# Linux,AIX, (pthread_self(), name)
|
|
# NetBSD (pthread_self(), \"%s\", name)
|
|
# Darwin (name)
|
|
for mac in \
|
|
"(pthread_self(), name)" \
|
|
"(pthread_self(), \"%s\", name)" \
|
|
"(name)" \
|
|
; do
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
|
|
@%:@include <pthread.h>
|
|
@%:@ifdef HAVE_PTHREAD_NP_H
|
|
@%:@include <pthread_np.h>
|
|
@%:@endif
|
|
@%:@define SET_THREAD_NAME(name) pthread_setname_np${mac}
|
|
]],
|
|
[[if (SET_THREAD_NAME("conftest")) return 1;]])],
|
|
[rb_cv_func_pthread_setname_np_arguments="${mac}"
|
|
break])
|
|
done
|
|
]
|
|
)
|
|
AS_IF([test -n "${rb_cv_func_pthread_setname_np_arguments}"], [
|
|
set_current_thread_name="pthread_setname_np${rb_cv_func_pthread_setname_np_arguments}"
|
|
])
|
|
], [test "$ac_cv_func_pthread_set_name_np" = yes], [
|
|
set_current_thread_name="pthread_set_name_np(pthread_self(), name)"
|
|
])
|
|
AS_IF([test -n "$set_current_thread_name"], [
|
|
AC_DEFINE_UNQUOTED(SET_CURRENT_THREAD_NAME(name), $set_current_thread_name)
|
|
AS_CASE([$set_current_thread_name],
|
|
[*'pthread_self()'*], [
|
|
set_another_thread_name=`echo "$set_current_thread_name" | sed 's/pthread_self()/thid/'`
|
|
AC_DEFINE_UNQUOTED(SET_ANOTHER_THREAD_NAME(thid,name), $set_another_thread_name)
|
|
])
|
|
])
|
|
])
|
|
|
|
AS_IF([test x"$ac_cv_header_ucontext_h" = xno], [
|
|
AC_CACHE_CHECK([if signal.h defines ucontext_t], [rb_cv_ucontext_in_signal_h],
|
|
[AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[@%:@include <signal.h>]],
|
|
[[size_t size = sizeof(ucontext_t);]])],
|
|
[rb_cv_ucontext_in_signal_h=yes], [rb_cv_ucontext_in_signal_h=no])])
|
|
AS_IF([test x"$rb_cv_ucontext_in_signal_h" = xyes], [
|
|
AC_DEFINE_UNQUOTED(UCONTEXT_IN_SIGNAL_H, 1)
|
|
])
|
|
])
|
|
AS_IF([test x"$ac_cv_header_ucontext_h" = xyes -o x"$rb_cv_ucontext_in_signal_h" = xyes], [
|
|
AC_CACHE_CHECK([if mcontext_t is a pointer], [rb_cv_mcontext_t_ptr],
|
|
[AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
|
|
@%:@include <signal.h>
|
|
@%:@ifdef HAVE_UCONTEXT_H
|
|
@%:@include <ucontext.h>
|
|
@%:@endif
|
|
mcontext_t test(mcontext_t mc) {return mc+1;}
|
|
]],
|
|
[[test(0);]])],
|
|
[rb_cv_mcontext_t_ptr=yes], [rb_cv_mcontext_t_ptr=no])])
|
|
AS_IF([test x"$rb_cv_mcontext_t_ptr" = xyes], [
|
|
AC_DEFINE_UNQUOTED(DEFINE_MCONTEXT_PTR(mc, uc), mcontext_t mc = (uc)->uc_mcontext)
|
|
], [
|
|
AC_DEFINE_UNQUOTED(DEFINE_MCONTEXT_PTR(mc, uc), mcontext_t *mc = &(uc)->uc_mcontext)
|
|
])
|
|
AS_IF([test x"$rb_with_pthread" = xyes], [
|
|
AC_CHECK_FUNCS(getcontext setcontext)
|
|
])
|
|
])
|
|
|
|
AS_IF([test "$ac_cv_func_fork_works" = "yes" -a "$rb_with_pthread" = "yes"], [
|
|
AC_CACHE_CHECK([if fork works with pthread], rb_cv_fork_with_pthread,
|
|
[AC_RUN_IFELSE([AC_LANG_SOURCE([[
|
|
#include <stdlib.h>
|
|
#include <unistd.h>
|
|
#include <pthread.h>
|
|
#include <stdio.h>
|
|
#include <sys/types.h>
|
|
#include <sys/wait.h>
|
|
#include <signal.h>
|
|
#ifndef EXIT_SUCCESS
|
|
#define EXIT_SUCCESS 0
|
|
#endif
|
|
#ifndef EXIT_FAILURE
|
|
#define EXIT_FAILURE 1
|
|
#endif
|
|
|
|
void *
|
|
thread_func(void *dmy)
|
|
{
|
|
return dmy;
|
|
}
|
|
|
|
int
|
|
use_threads(void)
|
|
{
|
|
pthread_t tid;
|
|
if (pthread_create(&tid, 0, thread_func, 0) != 0) {
|
|
return -1;
|
|
}
|
|
if (pthread_join(tid, 0) != 0) {
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
main(int argc, char *argv[])
|
|
{
|
|
pid_t pid;
|
|
if (use_threads()) return EXIT_FAILURE;
|
|
pid = fork();
|
|
|
|
if (pid) {
|
|
int loc;
|
|
sleep(1);
|
|
if (waitpid(pid, &loc, WNOHANG) == 0) {
|
|
kill(pid, SIGKILL);
|
|
return EXIT_FAILURE;
|
|
}
|
|
if (!WIFEXITED(loc) || WEXITSTATUS(loc) != EXIT_SUCCESS)
|
|
return EXIT_FAILURE;
|
|
}
|
|
else {
|
|
if (use_threads()) return EXIT_FAILURE;
|
|
}
|
|
|
|
return EXIT_SUCCESS;
|
|
}]])],
|
|
rb_cv_fork_with_pthread=yes,
|
|
rb_cv_fork_with_pthread=no,
|
|
rb_cv_fork_with_pthread=yes)])
|
|
test x$rb_cv_fork_with_pthread = xyes || AC_DEFINE(CANNOT_FORK_WITH_PTHREAD)
|
|
])
|
|
|
|
AC_CHECK_HEADERS([sys/user.h])
|
|
AS_IF([test "x$ac_cv_func_mmap" = xyes], [
|
|
AC_CACHE_CHECK([whether PAGE_SIZE is compile-time const], rb_cv_const_page_size,
|
|
[malloc_headers=`sed -n '/MALLOC_HEADERS_BEGIN/,/MALLOC_HEADERS_END/p' ${srcdir}/gc.c`
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[$malloc_headers
|
|
typedef char conftest_page[PAGE_SIZE];
|
|
]], [[]])],
|
|
[rb_cv_const_page_size=yes],
|
|
[rb_cv_const_page_size=no])])
|
|
])
|
|
AS_IF([test "x$rb_cv_const_page_size" = xyes],
|
|
[AC_DEFINE(HAVE_CONST_PAGE_SIZE, 1)],
|
|
[AC_DEFINE(HAVE_CONST_PAGE_SIZE, 0)]
|
|
)
|
|
|
|
AS_IF([test "x$ac_cv_func_ioctl" = xyes], [
|
|
AC_CACHE_CHECK([ioctl request type], rb_cv_ioctl_request_type,
|
|
[rb_cv_ioctl_request_type=no
|
|
dnl corresponding NUM2IOCTLREQ needs to be defined
|
|
for type in "unsigned long:ULONG_MAX" int:INT_MAX; do
|
|
max=`echo $type | sed 's/.*://'`
|
|
type=`echo $type | sed 's/:.*//'`
|
|
RUBY_WERROR_FLAG([
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
|
|
@%:@include <limits.h>
|
|
@%:@include <sys/types.h>
|
|
@%:@if defined(HAVE_SYS_IOCTL_H) && !defined(_WIN32)
|
|
@%:@include <sys/ioctl.h>
|
|
@%:@endif
|
|
]], [[
|
|
$type req = $max;
|
|
if (ioctl(0, req)) {/* do nothing*/};
|
|
]])],
|
|
[rb_cv_ioctl_request_type="$type"])
|
|
])
|
|
test "x$rb_cv_ioctl_request_type" = xno || break
|
|
done])
|
|
AS_CASE(["$rb_cv_ioctl_request_type"], [no|int], [],
|
|
["unsigned long"], [
|
|
AC_DEFINE_UNQUOTED(IOCTL_REQ_TYPE, [$rb_cv_ioctl_request_type])
|
|
AC_DEFINE_UNQUOTED(NUM2IOCTLREQ(num), [NUM2ULONG(num)])
|
|
])
|
|
])
|
|
|
|
}
|
|
|
|
: "runtime section" && {
|
|
dnl wheather use dln_a_out or not
|
|
AC_ARG_WITH(dln-a-out,
|
|
AS_HELP_STRING([--with-dln-a-out], [dln_a_out is deprecated]),
|
|
[
|
|
AS_CASE([$withval],
|
|
[yes], [
|
|
AC_MSG_ERROR(dln_a_out no longer supported)
|
|
])
|
|
])
|
|
|
|
AC_CACHE_CHECK(whether ELF binaries are produced, rb_cv_binary_elf,
|
|
[AC_LINK_IFELSE([AC_LANG_PROGRAM([[]], [[]])],[
|
|
AS_CASE(["`head -1 conftest$EXEEXT | tr -dc '\177ELF' | tr '\177' .`"],
|
|
[.ELF*], [rb_cv_binary_elf=yes], [rb_cv_binary_elf=no])],
|
|
rb_cv_binary_elf=no)])
|
|
|
|
AS_IF([test "$rb_cv_binary_elf" = yes], [
|
|
AC_DEFINE(USE_ELF)
|
|
AC_CHECK_HEADERS([elf.h elf_abi.h])
|
|
AS_IF([test $ac_cv_header_elf_h = yes -o $ac_cv_header_elf_abi_h = yes], [
|
|
AC_LIBOBJ([addr2line])
|
|
AC_CHECK_LIB([z], [uncompress])
|
|
])
|
|
])
|
|
|
|
AC_CHECK_HEADERS([mach-o/loader.h])
|
|
AS_IF([test "$ac_cv_header_mach_o_loader_h" = yes], [
|
|
AC_LIBOBJ([addr2line])
|
|
])
|
|
|
|
AS_CASE(["$target_os"],
|
|
[linux* | gnu* | k*bsd*-gnu | bsdi* | kopensolaris*-gnu], [
|
|
AS_IF([test "$rb_cv_binary_elf" = no], [
|
|
AC_MSG_ERROR(Not ELF)
|
|
], [
|
|
LDFLAGS="$LDFLAGS -rdynamic"
|
|
])])
|
|
LIBEXT=a
|
|
|
|
AC_ARG_WITH(mjit-tabs,
|
|
AS_HELP_STRING([--without-mjit-tabs], [expand tabs in mjit header]),
|
|
[AS_IF([test $withval = no], [MJIT_TABS=false])])
|
|
AC_SUBST(MJIT_TABS)dnl
|
|
AC_SUBST(DLDFLAGS)dnl
|
|
AC_SUBST(ARCH_FLAG)dnl
|
|
AC_SUBST(MJIT_HEADER_FLAGS)dnl
|
|
AC_SUBST(MJIT_HEADER_INSTALL_DIR)dnl
|
|
AC_SUBST(MJIT_CC)dnl
|
|
AS_CASE(["$GCC:$target_os"],
|
|
[yes:aix*], [mjit_std_cflag="-std=gnu99"],
|
|
[mjit_std_cflag=])
|
|
AC_SUBST(MJIT_CFLAGS, [${MJIT_CFLAGS-"-w ${mjit_std_cflag} ${orig_cflags}"}])dnl
|
|
AC_SUBST(MJIT_OPTFLAGS, [${MJIT_OPTFLAGS-'$(optflags)'}])dnl
|
|
AC_SUBST(MJIT_DEBUGFLAGS, [${MJIT_DEBUGFLAGS-'$(debugflags)'}])dnl
|
|
AC_SUBST(MJIT_LDSHARED)dnl
|
|
|
|
AC_SUBST(STATIC)dnl
|
|
AC_SUBST(CCDLFLAGS)dnl
|
|
AC_SUBST(LDSHARED)dnl
|
|
AC_SUBST(LDSHAREDXX)dnl
|
|
AC_SUBST(DLEXT)dnl
|
|
AC_SUBST(LIBEXT)dnl
|
|
AC_SUBST(ASMEXT, S)dnl
|
|
|
|
STATIC=
|
|
|
|
: "dlopen" && {
|
|
rb_cv_dlopen=unknown
|
|
AC_MSG_CHECKING(whether OS depend dynamic link works)
|
|
AS_IF([test "$GCC" = yes], [
|
|
AS_CASE(["$target_os"],
|
|
[darwin*], [
|
|
# The -fno-common is needed if we wish to embed the Ruby interpreter
|
|
# into a plugin module of some project (as opposed to embedding it
|
|
# within the project's application). The -I/usr/local/include is
|
|
# needed because CPP as discovered by configure (cc -E -traditional)
|
|
# fails to consult /usr/local/include by default. This causes
|
|
# mkmf.rb's have_header() to fail if the desired resource happens to be
|
|
# installed in the /usr/local tree.
|
|
RUBY_APPEND_OPTION(CCDLFLAGS, -fno-common)],
|
|
[bsdi*|cygwin*|msys*|mingw*|aix*|interix*], [ ],
|
|
[
|
|
RUBY_APPEND_OPTION(CCDLFLAGS, -fPIC)])
|
|
], [
|
|
AS_CASE(["$target_os"],
|
|
[hpux*], [CCDLFLAGS="$CCDLFLAGS +Z"],
|
|
[solaris*|irix*], [CCDLFLAGS="$CCDLFLAGS -KPIC"],
|
|
[sunos*], [CCDLFLAGS="$CCDLFLAGS -PIC"],
|
|
[esix*|uxpds*], [CCDLFLAGS="$CCDLFLAGS -KPIC"],
|
|
[: ${CCDLFLAGS=""}])
|
|
])
|
|
}
|
|
|
|
: "rpath" && {
|
|
AC_ARG_ENABLE(rpath,
|
|
AS_HELP_STRING([--enable-rpath], [embed run path into extension libraries.
|
|
enabled by default on ELF platforms]),
|
|
[enable_rpath=$enableval], [enable_rpath="$rb_cv_binary_elf"])
|
|
|
|
AS_CASE(["$target_os"],
|
|
[hpux*], [ DLDFLAGS="$DLDFLAGS -E"
|
|
: ${LDSHARED='$(LD) -b'}
|
|
XLDFLAGS="$XLDFLAGS -Wl,-E"
|
|
: ${LIBPATHENV=SHLIB_PATH}
|
|
rb_cv_dlopen=yes],
|
|
[solaris*], [ AS_IF([test "$GCC" = yes], [
|
|
: ${LDSHARED='$(CC) -shared'}
|
|
AS_IF([test "$rb_cv_prog_gnu_ld" = yes], [
|
|
LDFLAGS="$LDFLAGS -Wl,-E"
|
|
])
|
|
], [
|
|
: ${LDSHARED='$(CC) -G'}
|
|
])
|
|
AS_IF([test "$ac_cv_sizeof_voidp" = 8], [
|
|
: ${LIBPATHENV=LD_LIBRARY_PATH_64}
|
|
: ${PRELOADENV=LD_PRELOAD_64}
|
|
], [
|
|
: ${LIBPATHENV=LD_LIBRARY_PATH_32}
|
|
: ${PRELOADENV=LD_PRELOAD_32}
|
|
])
|
|
rb_cv_dlopen=yes],
|
|
[sunos*], [ : ${LDSHARED='$(LD) -assert nodefinitions'}
|
|
rb_cv_dlopen=yes],
|
|
[irix*], [ : ${LDSHARED='$(LD) -shared'}
|
|
rb_cv_dlopen=yes],
|
|
[sysv4*], [ : ${LDSHARED='$(LD) -G'}
|
|
rb_cv_dlopen=yes],
|
|
[nto-qnx*], [ : ${LDSHARED='$(CC) -shared'}
|
|
rb_cv_dlopen=yes],
|
|
[esix*|uxpds*], [ : ${LDSHARED='$(LD) -G'}
|
|
rb_cv_dlopen=yes],
|
|
[osf*], [ : ${LDSHARED='$(LD) -shared -expect_unresolved "*"'}
|
|
rb_cv_dlopen=yes],
|
|
[bsdi3*], [ AS_CASE(["$CC"],
|
|
[*shlicc*], [ : ${LDSHARED='$(CC) -r'}
|
|
rb_cv_dlopen=yes])],
|
|
[linux* | gnu* | k*bsd*-gnu | netbsd* | bsdi* | kopensolaris*-gnu | haiku*], [
|
|
: ${LDSHARED='$(CC) -shared'}
|
|
AS_IF([test "$rb_cv_binary_elf" = yes], [
|
|
LDFLAGS="$LDFLAGS -Wl,-export-dynamic"
|
|
])
|
|
rb_cv_dlopen=yes],
|
|
[interix*], [ : ${LDSHARED='$(CC) -shared'}
|
|
XLDFLAGS="$XLDFLAGS -Wl,-E"
|
|
LIBPATHFLAG=" -L%1\$-s"
|
|
rb_cv_dlopen=yes],
|
|
[freebsd*|dragonfly*], [
|
|
: ${LDSHARED='$(CC) -shared'}
|
|
AS_IF([test "$rb_cv_binary_elf" = yes], [
|
|
LDFLAGS="$LDFLAGS -rdynamic"
|
|
DLDFLAGS="$DLDFLAGS "'-Wl,-soname,$@'
|
|
], [
|
|
test "$GCC" = yes && test "$rb_cv_prog_gnu_ld" = yes || LDSHARED='$(LD) -Bshareable'
|
|
])
|
|
rb_cv_dlopen=yes],
|
|
[openbsd*|mirbsd*], [ : ${LDSHARED='$(CC) -shared ${CCDLFLAGS}'}
|
|
AS_IF([test "$rb_cv_binary_elf" = yes], [
|
|
LDFLAGS="$LDFLAGS -Wl,-E"
|
|
])
|
|
rb_cv_dlopen=yes],
|
|
[darwin*], [ : ${LDSHARED='$(CC) -dynamic -bundle'}
|
|
: ${DLDSHARED='$(CC) -dynamiclib'}
|
|
: ${LDFLAGS=""}
|
|
: ${LIBPATHENV=DYLD_FALLBACK_LIBRARY_PATH}
|
|
: ${PRELOADENV=DYLD_INSERT_LIBRARIES}
|
|
rb_cv_dlopen=yes],
|
|
[aix*], [ : ${LDSHARED='$(CC)'}
|
|
AS_IF([test "$GCC" = yes], [
|
|
LDSHARED="$LDSHARED ${linker_flag}-G -shared"
|
|
], [
|
|
LDSHARED="$LDSHARED ${linker_flag}-G"
|
|
])
|
|
EXTDLDFLAGS='-e$(TARGET_ENTRY)'
|
|
XLDFLAGS="${linker_flag}"'-bE:$(ARCHFILE)'" ${linker_flag}-brtl"
|
|
XLDFLAGS="$XLDFLAGS ${linker_flag}-blibpath:${prefix}/lib:${LIBPATH:-/usr/lib:/lib}"
|
|
: ${ARCHFILE="ruby.imp"}
|
|
TRY_LINK='$(CC) -oconftest $(INCFLAGS) -I$(hdrdir) $(CPPFLAGS)'
|
|
TRY_LINK="$TRY_LINK"' $(CFLAGS) $(src) $(LIBPATH) $(LDFLAGS) $(LOCAL_LIBS) $(LIBS)'
|
|
: ${LIBPATHENV=LIBPATH}
|
|
: ${PRELOADENV=LDR_PRELOAD}
|
|
rb_cv_dlopen=yes],
|
|
[nto-qnx*], [ DLDFLAGS="$DLDFLAGS -L/lib -L/usr/lib -L/usr/local/lib"
|
|
: ${LDSHARED='$(LD) -Bshareable -x'}
|
|
LDFLAGS="$LDFLAGS -L/lib -L/usr/lib -L/usr/local/lib"
|
|
rb_cv_dlopen=yes],
|
|
[cygwin*|msys*|mingw*], [
|
|
: ${LDSHARED='$(CC) -shared'}
|
|
XLDFLAGS="$XLDFLAGS -Wl,--stack,0x00200000,--enable-auto-import"
|
|
DLDFLAGS="${DLDFLAGS} -Wl,--enable-auto-image-base,--enable-auto-import"
|
|
: ${LIBPATHENV=PATH}
|
|
: ${PRELOADENV=""}
|
|
rb_cv_dlopen=yes],
|
|
[hiuxmpp], [ : ${LDSHARED='$(LD) -r'}],
|
|
[atheos*], [ : ${LDSHARED='$(CC) -shared'}
|
|
rb_cv_dlopen=yes],
|
|
[ : ${LDSHARED='$(LD)'}])
|
|
AC_MSG_RESULT($rb_cv_dlopen)
|
|
|
|
AS_IF([test "$rb_cv_dlopen" = yes], [
|
|
AS_CASE(["$target_os"],
|
|
[darwin*], [
|
|
for flag in \
|
|
"-undefined dynamic_lookup" \
|
|
"-multiply_defined suppress" \
|
|
; do
|
|
test "x${linker_flag}" = x || flag="${linker_flag}`echo ${flag} | tr ' ' ,`"
|
|
RUBY_TRY_LDFLAGS([$flag], [], [flag=])
|
|
AS_IF([test "x$flag" != x], [
|
|
RUBY_APPEND_OPTIONS(DLDFLAGS, [$flag])
|
|
])
|
|
done
|
|
])
|
|
])
|
|
|
|
AS_IF([test "$enable_rpath:${RPATHFLAG}" = yes:], [
|
|
AS_IF([test "x$rpathflag" != x], [
|
|
RPATHFLAG=" ${rpathflag}%1\$-s"
|
|
])
|
|
])
|
|
}
|
|
|
|
AS_IF([test "${LDSHAREDXX}" = ""], [
|
|
AS_CASE(["${LDSHARED}"],
|
|
[*'$(CC)'*], [
|
|
LDSHAREDXX=`echo "${LDSHARED}" | sed 's/\$(CC)/$(CXX)/'`
|
|
],
|
|
[*'${CC}'*], [
|
|
LDSHAREDXX=`echo "${LDSHARED}" | sed 's/\${CC}/${CXX}/'`
|
|
],
|
|
[*$CC*], [
|
|
LDSHAREDXX=`echo "${LDSHARED}" | sed "s|$CC|$CXX|"`
|
|
],
|
|
[ld" "*], [
|
|
])
|
|
])
|
|
AS_CASE([${RPATHFLAG}],[*'%1$'*],[: ${LIBPATHFLAG=' -L%1$-s'}],[: ${LIBPATHFLAG=' -L%s'}])
|
|
|
|
AC_SUBST(LINK_SO)
|
|
AC_SUBST(LIBPATHFLAG)
|
|
AC_SUBST(RPATHFLAG)
|
|
AC_SUBST(LIBPATHENV, "${LIBPATHENV-LD_LIBRARY_PATH}")
|
|
AC_SUBST(PRELOADENV, "${PRELOADENV-LD_PRELOAD}")
|
|
AC_SUBST(TRY_LINK)
|
|
|
|
AS_IF([test "x$OPT_DIR" != x], [
|
|
pat=`echo "${LDFLAGS_OPTDIR}" | sed ['s/[][\\.*|]/\\\\&/']`
|
|
LDFLAGS=`echo "${LDFLAGS}" | sed "s| ${pat}||"`
|
|
val=`IFS="$PATH_SEPARATOR"
|
|
for dir in $OPT_DIR; do
|
|
echo x ${LIBPATHFLAG} ${RPATHFLAG} |
|
|
sed "s/^x *//;s${IFS}"'%1\\$-s'"${IFS}${dir}/lib${IFS}g;s${IFS}%s${IFS}${dir}/lib${IFS}g"
|
|
done | tr '\012' ' ' | sed 's/ *$//'`
|
|
AS_IF([test x"$val" != x], [
|
|
test x"${LDFLAGS}" = x || LDFLAGS="$LDFLAGS "
|
|
LDFLAGS="$LDFLAGS$val"
|
|
test x"${DLDFLAGS}" = x || DLDFLAGS="$DLDFLAGS "
|
|
DLDFLAGS="$DLDFLAGS$val"
|
|
])
|
|
LDFLAGS_OPTDIR="$val"
|
|
])
|
|
|
|
AS_CASE(["$target_os"],
|
|
[freebsd*], [
|
|
AC_CHECK_LIB([procstat], [procstat_open_sysctl])
|
|
AS_IF([test "x$ac_cv_lib_procstat_procstat_open_sysctl" = xyes], [
|
|
AC_CHECK_FUNCS(procstat_getvmmap)
|
|
])
|
|
])
|
|
AS_CASE(["$target_cpu-$target_os"],
|
|
[*-darwin*], [
|
|
AC_CHECK_HEADERS([libproc.h])
|
|
AC_CHECK_HEADERS([execinfo.h])
|
|
AS_IF([test "x$ac_cv_header_execinfo_h" = xyes], [
|
|
AC_CHECK_LIB([execinfo], [backtrace])
|
|
AC_CHECK_HEADERS([libunwind.h])
|
|
])],
|
|
[*-freebsd*|x86_64-netbsd*], [
|
|
AC_CHECK_HEADERS([execinfo.h])
|
|
AS_IF([test "x$ac_cv_header_execinfo_h" = xyes], [
|
|
AC_CHECK_LIB([execinfo], [backtrace])
|
|
AC_CHECK_LIB([unwind], [unw_backtrace])
|
|
])])
|
|
AC_CHECK_FUNCS(backtrace)
|
|
|
|
AS_IF([test "x$ac_cv_func_backtrace" = xyes], [
|
|
AC_CACHE_CHECK(for broken backtrace, rb_cv_broken_backtrace,
|
|
[AC_RUN_IFELSE([AC_LANG_SOURCE([[
|
|
#include <unistd.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <stdint.h>
|
|
#include <string.h>
|
|
#include <signal.h>
|
|
#include <execinfo.h>
|
|
|
|
]`grep '^@%:@ *define *RUBY_SIGALTSTACK_SIZE' ${srcdir}/signal.c`[
|
|
#define TRACE_SIZE 256
|
|
|
|
void sigsegv(int signum, siginfo_t *info, void *ctx){
|
|
void *trace[TRACE_SIZE];
|
|
int n = backtrace(trace, TRACE_SIZE);
|
|
if (n > 0) {
|
|
/*fprintf(stdout, "backtrace:%d\n",n);*/
|
|
} else {
|
|
_exit(EXIT_FAILURE);
|
|
}
|
|
_exit(EXIT_SUCCESS);
|
|
}
|
|
int
|
|
main(void)
|
|
{
|
|
volatile int *a = NULL;
|
|
stack_t ss;
|
|
struct sigaction sa;
|
|
|
|
ss.ss_sp = malloc(RUBY_SIGALTSTACK_SIZE);
|
|
if (ss.ss_sp == NULL) {
|
|
fprintf(stderr, "cannot allocate memory for sigaltstack\n");
|
|
return EXIT_FAILURE;
|
|
}
|
|
ss.ss_size = RUBY_SIGALTSTACK_SIZE;
|
|
ss.ss_flags = 0;
|
|
if (sigaltstack(&ss, NULL) == -1) {
|
|
fprintf(stderr, "sigaltstack failed\n");
|
|
return EXIT_FAILURE;
|
|
}
|
|
memset(&sa, 0, sizeof(struct sigaction));
|
|
sigemptyset(&sa.sa_mask);
|
|
sa.sa_sigaction = sigsegv;
|
|
sa.sa_flags |= SA_SIGINFO;
|
|
sa.sa_flags |= SA_ONSTACK;
|
|
sigaction(SIGSEGV, &sa, NULL);
|
|
a[0] = 1;
|
|
return EXIT_SUCCESS;
|
|
}
|
|
]])],
|
|
rb_cv_broken_backtrace=no,
|
|
rb_cv_broken_backtrace=yes,
|
|
rb_cv_broken_backtrace=no)])
|
|
AS_IF([test "$rb_cv_broken_backtrace" = yes], [
|
|
AC_DEFINE(BROKEN_BACKTRACE, 1)
|
|
])
|
|
])
|
|
|
|
AC_ARG_WITH(valgrind,
|
|
AS_HELP_STRING([--without-valgrind],[disable valgrind memcheck support]),
|
|
[], with_valgrind=yes)
|
|
AS_IF([test x$with_valgrind != xno],
|
|
[AC_CHECK_HEADERS(valgrind/memcheck.h)])
|
|
|
|
: "dlext & soext" && {
|
|
AS_CASE(["$target_os"],
|
|
[hpux*], [
|
|
DLEXT=sl],
|
|
[darwin*], [
|
|
SOEXT=dylib
|
|
DLEXT=bundle],
|
|
[cygwin*|msys*|mingw*|*djgpp*], [
|
|
LOAD_RELATIVE=1
|
|
SOEXT=dll
|
|
DLEXT=so],
|
|
[
|
|
DLEXT=so])
|
|
: ${SOEXT="${DLEXT}"}
|
|
AC_SUBST(SOEXT)
|
|
}
|
|
|
|
AS_IF([test "$rb_cv_dlopen:$load_relative" = yes:yes], [
|
|
AS_IF([test "$ac_cv_func_dladdr" = yes], [
|
|
LOAD_RELATIVE=1
|
|
])
|
|
])
|
|
AS_IF([test x"$LOAD_RELATIVE" = x1], [
|
|
load_relative=yes
|
|
], [
|
|
unset load_relative
|
|
])
|
|
|
|
len=2 # .rb
|
|
n=`expr "$DLEXT" : '.*'`; test "$n" -gt "$len" && len=$n
|
|
AC_DEFINE_UNQUOTED(DLEXT_MAXLEN, `expr $len + 1`)
|
|
test ".$DLEXT" = "." || AC_DEFINE_UNQUOTED(DLEXT, ".$DLEXT")
|
|
AC_SUBST(DLEXT)
|
|
|
|
: "strip" && {
|
|
AC_MSG_CHECKING([for $STRIP flags])
|
|
AC_LINK_IFELSE([AC_LANG_PROGRAM], [AS_IF(
|
|
["${STRIP}" -A -n conftest$ac_exeext 2>/dev/null], [
|
|
AC_MSG_RESULT([-A -n])
|
|
STRIP="${STRIP} -A -n"
|
|
],
|
|
["${STRIP}" -S -x conftest$ac_exeext 2>/dev/null], [
|
|
AC_MSG_RESULT([-S -x])
|
|
STRIP="${STRIP} -S -x"
|
|
], [
|
|
AC_MSG_RESULT([none needed])
|
|
])
|
|
])
|
|
}
|
|
|
|
AC_ARG_WITH(ext,
|
|
AS_HELP_STRING([--with-ext=EXTS],
|
|
[pass to --with-ext option of extmk.rb]))
|
|
AC_ARG_WITH(out-ext,
|
|
AS_HELP_STRING([--with-out-ext=EXTS],
|
|
[pass to --without-ext option of extmk.rb]))
|
|
EXTSTATIC=
|
|
AC_SUBST(EXTSTATIC)dnl
|
|
AC_ARG_WITH(static-linked-ext,
|
|
AS_HELP_STRING([--with-static-linked-ext], [link external modules statically]),
|
|
[AS_CASE([$withval],[yes],[STATIC=;EXTSTATIC=static],[no],[],[EXTSTATIC="$withval"])])
|
|
AS_CASE([",$EXTSTATIC,"], [,static,|*,enc,*], [
|
|
ENCOBJS='enc/encinit.$(OBJEXT) enc/libenc.$(LIBEXT) enc/libtrans.$(LIBEXT)'
|
|
EXTOBJS='ext/extinit.$(OBJEXT)'
|
|
AC_DEFINE_UNQUOTED(EXTSTATIC, 1)
|
|
AC_SUBST(ENCSTATIC, static)
|
|
], [
|
|
ENCOBJS='dmyenc.$(OBJEXT)'
|
|
EXTOBJS='dmyext.$(OBJEXT)'
|
|
])
|
|
AC_SUBST(ENCOBJS)
|
|
AC_SUBST(EXTOBJS)
|
|
|
|
AC_ARG_WITH(setup,
|
|
AS_HELP_STRING([--with-setup=SETUP], [use extension libraries setup]),
|
|
[setup=$withval])
|
|
AS_IF([test -n "$setup"], [
|
|
AS_IF([! test -f "ext/$setup" -o -f "$srcdir/ext/$setup"], [
|
|
AC_MSG_ERROR(Setup file $setup not found under ext or $srcdir/ext)
|
|
])
|
|
], [test -f "$srcdir/ext/Setup.$target_os"], [
|
|
setup="Setup.$target_os"
|
|
], [
|
|
setup=
|
|
for file in "$srcdir"/ext/Setup.*; do
|
|
AS_CASE(["$file"], [*~|*.bak|*.orig|*.rej|*.tmp], [continue])
|
|
setup=`basename "$file"`
|
|
AS_CASE(["$target_os"], [`expr "$setup" : 'Setup.\(.*\)'`*], [break])
|
|
platform=`sed '/^option *platform */!d;s///;s/|/*|/g;q' "$file"`
|
|
AS_IF([test "x$platform" != x], [
|
|
eval "AS_CASE([\"\$target_os\"], [$platform*], [break])"
|
|
])
|
|
setup=
|
|
done
|
|
: ${setup:=Setup}
|
|
])
|
|
AC_SUBST(setup)
|
|
|
|
rubylibprefix='${libdir}/${RUBY_BASE_NAME}'
|
|
AC_ARG_WITH(rubylibprefix,
|
|
AS_HELP_STRING([--with-rubylibprefix=DIR], [prefix for ruby libraries [[LIBDIR/RUBY_BASE_NAME]]]),
|
|
[AS_IF([test "x$withval" = xno], [
|
|
AC_MSG_ERROR([No ruby, No libprefix])
|
|
])
|
|
rubylibprefix="$withval"])
|
|
AC_SUBST(rubylibprefix)
|
|
|
|
AS_IF([test x"${exec_prefix}" != xNONE], [
|
|
RUBY_EXEC_PREFIX="$exec_prefix"
|
|
], [test x"$prefix" != xNONE], [
|
|
RUBY_EXEC_PREFIX="$prefix"
|
|
], [
|
|
RUBY_EXEC_PREFIX=$ac_default_prefix
|
|
])
|
|
pat=`echo "${RUBY_EXEC_PREFIX}" | tr -c '\012' .`'\(.*\)'
|
|
for var in bindir libdir rubylibprefix; do
|
|
eval val='"$'$var'"'
|
|
AS_CASE(["$val"], ["${RUBY_EXEC_PREFIX}"*], [val='${exec_prefix}'"`expr \"$val\" : \"$pat\"`"])
|
|
eval $var='"$val"'
|
|
done
|
|
|
|
BTESTRUBY='$(MINIRUBY)'
|
|
BOOTSTRAPRUBY='$(BASERUBY)'
|
|
AS_IF([test x"$cross_compiling" = xyes], [
|
|
test x"$MINIRUBY" = x && MINIRUBY="${RUBY-$BASERUBY} -I`$CHDIR .; pwd` "-r'$(arch)-fake'
|
|
XRUBY_LIBDIR=`${RUBY-$BASERUBY} -rrbconfig -e ['puts RbConfig::CONFIG["libdir"]']`
|
|
XRUBY_RUBYLIBDIR=`${RUBY-$BASERUBY} -rrbconfig -e ['puts RbConfig::CONFIG["rubylibdir"]']`
|
|
XRUBY_RUBYHDRDIR=`${RUBY-$BASERUBY} -rrbconfig -e ['puts RbConfig::CONFIG["rubyhdrdir"]']`
|
|
AC_SUBST(XRUBY_LIBDIR)
|
|
AC_SUBST(XRUBY_RUBYLIBDIR)
|
|
AC_SUBST(XRUBY_RUBYHDRDIR)
|
|
PREP='$(arch)-fake.rb'
|
|
RUNRUBY_COMMAND='$(MINIRUBY) -I`cd $(srcdir)/lib; pwd`'
|
|
RUNRUBY='$(RUNRUBY_COMMAND)'
|
|
XRUBY='$(MINIRUBY)'
|
|
TEST_RUNNABLE=no
|
|
CROSS_COMPILING=yes
|
|
AC_DEFINE(CROSS_COMPILING, 1)
|
|
], [
|
|
MINIRUBY='./miniruby$(EXEEXT) -I$(srcdir)/lib -I.'
|
|
MINIRUBY="$MINIRUBY"' -I$(EXTOUT)/common'
|
|
PREP='miniruby$(EXEEXT)'
|
|
RUNRUBY_COMMAND='$(MINIRUBY) $(tooldir)/runruby.rb --extout=$(EXTOUT) $(RUNRUBYOPT)'
|
|
RUNRUBY='$(RUNRUBY_COMMAND) --'
|
|
XRUBY='$(RUNRUBY)'
|
|
AS_CASE(["$HAVE_BASERUBY:$build_os"], [no:*|*:mingw*], [BOOTSTRAPRUBY='$(MINIRUBY)'])
|
|
TEST_RUNNABLE=yes
|
|
CROSS_COMPILING=no
|
|
])
|
|
AC_SUBST(TEST_RUNNABLE)
|
|
AC_SUBST(CROSS_COMPILING)
|
|
AC_SUBST(MINIRUBY)
|
|
AC_SUBST(BTESTRUBY)
|
|
AC_SUBST(PREP)
|
|
AC_SUBST(RUNRUBY_COMMAND)
|
|
AC_SUBST(RUNRUBY)
|
|
AC_SUBST(XRUBY)
|
|
AC_SUBST(BOOTSTRAPRUBY)
|
|
AC_SUBST(EXTOUT, [${EXTOUT=.ext}])
|
|
|
|
FIRSTMAKEFILE=""
|
|
LIBRUBY_A='lib$(RUBY_SO_NAME)-static.a'
|
|
LIBRUBY='$(LIBRUBY_A)'
|
|
LIBRUBYARG_STATIC='-l$(RUBY_SO_NAME)-static'
|
|
LIBRUBYARG='$(LIBRUBYARG_STATIC)'
|
|
SOLIBS='$(MAINLIBS)'
|
|
|
|
AS_CASE(["$target_os"],
|
|
[cygwin*|msys*|mingw*|haiku*|darwin*], [
|
|
: ${DLDLIBS=""}
|
|
],
|
|
[
|
|
DLDLIBS="$DLDLIBS -lc"
|
|
])
|
|
|
|
AC_ARG_ENABLE(multiarch,
|
|
AS_HELP_STRING([--enable-multiarch], [enable multiarch compatible directories]),
|
|
[multiarch=], [unset multiarch])
|
|
AS_IF([test ${multiarch+set}], [
|
|
AC_DEFINE(ENABLE_MULTIARCH)
|
|
MJIT_HEADER_INSTALL_DIR=include/'${arch}/${RUBY_VERSION_NAME}'
|
|
], [
|
|
MJIT_HEADER_INSTALL_DIR=include/'${RUBY_VERSION_NAME}/${arch}'
|
|
])
|
|
|
|
archlibdir='${libdir}/${arch}'
|
|
sitearchlibdir='${libdir}/${sitearch}'
|
|
archincludedir='${includedir}/${arch}'
|
|
sitearchincludedir='${includedir}/${sitearch}'
|
|
|
|
AC_ARG_WITH(soname,
|
|
AS_HELP_STRING([--with-soname=SONAME], [base name of shared library]),
|
|
[RUBY_SO_NAME=$withval],
|
|
[
|
|
AS_CASE(["$target_os"],
|
|
[darwin*], [
|
|
RUBY_SO_NAME='$(RUBY_BASE_NAME).$(RUBY_API_VERSION)'
|
|
],
|
|
[cygwin*], [
|
|
RUBY_SO_NAME='$(RUBY_BASE_NAME)$(MAJOR)$(MINOR)0'
|
|
],
|
|
[mingw*], [
|
|
RUBY_SO_NAME="${rb_cv_msvcrt}"'-$(RUBY_BASE_NAME)$(MAJOR)$(MINOR)0'
|
|
AS_IF([test x"${target_cpu}" != xi386], [
|
|
RUBY_SO_NAME="${target_cpu}-${RUBY_SO_NAME}"
|
|
])
|
|
],
|
|
[RUBY_SO_NAME='$(RUBY_BASE_NAME)'])
|
|
])
|
|
|
|
LIBRUBY_LDSHARED=${DLDSHARED=${LDSHARED}}
|
|
LIBRUBY_DLDFLAGS=$DLDFLAGS
|
|
LIBRUBY_SO='lib$(RUBY_SO_NAME).$(SOEXT).$(RUBY_PROGRAM_VERSION)'
|
|
LIBRUBY_SONAME='lib$(RUBY_SO_NAME).$(SOEXT).$(RUBY_API_VERSION)'
|
|
LIBRUBY_ALIASES='lib$(RUBY_SO_NAME).$(SOEXT)'
|
|
ENABLE_SHARED=no
|
|
|
|
AC_ARG_ENABLE(shared,
|
|
AS_HELP_STRING([--enable-shared], [build a shared library for Ruby]),
|
|
[enable_shared=$enableval])
|
|
libprefix=${multiarch+'$(archlibdir)'}${multiarch-'$(libdir)'}
|
|
LIBRUBY_RELATIVE=${load_relative-no}
|
|
AS_CASE("$enable_shared", [yes], [
|
|
LIBRUBY='$(LIBRUBY_SO)'
|
|
LIBRUBYARG_SHARED='-l$(RUBY_SO_NAME)'
|
|
LIBRUBYARG='$(LIBRUBYARG_SHARED)'
|
|
LIBRUBY_RELATIVE=no
|
|
test -z "$CCDLFLAGS" || CFLAGS="$CFLAGS $CCDLFLAGS"
|
|
ENABLE_SHARED=yes
|
|
|
|
# libdir can be overridden in config.site file (on OpenSUSE at least).
|
|
libdir_basename=lib
|
|
AS_IF([test "$bindir" = '${exec_prefix}/bin'], [
|
|
AS_CASE(["$libdir"], ['${exec_prefix}/'*], [libdir_basename=`basename "$libdir"`])
|
|
])
|
|
AC_DEFINE_UNQUOTED(LIBDIR_BASENAME, ["${libdir_basename}"])
|
|
libdir_basename="${libdir_basename}"${multiarch+'/${arch}'}
|
|
|
|
# Debian bullseye reportedly has its ld(1) patched, which breaks
|
|
# --enable-shared --with-jemalloc combination. We might have to deal with
|
|
# the ld(1) change sooner or later, but in the meantime let us force it
|
|
# the old way.
|
|
#
|
|
# See https://github.com/ruby/ruby/pull/4627
|
|
RUBY_TRY_LDFLAGS([${linker_flag}--no-as-needed], [no_as_needed=yes], [no_as_needed=no])
|
|
AS_IF([test "$no_as_needed" = yes], [
|
|
RUBY_APPEND_OPTIONS(LDFLAGS, [${linker_flag}--no-as-needed])
|
|
])
|
|
|
|
AS_CASE(["$target_os"],
|
|
[freebsd*|dragonfly*], [],
|
|
[
|
|
AS_IF([test "$GCC" = yes], [
|
|
RUBY_TRY_LDFLAGS([${linker_flag}--no-undefined], [no_undefined=yes], [no_undefined=no])
|
|
AS_IF([test "no_undefined" = yes], [
|
|
RUBY_APPEND_OPTION(EXTLDFLAGS, [${linker_flag}--no-undefined])
|
|
])
|
|
])
|
|
])
|
|
|
|
AS_CASE(["$target_os"],
|
|
[sunos4*], [
|
|
LIBRUBY_ALIASES='$(LIBRUBY_SONAME) lib$(RUBY_SO_NAME).$(SOEXT)'
|
|
],
|
|
[linux* | gnu* | k*bsd*-gnu | atheos* | kopensolaris*-gnu | haiku*], [
|
|
RUBY_APPEND_OPTIONS(LIBRUBY_DLDFLAGS, ['-Wl,-soname,$(LIBRUBY_SONAME)' "$LDFLAGS_OPTDIR"])
|
|
LIBRUBY_ALIASES='$(LIBRUBY_SONAME) lib$(RUBY_SO_NAME).$(SOEXT)'
|
|
AS_IF([test "$load_relative" = yes], [
|
|
libprefix="'\$\${ORIGIN}/../${libdir_basename}'"
|
|
LIBRUBY_RPATHFLAGS="-Wl,-rpath,${libprefix}"
|
|
LIBRUBY_RELATIVE=yes
|
|
])
|
|
],
|
|
[freebsd*|dragonfly*], [
|
|
LIBRUBY_SO='lib$(RUBY_SO_NAME).$(SOEXT).$(MAJOR)$(MINOR)'
|
|
LIBRUBY_SONAME='$(LIBRUBY_SO)'
|
|
AS_IF([test "$rb_cv_binary_elf" != "yes" ], [
|
|
LIBRUBY_SO="$LIBRUBY_SO.\$(TEENY)"
|
|
LIBRUBY_ALIASES=''
|
|
], [test "$load_relative" = yes], [
|
|
libprefix="'\$\$ORIGIN/../${libdir_basename}'"
|
|
LIBRUBY_RPATHFLAGS="-Wl,-rpath,${libprefix}"
|
|
LIBRUBY_RELATIVE=yes
|
|
])
|
|
],
|
|
[netbsd*], [
|
|
LIBRUBY_SONAME='lib$(RUBY_SO_NAME).$(SOEXT).$(MAJOR)$(MINOR)'
|
|
LIBRUBY_SO="${LIBRUBY_SONAME}"'.$(TEENY)'
|
|
RUBY_APPEND_OPTIONS(LIBRUBY_DLDFLAGS, ['-Wl,-soname,$(LIBRUBY_SONAME)' "$LDFLAGS_OPTDIR"])
|
|
AS_IF([test "$rb_cv_binary_elf" = yes], [ # ELF platforms
|
|
LIBRUBY_ALIASES='$(LIBRUBY_SONAME) lib$(RUBY_SO_NAME).$(SOEXT)'
|
|
], [ # a.out platforms
|
|
LIBRUBY_ALIASES=""
|
|
])
|
|
],
|
|
[openbsd*|mirbsd*], [
|
|
LIBRUBY_SO='lib$(RUBY_SO_NAME).$(SOEXT).$(MAJOR).'`expr ${MINOR} \* 10 + ${TEENY}`
|
|
],
|
|
[solaris*], [
|
|
LIBRUBY_SO='lib$(RUBY_SO_NAME).$(SOEXT).$(MAJOR)'
|
|
LIBRUBY_SONAME='lib$(RUBY_SO_NAME).$(SOEXT).$(RUBY_PROGRAM_VERSION)'
|
|
LIBRUBY_ALIASES='$(LIBRUBY_SONAME) lib$(RUBY_SO_NAME).$(SOEXT)'
|
|
RUBY_APPEND_OPTIONS(LIBRUBY_DLDFLAGS, ["${linker_flag}-h${linker_flag:+,}"'$(@F)'])
|
|
XLDFLAGS="$XLDFLAGS "'-R${libdir}'
|
|
],
|
|
[hpux*], [
|
|
XLDFLAGS="$XLDFLAGS "'-Wl,+s,+b,$(libdir)'
|
|
LIBRUBY_ALIASES='$(LIBRUBY_SONAME) lib$(RUBY_SO_NAME).$(SOEXT)'
|
|
],
|
|
[aix*], [
|
|
RUBY_APPEND_OPTIONS(LIBRUBY_DLDFLAGS, ["${linker_flag}-bnoentry" "$XLDFLAGS" "$LDFLAGS_OPTDIR"])
|
|
LIBRUBYARG_SHARED='-L${libdir} -l${RUBY_SO_NAME}'
|
|
LIBS="$LIBS -lm -lc"
|
|
],
|
|
[darwin*], [
|
|
LIBRUBY_SO='lib$(RUBY_SO_NAME).$(SOEXT)'
|
|
LIBRUBY_SONAME='$(LIBRUBY_SO)'
|
|
LIBRUBY_ALIASES='lib$(RUBY_INSTALL_NAME).$(SOEXT)'
|
|
AS_IF([test "$load_relative" = yes], [
|
|
libprefix="@executable_path/../${libdir_basename}"
|
|
LIBRUBY_RELATIVE=yes
|
|
])
|
|
LIBRUBY_DLDFLAGS="$LIBRUBY_DLDFLAGS -install_name ${libprefix}"'/$(LIBRUBY_SONAME)'
|
|
LIBRUBY_DLDFLAGS="$LIBRUBY_DLDFLAGS "'-compatibility_version $(RUBY_API_VERSION)'
|
|
LIBRUBY_DLDFLAGS="$LIBRUBY_DLDFLAGS "'-current_version $(RUBY_PROGRAM_VERSION)'
|
|
AS_IF([test "$visibility_option" = ld], [
|
|
LIBRUBY_DLDFLAGS="$LIBRUBY_DLDFLAGS "'-Wl,-unexported_symbol,_Init_*'
|
|
LIBRUBY_DLDFLAGS="$LIBRUBY_DLDFLAGS "'-Wl,-unexported_symbol,_ruby_static_id_*'
|
|
LIBRUBY_DLDFLAGS="$LIBRUBY_DLDFLAGS "'-Wl,-unexported_symbol,*_threadptr_*'
|
|
])
|
|
LIBRUBY_DLDFLAGS="$LIBRUBY_DLDFLAGS "' $(XLDFLAGS)'
|
|
],
|
|
[interix*], [
|
|
LIBRUBYARG_SHARED='-L. -L${libdir} -l$(RUBY_SO_NAME)'
|
|
],
|
|
[cygwin*|msys*|mingw*|mswin*], [
|
|
LIBRUBY_RELATIVE=yes
|
|
])
|
|
], [
|
|
LIBRUBYARG_SHARED=
|
|
|
|
# enable PIE if possible
|
|
AC_ARG_ENABLE(pie,
|
|
AS_HELP_STRING([--disable-pie], [disable PIE feature]),
|
|
[pie=$enableval], [pie=])
|
|
AS_IF([test "$GCC" = yes -a -z "$EXTSTATIC" -a "x$pie" != xno], [
|
|
RUBY_TRY_CFLAGS(-fPIE, [pie=yes], [pie=no])
|
|
AS_IF([test "$pie" = yes], [
|
|
# Use -fPIE when testing -pie. RUBY_TRY_LDFLAGS sets
|
|
# $save_CFLAGS internally, so set other name here.
|
|
save_CFLAGS_before_pie="$CFLAGS"
|
|
CFLAGS="$CFLAGS -fPIE"
|
|
|
|
# gcc need -pie but clang need -Wl,-pie.
|
|
for pie in -pie -Wl,-pie; do
|
|
RUBY_TRY_LDFLAGS([$pie], [], [pie=])
|
|
AS_IF([test "x$pie" != x], [
|
|
RUBY_APPEND_OPTION(XCFLAGS, -fPIE)
|
|
RUBY_APPEND_OPTION(XLDFLAGS, $pie)
|
|
break
|
|
])
|
|
done
|
|
CFLAGS="$save_CFLAGS_before_pie"
|
|
])
|
|
])
|
|
])
|
|
AS_IF([test "$enable_rpath" = yes], [
|
|
test -z "$LIBRUBY_RPATHFLAGS" || LIBRUBY_RPATHFLAGS="$LIBRUBY_RPATHFLAGS "
|
|
rpathflag="${RPATHFLAG}"
|
|
AS_CASE(["${cross_compiling}${load_relative}"], [*yes*], [], [rpathflag="$RPATHFLAG$LIBPATHFLAG"])
|
|
rpathflag=`IFS="$PATH_SEPARATOR"
|
|
echo x "$rpathflag" |
|
|
sed "s/^x *//;s${IFS}"'%1\\$-s'"${IFS}${libprefix}${IFS}g;s${IFS}%s${IFS}${libprefix}${IFS}g"
|
|
`
|
|
LIBRUBY_RPATHFLAGS="$LIBRUBY_RPATHFLAGS${rpathflag}"
|
|
LIBRUBYARG_SHARED="$LIBRUBY_RPATHFLAGS $LIBRUBYARG_SHARED"
|
|
LIBRUBYARG_STATIC="$LIBRUBY_RPATHFLAGS $LIBRUBYARG_STATIC"
|
|
])
|
|
AC_SUBST(LIBRUBY_RELATIVE)
|
|
|
|
LDFLAGS="-L. $LDFLAGS"
|
|
AC_SUBST(ARCHFILE)
|
|
|
|
AS_IF([test "$EXEEXT" = .exe], [
|
|
EXECUTABLE_EXTS='".exe",".com",".cmd",".bat"'
|
|
AC_DEFINE_UNQUOTED(EXECUTABLE_EXTS, $EXECUTABLE_EXTS)
|
|
EXECUTABLE_EXTS=`echo $EXECUTABLE_EXTS | tr -d '"' | tr , ' '`
|
|
AC_SUBST(EXECUTABLE_EXTS)
|
|
])
|
|
|
|
AS_CASE("$cross_compiling:${LIBPATHENV}", [yes:* | no:], [], [
|
|
AC_MSG_CHECKING(whether wrapper for $LIBPATHENV is needed)
|
|
AS_IF([env ${LIBPATHENV}=/lib /bin/sh -c ': ${'${LIBPATHENV}'?}' 2>/dev/null],
|
|
[AC_MSG_RESULT(no)],
|
|
[PREP="$PREP"' exe/$(PROGRAM)'
|
|
AC_MSG_RESULT(yes)]
|
|
)
|
|
])
|
|
|
|
AC_ARG_ENABLE(dtrace,
|
|
AS_HELP_STRING([--enable-dtrace],
|
|
[enable DTrace for tracing inside ruby. enabled by default on systems having dtrace]),
|
|
[enable_dtrace=$enableval], [enable_dtrace=auto])
|
|
|
|
LIBRUBY_A_OBJS='$(OBJS)'
|
|
DTRACE_REBUILD=
|
|
AS_CASE(["${enable_dtrace}"],
|
|
[yes|auto], [
|
|
RUBY_DTRACE_AVAILABLE()
|
|
], [
|
|
rb_cv_dtrace_available=no
|
|
])
|
|
AS_CASE(["$target_os"],[freebsd*],[
|
|
rb_cv_dtrace_available=no
|
|
])
|
|
AS_IF([test "${enable_dtrace}" = yes], [dnl
|
|
AS_IF([test -z "$DTRACE"], [dnl
|
|
AC_MSG_ERROR([dtrace(1) is missing])
|
|
], [test "$cross_compiling" = yes], [dnl
|
|
AC_MSG_ERROR([--enable-dtrace, however, cross compiling])
|
|
], [test "${rb_cv_dtrace_available}" = "no"], [dnl
|
|
AC_MSG_ERROR([--enable-dtrace, however, USDT is not available])
|
|
])
|
|
])
|
|
AS_CASE([$rb_cv_dtrace_available],
|
|
[yes*], [dnl
|
|
RUBY_DTRACE_POSTPROCESS()
|
|
AS_IF([test "$rb_cv_prog_dtrace_g" != no], [dnl
|
|
DTRACE_OBJ='probes.$(OBJEXT)'
|
|
])
|
|
AS_IF([test "$rb_cv_prog_dtrace_g" = rebuild], [dnl
|
|
DTRACE_REBUILD=yes
|
|
LIBRUBY_A_OBJS='$(DTRACE_GLOMMED_OBJ)'
|
|
])
|
|
AS_CASE("${target_os}", [freebsd*], [dnl
|
|
# FreeBSD's dtrace requires libelf
|
|
LIBS="-lelf $LIBS"
|
|
])
|
|
DTRACE_EXT=d
|
|
], [dnl
|
|
enable_dtrace=no
|
|
DTRACE_EXT=dmyh
|
|
])
|
|
AC_SUBST(DTRACE_EXT)
|
|
AC_SUBST(DTRACE_OBJ)
|
|
AC_SUBST(DTRACE_REBUILD)
|
|
AC_SUBST(DTRACE_OPT)
|
|
AC_SUBST(LIBRUBY_A_OBJS)
|
|
|
|
AC_ARG_ENABLE(gcov,
|
|
AS_HELP_STRING([--enable-gcov], [enable coverage measurement by gcov]),
|
|
[gcov=yes])
|
|
AS_IF([test x"$gcov" = xyes], [
|
|
CFLAGS="$CFLAGS -coverage"
|
|
LDFLAGS="$LDFLAGS -coverage"
|
|
])
|
|
|
|
RUBY_SETJMP_TYPE
|
|
}
|
|
|
|
: "build section" && {
|
|
dnl build rdoc index if requested
|
|
RDOCTARGET=""
|
|
CAPITARGET=""
|
|
AC_ARG_ENABLE(install-doc,
|
|
AS_HELP_STRING([--disable-install-doc], [do not install either rdoc indexes or C API documents during install]),
|
|
[install_doc=$enableval], [install_doc=yes])
|
|
AC_ARG_WITH(rdoc,
|
|
AS_HELP_STRING([--with-rdoc=ri,html], [comma/space separated list of RDoc formats to install]),
|
|
[install_rdoc=`echo ,$withval, | sed 'y/,/ /;s/ ri / rdoc /;s/^ *//;s/ *$//'`], [
|
|
AC_ARG_ENABLE(install-rdoc,
|
|
AS_HELP_STRING([--disable-install-rdoc], [do not install rdoc indexes during install]),
|
|
[install_rdoc=$enableval], [install_rdoc=yes])
|
|
])
|
|
AC_ARG_ENABLE(install-capi,
|
|
AS_HELP_STRING([--disable-install-capi], [do not install C API documents during install]),
|
|
[install_capi=$enableval], [install_capi=no])
|
|
|
|
AS_IF([test "$install_doc" != no], [
|
|
AS_CASE(["$install_rdoc"],
|
|
[yes], [
|
|
RDOCTARGET="rdoc"
|
|
],
|
|
[all], [
|
|
RDOCTARGET="rdoc html"
|
|
],
|
|
[no|''], [
|
|
RDOCTARGET="nodoc"
|
|
],
|
|
[
|
|
RDOCTARGET="$install_rdoc"
|
|
])
|
|
AS_IF([test "$install_capi" != no -a -n "$DOXYGEN"], [
|
|
CAPITARGET="capi"
|
|
], [
|
|
CAPITARGET="nodoc"
|
|
])
|
|
], [
|
|
RDOCTARGET="nodoc"
|
|
CAPITARGET="nodoc"
|
|
])
|
|
|
|
AC_SUBST(RDOCTARGET)
|
|
AC_SUBST(CAPITARGET)
|
|
|
|
AS_CASE(["$RDOCTARGET:$CAPITARGET"],[nodoc:nodoc],[INSTALLDOC=nodoc],[INSTALLDOC=all])
|
|
AC_SUBST(INSTALLDOC)
|
|
|
|
AC_ARG_ENABLE(jit-support,
|
|
AS_HELP_STRING([--disable-jit-support], [disable JIT features]),
|
|
[MJIT_SUPPORT=$enableval
|
|
AS_IF([test x"$enable_jit_support" = "xyes"],
|
|
[AC_DEFINE(USE_MJIT, 1)],
|
|
[AC_DEFINE(USE_MJIT, 0)])],
|
|
[MJIT_SUPPORT=yes
|
|
AC_DEFINE(USE_MJIT, 1)])
|
|
|
|
AC_SUBST(MJIT_SUPPORT)
|
|
|
|
AC_ARG_ENABLE(install-static-library,
|
|
AS_HELP_STRING([--disable-install-static-library], [do not install static ruby library]),
|
|
[INSTALL_STATIC_LIBRARY=$enableval
|
|
AS_IF([test x"$enable_shared" = xno -a x"$INSTALL_STATIC_LIBRARY" = xno],
|
|
[AC_MSG_ERROR([must install either static or shared library])],
|
|
[])],
|
|
AS_IF([test x"$enable_shared" = xyes],
|
|
[INSTALL_STATIC_LIBRARY=no],
|
|
[INSTALL_STATIC_LIBRARY=yes]))
|
|
AC_SUBST(INSTALL_STATIC_LIBRARY)
|
|
|
|
AS_IF([test "$rb_with_pthread" = "yes"], [
|
|
THREAD_MODEL=pthread
|
|
])
|
|
AC_CACHE_CHECK([for prefix of external symbols], rb_cv_symbol_prefix, [
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[extern void conftest_external(void) {}]], [[]])],[
|
|
rb_cv_symbol_prefix=`$NM conftest.$ac_objext |
|
|
sed -n ['/.*T[ ]\([^ ]*\)conftest_external.*/!d;s//\1/p;q']`
|
|
],
|
|
[rb_cv_symbol_prefix=''])
|
|
test -n "$rb_cv_symbol_prefix" || rb_cv_symbol_prefix=NONE
|
|
])
|
|
SYMBOL_PREFIX="$rb_cv_symbol_prefix"
|
|
test "x$SYMBOL_PREFIX" = xNONE && SYMBOL_PREFIX=''
|
|
DLNOBJ=dln.o
|
|
AC_ARG_ENABLE(dln,
|
|
AS_HELP_STRING([--disable-dln], [disable dynamic link feature]),
|
|
[test "$enableval" = yes || DLNOBJ=dmydln.o])
|
|
AC_SUBST(DLNOBJ)
|
|
MINIDLNOBJ=dmydln.o
|
|
|
|
AS_CASE(["$target_os"],
|
|
[linux*], [
|
|
],
|
|
[netbsd*], [
|
|
RUBY_APPEND_OPTION(CFLAGS, -pipe)
|
|
],
|
|
[darwin*], [
|
|
RUBY_APPEND_OPTION(CFLAGS, -pipe)
|
|
AC_COMPILE_IFELSE([
|
|
AC_LANG_BOOL_COMPILE_TRY([@%:@include <AvailabilityMacros.h>],
|
|
[MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_7 &&
|
|
MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_10])],
|
|
[dnl
|
|
RUBY_APPEND_OPTION(XLDFLAGS, [-framework Security])
|
|
RUBY_APPEND_OPTION(LIBRUBYARG_STATIC, [-framework Security])
|
|
]dnl
|
|
)
|
|
RUBY_APPEND_OPTION(XLDFLAGS, [-framework CoreFoundation])
|
|
RUBY_APPEND_OPTION(LIBRUBYARG_STATIC, [-framework CoreFoundation])
|
|
],
|
|
[osf*], [
|
|
AS_IF([test "$GCC" != "yes" ], [
|
|
# compile something small: taint.c is fine for this.
|
|
# the main point is the '-v' flag of 'cc'.
|
|
AS_CASE(["`cc -v -I. -c main.c -o /tmp/main.o 2>&1`"],
|
|
[*/gemc_cc*], [ # we have the new DEC GEM CC
|
|
CFLAGS="$CFLAGS -oldc"
|
|
],
|
|
[ # we have the old MIPS CC
|
|
])
|
|
# cleanup
|
|
rm -f /tmp/main.o
|
|
CFLAGS="$CFLAGS -std"
|
|
])
|
|
],
|
|
[cygwin*|msys*|mingw*], [
|
|
LIBRUBY_DLDFLAGS="${LIBRUBY_DLDFLAGS}"' -Wl,--out-implib=$(LIBRUBY)'
|
|
AS_CASE(["$target_os"],
|
|
[cygwin*], [
|
|
AS_IF([test x"$enable_shared" = xyes], [
|
|
LIBRUBY_SO='cyg$(RUBY_SO_NAME)'.dll
|
|
LIBRUBY_DLDFLAGS="${LIBRUBY_DLDFLAGS}"' $(RUBYDEF)'
|
|
])
|
|
],
|
|
[mingw*], [
|
|
AS_IF([test x"$enable_shared" = xyes], [
|
|
LIBRUBY_SO='$(RUBY_SO_NAME)'.dll
|
|
LIBRUBY_DLDFLAGS="${LIBRUBY_DLDFLAGS}"' $(RUBYDEF)'
|
|
])
|
|
EXPORT_PREFIX=' '
|
|
EXTDLDFLAGS='$(DEFFILE)'
|
|
AC_LIBOBJ([win32/win32])
|
|
AC_LIBOBJ([win32/file])
|
|
COMMON_LIBS=m
|
|
# COMMON_MACROS="WIN32_LEAN_AND_MEAN="
|
|
COMMON_HEADERS="winsock2.h windows.h"
|
|
THREAD_MODEL=win32
|
|
PLATFORM_DIR=win32
|
|
])
|
|
LIBRUBY_ALIASES=''
|
|
FIRSTMAKEFILE=GNUmakefile:cygwin/GNUmakefile.in
|
|
AS_IF([test x"$enable_shared" = xyes], [
|
|
LIBRUBY='lib$(RUBY_SO_NAME).dll.a'
|
|
], [
|
|
LIBRUBY_SO=dummy
|
|
LIBRUBY='lib$(RUBY_SO_NAME).a'
|
|
LIBRUBYARG='-l$(RUBY_SO_NAME)'
|
|
])
|
|
],
|
|
[hpux*], [
|
|
AS_CASE(["$YACC"],[*yacc*], [
|
|
XCFLAGS="$XCFLAGS -DYYMAXDEPTH=300"
|
|
YACC="$YACC -Nl40000 -Nm40000"
|
|
])
|
|
])
|
|
|
|
MINIOBJS="$MINIDLNOBJ"
|
|
|
|
AS_CASE(["$THREAD_MODEL"],
|
|
[pthread], [AC_CHECK_HEADERS(pthread.h)],
|
|
[win32], [],
|
|
[""], [AC_MSG_ERROR(thread model is missing)],
|
|
[AC_MSG_ERROR(unknown thread model $THREAD_MODEL)])
|
|
|
|
AC_ARG_ENABLE(debug-env,
|
|
AS_HELP_STRING([--enable-debug-env], [enable RUBY_DEBUG environment variable]),
|
|
[AC_SUBST(ENABLE_DEBUG_ENV, yes)])
|
|
|
|
AS_CASE(["$FIRSTMAKEFILE"], [*GNUmakefile:*], [gnumake=yes], [
|
|
AC_MSG_CHECKING([if ${MAKE-make} is GNU make])
|
|
mkdir conftest.dir
|
|
echo "all:; @echo yes" > conftest.dir/GNUmakefile
|
|
echo "all:; @echo no" > conftest.dir/Makefile
|
|
gnumake=`(cd conftest.dir; ${MAKE-make})`
|
|
rm -fr conftest.dir
|
|
AS_CASE(["$gnumake"],
|
|
[*yes*], [
|
|
FIRSTMAKEFILE=GNUmakefile:template/GNUmakefile.in
|
|
gnumake=yes],
|
|
[
|
|
gnumake=no])
|
|
AC_MSG_RESULT($gnumake)
|
|
])
|
|
AS_IF([test "$gnumake" = yes], [ NULLCMD=: ], [
|
|
AC_MSG_CHECKING([for safe null command for ${MAKE-make}])
|
|
mkdir conftest.dir
|
|
NULLCMD=
|
|
for cmd in : true; do
|
|
echo 'A=1' > conftest.dir/Makefile
|
|
echo 'B=$(A:1=@'$cmd')' >> conftest.dir/Makefile
|
|
echo 'all:; $B 1 2 3 4 5 6 7 8 9' >> conftest.dir/Makefile
|
|
AS_IF([(cd conftest.dir; ${MAKE-make} >/dev/null 2>/dev/null)], [
|
|
NULLCMD=$cmd
|
|
break
|
|
])
|
|
done
|
|
rm -fr conftest.dir
|
|
AS_IF([test -z "$NULLCMD"], [
|
|
AC_MSG_ERROR(no candidate for safe null command)
|
|
])
|
|
AC_MSG_RESULT($NULLCMD)
|
|
])
|
|
AC_SUBST(NULLCMD)
|
|
|
|
AS_IF([test "${universal_binary-no}" = yes ], [
|
|
AC_CACHE_CHECK([for architecture macros], rb_cv_architecture_macros, [
|
|
mv confdefs.h confdefs1.h
|
|
: > confdefs.h
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[@%:@if defined __`echo ${universal_archnames} |
|
|
sed 's/=[^ ]*//g;s/ /__ || defined __/g'`__
|
|
@%:@else
|
|
@%:@error
|
|
>>>>>><<<<<<
|
|
@%:@endif]], [[]])],[
|
|
rb_cv_architecture_macros=yes
|
|
mv -f confdefs1.h confdefs.h
|
|
], [
|
|
rb_cv_architecture_macros=no
|
|
archflagpat=`eval echo '"'"${ARCH_FLAG}"'"' | sed 's/[[][|.*]]/\\&/g'`
|
|
new_cflags=`echo "$CFLAGS" | sed "s|$archflagpat"'||'`
|
|
for archs in ${universal_archnames}; do
|
|
cpu=${archs@%:@*=}
|
|
archs=${archs%=*}
|
|
CFLAGS="$new_cflags -arch $archs"
|
|
archs="__${archs}__"
|
|
AC_MSG_CHECKING([for macro ${archs} on ${cpu}])
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[@%:@ifndef ${archs}
|
|
@%:@error
|
|
@%:@endif]], [[]])],
|
|
[AC_MSG_RESULT([yes])], [AC_MSG_RESULT([no])])
|
|
done
|
|
mv -f confdefs1.h confdefs.h
|
|
AC_MSG_ERROR([failed])
|
|
])])
|
|
AC_CACHE_CHECK(whether __ARCHITECTURE__ is available, rb_cv_architecture_available,
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[@%:@include <stdio.h>
|
|
const char arch[[]] = __ARCHITECTURE__;]], [[puts(arch);]])],
|
|
[rb_cv_architecture_available=yes], [rb_cv_architecture_available=no]))
|
|
])
|
|
|
|
: ${MJIT_LDSHARED=`echo "$LDSHARED" | sed ['s|\$(LD)|'"${LD}"'|g;s|\$(CC)|$(MJIT_CC)|g']`}
|
|
|
|
MAINLIBS="$LIBS"
|
|
LIBS=$ORIG_LIBS
|
|
AS_IF([test -n "${LIBS}"], [
|
|
libspat=`echo "${LIBS}" | sed 's/[[][|.*$^]]/\\&/g;s/^ */ /;s/^ *$/ /'`
|
|
MAINFLAGS=`echo " $MAINLIBS " | sed "s|$libspat"'||;s/^ *//;s/ *$//'`
|
|
])
|
|
LIBRUBYARG_STATIC="${LIBRUBYARG_STATIC} \$(MAINLIBS)"
|
|
LIBRUBYARG_SHARED="${LIBRUBYARG_SHARED} \$(MAINLIBS)"
|
|
CPPFLAGS="$CPPFLAGS "'$(DEFS)'
|
|
test -z "$CPPFLAGS" || CPPFLAGS="$CPPFLAGS "; CPPFLAGS="$CPPFLAGS"'${cppflags}'
|
|
AS_IF([test -n "${cflags+set}"], [
|
|
cflagspat=`eval echo '"'"${cflags}"'"' | sed 's/[[][|.*]]/\\&/g;s/^ */ /;s/^ *$/ /'`
|
|
CFLAGS=`echo " $CFLAGS " | sed "s|$cflagspat"'|${cflags}|;s/^ *//;s/ *$//'`
|
|
])
|
|
AS_IF([test -n "${cxxflags+set}"], [
|
|
cxxflagspat=`eval echo '"'"${cxxflags}"'"' | sed 's/[[][|.*]]/\\&/g;s/^ */ /;s/^ *$/ /'`
|
|
CXXFLAGS=`echo " $CXXFLAGS " | sed "s|$cxxflagspat"'|${cxxflags}|;s/^ *//;s/ *$//'`
|
|
])
|
|
AS_IF([test "${ARCH_FLAG}"], [
|
|
archflagpat=`eval echo '"'"${ARCH_FLAG}"'"' | sed 's/[[][|.*]]/\\&/g'`
|
|
CFLAGS=`echo "$CFLAGS" | sed "s| *$archflagpat"'||'`
|
|
CXXFLAGS=`echo "$CXXFLAGS" | sed "s| *$archflagpat"'||'`
|
|
LDFLAGS=`echo "$LDFLAGS" | sed "s| *$archflagpat"'||'`
|
|
])
|
|
rb_cv_warnflags=`echo "$rb_cv_warnflags" | sed 's/^ *//;s/ *$//'`
|
|
warnflags="$rb_cv_warnflags"
|
|
AC_SUBST(cppflags)dnl
|
|
AC_SUBST(cflags, ["${orig_cflags:+$orig_cflags }"'${optflags} ${debugflags} ${warnflags}'])dnl
|
|
AC_SUBST(cxxflags)dnl
|
|
AC_SUBST(optflags)dnl
|
|
AC_SUBST(debugflags)dnl
|
|
AC_SUBST(warnflags)dnl
|
|
AC_SUBST(strict_warnflags)dnl
|
|
AC_SUBST(XCFLAGS)dnl
|
|
AC_SUBST(XLDFLAGS)dnl
|
|
AC_SUBST(EXTLDFLAGS)dnl
|
|
AC_SUBST(EXTDLDFLAGS)dnl
|
|
AC_SUBST(LIBRUBY_LDSHARED)
|
|
AC_SUBST(LIBRUBY_DLDFLAGS)
|
|
AC_SUBST(RUBY_INSTALL_NAME)
|
|
AC_SUBST(rubyw_install_name)
|
|
AC_SUBST(RUBYW_INSTALL_NAME)
|
|
AC_SUBST(RUBY_SO_NAME)
|
|
AC_SUBST(LIBRUBY_A)
|
|
AC_SUBST(LIBRUBY_SO)
|
|
AC_SUBST(LIBRUBY_SONAME)
|
|
AC_SUBST(LIBRUBY_ALIASES)
|
|
AC_SUBST(LIBRUBY)
|
|
AC_SUBST(LIBRUBYARG)
|
|
AC_SUBST(LIBRUBYARG_STATIC)
|
|
AC_SUBST(LIBRUBYARG_SHARED)
|
|
AC_SUBST(SOLIBS)
|
|
AC_SUBST(DLDLIBS)
|
|
AC_SUBST(DLDSHARED)
|
|
AC_SUBST(ENABLE_SHARED)
|
|
AC_SUBST(MAINLIBS)
|
|
AC_SUBST(COMMON_LIBS)
|
|
AC_SUBST(COMMON_MACROS)
|
|
AC_SUBST(COMMON_HEADERS)
|
|
AC_SUBST(EXPORT_PREFIX)
|
|
AC_SUBST(SYMBOL_PREFIX)
|
|
AC_SUBST(MINIOBJS)
|
|
AC_SUBST(THREAD_MODEL)
|
|
AC_SUBST(PLATFORM_DIR)
|
|
|
|
firstmf=`echo $FIRSTMAKEFILE | sed 's/:.*//'`
|
|
firsttmpl=`echo $FIRSTMAKEFILE | sed 's/.*://'`
|
|
MAKEFILES="Makefile $firstmf"
|
|
MAKEFILES="`echo $MAKEFILES`"
|
|
AC_SUBST(MAKEFILES)
|
|
|
|
ri_prefix=
|
|
test "$program_prefix" != NONE &&
|
|
ri_prefix=$program_prefix
|
|
|
|
ri_suffix=
|
|
test "$program_suffix" != NONE &&
|
|
ri_suffix=$program_suffix
|
|
|
|
RUBY_INSTALL_NAME="${ri_prefix}"'$(RUBY_BASE_NAME)'"${ri_suffix}"
|
|
AS_CASE(["$target_os"],
|
|
[cygwin*|msys*|mingw*], [
|
|
RUBYW_INSTALL_NAME="${ri_prefix}"'$(RUBYW_BASE_NAME)'"${ri_suffix}"
|
|
rubyw_install_name='$(RUBYW_INSTALL_NAME)'
|
|
])
|
|
|
|
rubylibdir='${rubylibprefix}/${ruby_version}'
|
|
rubyarchdir=${multiarch+'${rubyarchprefix}/${ruby_version}'}${multiarch-'${rubylibdir}/${arch}'}
|
|
|
|
rubyarchprefix=${multiarch+'${archlibdir}/${RUBY_BASE_NAME}'}${multiarch-'${rubylibprefix}/${arch}'}
|
|
AC_ARG_WITH(rubyarchprefix,
|
|
AS_HELP_STRING([--with-rubyarchprefix=DIR],
|
|
[prefix for architecture dependent ruby libraries [[RUBYLIBPREFIX/ARCH]]]),
|
|
[rubyarchprefix="$withval"])
|
|
AC_SUBST(rubyarchprefix)
|
|
|
|
rubysitearchprefix=${multiarch+'${sitearchlibdir}/${RUBY_BASE_NAME}'}${multiarch-'${rubylibprefix}/${sitearch}'}
|
|
AC_ARG_WITH(rubysitearchprefix,
|
|
AS_HELP_STRING([--with-rubysitearchprefix=DIR],
|
|
[prefix for architecture dependent site libraries [[RUBYLIBPREFIX/SITEARCH]]]),
|
|
[rubysitearchprefix="$withval"])
|
|
AC_SUBST(rubysitearchprefix)
|
|
|
|
RI_BASE_NAME=`echo ${RUBY_BASE_NAME} | sed 's/ruby/ri/'`
|
|
ridir='${datarootdir}/${RI_BASE_NAME}'
|
|
AC_ARG_WITH(ridir,
|
|
AS_HELP_STRING([--with-ridir=DIR], [ri documentation [[DATAROOTDIR/ri]]]),
|
|
[ridir=$withval])
|
|
AC_SUBST(ridir)
|
|
AC_SUBST(RI_BASE_NAME)
|
|
|
|
AC_ARG_WITH(ruby-version,
|
|
AS_HELP_STRING([--with-ruby-version=STR], [ruby version string for version specific directories [[full]] (full|minor|STR)]),
|
|
[ruby_version=$withval],
|
|
[ruby_version=full])
|
|
unset RUBY_LIB_VERSION
|
|
unset RUBY_LIB_VERSION_STYLE
|
|
AS_CASE(["$ruby_version"],
|
|
[full], [RUBY_LIB_VERSION_STYLE='3 /* full */'],
|
|
[minor], [RUBY_LIB_VERSION_STYLE='2 /* minor */'])
|
|
AS_IF([test ${RUBY_LIB_VERSION_STYLE+set}], [
|
|
{
|
|
echo "#define RUBY_LIB_VERSION_STYLE $RUBY_LIB_VERSION_STYLE"
|
|
echo '#define STRINGIZE(x) x'
|
|
test -f revision.h -o -f "${srcdir}/revision.h" || echo '#define RUBY_REVISION 0'
|
|
echo '#include "version.h"'
|
|
echo 'ruby_version=RUBY_LIB_VERSION'
|
|
} > conftest.c
|
|
ruby_version="`$CPP -I. -I"${srcdir}" -I"${srcdir}/include" conftest.c | sed '/^ruby_version=/!d;s/ //g'`"
|
|
eval $ruby_version
|
|
], [test -z "${ruby_version}"], [
|
|
AC_MSG_ERROR([No ruby version, No place for bundled libraries])
|
|
], [
|
|
RUBY_LIB_VERSION="${ruby_version}"
|
|
])
|
|
AC_SUBST(RUBY_LIB_VERSION_STYLE)
|
|
AC_SUBST(RUBY_LIB_VERSION)
|
|
|
|
AC_ARG_WITH(sitedir,
|
|
AS_HELP_STRING([--with-sitedir=DIR], [site libraries in DIR [[RUBY_LIB_PREFIX/site_ruby]], "no" to disable site directory]),
|
|
[sitedir=$withval],
|
|
[sitedir='${rubylibprefix}/site_ruby'])
|
|
sitelibdir='${sitedir}/${ruby_version}'
|
|
|
|
AC_ARG_WITH(sitearchdir,
|
|
AS_HELP_STRING([--with-sitearchdir=DIR],
|
|
[architecture dependent site libraries in DIR [[SITEDIR/SITEARCH]], "no" to disable site directory]),
|
|
[sitearchdir=$withval],
|
|
[sitearchdir=${multiarch+'${rubysitearchprefix}/site_ruby/${ruby_version}'}${multiarch-'${sitelibdir}/${sitearch}'}])
|
|
|
|
AC_ARG_WITH(vendordir,
|
|
AS_HELP_STRING([--with-vendordir=DIR], [vendor libraries in DIR [[RUBY_LIB_PREFIX/vendor_ruby]], "no" to disable vendor directory]),
|
|
[vendordir=$withval],
|
|
[vendordir='${rubylibprefix}/vendor_ruby'])
|
|
vendorlibdir='${vendordir}/${ruby_version}'
|
|
|
|
AC_ARG_WITH(vendorarchdir,
|
|
AS_HELP_STRING([--with-vendorarchdir=DIR],
|
|
[architecture dependent vendor libraries in DIR [[VENDORDIR/SITEARCH]], "no" to disable vendor directory]),
|
|
[vendorarchdir=$withval],
|
|
[vendorarchdir=${multiarch+'${rubysitearchprefix}/vendor_ruby/${ruby_version}'}${multiarch-'${vendorlibdir}/${sitearch}'}])
|
|
|
|
AS_IF([test "${LOAD_RELATIVE+set}"], [
|
|
AC_DEFINE_UNQUOTED(LOAD_RELATIVE, $LOAD_RELATIVE)
|
|
RUBY_EXEC_PREFIX=''
|
|
])
|
|
|
|
AC_SUBST(RUBY_EXEC_PREFIX)
|
|
|
|
AC_SUBST(libdirname, ${multiarch+arch}libdir)
|
|
AC_SUBST(archlibdir)dnl
|
|
AC_SUBST(sitearchlibdir)dnl
|
|
AC_SUBST(archincludedir)dnl
|
|
AC_SUBST(sitearchincludedir)dnl
|
|
AC_SUBST(arch)dnl
|
|
AC_SUBST(sitearch)dnl
|
|
AC_SUBST(ruby_version)dnl
|
|
AC_SUBST(rubylibdir)dnl
|
|
AC_SUBST(rubyarchdir)dnl
|
|
AC_SUBST(sitedir)dnl
|
|
AC_SUBST(sitelibdir)dnl
|
|
AC_SUBST(sitearchdir)dnl
|
|
AC_SUBST(vendordir)dnl
|
|
AC_SUBST(vendorlibdir)dnl
|
|
AC_SUBST(vendorarchdir)dnl
|
|
|
|
AC_SUBST(CONFIGURE, "`echo $0 | sed 's|.*/||'`")dnl
|
|
AC_SUBST(configure_args, "`echo "${ac_configure_args}" | sed 's/\\$/$$/g'`")dnl
|
|
|
|
AS_IF([test "${universal_binary-no}" = yes ], [
|
|
arch="universal-${target_os}"
|
|
AS_IF([test "${rb_cv_architecture_available}" = yes], [
|
|
AC_DEFINE_UNQUOTED(RUBY_PLATFORM_CPU, __ARCHITECTURE__)
|
|
], [
|
|
for archs in ${universal_archnames}; do
|
|
cpu=`echo $archs | sed 's/.*=//'`
|
|
archs=`echo $archs | sed 's/=.*//'`
|
|
RUBY_DEFINE_IF([defined __${archs}__ &&! defined RUBY_PLATFORM_CPU], RUBY_PLATFORM_CPU, ["${cpu}"])
|
|
done
|
|
])
|
|
ints='long int short'
|
|
test "$ac_cv_type_long_long" = yes && ints="'long long' $ints"
|
|
AC_SUBST(UNIVERSAL_ARCHNAMES, "${universal_archnames}")
|
|
AC_SUBST(UNIVERSAL_INTS, "${ints}")
|
|
AC_DEFINE_UNQUOTED(RUBY_PLATFORM_OS, "${target_os}")
|
|
AC_DEFINE_UNQUOTED(RUBY_ARCH, "universal-" RUBY_PLATFORM_OS)
|
|
AC_DEFINE_UNQUOTED(RUBY_PLATFORM, "universal." RUBY_PLATFORM_CPU "-" RUBY_PLATFORM_OS)
|
|
], [
|
|
AS_IF([test "${target_os}-${rb_cv_msvcrt}" = "mingw32-ucrt" ], [
|
|
arch="${target_cpu}-mingw-ucrt"
|
|
], [
|
|
arch="${target_cpu}-${target_os}"
|
|
])
|
|
AC_DEFINE_UNQUOTED(RUBY_PLATFORM, "$arch")
|
|
])
|
|
|
|
unset sitearch
|
|
AS_CASE(["$target_os"],[mingw*],[sitearch="$target_cpu-$rb_cv_msvcrt"])
|
|
: ${sitearch='${arch}'}
|
|
|
|
AC_ARG_WITH(search-path,
|
|
AS_HELP_STRING([--with-search-path=DIR], [specify the additional search path]),
|
|
[search_path=$withval])
|
|
AS_IF([test "$search_path" != ""], [
|
|
AC_SUBST(RUBY_SEARCH_PATH, $search_path)
|
|
])
|
|
|
|
AC_ARG_WITH(rubyhdrdir,
|
|
AS_HELP_STRING([--with-rubyhdrdir=DIR], [core headers in DIR [[INCLUDEDIR/RUBY_BASE_NAME-RUBY_VERSION]]]),
|
|
[rubyhdrdir=$withval],
|
|
[rubyhdrdir='${includedir}/${RUBY_VERSION_NAME}'])
|
|
|
|
AC_ARG_WITH(rubyarchhdrdir,
|
|
AS_HELP_STRING([--with-rubyarchhdrdir=DIR],
|
|
[architecture dependent core headers in DIR [[$(rubyhdrdir)/$(arch)]]]),
|
|
[rubyarchhdrdir=$withval],
|
|
[rubyarchhdrdir=${multiarch+'${archincludedir}/${RUBY_VERSION_NAME}'}${multiarch-'${rubyhdrdir}/${arch}'}])
|
|
|
|
AC_ARG_WITH(sitehdrdir,
|
|
AS_HELP_STRING([--with-sitehdrdir=DIR], [core site headers in DIR [[RUBYHDRDIR/site_ruby]]]),
|
|
[sitehdrdir=$withval],
|
|
[sitehdrdir='${rubyhdrdir}/site_ruby'])
|
|
|
|
AC_ARG_WITH(sitearchhdrdir,
|
|
AS_HELP_STRING([--with-sitearchhdrdir=DIR],
|
|
[architecture dependent core site headers in DIR [[RUBYHDRDIR/site_ruby]]]),
|
|
[sitearchhdrdir=$withval],
|
|
[sitearchhdrdir=${multiarch+'${sitearchincludedir}/${RUBY_VERSION_NAME}/site_ruby'}${multiarch-'${sitehdrdir}/${sitearch}'}])
|
|
|
|
AC_ARG_WITH(vendorhdrdir,
|
|
AS_HELP_STRING([--with-vendorhdrdir=DIR], [core vendor headers in DIR [[RUBYHDRDIR/vendor_ruby]]]),
|
|
[vendorhdrdir=$withval],
|
|
[vendorhdrdir='${rubyhdrdir}/vendor_ruby'])
|
|
|
|
AC_ARG_WITH(vendorarchhdrdir,
|
|
AS_HELP_STRING([--with-vendorarchhdrdir=DIR],
|
|
[architecture dependent core vendor headers in DIR [[RUBYHDRDIR/vendor_ruby]]]),
|
|
[vendorarchhdrdir=$withval],
|
|
[vendorarchhdrdir=${multiarch+'${sitearchincludedir}/${RUBY_VERSION_NAME}/vendor_ruby'}${multiarch-'${vendorhdrdir}/${sitearch}'}])
|
|
|
|
AC_SUBST(rubyhdrdir)dnl
|
|
AC_SUBST(sitehdrdir)dnl
|
|
AC_SUBST(vendorhdrdir)dnl
|
|
AC_SUBST(rubyarchhdrdir)dnl
|
|
AC_SUBST(sitearchhdrdir)dnl
|
|
AC_SUBST(vendorarchhdrdir)dnl
|
|
|
|
AC_ARG_WITH(mantype,
|
|
AS_HELP_STRING([--with-mantype=TYPE], [specify man page type; TYPE is one of man and doc]),
|
|
[
|
|
AS_CASE(["$withval"],
|
|
[man|man.gz|man.bz2|doc|doc.gz|doc.bz2], [MANTYPE=$withval],
|
|
[AC_MSG_ERROR(invalid man type: $withval)])
|
|
])
|
|
AS_IF([test -z "$MANTYPE"], [
|
|
dnl Looks for nroff with -mdoc support.
|
|
AC_CACHE_VAL([ac_cv_path_NROFF], [
|
|
AC_PATH_PROGS_FEATURE_CHECK([NROFF],
|
|
[nroff awf mandoc],
|
|
[$ac_path_NROFF -mdoc ${srcdir}/man/ruby.1 \
|
|
>/dev/null 2>&1 &&
|
|
ac_cv_path_NROFF=$ac_path_NROFF \
|
|
ac_path_NROFF_found=:],
|
|
[], ["/usr/bin:/usr/ucb"]
|
|
)
|
|
])
|
|
AS_IF([test -n "$ac_cv_path_NROFF"], [
|
|
MANTYPE=doc
|
|
], [
|
|
MANTYPE=man
|
|
])
|
|
])
|
|
AC_SUBST(MANTYPE)
|
|
|
|
AC_ARG_ENABLE(rubygems,
|
|
AS_HELP_STRING([--disable-rubygems], [disable rubygems by default]),
|
|
[enable_rubygems="$enableval"], [enable_rubygems=yes])
|
|
AS_IF([test x"$enable_rubygems" = xno], [
|
|
USE_RUBYGEMS=no
|
|
], [
|
|
USE_RUBYGEMS=yes
|
|
])
|
|
AC_SUBST(USE_RUBYGEMS)
|
|
|
|
arch_hdrdir="${EXTOUT}/include/${arch}/ruby"
|
|
AS_MKDIR_P("${arch_hdrdir}")
|
|
config_h="${arch_hdrdir}/config.h"
|
|
guard=INCLUDE_RUBY_CONFIG_H
|
|
{
|
|
echo "#ifndef $guard"
|
|
echo "#define $guard 1"
|
|
grep -v "^#define PACKAGE_" confdefs.h
|
|
echo "#endif /* $guard */"
|
|
} | tr -d '\015' |
|
|
(
|
|
AS_IF([test "x$CONFIGURE_TTY" = xyes], [color=--color], [color=])
|
|
exec ${SHELL} ${tooldir}/ifchange $color "${config_h}" -
|
|
) >&AS_MESSAGE_FD || AC_MSG_ERROR([failed to create ${config_h}])
|
|
tr -d '\015' < largefile.h > confdefs.h
|
|
rm largefile.h
|
|
|
|
BUILTIN_ENCS=["`sed -n -e '/^BUILTIN_ENCS[ ]*=/{' \
|
|
-e s/// -e :l -e '/\\\\$/N' -e 's/\\\\\\n/ /' -e 't l' -e p \
|
|
-e '}' "${srcdir}/enc/Makefile.in"`"]
|
|
BUILTIN_ENCOBJS=
|
|
for e in $BUILTIN_ENCS; do BUILTIN_ENCOBJS="$BUILTIN_ENCOBJS "`echo $e | sed 's/\.c$/.$(OBJEXT)/'`; done
|
|
AC_SUBST(BUILTIN_ENCOBJS)
|
|
|
|
BUILTIN_TRANSES=["`sed -n -e '/^BUILTIN_TRANSES[ ]*=/{' \
|
|
-e s/// -e :l -e '/\\\\$/N' -e 's/\\\\\\n/ /' -e 't l' -e p \
|
|
-e '}' "${srcdir}/enc/Makefile.in"`"]
|
|
BUILTIN_TRANSSRCS=
|
|
BUILTIN_TRANSOBJS=
|
|
for e in $BUILTIN_TRANSES; do
|
|
BUILTIN_TRANSSRCS="$BUILTIN_TRANSSRCS "`echo $e | sed 's/\.trans$/.c/'`
|
|
BUILTIN_TRANSOBJS="$BUILTIN_TRANSOBJS "`echo $e | sed 's/\.trans$/.$(OBJEXT)/'`
|
|
done
|
|
AC_SUBST(BUILTIN_TRANSSRCS)
|
|
AC_SUBST(BUILTIN_TRANSOBJS)
|
|
|
|
PACKAGE=$RUBY_BASE_NAME
|
|
AC_SUBST(PACKAGE)
|
|
AS_MESSAGE([$PACKAGE library version = $ruby_version])
|
|
|
|
AS_IF([test x"$CC_WRAPPER" != x], [
|
|
CC='$(CC_WRAPPER) '"${CC@%:@$CC_WRAPPER }"
|
|
CPP='$(CC_WRAPPER) '"${CPP@%:@$CC_WRAPPER }"
|
|
CC_WRAPPER='$(rubyarchdir)/darwin-cc'
|
|
XCC_WRAPPER='$(top_srcdir)/tool/darwin-cc'
|
|
])
|
|
AC_SUBST(CC_WRAPPER, '')
|
|
AC_SUBST(XCC_WRAPPER)
|
|
|
|
AS_CASE([" $CPP "], [*" $CC "*], [CPP=`echo " $CPP " | sed "s| $CC |"' $(CC) |;s/^ *//;s/ *$//'`])
|
|
|
|
AS_IF([test x"$firstmf" != x], [
|
|
AC_CONFIG_FILES($firstmf:$firsttmpl, [], [firstmf="$firstmf" firsttmpl="$firsttmpl"])
|
|
])
|
|
AC_CONFIG_FILES(Makefile:template/Makefile.in, [
|
|
tmpmk=confmk$$.tmp
|
|
{
|
|
AS_IF([test ${VCS+set}], [
|
|
:
|
|
], [git_dir=`$GIT --work-tree="$srcdir" --git-dir="$srcdir/.git" rev-parse --git-dir 2>/dev/null`], [
|
|
VCS='$(GIT)'
|
|
], [
|
|
VCS='echo cannot'
|
|
])
|
|
AS_CASE("$VCS",
|
|
['$(GIT)'|git], [VCSUP='$(VCS) pull --rebase $(GITPULLOPTIONS)'],
|
|
[VCSUP='$(VCS)'])
|
|
sed -n \
|
|
-e '[/^@%:@define \(RUBY_RELEASE_[A-Z]*\) \([0-9][0-9]*\)/]{' \
|
|
-e 's//\1 = \2/' \
|
|
-e '[s/ \([0-9]\)$/ 0\1/]' \
|
|
-e p \
|
|
-e '}' "$srcdir/version.h"
|
|
sed '/^MISSING/s/\$U\././g;/^VCS *=/s#@VCS@#'"$VCS"'#;/^VCSUP *=/s#@VCSUP@#'"$VCSUP"'#' Makefile
|
|
echo; test x"$EXEEXT" = x || echo 'miniruby: miniruby$(EXEEXT)'
|
|
AS_IF([test "$gnumake" != yes], [
|
|
echo ['$(MKFILES): $(srcdir)/common.mk']
|
|
sed ['s/{\$([^(){}]*)[^{}]*}//g'] ${srcdir}/common.mk
|
|
], [
|
|
echo 'distclean-local::; @$(RM) GNUmakefile uncommon.mk'
|
|
])
|
|
} > $tmpmk && AS_IF([! grep '^ruby:' $tmpmk > /dev/null], [
|
|
AS_IF([test "${gnumake}" = yes], [
|
|
tmpgmk=confgmk$$.tmp
|
|
{
|
|
echo "include $tmpmk"
|
|
echo "-include uncommon.mk"
|
|
} > $tmpgmk
|
|
], [
|
|
tmpgmk=$tmpmk
|
|
]) &&
|
|
test -z "`${MAKE-make} -f $tmpgmk info-program | grep '^PROGRAM=ruby$'`" &&
|
|
echo 'ruby: $(PROGRAM);' >> $tmpmk
|
|
test "$tmpmk" = "$tmpgmk" || rm -f "$tmpgmk"
|
|
]) && mv -f $tmpmk Makefile],
|
|
[EXEEXT='$EXEEXT' MAKE='${MAKE-make}' gnumake='$gnumake' GIT='$GIT'])
|
|
|
|
AC_ARG_WITH([ruby-pc],
|
|
AS_HELP_STRING([--with-ruby-pc=FILENAME], [pc file basename]),
|
|
[ruby_pc="$withval"],
|
|
[ruby_pc="${RUBY_BASE_NAME}-${MAJOR}.${MINOR}.pc"])
|
|
AC_SUBST(ruby_pc)
|
|
AC_SUBST(exec, [exec])
|
|
|
|
AC_ARG_WITH(destdir,
|
|
AS_HELP_STRING([--with-destdir=DESTDIR], [specify default directory to install]),
|
|
[DESTDIR="$withval"])
|
|
AC_SUBST(DESTDIR)
|
|
|
|
AC_OUTPUT
|
|
}
|
|
}
|
|
|
|
AS_IF([test "$silent" = yes], [], [
|
|
AS_IF([${FOLD+:} false], [], [
|
|
AS_IF([test "`echo abcdefg hijklmno | fold -s -w10 | sed 1d`" = hijklmno], [FOLD="fold"], [FOLD=])
|
|
])
|
|
fold_width=`expr $COLUMNS - 30 2>/dev/null` || fold_width=50
|
|
AS_REQUIRE_SHELL_FN([config_summary],
|
|
[AS_FUNCTION_DESCRIBE([config_summary], [NAME, VAL], [configuration summary])],
|
|
[AS_IF([test -z "$2"], [], [
|
|
AS_ECHO_N([" * $1: "]) | dd bs=1 count=26 2>/dev/null
|
|
AS_IF([test "$FOLD"], [
|
|
echo "$2" | fold -s -w$fold_width |
|
|
sed '1!s/^/ /;$!s/$/\\/'
|
|
], [echo "$2"])
|
|
])]
|
|
)
|
|
|
|
AS_IF([test $install_doc = yes],
|
|
[DOCTARGETS=`echo " $RDOCTARGET $CAPITARGET " | sed 's/ nodoc //g;s/^ *//;s/ *$//'`],
|
|
[DOCTARGETS=no])
|
|
echo "---"
|
|
echo "Configuration summary for $RUBY_BASE_NAME version $MAJOR.$MINOR.$TEENY"
|
|
echo ""
|
|
config_summary "Installation prefix" "$prefix"
|
|
config_summary "exec prefix" "$exec_prefix"
|
|
config_summary "arch" "$arch"
|
|
config_summary "site arch" "$sitearch"
|
|
config_summary "RUBY_BASE_NAME" "$RUBY_BASE_NAME"
|
|
config_summary "enable shared" "$enable_shared"
|
|
config_summary "ruby lib prefix" "$rubylibprefix"
|
|
config_summary "site libraries path" "$rubysitearchprefix"
|
|
config_summary "vendor path" "$vendordir"
|
|
config_summary "target OS" "$target_os"
|
|
config_summary "compiler" "$CC"
|
|
config_summary "with pthread" "$enable_pthread"
|
|
config_summary "with coroutine" "$coroutine_type"
|
|
config_summary "enable shared libs" "$ENABLE_SHARED"
|
|
config_summary "dynamic library ext" "$DLEXT"
|
|
config_summary "CFLAGS" "$cflags"
|
|
config_summary "CPPFLAGS" "$cppflags"
|
|
config_summary "LDFLAGS" "$LDFLAGS"
|
|
config_summary "DLDFLAGS" "$DLDFLAGS"
|
|
config_summary "optflags" "$optflags"
|
|
config_summary "debugflags" "$debugflags"
|
|
config_summary "warnflags" "$warnflags"
|
|
config_summary "strip command" "$STRIP"
|
|
config_summary "install doc" "$DOCTARGETS"
|
|
config_summary "JIT support" "$MJIT_SUPPORT"
|
|
config_summary "man page type" "$MANTYPE"
|
|
config_summary "search path" "$search_path"
|
|
config_summary "static-linked-ext" ${EXTSTATIC:+"yes"}
|
|
config_summary "BASERUBY -v" "$BASERUBY_VERSION"
|
|
echo ""
|
|
echo "---"
|
|
])
|