mirror of
https://github.com/ruby/ruby.git
synced 2022-11-09 12:17:21 -05:00
f0371f2f28
pthread.h only when pthread. [ruby-core:23577] git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@23601 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2568 lines
74 KiB
Text
2568 lines
74 KiB
Text
dnl Process this file with autoconf to produce a configure script.
|
|
dnl {
|
|
AC_INIT()
|
|
AC_CONFIG_AUX_DIR(tool)
|
|
|
|
AC_PREREQ(2.60)
|
|
|
|
AC_DEFUN([RUBY_PREREQ_AC],
|
|
[m4_if(m4_version_compare(m4_defn([m4_PACKAGE_VERSION]), [$1]), [-1],
|
|
AC_MSG_ERROR([Autoconf version ]$1[ or higher is required]$2))])
|
|
|
|
AC_DEFUN([when], dnl [(] makes parentheses balanced.
|
|
dnl note that spaces after comma need to be quoted.
|
|
[[$*]][)])
|
|
|
|
dnl environment section {
|
|
|
|
AC_ARG_WITH(baseruby,
|
|
AS_HELP_STRING([--with-baseruby=RUBY], [ use RUBY as baseruby; RUBY is the pathname of ruby]),
|
|
[
|
|
case "$withval" in
|
|
when(*ruby*)
|
|
BASERUBY=$withval
|
|
;;
|
|
when(*)
|
|
AC_MSG_ERROR(need ruby)
|
|
;;
|
|
esac
|
|
],
|
|
[
|
|
BASERUBY="ruby"
|
|
])
|
|
test "`RUBYOPT=- $BASERUBY -e 'p 42' 2>/dev/null`" = 42 ||
|
|
BASERUBY="echo executable host ruby is required. use --with-baseruby option.; false"
|
|
AC_SUBST(BASERUBY)
|
|
|
|
AC_DEFUN([RUBY_MINGW32],
|
|
[case "$host_os" in
|
|
when(cygwin*)
|
|
AC_CACHE_CHECK(for mingw32 environment, rb_cv_mingw32,
|
|
[AC_TRY_CPP([
|
|
#ifndef __MINGW32__
|
|
# error
|
|
#endif
|
|
], rb_cv_mingw32=yes,rb_cv_mingw32=no)
|
|
rm -f conftest*])
|
|
test "$rb_cv_mingw32" = yes && target_os="mingw32"
|
|
;;
|
|
esac])
|
|
|
|
AC_DEFUN([RUBY_CPPOUTFILE],
|
|
[AC_CACHE_CHECK(whether ${CPP} accepts -o, rb_cv_cppoutfile,
|
|
[cppflags=$CPPFLAGS
|
|
CPPFLAGS='-o conftest.i'
|
|
AC_TRY_CPP([], rb_cv_cppoutfile=yes, rb_cv_cppoutfile=no)
|
|
CPPFLAGS=$cppflags
|
|
rm -f conftest*])
|
|
if test "$rb_cv_cppoutfile" = yes; then
|
|
CPPOUTFILE='-o conftest.i'
|
|
elif test "$rb_cv_cppoutfile" = no; then
|
|
CPPOUTFILE='> conftest.i'
|
|
elif test -n "$rb_cv_cppoutfile"; then
|
|
CPPOUTFILE="$rb_cv_cppoutfile"
|
|
fi
|
|
AC_SUBST(CPPOUTFILE)])
|
|
|
|
AC_DEFUN([RUBY_PROG_GNU_LD],
|
|
[AC_CACHE_CHECK(whether the linker is GNU ld, rb_cv_prog_gnu_ld,
|
|
[if `$CC $CFLAGS $CPPFLAGS $LDFLAGS --print-prog-name=ld 2>&1` -v 2>&1 | grep "GNU ld" > /dev/null; then
|
|
rb_cv_prog_gnu_ld=yes
|
|
else
|
|
rb_cv_prog_gnu_ld=no
|
|
fi
|
|
])
|
|
GNU_LD=$rb_cv_prog_gnu_ld
|
|
AC_SUBST(GNU_LD)])
|
|
|
|
eval `sed -n 's/^#define RUBY_VERSION_\([A-Z][A-Z_0-9]*\) \([0-9][0-9]*\)/\1=\2/p' $srcdir/version.h`
|
|
for v in MAJOR MINOR TEENY; do
|
|
if eval "test \"\$$v\" = ''"; then
|
|
AC_MSG_ERROR(could not determine $v number from version.h)
|
|
fi
|
|
done
|
|
AC_SUBST(MAJOR)
|
|
AC_SUBST(MINOR)
|
|
AC_SUBST(TEENY)
|
|
if test "$MAJOR" = "1"; then
|
|
AC_DEFINE(CANONICALIZATION_FOR_MATHN)
|
|
fi
|
|
dnl checks for alternative programs
|
|
AC_ARG_WITH(gcc,
|
|
AS_HELP_STRING([--without-gcc], [never use gcc]),
|
|
[
|
|
case $withval in
|
|
when(no)
|
|
: ${CC=cc}
|
|
;;
|
|
when(yes)
|
|
: ${CC=gcc}
|
|
;;
|
|
when(*)
|
|
CC=$withval
|
|
;;
|
|
esac])
|
|
dnl If the user switches compilers, we can't believe the cache
|
|
if test ! -z "$ac_cv_prog_CC" -a ! -z "$CC" -a "$CC" != "$ac_cv_prog_CC"
|
|
then
|
|
AC_MSG_ERROR(cached CC is different -- throw away $cache_file
|
|
(it is also a good idea to do 'make clean' before compiling))
|
|
fi
|
|
|
|
if test "$program_prefix" = NONE; then
|
|
program_prefix=
|
|
fi
|
|
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_CANONICAL_TARGET
|
|
target_os=`echo $target_os | sed 's/linux-gnu$/linux/;s/linux-gnu/linux-/'`
|
|
ac_install_sh='' # unusable for extension libraries.
|
|
|
|
AC_DEFUN([RUBY_APPEND_OPTION],
|
|
[case " [$]{$1-} " in # RUBY_APPEND_OPTION($1, $2)
|
|
when(*' $2 '*);; when(' ') $1="$2";; when(*) $1="[$]$1 $2";;
|
|
esac])
|
|
AC_DEFUN([RUBY_APPEND_OPTIONS],
|
|
[{ for rb_opt in $2; do # RUBY_APPEND_OPTIONS($1, $2)
|
|
case " [$]{$1-} " in
|
|
when(*" [$]{rb_opt} "*);; when(' ') $1="[$]{rb_opt}";; when(*) $1="[$]$1 [$]{rb_opt}";;
|
|
esac
|
|
done; }])
|
|
AC_DEFUN([RUBY_PREPEND_OPTION],
|
|
[case " [$]{$1-} " in # RUBY_PREPEND_OPTION($1, $2)
|
|
when(*' $2 '*);; when(' ') $1="$2";; when(*) $1="$2 [$]$1";;
|
|
esac])
|
|
AC_DEFUN([RUBY_PREPEND_OPTIONS],
|
|
[{ unset rb_opts; for rb_opt in $2; do # RUBY_PREPEND_OPTIONS($1, $2)
|
|
case " [$]{rb_opts} [$]{$1-} " in
|
|
when(*" [$]{rb_opt} "*);; when(' ') $1="[$]{rb_opt}";; when(*) rb_opts="[$]{rb_opts}[$]{rb_opt} ";;
|
|
esac
|
|
done
|
|
$1="[$]{rb_opts}[$]$1"; }])
|
|
|
|
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])
|
|
test ${CFLAGS+set} && CFLAGS=`echo "$CFLAGS" | sed 's/ *-arch *[^ ]*//g'`
|
|
test ${LDFLAGS+set} && LDFLAGS=`echo "$LDFLAGS" | sed 's/ *-arch *[^ ]*//g'`
|
|
unset ARCH_FLAG universal_binary universal_archnames
|
|
if test ${target_archs+set}; then
|
|
AC_MSG_CHECKING([target architectures])
|
|
target_archs=`echo $target_archs | tr , ' '`
|
|
# /usr/lib/arch_tool -archify_list $TARGET_ARCHS
|
|
for archs in $target_archs
|
|
do
|
|
case ",$universal_binary," in
|
|
when(*",$archs,"*)
|
|
;;
|
|
when(*)
|
|
cpu=`$SHELL "$ac_aux_dir/config.sub" "${archs}-${target_os}" 2>&1` || {
|
|
AC_MSG_RESULT([failed])
|
|
AC_MSG_ERROR([$cpu])
|
|
}
|
|
cpu=`echo $cpu | sed 's/-.*-.*//'`
|
|
universal_binary="${universal_binary+$universal_binary,}$cpu"
|
|
universal_archnames="${universal_archnames} ${archs}=${cpu}"
|
|
ARCH_FLAG="${ARCH_FLAG+$ARCH_FLAG }-arch $archs"
|
|
;;
|
|
esac
|
|
done
|
|
target_archs="$universal_binary"
|
|
unset universal_binary
|
|
case "$target_archs" in
|
|
when(*,*) universal_binary=yes;;
|
|
when(*) unset universal_archnames;;
|
|
esac
|
|
AC_MSG_RESULT([$target_archs])
|
|
|
|
if test "${universal_binary-no}" = yes; then
|
|
RUBY_PREREQ_AC(2.63, [ to compile universal binary])
|
|
AC_SUBST(try_header,try_compile)
|
|
target=`echo $target | sed "s/^$target_cpu-/universal-/"`
|
|
target_alias=`echo $target_alias | sed "s/^$target_cpu-/universal-/"`
|
|
target_cpu=universal
|
|
else
|
|
target=`echo $target | sed "s/^$target_cpu-/${target_archs}-/"`
|
|
target_alias=`echo $target_alias | sed "s/^$target_cpu-/${target_archs}-/"`
|
|
target_cpu=${target_archs}
|
|
fi
|
|
CFLAGS="$CFLAGS ${ARCH_FLAG}"
|
|
LDFLAGS="${LDFLAGS+$LDFLAGS }${ARCH_FLAG}"
|
|
else
|
|
target_archs="$target_cpu"
|
|
fi
|
|
|
|
case $target_cpu in
|
|
when(i?86) frame_address=yes;;
|
|
when(*) frame_address=no;;
|
|
esac
|
|
AC_ARG_ENABLE(frame-address,
|
|
AS_HELP_STRING([--enable-frame-address], [use GCC __builtin_frame_address()]),
|
|
[frame_address=$enableval])
|
|
if test $frame_address = yes; then
|
|
AC_DEFINE(USE_BUILTIN_FRAME_ADDRESS)
|
|
fi
|
|
|
|
AC_ARG_ENABLE(load-relative,
|
|
AS_HELP_STRING([--enable-load-relative], [resolve load paths at run time]),
|
|
[load_relative=$enableval])
|
|
|
|
AC_ARG_PROGRAM
|
|
|
|
dnl Checks for programs.
|
|
|
|
if test -z "${CFLAGS+set}"; then
|
|
orig_cflags="$cflags"
|
|
cflags="$cflags "'${optflags} ${debugflags} ${warnflags}'
|
|
fi
|
|
if test -z "${CXXFLAGS+set}"; then
|
|
orig_cxxflags="$cxxflags"
|
|
cxxflags="$cxxflags "'${optflags} ${debugflags} ${warnflags}'
|
|
fi
|
|
|
|
if test x"${build}" != x"${host}"; then
|
|
AC_CHECK_TOOL(CC, gcc)
|
|
fi
|
|
AC_PROG_CC
|
|
AC_PROG_CXX
|
|
AC_PROG_GCC_TRADITIONAL
|
|
test $ac_cv_prog_cc_g = yes && : ${debugflags=-g}
|
|
if test "$GCC" = yes; then
|
|
linker_flag=-Wl,
|
|
: ${optflags=-O3}
|
|
else
|
|
linker_flag=
|
|
fi
|
|
|
|
RUBY_PROG_GNU_LD
|
|
RUBY_CPPOUTFILE
|
|
|
|
: ${OUTFLAG='-o '}
|
|
: ${COUTFLAG=${OUTFLAG}}
|
|
AC_SUBST(OUTFLAG)
|
|
AC_SUBST(COUTFLAG)
|
|
|
|
RUBY_MINGW32
|
|
|
|
AC_CHECK_TOOL(RANLIB, ranlib, :)
|
|
AC_CHECK_TOOL(AR, ar)
|
|
if test -z "$AR"; then
|
|
AC_CHECK_PROGS(AR, aal, ar)
|
|
fi
|
|
|
|
AC_CHECK_TOOL(AS, as)
|
|
ASFLAGS=$ASFLAGS
|
|
AC_SUBST(ASFLAGS)
|
|
|
|
case "$target_os" in
|
|
when(cygwin*|mingw*|darwin*)
|
|
ac_cv_prog_ac_ct_OBJCOPY=":";;
|
|
esac
|
|
|
|
# BSD's ports and MacPorts prefix GNU binutils with 'g'
|
|
AC_CHECK_TOOLS(OBJDUMP, [objdump gobjdump])
|
|
AC_CHECK_TOOLS(OBJCOPY, [objcopy gobjcopy])
|
|
|
|
case "$target_os" in
|
|
when(cygwin*|mingw*)
|
|
AC_CHECK_TOOL(NM, nm)
|
|
AC_CHECK_TOOL(WINDRES, windres)
|
|
AC_CHECK_TOOL(DLLWRAP, dllwrap)
|
|
target_cpu=`echo $target_cpu | sed s/i.86/i386/`
|
|
case "$target_os" in
|
|
when(mingw*)
|
|
test "$rb_cv_msvcrt" = "" && unset rb_cv_msvcrt
|
|
AC_CACHE_CHECK(for mingw32 runtime DLL, rb_cv_msvcrt, [
|
|
AC_TRY_LINK([#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;}'`],
|
|
[rb_cv_msvcrt=msvcrt])
|
|
test "$rb_cv_msvcrt" = "" && rb_cv_msvcrt=msvcrt])
|
|
esac
|
|
: ${enable_shared=yes}
|
|
;;
|
|
when(aix*)
|
|
AC_CHECK_TOOL(NM, nm, /usr/ccs/bin/nm, /usr/ccs/bin:$PATH)
|
|
;;
|
|
when(hiuxmpp*)
|
|
# by TOYODA Eizi <toyoda@npd.kishou.go.jp>
|
|
AC_DEFINE(__HIUX_MPP__)
|
|
;;
|
|
esac
|
|
|
|
AC_PROG_LN_S
|
|
AC_PROG_MAKE_SET
|
|
AC_PROG_INSTALL
|
|
|
|
# checks for UNIX variants that set C preprocessor variables
|
|
AC_USE_SYSTEM_EXTENSIONS
|
|
|
|
AC_SUBST(RM, ['rm -f'])
|
|
AC_SUBST(CP, ['cp'])
|
|
if $as_mkdir_p; then
|
|
MAKEDIRS='mkdir -p'
|
|
else
|
|
MAKEDIRS='install -d'
|
|
fi
|
|
AC_SUBST(MAKEDIRS)
|
|
AC_SUBST(RMDIRS, ['$(top_srcdir)/tool/rmdirs'])
|
|
AC_SUBST(RMALL, ['rm -fr'])
|
|
|
|
AC_MSG_CHECKING([for cd using phisical 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)
|
|
if test -e conf$$.dir/src/cdcmd; then
|
|
read CHDIR < conf$$.dir/src/cdcmd 2> /dev/null
|
|
else
|
|
CHDIR=cd
|
|
fi
|
|
rm -fr conf$$.dir
|
|
AC_MSG_RESULT([$CHDIR])
|
|
AC_SUBST(CHDIR)
|
|
|
|
dnl }
|
|
dnl compiler section {
|
|
|
|
if test "$GCC:${warnflags+set}:no" = yes::no; then
|
|
save_CFLAGS="$CFLAGS"
|
|
for wflag in -Wno-missing-field-initializers -Wshorten-64-to-32; do
|
|
CFLAGS="$CFLAGS $wflag"
|
|
AC_MSG_CHECKING([whether $wflag is accepted])
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([])],
|
|
[warnflags="${warnflags+$warnflags }$wflag"
|
|
AC_MSG_RESULT(yes)],
|
|
[AC_MSG_RESULT(no)])
|
|
done
|
|
CFLAGS="$save_CFLAGS"
|
|
unset save_CFLAGS
|
|
warnflags="-Wall -Wno-unused-parameter -Wno-parentheses ${warnflags+$warnflags }-Wpointer-arith -Wwrite-strings"
|
|
fi
|
|
|
|
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\""
|
|
|
|
dnl check for large file stuff
|
|
mv confdefs.h confdefs1.h
|
|
: > confdefs.h
|
|
AC_SYS_LARGEFILE
|
|
mv confdefs.h largefile.h
|
|
mv confdefs1.h confdefs.h
|
|
cat largefile.h >> confdefs.h
|
|
|
|
case "$target_os" in
|
|
when(mingw*)
|
|
ac_cv_type_off_t=yes
|
|
ac_cv_sizeof_off_t=8
|
|
;;
|
|
esac
|
|
|
|
AC_CHECK_TYPES([long long, off_t])
|
|
|
|
AC_CACHE_CHECK([char bit], [rb_cv_char_bit],
|
|
[_AC_COMPUTE_INT_COMPILE([CHAR_BIT], [rb_cv_char_bit],
|
|
[AC_INCLUDES_DEFAULT([@%:@include <limits.h>])], [rb_cv_char_bit=8])])
|
|
|
|
dnl RUBY_CHECK_SIZEOF [typename], [maybe same size types], [macros], [include]
|
|
AC_DEFUN([RUBY_CHECK_SIZEOF],
|
|
[m4_bmatch([$1], [\.], [], [if test "$universal_binary" = yes; then])
|
|
AC_CACHE_CHECK([size of $1], [AS_TR_SH([ac_cv_sizeof_$1])], [
|
|
unset AS_TR_SH(ac_cv_sizeof_$1)
|
|
rbcv_var="
|
|
typedef m4_bpatsubst([$1], [\..*]) ac__type_sizeof_;
|
|
static ac__type_sizeof_ *rbcv_ptr;
|
|
@%:@define AS_TR_CPP(SIZEOF_$1) sizeof((*rbcv_ptr)[]m4_bmatch([$1], [\.], .m4_bpatsubst([$1], [^[^.]*\.])))
|
|
"
|
|
m4_ifval([$2], [test -z "${AS_TR_SH(ac_cv_sizeof_$1)+set}" && {
|
|
for t in $2; do
|
|
AC_COMPILE_IFELSE(
|
|
[AC_LANG_BOOL_COMPILE_TRY(AC_INCLUDES_DEFAULT([$4]
|
|
[$rbcv_var]),
|
|
[AS_TR_CPP(SIZEOF_$1) == sizeof($t)])], [
|
|
AS_TR_SH(ac_cv_sizeof_$1)=AS_TR_CPP([SIZEOF_]$t)
|
|
break])
|
|
done
|
|
}])
|
|
unset cond
|
|
m4_ifval([$3], [test -z "${AS_TR_SH(ac_cv_sizeof_$1)+set}" && {
|
|
for s in 32 64 128; do
|
|
for t in $3; do
|
|
cond="${cond}
|
|
@%:@${cond+el}if defined(__${t}${s}__) || defined(__${t}${s}) || defined(_${t}${s}) || defined(${t}${s})"
|
|
hdr="AC_INCLUDES_DEFAULT([$4
|
|
@%:@if defined(__${t}${s}__) || defined(__${t}${s}) || defined(_${t}${s}) || defined(${t}${s})
|
|
@%:@ define AS_TR_CPP(HAVE_$1) 1
|
|
@%:@else
|
|
@%:@ define AS_TR_CPP(HAVE_$1) 0
|
|
@%:@endif])"
|
|
AC_COMPILE_IFELSE([AC_LANG_BOOL_COMPILE_TRY([$hdr], [!AS_TR_CPP(HAVE_$1)])], [continue])
|
|
AC_COMPILE_IFELSE([AC_LANG_BOOL_COMPILE_TRY([$hdr]
|
|
[$rbcv_var],
|
|
[AS_TR_CPP(HAVE_$1) == (AS_TR_CPP(SIZEOF_$1) == ([$[s / rb_cv_char_bit]]))])],
|
|
[AS_TR_SH(ac_cv_sizeof_$1)="${AS_TR_SH(ac_cv_sizeof_$1)+${AS_TR_SH(ac_cv_sizeof_$1)-} }${t}${s}"])
|
|
done
|
|
done
|
|
}])
|
|
m4_ifval([$2][$3], [case "${AS_TR_SH(ac_cv_sizeof_$1)}" in
|
|
when([SIZEOF_*]);;
|
|
when(*)])
|
|
_AC_COMPUTE_INT_COMPILE(AS_TR_CPP(SIZEOF_$1), [t], [AC_INCLUDES_DEFAULT([$4])]
|
|
[${cond+$cond
|
|
@%:@else}
|
|
$rbcv_var
|
|
${cond+@%:@endif}
|
|
@%:@ifndef AS_TR_CPP(SIZEOF_$1)
|
|
@%:@define AS_TR_CPP(SIZEOF_$1) 0
|
|
@%:@endif], [unset t])
|
|
if test ${t-0} != 0; then
|
|
AS_TR_SH(ac_cv_sizeof_$1)="${AS_TR_SH(ac_cv_sizeof_$1)+${AS_TR_SH(ac_cv_sizeof_$1)-} }${t}"
|
|
fi
|
|
m4_ifval([$2][$3], [;; esac])
|
|
: ${AS_TR_SH(ac_cv_sizeof_$1)=0}
|
|
])
|
|
{
|
|
unset cond
|
|
for t in ${AS_TR_SH(ac_cv_sizeof_$1)-}; do
|
|
case "$t" in
|
|
when([[0-9]*|SIZEOF_*])
|
|
${cond+echo "@%:@else"}
|
|
echo "[@%:@define ]AS_TR_CPP(SIZEOF_$1) [$t]"
|
|
break
|
|
;;
|
|
when([*])
|
|
s=`expr $t : ['.*[^0-9]\([0-9][0-9]*\)$']`
|
|
echo "@%:@${cond+el}if defined(__${t}__) || defined(__${t}) || defined(_${t}) || defined($t)"
|
|
echo "@%:@define AS_TR_CPP(SIZEOF_$1) [$[s / rb_cv_char_bit]]"
|
|
cond=1
|
|
;;
|
|
esac
|
|
done
|
|
${cond+echo "@%:@endif"}
|
|
} >> confdefs.h
|
|
m4_bmatch([$1], [\.], [], [else
|
|
AC_CHECK_SIZEOF([$1], 0, [$4])
|
|
fi])
|
|
])
|
|
|
|
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)
|
|
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>])
|
|
|
|
dnl RUBY_REPLACE_TYPE [typename] [default type] [macro type] [included]
|
|
AC_DEFUN([RUBY_REPLACE_TYPE], [dnl
|
|
AC_CHECK_TYPE([$1], [n=[$1]], [n=[$2]], [$4])
|
|
AC_CACHE_CHECK([for convertible type of [$1]], rb_cv_[$1]_convertible, [
|
|
u= t=
|
|
case "$n " in
|
|
when(*" signed "*) ;;
|
|
when(*" unsigned "*)
|
|
u=U;;
|
|
when(*)
|
|
AC_COMPILE_IFELSE(
|
|
[AC_LANG_BOOL_COMPILE_TRY([AC_INCLUDES_DEFAULT([$4])], [($n)-1 > 0])],
|
|
[u=U]);;
|
|
esac
|
|
if test x"$t" = x; then
|
|
for t in "long long" long int short; do
|
|
test -n "$u" && t="unsigned $t"
|
|
AC_COMPILE_IFELSE(
|
|
[AC_LANG_BOOL_COMPILE_TRY([AC_INCLUDES_DEFAULT([$4])]
|
|
[typedef $n rbcv_conftest_target_type;
|
|
typedef $t rbcv_conftest_replace_type;
|
|
extern rbcv_conftest_target_type rbcv_conftest_var;
|
|
extern rbcv_conftest_replace_type rbcv_conftest_var;
|
|
extern rbcv_conftest_target_type rbcv_conftest_func(void);
|
|
extern rbcv_conftest_replace_type rbcv_conftest_func(void);
|
|
], [sizeof(rbcv_conftest_target_type) == sizeof(rbcv_conftest_replace_type)])],
|
|
[n="$t"; break])
|
|
done
|
|
fi
|
|
case " $n " in
|
|
when(*" long long "*)
|
|
t=LL;;
|
|
when(*" long "*)
|
|
t=LONG;;
|
|
when(*)
|
|
t=INT;;
|
|
esac
|
|
rb_cv_[$1]_convertible=${u}${t}])
|
|
m4_ifval([$2], AC_DEFINE_UNQUOTED(rb_[$1], $n))
|
|
AC_DEFINE_UNQUOTED([$3]2NUM[(v)], [${rb_cv_[$1]_convertible}2NUM(v)])
|
|
AC_DEFINE_UNQUOTED(NUM2[$3][(v)], [NUM2${rb_cv_[$1]_convertible}(v)])
|
|
AC_DEFINE_UNQUOTED(PRI_[$3]_PREFIX,
|
|
["`echo ${rb_cv_[$1]_convertible} | sed ['s/^U//;s/[^L].*//;y/L/l/']`"])
|
|
])
|
|
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>])
|
|
|
|
AC_CACHE_CHECK(for prototypes, rb_cv_have_prototypes,
|
|
[AC_TRY_COMPILE([int foo(int x) { return 0; }], [return foo(10);],
|
|
rb_cv_have_prototypes=yes,
|
|
rb_cv_have_prototypes=no)])
|
|
if test "$rb_cv_have_prototypes" = yes; then
|
|
AC_DEFINE(HAVE_PROTOTYPES)
|
|
fi
|
|
|
|
AC_CACHE_CHECK(token paste string, rb_cv_tokenpaste,
|
|
[AC_TRY_COMPILE([#define paste(a,b) a##b],
|
|
[int xy = 1; return paste(x,y);],
|
|
rb_cv_tokenpaste=ansi,
|
|
rb_cv_tokenpaste=knr)])
|
|
if test "$rb_cv_tokenpaste" = ansi; then
|
|
AC_DEFINE(TOKEN_PASTE(x,y),[x##y])
|
|
else
|
|
AC_DEFINE(TOKEN_PASTE(x,y),[x/**/y])
|
|
fi
|
|
|
|
AC_CACHE_CHECK(stringization, rb_cv_stringization, [
|
|
rb_cv_stringization=no
|
|
for string in "#expr" '"expr"'; do
|
|
AC_COMPILE_IFELSE([
|
|
AC_LANG_BOOL_COMPILE_TRY([
|
|
#define STRINGIZE0(expr) $string
|
|
#define STRINGIZE(expr) STRINGIZE0(expr)
|
|
#undef real_test_for_stringization
|
|
#define test_for_stringization -.real_test_for_stringization.-
|
|
const char stringized[[]] = STRINGIZE(test_for_stringization);
|
|
], [sizeof(stringized) == 32])],
|
|
[rb_cv_stringization="$string"; break],
|
|
[rb_cv_stringization=no])
|
|
done]
|
|
)
|
|
AC_DEFINE(STRINGIZE(expr),STRINGIZE0(expr))
|
|
if test x"$rb_cv_stringization" != xno -a "$rb_cv_stringization" != "#expr"; then
|
|
AC_DEFINE_UNQUOTED(STRINGIZE0(expr),$rb_cv_stringization)
|
|
AC_DEFINE(OLD_FASHIONED_STRINGIZATION,1)
|
|
fi
|
|
|
|
AC_CACHE_CHECK([string literal concatenation],
|
|
rb_cv_string_literal_concatenation, [
|
|
AC_COMPILE_IFELSE([
|
|
AC_LANG_BOOL_COMPILE_TRY([
|
|
const char concatenated_literal[[]] = "literals" "to"
|
|
"be" "concatenated.";
|
|
], [sizeof(concatenated_literal) == 26])],
|
|
[rb_cv_string_literal_concatenation=yes],
|
|
[rb_cv_string_literal_concatenation=no])]
|
|
)
|
|
if test "$rb_cv_string_literal_concatenation" = no; then
|
|
AC_DEFINE(NO_STRING_LITERAL_CONCATENATION,1)
|
|
fi
|
|
|
|
AC_CACHE_CHECK(for variable length prototypes and stdarg.h, rb_cv_stdarg,
|
|
[AC_TRY_COMPILE([
|
|
#include <stdarg.h>
|
|
int foo(int x, ...) {
|
|
va_list va;
|
|
va_start(va, x);
|
|
va_arg(va, int);
|
|
va_arg(va, char *);
|
|
va_arg(va, double);
|
|
return 0;
|
|
}
|
|
], [return foo(10, "", 3.14);],
|
|
rb_cv_stdarg=yes,
|
|
rb_cv_stdarg=no)])
|
|
if test "$rb_cv_stdarg" = yes; then
|
|
AC_DEFINE(HAVE_STDARG_PROTOTYPES)
|
|
fi
|
|
|
|
AC_CACHE_CHECK(for variable length macro, rb_cv_va_args_macro,
|
|
[AC_TRY_COMPILE([@%:@define FOO(a, ...) foo(a, @%:@@%:@__VA_ARGS__)],
|
|
[FOO(1);FOO(1,2);FOO(1,2,3);],
|
|
rb_cv_va_args_macro=yes,
|
|
rb_cv_va_args_macro=no)])
|
|
if test "$rb_cv_va_args_macro" = yes; then
|
|
AC_DEFINE(HAVE_VA_ARGS_MACRO)
|
|
fi
|
|
|
|
AC_DEFUN([RUBY_DEFINE_IF], [dnl
|
|
m4_ifval([$1],[test "$1" && cat <<EOH >> confdefs.h
|
|
@%:@if $1
|
|
EOH
|
|
])dnl
|
|
AC_DEFINE_UNQUOTED($2, $3)
|
|
m4_ifval([$1],[test "$1" && cat <<EOH >> confdefs.h
|
|
@%:@endif /* $1 */
|
|
EOH
|
|
])dnl
|
|
])dnl
|
|
|
|
AC_DEFUN([RUBY_FUNC_ATTRIBUTE], [dnl
|
|
m4_ifval([$2], dnl
|
|
[AS_VAR_PUSHDEF([attrib],[$2])], dnl
|
|
[AS_VAR_PUSHDEF([attrib],[FUNC_]AS_TR_CPP($1))] dnl
|
|
)dnl
|
|
m4_ifval([$3], dnl
|
|
[AS_VAR_PUSHDEF([rbcv],[$3])], dnl
|
|
[AS_VAR_PUSHDEF([rbcv],[rb_cv_func_][$1])]dnl
|
|
)dnl
|
|
m4_ifval([$4], [rbcv_cond=[$4]; test "$rbcv_cond" || unset rbcv_cond])
|
|
AC_CACHE_CHECK(for [$1] function attribute, rbcv,
|
|
[rbcv=x
|
|
if test "${ac_c_werror_flag+set}"; then
|
|
rb_c_werror_flag="$ac_c_werror_flag"
|
|
else
|
|
unset rb_c_werror_flag
|
|
fi
|
|
ac_c_werror_flag=yes
|
|
for mac in "__attribute__ (($1)) x" "x __attribute__ (($1))" "__declspec($1) x" x; do
|
|
m4_ifval([$4],mac="$mac"${rbcv_cond+" /* only if $rbcv_cond */"})
|
|
AC_TRY_COMPILE(
|
|
m4_ifval([$4],${rbcv_cond+[@%:@if ]$rbcv_cond})
|
|
[@%:@define ]attrib[(x) $mac]
|
|
m4_ifval([$4],${rbcv_cond+[@%:@else]}
|
|
${rbcv_cond+[@%:@define ]attrib[(x) x]}
|
|
${rbcv_cond+[@%:@endif]})
|
|
attrib[(void conftest_attribute_check(void));], [],
|
|
[rbcv="$mac"; break])
|
|
done
|
|
if test "${rb_c_werror_flag+set}"; then
|
|
ac_c_werror_flag="$rb_c_werror_flag"
|
|
else
|
|
unset ac_c_werror_flag
|
|
fi
|
|
])
|
|
if test "$rbcv" != x; then
|
|
RUBY_DEFINE_IF([${rbcv_cond}], attrib[(x)], $rbcv)
|
|
fi
|
|
AS_VAR_POPDEF([attrib])
|
|
AS_VAR_POPDEF([rbcv])
|
|
])
|
|
|
|
RUBY_FUNC_ATTRIBUTE(noreturn, NORETURN)
|
|
RUBY_FUNC_ATTRIBUTE(deprecated, DEPRECATED)
|
|
RUBY_FUNC_ATTRIBUTE(noinline, NOINLINE)
|
|
|
|
if_i386=${universal_binary+[defined __i386__]}
|
|
RUBY_FUNC_ATTRIBUTE(stdcall, [], [], ${if_i386})
|
|
RUBY_FUNC_ATTRIBUTE(cdecl, [], [], ${if_i386})
|
|
RUBY_FUNC_ATTRIBUTE(fastcall, [], [], ${if_i386})
|
|
|
|
if test "$GCC" = yes; then
|
|
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_TRY_LINK([void foo(void) {}
|
|
void bar(void) __attribute__(($a("foo")));], [bar()],
|
|
[rb_cv_gcc_function_alias=$a; break])
|
|
done])
|
|
if test "$rb_cv_gcc_function_alias" != no; then
|
|
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)])
|
|
fi
|
|
fi
|
|
|
|
AC_CACHE_CHECK([for RUBY_EXTERN], rb_cv_ruby_extern,
|
|
[rb_cv_ruby_extern=no
|
|
for mac in "__attribute__((dllimport))" "__declspec(dllimport)"; do
|
|
AC_TRY_COMPILE(
|
|
[extern $mac void conftest(void);],
|
|
[rb_cv_ruby_extern="extern $mac"; break])
|
|
done])
|
|
test "x$rb_cv_ruby_extern" = xno || AC_DEFINE_UNQUOTED(RUBY_EXTERN, $rb_cv_ruby_extern)
|
|
|
|
RUBY_APPEND_OPTION(XCFLAGS, -DRUBY_EXPORT)
|
|
|
|
dnl }
|
|
dnl header and library section {
|
|
|
|
dnl Check whether we need to define sys_nerr locally
|
|
AC_CHECK_DECLS([sys_nerr], [], [], [$ac_includes_default
|
|
#include <errno.h>])
|
|
|
|
AC_ARG_ENABLE(win95,
|
|
AS_HELP_STRING([--enable-win95], [enable Windows 95 series support]),
|
|
[case "$enableval" in
|
|
when(yes|no) enable_win95=$enableval;;
|
|
when(*) unset enable_win95;;
|
|
esac])
|
|
|
|
case "$target_os" in
|
|
when(freebsd*)
|
|
AC_CACHE_CHECK([whether pthread should be enabled by default],
|
|
rb_cv_enable_pthread_default,
|
|
[AC_TRY_CPP([
|
|
#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_default=$rb_cv_enable_pthread_default
|
|
;;
|
|
when(mingw*)
|
|
enable_pthread_default=no
|
|
;;
|
|
when(*)
|
|
enable_pthread_default=yes
|
|
;;
|
|
esac
|
|
|
|
AC_ARG_ENABLE(pthread,
|
|
AS_HELP_STRING([--enable-pthread], [use pthread library]),
|
|
[enable_pthread=$enableval], [enable_pthread=$enable_pthread_default])
|
|
|
|
dnl Checks for libraries.
|
|
case "$target_os" in
|
|
when(*bsd*|dragonfly*)
|
|
;;
|
|
when(*)
|
|
ac_cv_func_daemon=no
|
|
;;
|
|
esac
|
|
|
|
case "$target_os" in
|
|
when(nextstep*) ;;
|
|
when(openstep*) ;;
|
|
when(rhapsody*) ;;
|
|
when(darwin*) RUBY_PREPEND_OPTION(LIBS, -lobjc)
|
|
RUBY_APPEND_OPTIONS(CPPFLAGS, -D_XOPEN_SOURCE -D_DARWIN_C_SOURCE)
|
|
AC_MSG_CHECKING(whether Mac OS X 10.5 or later)
|
|
AC_TRY_CPP([#include <AvailabilityMacros.h>
|
|
#if MAC_OS_X_VERSION_MAX_ALLOWED <= 1040
|
|
#error pre OS X 10.4
|
|
[!<===== pre OS X 10.4 =====>]
|
|
#endif
|
|
],
|
|
[macosx_10_5=yes], [macosx_10_5=no])
|
|
AC_MSG_RESULT($macosx_10_5)
|
|
if test $macosx_10_5 = yes; then
|
|
ac_cv_header_ucontext_h=no
|
|
else
|
|
AC_DEFINE(BROKEN_SETREUID, 1)
|
|
AC_DEFINE(BROKEN_SETREGID, 1)
|
|
fi
|
|
ac_cv_type_getgroups=gid_t # getgroups() on Rosetta fills garbage
|
|
ac_cv_lib_crypt_crypt=no
|
|
AC_CACHE_CHECK(for broken crypt with 8bit chars, rb_cv_broken_crypt,
|
|
[AC_TRY_RUN([
|
|
#include <stdio.h>
|
|
#include <unistd.h>
|
|
#include <string.h>
|
|
int
|
|
main()
|
|
{
|
|
char buf[256];
|
|
strcpy(buf, crypt("", "\xE0\xA0"));
|
|
return strcmp(buf, crypt("", "\xE0\xA0"));
|
|
}
|
|
],
|
|
rb_cv_broken_crypt=no,
|
|
rb_cv_broken_crypt=yes,
|
|
rb_cv_broken_crypt=yes)])
|
|
if test "$rb_cv_broken_crypt" = yes; then
|
|
AC_DEFINE(BROKEN_CRYPT, 1)
|
|
fi
|
|
;;
|
|
when(hpux*) LIBS="-lm $LIBS"
|
|
ac_cv_c_inline=no;;
|
|
when(human*) ac_cv_func_getpgrp_void=yes
|
|
ac_cv_func_setitimer=no
|
|
AC_CHECK_LIB(signal, _harderr)
|
|
AC_CHECK_LIB(hmem, hmemset)
|
|
AC_CHECK_FUNCS(select)
|
|
AC_CACHE_CHECK(whether PD libc _dtos18 fail to convert big number,
|
|
rb_cv_missing__dtos18,
|
|
[AC_TRY_RUN([
|
|
#include <stdio.h>
|
|
int
|
|
main()
|
|
{
|
|
char buf[256];
|
|
sprintf(buf, "%g", 1e+300);
|
|
return (strcmp (buf, "1e+300") ? 0 : 1);
|
|
}
|
|
],
|
|
rb_cv_missing__dtos18=yes, rb_cv_missing__dtos18=no, rb_cv_missing__dtos18=no)])
|
|
if test "$rb_cv_missing__dtos18" = yes; then
|
|
AC_DEFINE(MISSING__DTOS18)
|
|
fi
|
|
AC_CACHE_CHECK(whether PD libc fconvert fail to round,
|
|
rb_cv_missing_fconvert,
|
|
[AC_TRY_RUN([
|
|
#include <stdio.h>
|
|
#include <math.h>
|
|
int
|
|
main()
|
|
{
|
|
char buf[256];
|
|
sprintf(buf, "%f", log(exp(1.0)));
|
|
return (strcmp (buf, "1.000000") ? 0 : 1);
|
|
}
|
|
],
|
|
rb_cv_missing_fconvert=yes, rb_cv_missing_fconvert=no, rb_cv_missing_fconvert=no)])
|
|
if test "$rb_cv_missing_fconvert" = yes; then
|
|
AC_DEFINE(MISSING_FCONVERT)
|
|
fi
|
|
;;
|
|
when(beos*|haiku*)
|
|
ac_cv_func_link=no
|
|
ac_cv_func_sched_yield=no
|
|
ac_cv_func_pthread_attr_setinheritsched=no
|
|
case "$target_os" in
|
|
when(beos*) ac_cv_header_net_socket_h=yes;;
|
|
when(haiku*) ac_cv_func_shutdown=no;;
|
|
esac
|
|
LIBS="$LIBS" # m lib is include in root under BeOS/Haiku
|
|
;;
|
|
when(cygwin*) ac_cv_header_langinfo_h=yes
|
|
AC_LIBOBJ([langinfo])
|
|
;;
|
|
when(mingw*) LIBS="-lshell32 -lws2_32 $LIBS"
|
|
ac_cv_header_a_out_h=no
|
|
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_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_isinf=yes
|
|
ac_cv_func_isnan=yes
|
|
ac_cv_func_finite=yes
|
|
ac_cv_func_link=yes
|
|
ac_cv_func_truncate=yes
|
|
ac_cv_func_fseeko=yes
|
|
ac_cv_func_ftello=yes
|
|
ac_cv_lib_crypt_crypt=no
|
|
ac_cv_func_getpgrp_void=no
|
|
ac_cv_func_setpgrp_void=yes
|
|
ac_cv_func_memcmp_working=yes
|
|
ac_cv_lib_dl_dlopen=no
|
|
rb_cv_binary_elf=no
|
|
rb_cv_negative_time_t=no
|
|
ac_cv_func_fcntl=yes
|
|
ac_cv_func_flock=yes
|
|
AC_LIBOBJ([langinfo])
|
|
: ${enable_win95=maybe}
|
|
;;
|
|
when(os2-emx*) LIBS="-lm $LIBS"
|
|
ac_cv_lib_dir_opendir=no;;
|
|
when(msdosdjgpp*)
|
|
LIBS="-lm $LIBS"
|
|
ac_cv_func_getpgrp_void=yes
|
|
ac_cv_func_setitimer=no
|
|
ac_cv_sizeof_rlim_t=4
|
|
ac_cv_func_fork=no
|
|
ac_cv_func_setrlimit=no
|
|
ac_cv_header_sys_socket_h=no
|
|
;;
|
|
when(bsdi*) LIBS="-lm $LIBS"
|
|
AC_DEFINE(BROKEN_SETREUID, 1)
|
|
AC_DEFINE(BROKEN_SETREGID, 1)
|
|
ac_cv_sizeof_rlim_t=8;;
|
|
when(freebsd*) LIBS="-lm $LIBS"
|
|
;;
|
|
when(dragonfly*) LIBS="-lm $LIBS"
|
|
;;
|
|
when(bow) ac_cv_func_setitimer=no
|
|
;;
|
|
when(superux*) ac_cv_func_setitimer=no
|
|
;;
|
|
when(*) LIBS="-lm $LIBS";;
|
|
esac
|
|
AC_CHECK_LIB(crypt, crypt)
|
|
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, socketpair) # SunOS/Solaris
|
|
AC_CHECK_LIB(rt, clock_gettime) # GNU/Linux
|
|
if test "${enable_win95}" = maybe; then
|
|
AC_HAVE_LIBRARY(unicows, [enable_win95=yes], [enable_win95=no])
|
|
fi
|
|
if test "${enable_win95}" = yes; then
|
|
AC_DEFINE(WIN95)
|
|
LIBS="-lunicows $LIBS"
|
|
fi
|
|
|
|
case "$target_cpu" in
|
|
when(alpha*) case "$target_os"::"$GCC" in
|
|
when(*::yes) CFLAGS="-mieee $CFLAGS" ;; # gcc
|
|
when(osf*) CFLAGS="-ieee $CFLAGS" ;; # ccc
|
|
esac ;;
|
|
esac
|
|
|
|
ac_cv_header_net_socket_h=${ac_cv_header_net_socket_h=no}
|
|
if test "$ac_cv_header_net_socket_h" = yes; then
|
|
ac_cv_header_sys_socket_h=${ac_cv_header_sys_socket_h=no}
|
|
else
|
|
ac_cv_header_sys_socket_h=${ac_cv_header_sys_socket_h=yes}
|
|
fi
|
|
|
|
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(limits.h sys/file.h sys/ioctl.h sys/syscall.h\
|
|
fcntl.h sys/fcntl.h sys/select.h sys/time.h sys/times.h sys/param.h\
|
|
syscall.h pwd.h grp.h a.out.h utime.h direct.h sys/resource.h \
|
|
sys/mkdev.h sys/utime.h xti.h netinet/in_systm.h float.h ieeefp.h \
|
|
ucontext.h intrinsics.h langinfo.h locale.h sys/sendfile.h time.h \
|
|
net/socket.h sys/socket.h)
|
|
|
|
dnl Check additional types.
|
|
RUBY_CHECK_SIZEOF(rlim_t, [int long "long long"], [], [
|
|
#ifdef HAVE_SYS_TYPES_H
|
|
# include <sys/types.h>
|
|
#endif
|
|
#ifdef HAVE_SYS_TIME_H
|
|
# include <sys/time.h>
|
|
#endif
|
|
#ifdef HAVE_SYS_RESOURCE_H
|
|
# include <sys/resource.h>
|
|
#endif
|
|
#ifdef HAVE_UNISTD_H
|
|
# include <unistd.h>
|
|
#endif
|
|
#include <stdio.h>
|
|
])
|
|
|
|
AC_TYPE_SIZE_T
|
|
RUBY_CHECK_SIZEOF(size_t, [int long void*], [], [@%:@include <sys/types.h>])
|
|
RUBY_CHECK_SIZEOF(ptrdiff_t, size_t, [], [@%:@include <stddef.h>])
|
|
AC_STRUCT_ST_BLKSIZE
|
|
AC_STRUCT_ST_BLOCKS
|
|
AC_STRUCT_ST_RDEV
|
|
RUBY_CHECK_SIZEOF([struct stat.st_size], [int long "long long"])
|
|
if test "$ac_cv_member_struct_stat_st_blocks" = yes; then
|
|
RUBY_CHECK_SIZEOF([struct stat.st_blocks], [int long "long long"])
|
|
fi
|
|
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_TYPES([struct timespec], [], [], [@%:@ifdef HAVE_TIME_H
|
|
@%:@include <time.h>
|
|
@%:@endif])
|
|
|
|
AC_CHECK_TYPE(fd_mask, [AC_DEFINE(HAVE_RB_FD_INIT, 1)])
|
|
|
|
dnl RUBY_DEFINT TYPENAME, SIZE, [SIGNED-OR-UNSIGNED], [INCLUDES = DEFAULT-INCLUDES]
|
|
AC_DEFUN([RUBY_DEFINT], [dnl
|
|
AC_CACHE_CHECK([for $1], [rb_cv_type_$1],
|
|
[AC_COMPILE_IFELSE([AC_LANG_PROGRAM([AC_INCLUDES_DEFAULT([$4])
|
|
typedef $1 t; int s = sizeof(t) == 42;])],
|
|
[rb_cv_type_$1=yes],
|
|
[case m4_bmatch([$2], [^[1-9][0-9]*$], $2, [$ac_cv_sizeof_]AS_TR_SH($2)) in
|
|
when("1") rb_cv_type_$1="m4_if([$3], [], [signed ], [$3 ])char";;
|
|
when("$ac_cv_sizeof_short") rb_cv_type_$1="m4_if([$3], [], [], [$3 ])short";;
|
|
when("$ac_cv_sizeof_int") rb_cv_type_$1="m4_if([$3], [], [], [$3 ])int";;
|
|
when("$ac_cv_sizeof_long") rb_cv_type_$1="m4_if([$3], [], [], [$3 ])long";;
|
|
when("$ac_cv_sizeof_long_long") rb_cv_type_$1="m4_if([$3], [], [], [$3 ])long long";;
|
|
when("$ac_cv_sizeof___int64") rb_cv_type_$1="m4_if([$3], [], [], [$3 ])__int64";;
|
|
when(*) rb_cv_type_$1=no;;
|
|
esac])])
|
|
if test "${rb_cv_type_$1}" != no; then
|
|
AC_DEFINE([HAVE_]AS_TR_CPP($1), 1)
|
|
if test "${rb_cv_type_$1}" = yes; then
|
|
m4_bmatch([$2], [^[1-9][0-9]*$], [AC_CHECK_SIZEOF([$1], 0, [AC_INCLUDES_DEFAULT([$4])])],
|
|
[RUBY_CHECK_SIZEOF([$1], [$2], [], [AC_INCLUDES_DEFAULT([$4])])])
|
|
else
|
|
AC_DEFINE_UNQUOTED($1, [$rb_cv_type_$1])
|
|
AC_DEFINE_UNQUOTED([SIZEOF_]AS_TR_CPP($1), [SIZEOF_]AS_TR_CPP([$rb_cv_type_$1]))
|
|
fi
|
|
fi
|
|
])
|
|
|
|
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)
|
|
RUBY_DEFINT(ssize_t, size_t, [], [@%:@include <sys/types.h>]) dnl may differ from int, so not use AC_TYPE_SSIZE_T.
|
|
|
|
AC_CACHE_CHECK(for stack end address, rb_cv_stack_end_address,
|
|
[rb_cv_stack_end_address=no
|
|
for addr in __libc_stack_end _SEND; do
|
|
AC_TRY_LINK(
|
|
[extern void *$addr;],
|
|
[if (!$addr) return 1;],
|
|
[rb_cv_stack_end_address="$addr"; break])
|
|
done])
|
|
if test $rb_cv_stack_end_address != no; then
|
|
AC_DEFINE_UNQUOTED(STACK_END_ADDRESS, $rb_cv_stack_end_address)
|
|
fi
|
|
|
|
dnl Checks for library functions.
|
|
AC_TYPE_GETGROUPS
|
|
AC_TYPE_SIGNAL
|
|
case "${target_cpu}-${target_os}:${target_archs}" in
|
|
when(powerpc-darwin*)
|
|
AC_LIBSOURCES(alloca.c)
|
|
AC_SUBST([ALLOCA], [\${LIBOBJDIR}alloca.${ac_objext}])
|
|
AC_DEFINE(C_ALLOCA)
|
|
AC_DEFINE_UNQUOTED(alloca, alloca)
|
|
;;
|
|
when(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)
|
|
;;
|
|
when(*)
|
|
AC_FUNC_ALLOCA
|
|
;;
|
|
esac
|
|
AC_FUNC_MEMCMP
|
|
|
|
# http://sources.redhat.com/ml/libc-hacker/2005-08/msg00008.html
|
|
# Debian GNU/Linux Etch's libc6.1 2.3.6.ds1-13etch5 has this problem.
|
|
# Debian GNU/Linux Lenny's libc6.1 2.7-10 has no problem.
|
|
AC_CACHE_CHECK(for broken erfc of glibc-2.3.6 on IA64, rb_cv_broken_glibc_ia64_erfc,
|
|
[AC_TRY_RUN([
|
|
#include <math.h>
|
|
int
|
|
main()
|
|
{
|
|
erfc(10000.0);
|
|
return 0;
|
|
}
|
|
],
|
|
rb_cv_broken_glibc_ia64_erfc=no,
|
|
rb_cv_broken_glibc_ia64_erfc=yes,
|
|
rb_cv_broken_glibc_ia64_erfc=no)])
|
|
case $rb_cv_broken_glibc_ia64_erfc in
|
|
when(yes) ac_cv_func_erf=no;;
|
|
esac
|
|
|
|
AC_REPLACE_FUNCS(dup2 memmove strerror\
|
|
strchr strstr crypt flock vsnprintf\
|
|
isnan finite isinf hypot acosh erf tgamma lgamma_r cbrt \
|
|
strlcpy strlcat)
|
|
AC_CHECK_FUNCS(fmod killpg wait4 waitpid fork spawnv syscall chroot fsync getcwd eaccess\
|
|
truncate ftruncate chsize times utimes utimensat fcntl lockf lstat\
|
|
link symlink readlink readdir_r\
|
|
setitimer setruid seteuid setreuid setresuid setproctitle socketpair\
|
|
setrgid setegid setregid setresgid issetugid pause lchown lchmod\
|
|
getpgrp setpgrp getpgid setpgid initgroups getgroups setgroups\
|
|
getpriority getrlimit setrlimit sysconf group_member\
|
|
dlopen sigprocmask sigaction sigsetjmp _setjmp _longjmp snprintf\
|
|
setsid telldir seekdir fchmod cosh sinh tanh log2 round signbit\
|
|
setuid setgid daemon select_large_fdset setenv unsetenv\
|
|
mktime timegm gmtime_r clock_gettime gettimeofday\
|
|
pread sendfile shutdown sigaltstack)
|
|
|
|
AC_CACHE_CHECK(for __builtin_setjmp, ac_cv_func___builtin_setjmp,
|
|
[AC_TRY_LINK([@%:@include <setjmp.h>
|
|
jmp_buf jb; void t(v) int v; {__builtin_longjmp(jb, v);}],
|
|
[__builtin_setjmp(jb);],
|
|
[ac_cv_func___builtin_setjmp=yes],
|
|
[ac_cv_func___builtin_setjmp=no])
|
|
])
|
|
|
|
test x$ac_cv_func__longjmp = xno && ac_cv_func__setjmp=no
|
|
|
|
AC_MSG_CHECKING(for setjmp type)
|
|
AC_ARG_WITH(setjmp-type,
|
|
AS_HELP_STRING([--with-setjmp-type],[select setjmp type]),
|
|
[
|
|
case $withval in
|
|
when(__builtin_setjmp) setjmp_prefix=__builtin_;;
|
|
when(_setjmp) setjmp_prefix=_;;
|
|
when(sigsetjmp) setjmp_prefix=sig;;
|
|
when(setjmp) setjmp_prefix=;;
|
|
when('') unset setjmp_prefix;;
|
|
when(*) AC_MSG_ERROR(invalid setjmp type: $withval);;
|
|
esac], [unset setjmp_prefix])
|
|
if test ${setjmp_prefix+set}; then
|
|
if test "${setjmp_prefix}" && eval test '$ac_cv_func_'${setjmp_prefix}setjmp = no; then
|
|
AC_MSG_ERROR(${setjmp_prefix}setjmp is not available)
|
|
fi
|
|
elif test "$ac_cv_func___builtin_setjmp" = yes; then
|
|
setjmp_prefix=__builtin_
|
|
elif test "$ac_cv_func__setjmp" = yes; then
|
|
setjmp_prefix=_
|
|
elif test "$ac_cv_func_sigsetjmp" = yes; then
|
|
case $target_os in
|
|
when(solaris*|cygwin*)
|
|
setjmp_prefix=;;
|
|
when(*)
|
|
setjmp_prefix=sig;;
|
|
esac
|
|
else
|
|
setjmp_prefix=
|
|
fi
|
|
if test x$setjmp_prefix = xsig; then
|
|
setjmp_sigmask=yes
|
|
else
|
|
unset setjmp_sigmask
|
|
fi
|
|
AC_MSG_RESULT(${setjmp_prefix}setjmp)
|
|
AC_DEFINE_UNQUOTED([RUBY_SETJMP(env)], [${setjmp_prefix}setjmp(env${setjmp_sigmask+,0})])
|
|
AC_DEFINE_UNQUOTED([RUBY_LONGJMP(env,val)], [${setjmp_prefix}longjmp(env,val)])
|
|
AC_DEFINE_UNQUOTED(RUBY_JMP_BUF, ${setjmp_sigmask+${setjmp_prefix}}jmp_buf)
|
|
|
|
AC_ARG_ENABLE(setreuid,
|
|
AS_HELP_STRING([--enable-setreuid], [use setreuid()/setregid() according to need even if obsolete]),
|
|
[use_setreuid=$enableval])
|
|
if test "$use_setreuid" = yes; then
|
|
AC_DEFINE(USE_SETREUID)
|
|
AC_DEFINE(USE_SETREGID)
|
|
fi
|
|
AC_STRUCT_TIMEZONE
|
|
AC_CACHE_CHECK(for struct tm.tm_gmtoff, rb_cv_member_struct_tm_tm_gmtoff,
|
|
[AC_TRY_COMPILE([#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])])
|
|
if test "$rb_cv_member_struct_tm_tm_gmtoff" = yes; then
|
|
AC_DEFINE(HAVE_STRUCT_TM_TM_GMTOFF)
|
|
fi
|
|
AC_CACHE_CHECK(for external int daylight, rb_cv_have_daylight,
|
|
[AC_TRY_LINK([#include <time.h>
|
|
int i;],
|
|
[i = daylight;],
|
|
rb_cv_have_daylight=yes,
|
|
rb_cv_have_daylight=no)])
|
|
if test "$rb_cv_have_daylight" = yes; then
|
|
AC_DEFINE(HAVE_DAYLIGHT)
|
|
fi
|
|
AC_DEFUN([RUBY_CHECK_VARTYPE], [dnl
|
|
AC_CACHE_CHECK([for external $1], AS_TR_SH(rb_cv_var_$1),
|
|
[AS_TR_SH(rb_cv_var_$1)=no
|
|
AC_TRY_COMPILE([
|
|
#ifndef _XOPEN_SOURCE
|
|
#define _XOPEN_SOURCE 1
|
|
#endif
|
|
$2
|
|
;
|
|
const volatile void *volatile t;],
|
|
[t = &(&$1)[0];],
|
|
[for t in $3; do
|
|
AC_TRY_COMPILE([
|
|
#ifndef _XOPEN_SOURCE
|
|
#define _XOPEN_SOURCE 1
|
|
#endif
|
|
$2
|
|
;
|
|
extern $t $1;
|
|
const volatile void *volatile t;],
|
|
[t = &(&$1)[0];],
|
|
[AS_TR_SH(rb_cv_var_$1)=$t; break])
|
|
done])])
|
|
if test "${AS_TR_SH(rb_cv_var_$1)}" != no; then
|
|
AC_DEFINE(AS_TR_CPP(HAVE_VAR_$1))
|
|
AC_DEFINE_UNQUOTED(AS_TR_CPP(TYPEOF_VAR_$1), ${AS_TR_SH(rb_cv_var_$1)})
|
|
fi])
|
|
RUBY_CHECK_VARTYPE(timezone, [@%:@include <time.h>], [long int])
|
|
RUBY_CHECK_VARTYPE(altzone, [@%:@include <time.h>], [long int])
|
|
AC_CHECK_FUNCS(timezone)
|
|
if test "$ac_cv_func_timezone" = yes; then
|
|
AC_CACHE_CHECK([whether timezone requires zero arguments], rb_cv_func_timezone_void,
|
|
[AC_TRY_COMPILE([@%:@include <time.h>],
|
|
[(void)timezone(0, 0);],
|
|
[rb_cv_func_timezone_void=no],
|
|
[rb_cv_func_timezone_void=yes])]
|
|
)
|
|
if test $rb_cv_func_timezone_void = yes; then
|
|
AC_DEFINE(TIMEZONE_VOID)
|
|
fi
|
|
fi
|
|
|
|
AC_CACHE_CHECK(for negative time_t for gmtime(3), rb_cv_negative_time_t,
|
|
[AC_TRY_RUN([
|
|
#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)])
|
|
if test "$rb_cv_negative_time_t" = yes; then
|
|
AC_DEFINE(NEGATIVE_TIME_T)
|
|
fi
|
|
|
|
if test "$ac_cv_func_sigprocmask" = yes && test "$ac_cv_func_sigaction" = yes; then
|
|
AC_DEFINE(POSIX_SIGNAL)
|
|
else
|
|
AC_CHECK_FUNCS(sigsetmask)
|
|
AC_CACHE_CHECK(for BSD signal semantics, rb_cv_bsd_signal,
|
|
[AC_TRY_RUN([
|
|
#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)])
|
|
if test "$rb_cv_bsd_signal" = yes; then
|
|
AC_DEFINE(BSD_SIGNAL)
|
|
fi
|
|
fi
|
|
|
|
AC_FUNC_GETPGRP
|
|
AC_FUNC_SETPGRP
|
|
|
|
AC_C_BIGENDIAN
|
|
AC_C_CONST
|
|
AC_C_CHAR_UNSIGNED
|
|
AC_C_INLINE
|
|
AC_C_VOLATILE
|
|
|
|
if test x"$target_cpu" = xia64; then
|
|
AC_LIBOBJ([ia64])
|
|
AC_CACHE_CHECK(for __libc_ia64_register_backing_store_base,
|
|
rb_cv___libc_ia64_register_backing_store_base,
|
|
[rb_cv___libc_ia64_register_backing_store_base=no
|
|
AC_TRY_LINK(
|
|
[extern unsigned long __libc_ia64_register_backing_store_base;],
|
|
[unsigned long p = __libc_ia64_register_backing_store_base;
|
|
printf("%ld\n", p);],
|
|
[rb_cv___libc_ia64_register_backing_store_base=yes])])
|
|
if test $rb_cv___libc_ia64_register_backing_store_base = yes; then
|
|
AC_DEFINE(HAVE___LIBC_IA64_REGISTER_BACKING_STORE_BASE)
|
|
fi
|
|
fi
|
|
|
|
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)])
|
|
if test "$rb_cv_rshift_sign" = yes; then
|
|
AC_DEFINE(RSHIFT(x,y), ((x)>>(int)y))
|
|
else
|
|
AC_DEFINE(RSHIFT(x,y), (((x)<0) ? ~((~(x))>>y) : (x)>>y))
|
|
fi
|
|
|
|
AC_MSG_CHECKING(read count field in FILE structures)
|
|
AC_CACHE_VAL(rb_cv_fcnt,
|
|
[for fcnt in dnl
|
|
_cnt dnl
|
|
__cnt dnl
|
|
_r dnl
|
|
readCount dnl
|
|
_rcount dnl for emx0.9c
|
|
; do
|
|
AC_TRY_COMPILE([#include <stdio.h>
|
|
],
|
|
[FILE *f = stdin; f->$fcnt = 0;],
|
|
rb_cv_fcnt="$fcnt"; break,
|
|
rb_cv_fcnt="not found")
|
|
done])
|
|
if test "$rb_cv_fcnt" = "not found"; then
|
|
AC_MSG_RESULT([not found(OK if using GNU libc)])
|
|
else
|
|
AC_MSG_RESULT($rb_cv_fcnt)
|
|
AC_DEFINE_UNQUOTED(FILE_COUNT, $rb_cv_fcnt)
|
|
fi
|
|
|
|
AC_MSG_CHECKING(read buffer ptr field in FILE structures)
|
|
AC_CACHE_VAL(rb_cv_frptr,
|
|
[for frptr in dnl
|
|
_IO_read_ptr dnl
|
|
_ptr dnl
|
|
__ptr dnl
|
|
bufpos dnl
|
|
_p dnl
|
|
__bufpos dnl
|
|
; do
|
|
AC_TRY_COMPILE([#include <stdio.h>
|
|
],
|
|
[FILE *f = stdin; char buf[256]; f->$frptr = buf;],
|
|
rb_cv_frptr="$frptr"; break,
|
|
rb_cv_frptr="not found")
|
|
done])
|
|
if test "$rb_cv_frptr" = "not found"; then
|
|
AC_MSG_RESULT([not found])
|
|
else
|
|
AC_MSG_RESULT($rb_cv_frptr)
|
|
AC_DEFINE_UNQUOTED(FILE_READPTR, $rb_cv_frptr)
|
|
|
|
if test "$rb_cv_fcnt" = "not found"; then
|
|
AC_MSG_CHECKING(read buffer end field in FILE structures)
|
|
AC_CACHE_VAL(rb_cv_frend,
|
|
[for frend in dnl
|
|
_IO_read_end dnl
|
|
bufread dnl
|
|
__bufread dnl
|
|
; do
|
|
AC_TRY_COMPILE([#include <stdio.h>
|
|
],
|
|
[FILE *f = stdin; char buf[256]; f->$frend = buf;],
|
|
rb_cv_frend="$frend"; break,
|
|
rb_cv_frend="not found")
|
|
done])
|
|
if test "$rb_cv_frend" = "not found"; then
|
|
AC_MSG_RESULT([not found])
|
|
else
|
|
AC_MSG_RESULT($rb_cv_frend)
|
|
AC_DEFINE_UNQUOTED(FILE_READEND, $rb_cv_frend)
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
RUBY_CHECK_SIZEOF([struct stat.st_ino], [long "long long"], [], [@%:@include <sys/stat.h>])
|
|
|
|
if test "$ac_cv_func_sysconf" = yes; then
|
|
AC_DEFUN([RUBY_CHECK_SYSCONF], [dnl
|
|
AC_CACHE_CHECK([whether _SC_$1 is supported], rb_cv_have_sc_[]m4_tolower($1),
|
|
[AC_TRY_COMPILE([#include <unistd.h>
|
|
],
|
|
[_SC_$1 >= 0],
|
|
rb_cv_have_sc_[]m4_tolower($1)=yes,
|
|
rb_cv_have_sc_[]m4_tolower($1)=no)
|
|
])
|
|
if test "$rb_cv_have_sc_[]m4_tolower($1)" = yes; then
|
|
AC_DEFINE(HAVE__SC_$1)
|
|
fi
|
|
])
|
|
RUBY_CHECK_SYSCONF(CLK_TCK)
|
|
fi
|
|
|
|
case "$target_cpu" in
|
|
when(m68*|i?86|ia64|sparc*|alpha*) rb_cv_stack_grow_dir=-1;;
|
|
when(hppa*) rb_cv_stack_grow_dir=+1;;
|
|
esac
|
|
AC_CACHE_CHECK(stack growing direction, rb_cv_stack_grow_dir,
|
|
[AC_TRY_RUN([
|
|
/* recurse to get rid of inlining */
|
|
static int
|
|
stack_growup_p(addr, n)
|
|
volatile int *addr, n;
|
|
{
|
|
volatile int end;
|
|
if (n > 0)
|
|
return *addr = stack_growup_p(addr, n - 1);
|
|
else
|
|
return (&end > addr);
|
|
}
|
|
int main()
|
|
{
|
|
int x;
|
|
return stack_growup_p(&x, 10);
|
|
}
|
|
], rb_cv_stack_grow_dir=-1, rb_cv_stack_grow_dir=+1, rb_cv_stack_grow_dir=0)])
|
|
AC_DEFINE_UNQUOTED(STACK_GROW_DIRECTION, $rb_cv_stack_grow_dir)
|
|
|
|
if test x"$enable_pthread" = xyes; then
|
|
for pthread_lib in thr pthread pthreads c c_r root; do
|
|
AC_CHECK_LIB($pthread_lib, pthread_kill,
|
|
rb_with_pthread=yes, rb_with_pthread=no)
|
|
if test "$rb_with_pthread" = "yes"; then break; fi
|
|
done
|
|
if test x"$rb_with_pthread" = xyes; then
|
|
AC_DEFINE(_REENTRANT)
|
|
AC_DEFINE(_THREAD_SAFE)
|
|
AC_DEFINE(HAVE_LIBPTHREAD)
|
|
case $pthread_lib in
|
|
when(c)
|
|
;;
|
|
when(root)
|
|
;;
|
|
when(c_r)
|
|
MAINLIBS="-pthread $MAINLIBS"
|
|
;;
|
|
when(*)
|
|
LIBS="-l$pthread_lib $LIBS"
|
|
;;
|
|
esac
|
|
else
|
|
AC_MSG_WARN("Don't know how to find pthread library on your system -- thread support disabled")
|
|
fi
|
|
AC_CHECK_FUNCS(nanosleep sched_yield pthread_attr_setinheritsched)
|
|
if test x"$ac_cv_func_nanosleep" = xno; then
|
|
AC_CHECK_LIB(rt, nanosleep)
|
|
if test x"$ac_cv_lib_rt_nanosleep" = xyes; then
|
|
AC_DEFINE(HAVE_NANOSLEEP)
|
|
fi
|
|
fi
|
|
fi
|
|
if test x"$ac_cv_header_ucontext_h" = xyes; then
|
|
if test x"$rb_with_pthread" = xyes; then
|
|
AC_CHECK_FUNCS(getcontext setcontext)
|
|
fi
|
|
fi
|
|
|
|
if test "$ac_cv_func_fork" = "yes" -a "$rb_with_pthread" = "yes"; then
|
|
AC_CACHE_CHECK([if fork works with pthread], rb_cv_fork_with_pthread,
|
|
[AC_TRY_RUN([
|
|
#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)
|
|
fi
|
|
|
|
AC_CHECK_FUNCS(backtrace)
|
|
|
|
AC_ARG_WITH(valgrind,
|
|
AS_HELP_STRING([--with-valgrind],[enable valgrind memcheck support]),
|
|
[AC_CHECK_HEADERS(valgrind/memcheck.h)])
|
|
|
|
dnl }
|
|
dnl runtime section {
|
|
|
|
dnl wheather use dln_a_out or not
|
|
AC_ARG_WITH(dln-a-out,
|
|
AS_HELP_STRING([--with-dln-a-out], [use dln_a_out if possible]),
|
|
[
|
|
case $withval in
|
|
when(yes)
|
|
if test "$enable_shared" = yes; then
|
|
AC_MSG_ERROR(dln_a_out can not make shared library)
|
|
fi
|
|
with_dln_a_out=yes;;
|
|
when(*)
|
|
with_dln_a_out=no;;
|
|
esac], [with_dln_a_out=no])
|
|
|
|
AC_CACHE_CHECK(whether ELF binaries are produced, rb_cv_binary_elf,
|
|
[AC_TRY_LINK([],[], [
|
|
case "`head -1 conftest$EXEEXT | cat -e`" in
|
|
when('^?ELF'*)
|
|
rb_cv_binary_elf=yes;;
|
|
when(*)
|
|
rb_cv_binary_elf=no;;
|
|
esac],
|
|
rb_cv_binary_elf=no)])
|
|
|
|
if test "$rb_cv_binary_elf" = yes; then
|
|
AC_DEFINE(USE_ELF)
|
|
if test "$with_dln_a_out" = yes; then
|
|
AC_MSG_ERROR(dln_a_out does not work with ELF)
|
|
fi
|
|
fi
|
|
|
|
case "$target_os" in
|
|
when(linux* | gnu* | k*bsd*-gnu | bsdi* | kopensolaris*-gnu)
|
|
if test "$rb_cv_binary_elf" = no; then
|
|
with_dln_a_out=yes
|
|
else
|
|
LDFLAGS="$LDFLAGS -rdynamic"
|
|
fi;;
|
|
esac
|
|
LIBEXT=a
|
|
|
|
AC_SUBST(DLDFLAGS)dnl
|
|
AC_SUBST(ARCH_FLAG)dnl
|
|
|
|
AC_SUBST(STATIC)dnl
|
|
AC_SUBST(CCDLFLAGS)dnl
|
|
AC_SUBST(LDSHARED)dnl
|
|
AC_SUBST(LDSHAREDXX)dnl
|
|
AC_SUBST(DLEXT)dnl
|
|
AC_SUBST(DLEXT2)dnl
|
|
AC_SUBST(LIBEXT)dnl
|
|
|
|
STATIC=
|
|
: ${PATHFLAG=''}
|
|
|
|
if test "$with_dln_a_out" != yes; then
|
|
rb_cv_dlopen=unknown
|
|
AC_MSG_CHECKING(whether OS depend dynamic link works)
|
|
if test "$GCC" = yes; then
|
|
case "$target_os" in
|
|
when(nextstep*|openstep*|rhapsody*|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);;
|
|
when(human*|bsdi*|beos*|haiku*|cygwin*|mingw*|aix*|interix*) ;;
|
|
when(*)
|
|
RUBY_APPEND_OPTION(CCDLFLAGS, -fPIC);;
|
|
esac
|
|
else
|
|
case "$target_os" in
|
|
when(hpux*) CCDLFLAGS="$CCDLFLAGS +Z";;
|
|
when(solaris*|irix*) CCDLFLAGS="$CCDLFLAGS -KPIC" ;;
|
|
when(sunos*) CCDLFLAGS="$CCDLFLAGS -PIC" ;;
|
|
when(esix*|uxpds*) CCDLFLAGS="$CCDLFLAGS -KPIC" ;;
|
|
when(*) : ${CCDLFLAGS=""} ;;
|
|
esac
|
|
fi
|
|
|
|
|
|
AC_ARG_ENABLE(rpath,
|
|
AS_HELP_STRING([--disable-rpath], [embed run path into extension libraries]),
|
|
[enable_rpath=$enableval], [enable_rpath="$rb_cv_binary_elf"])
|
|
if test "$enable_rpath" = yes; then
|
|
RPATHFLAG=" ${linker_flag}-R%1\$-s"
|
|
fi
|
|
|
|
case "$target_os" in
|
|
when(hpux*) DLDFLAGS="$DLDFLAGS -E"
|
|
: ${LDSHARED='ld -b'}
|
|
XLDFLAGS="$XLDFLAGS -Wl,-E"
|
|
: ${LIBPATHENV=SHLIB_PATH}
|
|
if test "$rb_cv_prog_gnu_ld" = no; then
|
|
RPATHFLAG=' +b %1$-s'
|
|
fi
|
|
rb_cv_dlopen=yes;;
|
|
when(solaris*) if test "$GCC" = yes; then
|
|
: ${LDSHARED='$(CC) -shared'}
|
|
if test "$rb_cv_prog_gnu_ld" = yes; then
|
|
LDFLAGS="$LDFLAGS -Wl,-E"
|
|
fi
|
|
else
|
|
: ${LDSHARED='ld -G'}
|
|
fi
|
|
rb_cv_dlopen=yes;;
|
|
when(sunos*) : ${LDSHARED='ld -assert nodefinitions'}
|
|
rb_cv_dlopen=yes;;
|
|
when(irix*) : ${LDSHARED='ld -shared'}
|
|
rb_cv_dlopen=yes;;
|
|
when(sysv4*) : ${LDSHARED='ld -G'}
|
|
rb_cv_dlopen=yes;;
|
|
when(nto-qnx*) : ${LDSHARED="qcc -shared"}
|
|
rb_cv_dlopen=yes ;;
|
|
when(esix*|uxpds*) : ${LDSHARED="ld -G"}
|
|
rb_cv_dlopen=yes ;;
|
|
when(osf*) : ${LDSHARED="ld -shared -expect_unresolved \"*\""}
|
|
rb_cv_dlopen=yes ;;
|
|
when(bsdi3*) case "$CC" in
|
|
when(*shlicc*) : ${LDSHARED="$CC -r"}
|
|
rb_cv_dlopen=yes ;;
|
|
esac ;;
|
|
when(linux* | gnu* | k*bsd*-gnu | netbsd* | bsdi* | kopensolaris*-gnu)
|
|
: ${LDSHARED='${CC} -shared'}
|
|
if test "$rb_cv_binary_elf" = yes; then
|
|
LDFLAGS="$LDFLAGS -Wl,-export-dynamic"
|
|
fi
|
|
rb_cv_dlopen=yes ;;
|
|
when(interix*) : ${LDSHARED="$CC -shared"}
|
|
XLDFLAGS="$XLDFLAGS -Wl,-E"
|
|
LIBPATHFLAG=" -L%1\$-s"
|
|
rb_cv_dlopen=yes ;;
|
|
when(freebsd*|dragonfly*)
|
|
: ${LDSHARED="$CC -shared"}
|
|
if test "$rb_cv_binary_elf" = yes; then
|
|
LDFLAGS="$LDFLAGS -rdynamic"
|
|
DLDFLAGS="$DLDFLAGS "'-Wl,-soname,$(.TARGET)'
|
|
else
|
|
test "$GCC" = yes && test "$rb_cv_prog_gnu_ld" = yes || LDSHARED="ld -Bshareable"
|
|
fi
|
|
rb_cv_dlopen=yes ;;
|
|
when(openbsd*) : ${LDSHARED="\$(CC) -shared ${CCDLFLAGS}"}
|
|
if test "$rb_cv_binary_elf" = yes; then
|
|
LDFLAGS="$LDFLAGS -Wl,-E"
|
|
fi
|
|
rb_cv_dlopen=yes ;;
|
|
when(nextstep*) : ${LDSHARED='cc -r -nostdlib'}
|
|
LDFLAGS="$LDFLAGS -u libsys_s"
|
|
rb_cv_dlopen=yes ;;
|
|
when(openstep*) : ${LDSHARED='cc -dynamic -bundle -undefined suppress'}
|
|
: ${LDFLAGS=""}
|
|
rb_cv_dlopen=yes ;;
|
|
when(rhapsody*) : ${LDSHARED='cc -dynamic -bundle -undefined suppress'}
|
|
: ${LDFLAGS=""}
|
|
rb_cv_dlopen=yes ;;
|
|
when(darwin*) : ${LDSHARED='$(CC) -dynamic -bundle -undefined suppress -flat_namespace'}
|
|
: ${LDFLAGS=""}
|
|
: ${LIBPATHENV=DYLD_LIBRARY_PATH}
|
|
# /usr/local/include is always searched for
|
|
# some reason, but /usr/local/lib is not.
|
|
hdr=`find /usr/local/include -name \*.h -type f | sed 's:^/usr/local/include/::;q'`
|
|
if test -n "$hdr" && $CC -E -include "$hdr" -xc /dev/null | fgrep -q "$hdr"; then
|
|
$CC -print-search-dirs | grep -q '^libraries:.*:/usr/local/lib/*' ||
|
|
echo " $LDFLAGS " | grep -q ' -L */usr/local/lib/* ' ||
|
|
LDFLAGS="${LDFLAGS:+$LDFLAGS }-L/usr/local/lib"
|
|
fi
|
|
rb_cv_dlopen=yes ;;
|
|
when(aix*) if test "$GCC" = yes; then
|
|
: ${LDSHARED='$(CC) -shared'}
|
|
else
|
|
: ${LDSHARED='$(CC)'}
|
|
fi
|
|
LDSHARED="$LDSHARED ${linker_flag}-G"
|
|
DLDFLAGS='-eInit_$(TARGET)'
|
|
XLDFLAGS="${linker_flag}-bE:ruby.imp ${linker_flag}-brtl"
|
|
XLDFLAGS="$XLDFLAGS ${linker_flag}-blibpath:${prefix}/lib:${LIBPATH:-/usr/lib:/lib}"
|
|
: ${ARCHFILE="ruby.imp"}
|
|
TRY_LINK='$(CC) $(LDFLAGS) -oconftest $(INCFLAGS) -I$(hdrdir) $(CPPFLAGS)'
|
|
TRY_LINK="$TRY_LINK"' $(CFLAGS) $(src) $(LIBPATH) $(LOCAL_LIBS) $(LIBS)'
|
|
: ${LIBPATHENV=SHLIB_PATH}
|
|
RPATHFLAG=" ${linker_flag}-blibpath:%1\$-s"
|
|
rb_cv_dlopen=yes ;;
|
|
when(human*) : ${DLDFLAGS=''}
|
|
: ${LDSHARED=''}
|
|
: ${LDFLAGS=''}
|
|
: ${LINK_SO='ar cru $@ $(OBJS)'}
|
|
rb_cv_dlopen=yes ;;
|
|
when(beos*) case "$target_cpu" in
|
|
when(powerpc*)
|
|
: ${LDSHARED="ld -xms"}
|
|
DLDFLAGS="$DLDFLAGS "'-export Init_$(TARGET) -lbe -lroot glue-noinit.a init_term_dyn.o start_dyn.o'
|
|
LDFLAGS="$LDFLAGS -L/boot/home/config/lib -lbe -lroot"
|
|
;;
|
|
when(i586*)
|
|
: ${LDSHARED="ld -shared"}
|
|
DLDFLAGS="$DLDFLAGS -L/boot/develop/lib/x86 -L/boot/home/config/lib \$(topdir)/_APP_ -lbe -lroot"
|
|
LDFLAGS="$LDFLAGS -L/boot/develop/lib/x86 -L/boot/home/config/lib -lbe -lroot"
|
|
;;
|
|
esac
|
|
: ${LIBPATHENV=LIBRARY_PATH}
|
|
rb_cv_dlopen=yes ;;
|
|
when(haiku*) case "$target_cpu" in
|
|
when(powerpc*)
|
|
: ${LDSHARED="ld -xms"}
|
|
DLDFLAGS="$DLDFLAGS "'-export Init_$(TARGET) -lbe -lroot glue-noinit.a init_term_dyn.o start_dyn.o'
|
|
;;
|
|
when(i586*)
|
|
: ${LDSHARED="ld -shared"}
|
|
DLDFLAGS="$DLDFLAGS -L/boot/develop/lib/x86 -lbe -lroot"
|
|
;;
|
|
esac
|
|
: ${LIBPATHENV=LIBRARY_PATH}
|
|
rb_cv_dlopen=yes ;;
|
|
when(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;;
|
|
when(cygwin*|mingw*)
|
|
: ${LDSHARED="${CC} -shared "'$(if $(filter-out -g -g0,$(debugflags)),,-s)'}
|
|
XLDFLAGS="$XLDFLAGS -Wl,--stack,0x00200000,--enable-auto-import"
|
|
DLDFLAGS="${DLDFLAGS} -Wl,--enable-auto-image-base,--enable-auto-import"
|
|
: ${LIBPATHENV=""}
|
|
rb_cv_dlopen=yes ;;
|
|
when(hiuxmpp) : ${LDSHARED='ld -r'} ;;
|
|
when(atheos*) : ${LDSHARED="$CC -shared"}
|
|
rb_cv_dlopen=yes ;;
|
|
when(os2-emx*) LDFLAGS="$LDFLAGS -Zomf"
|
|
;;
|
|
when(*) : ${LDSHARED='ld'} ;;
|
|
esac
|
|
AC_MSG_RESULT($rb_cv_dlopen)
|
|
fi
|
|
if test "${LDSHAREDXX}" = ""; then
|
|
case "${LDSHARED}" in
|
|
when(*'$(CC)'*)
|
|
LDSHAREDXX=`echo "${LDSHARED}" | sed 's/\$(CC)/$(CXX)/'`
|
|
;;
|
|
when(*'${CC}'*)
|
|
LDSHAREDXX=`echo "${LDSHARED}" | sed 's/\${CC}/${CXX}/'`
|
|
;;
|
|
when(*$CC*)
|
|
LDSHAREDXX=`echo "${LDSHARED}" | sed "s|$CC|$CXX|"`
|
|
;;
|
|
when(ld" "*)
|
|
;;
|
|
esac
|
|
fi
|
|
case ${RPATHFLAG} in
|
|
when(*'%1$'*)
|
|
: ${LIBPATHFLAG=' -L%1$-s'};;
|
|
when(*)
|
|
: ${LIBPATHFLAG=' -L%s'};;
|
|
esac
|
|
|
|
AC_SUBST(LINK_SO)
|
|
AC_SUBST(LIBPATHFLAG)
|
|
AC_SUBST(RPATHFLAG)
|
|
AC_SUBST(LIBPATHENV, "${LIBPATHENV-LD_LIBRARY_PATH}")
|
|
AC_SUBST(TRY_LINK)
|
|
|
|
dln_a_out_works=no
|
|
if test "$ac_cv_header_a_out_h" = yes; then
|
|
if test "$with_dln_a_out" = yes || test "$rb_cv_dlopen" = unknown; then
|
|
cat confdefs.h > config.h
|
|
AC_CACHE_CHECK(whether matz's dln works, rb_cv_dln_a_out,
|
|
[AC_TRY_COMPILE([
|
|
#define USE_DLN_A_OUT
|
|
#include "dln.c"
|
|
],
|
|
[],
|
|
rb_cv_dln_a_out=yes,
|
|
rb_cv_dln_a_out=no)])
|
|
if test "$rb_cv_dln_a_out" = yes; then
|
|
dln_a_out_works=yes
|
|
AC_DEFINE(USE_DLN_A_OUT)
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
if test "$dln_a_out_works" = yes; then
|
|
if test "$GCC" = yes; then
|
|
STATIC=-static
|
|
else
|
|
STATIC=-Bstatic
|
|
fi
|
|
DLEXT=so
|
|
CCDLFLAGS=
|
|
else
|
|
case "$target_os" in
|
|
when(hpux*)
|
|
DLEXT=sl;;
|
|
when(nextstep*|openstep*|rhapsody*|darwin*)
|
|
DLEXT=bundle;;
|
|
when(os2-emx*)
|
|
LOAD_RELATIVE=1
|
|
DLEXT=dll;;
|
|
when(cygwin*|mingw*|*djgpp*)
|
|
LOAD_RELATIVE=1
|
|
AC_DEFINE(MANGLED_PATH)
|
|
DLEXT=so;;
|
|
when(*)
|
|
DLEXT=so;;
|
|
esac
|
|
fi
|
|
if test "$rb_cv_dlopen:$load_relative" = yes:yes; then
|
|
AC_CHECK_FUNCS(dladdr)
|
|
if test "$ac_cv_func_dladdr" = yes; then
|
|
LOAD_RELATIVE=1
|
|
else
|
|
unset load_relative
|
|
fi
|
|
fi
|
|
|
|
len=2 # .rb
|
|
n=`expr "$DLEXT" : '.*'`; test "$n" -gt "$len" && len=$n
|
|
n=`expr "$DLEXT2" : '.*'`; test "$n" -gt "$len" && len=$n
|
|
AC_DEFINE_UNQUOTED(DLEXT_MAXLEN, `expr $len + 1`)
|
|
test ".$DLEXT" = "." || AC_DEFINE_UNQUOTED(DLEXT, ".$DLEXT")
|
|
test ".$DLEXT2" = "." || AC_DEFINE_UNQUOTED(DLEXT2, ".$DLEXT2")
|
|
AC_SUBST(DLEXT)
|
|
|
|
AC_SUBST(STRIP)dnl
|
|
if test "$with_dln_a_out" = yes; then
|
|
STRIP=true
|
|
else
|
|
STRIP=strip
|
|
fi
|
|
|
|
case "$target_os" in
|
|
when(linux* | gnu* | k*bsd*-gnu | kopensolaris*-gnu)
|
|
STRIP='strip -S -x';;
|
|
when(nextstep* | openstep* | rhapsody* | darwin*)
|
|
STRIP='strip -A -n';;
|
|
esac
|
|
|
|
EXTSTATIC=
|
|
AC_SUBST(EXTSTATIC)dnl
|
|
AC_ARG_WITH(static-linked-ext,
|
|
AS_HELP_STRING([--with-static-linked-ext], [link external modules statically]),
|
|
[case $withval in
|
|
when(yes)
|
|
STATIC=
|
|
EXTSTATIC=static;;
|
|
when(*) ;;
|
|
esac])
|
|
|
|
case "$target_os" in
|
|
when(human*)
|
|
setup=Setup.x68
|
|
;;
|
|
dnl OS/2 environment w/ Autoconf 2.1x for EMX
|
|
when(os2-emx)
|
|
setup=Setup.emx
|
|
;;
|
|
when(*djgpp*)
|
|
setup=Setup.dj
|
|
;;
|
|
when(*)
|
|
setup=Setup
|
|
;;
|
|
esac
|
|
|
|
AC_SUBST(setup)
|
|
|
|
if test "$prefix" = NONE; then
|
|
prefix=$ac_default_prefix
|
|
fi
|
|
|
|
if test x"$cross_compiling" = xyes; then
|
|
test x"$MINIRUBY" = x && MINIRUBY="${RUBY-ruby} -I`pwd` "-r'$(arch)-fake'
|
|
PREP='$(arch)-fake.rb'
|
|
RUNRUBY='$(MINIRUBY) -I`cd $(srcdir)/lib; pwd`'
|
|
else
|
|
MINIRUBY='./miniruby$(EXEEXT) -I$(srcdir)/lib'
|
|
MINIRUBY="$MINIRUBY"' -I$(EXTOUT)/common -I./- -r$(srcdir)/ext/purelib.rb'
|
|
PREP='miniruby$(EXEEXT)'
|
|
RUNRUBY='$(MINIRUBY) $(srcdir)/tool/runruby.rb --extout=$(EXTOUT)'
|
|
fi
|
|
AC_SUBST(MINIRUBY)
|
|
AC_SUBST(PREP)
|
|
AC_SUBST(RUNRUBY)
|
|
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=
|
|
|
|
case "$target_os" in
|
|
when(cygwin*|mingw*|beos*|haiku*|openstep*|nextstep*|rhapsody*|darwin*|os2-emx*)
|
|
: ${DLDLIBS=""}
|
|
;;
|
|
when(*)
|
|
DLDLIBS="$DLDLIBS -lc"
|
|
;;
|
|
esac
|
|
|
|
AC_ARG_WITH(soname,
|
|
AS_HELP_STRING([--with-soname=SONAME], [base name of shared library]),
|
|
[RUBY_SO_NAME=$withval], [RUBY_SO_NAME='$(RUBY_BASE_NAME)'])
|
|
|
|
LIBRUBY_LDSHARED=$LDSHARED
|
|
LIBRUBY_DLDFLAGS=$DLDFLAGS
|
|
LIBRUBY_SO='lib$(RUBY_SO_NAME).so.$(MAJOR).$(MINOR).$(TEENY)'
|
|
LIBRUBY_ALIASES='lib$(RUBY_SO_NAME).so'
|
|
ENABLE_SHARED=no
|
|
|
|
AC_ARG_ENABLE(shared,
|
|
AS_HELP_STRING([--enable-shared], [build a shared library for Ruby]),
|
|
[enable_shared=$enableval])
|
|
LIBRUBYARG_SHARED='-l$(RUBY_SO_NAME)'
|
|
if test "$enable_shared" = 'yes'; then
|
|
LIBRUBY='$(LIBRUBY_SO)'
|
|
LIBRUBYARG='$(LIBRUBYARG_SHARED)'
|
|
test -z "$CCDLFLAGS" || CFLAGS="$CFLAGS $CCDLFLAGS"
|
|
ENABLE_SHARED=yes
|
|
if test "$rb_cv_binary_elf" = yes; then
|
|
SOLIBS='$(LIBS)'
|
|
fi
|
|
case "$target_os" in
|
|
when(sunos4*)
|
|
LIBRUBY_ALIASES='lib$(RUBY_SO_NAME).so.$(MAJOR).$(MINOR) lib$(RUBY_SO_NAME).so'
|
|
;;
|
|
when(linux* | gnu* | k*bsd*-gnu | atheos* | kopensolaris*-gnu)
|
|
LIBRUBY_DLDFLAGS='-Wl,-soname,lib$(RUBY_SO_NAME).so.$(MAJOR).$(MINOR)'
|
|
LIBRUBY_ALIASES='lib$(RUBY_SO_NAME).so.$(MAJOR).$(MINOR) lib$(RUBY_SO_NAME).so'
|
|
;;
|
|
when(freebsd*|dragonfly*)
|
|
SOLIBS='$(LIBS)'
|
|
LIBRUBY_SO='lib$(RUBY_SO_NAME).so.$(MAJOR)$(MINOR)'
|
|
if test "$rb_cv_binary_elf" != "yes" ; then
|
|
LIBRUBY_SO="$LIBRUBY_SO.\$(TEENY)"
|
|
LIBRUBY_ALIASES=''
|
|
fi
|
|
;;
|
|
when(netbsd*)
|
|
SOLIBS='$(LIBS)'
|
|
LIBRUBY_SO='lib$(RUBY_SO_NAME).so.$(MAJOR)$(MINOR).$(TEENY)'
|
|
LIBRUBY_DLDFLAGS='-Wl,-soname,lib$(RUBY_SO_NAME).so.$(MAJOR)$(MINOR)'
|
|
if test "$rb_cv_binary_elf" = yes; then # ELF platforms
|
|
LIBRUBY_ALIASES='lib$(RUBY_SO_NAME).so.$(MAJOR)$(MINOR) lib$(RUBY_SO_NAME).so'
|
|
else # a.out platforms
|
|
LIBRUBY_ALIASES=""
|
|
fi
|
|
;;
|
|
when(openbsd*)
|
|
SOLIBS='$(LIBS)'
|
|
LIBRUBY_SO='lib$(RUBY_INSTALL_NAME).so.$(MAJOR).'`expr ${MINOR} \* 10 + ${TEENY}`
|
|
;;
|
|
when(solaris*)
|
|
SOLIBS='$(LIBS)'
|
|
LIBRUBY_SO='lib$(RUBY_SO_NAME).so.$(MAJOR)'
|
|
LIBRUBY_ALIASES='lib$(RUBY_SO_NAME).so.$(MAJOR).$(MINOR).$(TEENY) lib$(RUBY_SO_NAME).so'
|
|
if test "$GCC" = yes; then
|
|
LIBRUBY_DLDFLAGS="$DLDFLAGS "'-Wl,-h,$(@F)'
|
|
fi
|
|
XLDFLAGS="$XLDFLAGS "'-R${libdir}'
|
|
;;
|
|
when(hpux*)
|
|
XLDFLAGS="$XLDFLAGS "'-Wl,+s,+b,$(libdir)'
|
|
LIBRUBY_SO='lib$(RUBY_SO_NAME).sl.$(MAJOR).$(MINOR).$(TEENY)'
|
|
LIBRUBY_ALIASES='lib$(RUBY_SO_NAME).sl.$(MAJOR).$(MINOR) lib$(RUBY_SO_NAME).sl'
|
|
;;
|
|
when(aix*)
|
|
LIBRUBY_DLDFLAGS="${linker_flag}-bnoentry $XLDFLAGS"
|
|
LIBRUBYARG_SHARED='-L${libdir} -l${RUBY_SO_NAME}'
|
|
SOLIBS='-lm -lc'
|
|
;;
|
|
when(beos*)
|
|
case "$target_cpu" in
|
|
when(powerpc*)
|
|
LIBRUBY_DLDFLAGS='-f ruby.exp -lnet -lbe -lroot glue-noinit.a init_term_dyn.o start_dyn.o'
|
|
;;
|
|
esac
|
|
;;
|
|
when(darwin*)
|
|
RUBY_SO_NAME="$RUBY_SO_NAME"'.$(MAJOR).$(MINOR).$(TEENY)'
|
|
LIBRUBY_LDSHARED='$(CC) -dynamiclib -undefined suppress -flat_namespace'
|
|
if test "$load_relative" = yes; then
|
|
libprefix='@executable_path/../lib'
|
|
else
|
|
libprefix='$(libdir)'
|
|
fi
|
|
LIBRUBY_DLDFLAGS='-install_name '${libprefix}'/$(LIBRUBY_SO)'
|
|
LIBRUBY_DLDFLAGS="$LIBRUBY_DLDFLAGS "'-current_version $(MAJOR).$(MINOR).$(TEENY)'
|
|
LIBRUBY_DLDFLAGS="$LIBRUBY_DLDFLAGS "'-compatibility_version $(ruby_version)'
|
|
LIBRUBY_DLDFLAGS="$LIBRUBY_DLDFLAGS "'-Wl,-unexported_symbol,_Init_* $(XLDFLAGS)'
|
|
LIBRUBY_SO='lib$(RUBY_SO_NAME).dylib'
|
|
LIBRUBY_ALIASES='lib$(RUBY_BASE_NAME).$(MAJOR).$(MINOR).dylib lib$(RUBY_INSTALL_NAME).dylib'
|
|
;;
|
|
when(interix*)
|
|
LIBRUBYARG_SHARED='-L. -L${libdir} -l$(RUBY_SO_NAME)'
|
|
;;
|
|
when(*)
|
|
;;
|
|
esac
|
|
fi
|
|
if test "$enable_rpath" = yes; then
|
|
LIBRUBY_RPATHFLAGS="${linker_flag}-R ${linker_flag}\$(libdir) -L\$(libdir)"
|
|
LIBRUBYARG_SHARED="$LIBRUBY_RPATHFLAGS $LIBRUBYARG_SHARED"
|
|
LIBRUBYARG_STATIC="$LIBRUBY_RPATHFLAGS $LIBRUBYARG_STATIC"
|
|
fi
|
|
|
|
LDFLAGS="-L. $LDFLAGS"
|
|
AC_SUBST(ARCHFILE)
|
|
|
|
dnl }
|
|
dnl build section {
|
|
|
|
dnl build rdoc index if requested
|
|
RDOCTARGET=""
|
|
AC_ARG_ENABLE(install-doc,
|
|
AS_HELP_STRING([--disable-install-doc], [do not install rdoc indexes during install]),
|
|
[install_doc=$enableval], [install_doc=yes])
|
|
if test "$install_doc" != no; then
|
|
RDOCTARGET="install-doc"
|
|
fi
|
|
AC_SUBST(RDOCTARGET)
|
|
|
|
if test "$rb_with_pthread" = "yes"; then
|
|
THREAD_MODEL=pthread
|
|
fi
|
|
MINIDLNOBJ=dln.o
|
|
case "$target_os" in
|
|
when(linux*)
|
|
;;
|
|
when(netbsd*)
|
|
RUBY_APPEND_OPTION(CFLAGS, -pipe)
|
|
;;
|
|
when(nextstep*|openstep*)
|
|
RUBY_APPEND_OPTION(CPPFLAGS, -I/usr/local/include)
|
|
;;
|
|
when(rhapsody*)
|
|
RUBY_APPEND_OPTIONS(CFLAGS, -pipe -no-precomp)
|
|
;;
|
|
when(darwin*)
|
|
RUBY_APPEND_OPTION(CFLAGS, -pipe)
|
|
MINIDLNOBJ=dmydln.o
|
|
;;
|
|
when(human*)
|
|
AC_LIBOBJ([x68.o])
|
|
CFLAGS="$CFLAGS -fansi-only"
|
|
XCFLAGS="$XCFLAGS -cc1-stack=262144 -cpp-stack=2694144"
|
|
EXEEXT=.x
|
|
OBJEXT=o
|
|
;;
|
|
when(os2-emx)
|
|
AC_LIBOBJ([os2])
|
|
CFLAGS="$CFLAGS -DOS2"
|
|
LIBRUBY_A=`echo $LIBRUBY_A | sed 's/^lib//'`
|
|
LIBRUBY_SO=`echo $LIBRUBY_SO | sed 's/^lib//'`
|
|
LIBRUBY_ALIASES=`for i in $LIBRUBY_ALIASES; do echo "$i"; done | sed 's/^lib//'`
|
|
;;
|
|
when(osf*)
|
|
if test "$GCC" != "yes" ; then
|
|
# compile something small: taint.c is fine for this.
|
|
# the main point is the '-v' flag of 'cc'.
|
|
case "`cc -v -I. -c main.c -o /tmp/main.o 2>&1`" in
|
|
when(*/gemc_cc*) # we have the new DEC GEM CC
|
|
CFLAGS="$CFLAGS -oldc"
|
|
;;
|
|
when(*) # we have the old MIPS CC
|
|
;;
|
|
esac
|
|
# cleanup
|
|
rm -f /tmp/main.o
|
|
CFLAGS="$CFLAGS -std"
|
|
fi
|
|
;;
|
|
when(beos*)
|
|
case "$target_cpu" in
|
|
when(powerpc*)
|
|
CFLAGS="$CFLAGS -relax_pointers"
|
|
;;
|
|
esac
|
|
CPPFLAGS="$CPPFLAGS -I/boot/home/config/include"
|
|
;;
|
|
when(cygwin*|mingw*)
|
|
RUBY_SO_NAME="${RUBY_SO_NAME}${MAJOR}${MINOR}${TEENY}"
|
|
LIBRUBY_DLDFLAGS="${DLDFLAGS}"' -Wl,--out-implib=$(LIBRUBY)'
|
|
case "$target_os" in
|
|
when(cygwin*)
|
|
if test x"$enable_shared" = xyes; then
|
|
LIBRUBY_SO='cyg$(RUBY_SO_NAME)'.dll
|
|
LIBRUBY_DLDFLAGS="${LIBRUBY_DLDFLAGS}"' $(RUBYDEF)'
|
|
fi
|
|
;;
|
|
when(mingw*)
|
|
RUBY_SO_NAME="${rb_cv_msvcrt}-${RUBY_SO_NAME}"
|
|
if test x"$enable_shared" = xyes; then
|
|
LIBRUBY_SO='$(RUBY_SO_NAME)'.dll
|
|
LIBRUBY_DLDFLAGS="${LIBRUBY_DLDFLAGS}"' $(RUBYDEF)'
|
|
fi
|
|
AC_LIBOBJ([win32])
|
|
COMMON_LIBS=m
|
|
# COMMON_MACROS="WIN32_LEAN_AND_MEAN="
|
|
COMMON_HEADERS="winsock2.h windows.h"
|
|
THREAD_MODEL=win32
|
|
;;
|
|
esac
|
|
LIBRUBY_ALIASES=''
|
|
FIRSTMAKEFILE=GNUmakefile:cygwin/GNUmakefile.in
|
|
SOLIBS='$(LIBS)'
|
|
if test x"$enable_shared" = xyes; then
|
|
LIBRUBY='lib$(RUBY_SO_NAME).dll.a'
|
|
else
|
|
LIBRUBY_SO=dummy
|
|
LIBRUBY='lib$(RUBY_SO_NAME).a'
|
|
LIBRUBYARG='-l$(RUBY_SO_NAME)'
|
|
fi
|
|
MINIDLNOBJ=dmydln.o
|
|
;;
|
|
when(hpux*)
|
|
case "$YACC" in
|
|
when(*yacc*)
|
|
XCFLAGS="$XCFLAGS -DYYMAXDEPTH=300"
|
|
YACC="$YACC -Nl40000 -Nm40000"
|
|
;;
|
|
esac
|
|
MINIDLNOBJ=dmydln.o
|
|
;;
|
|
when(*msdosdjgpp*)
|
|
FIRSTMAKEFILE=GNUmakefile:djgpp/GNUmakefile.in
|
|
;;
|
|
when(*)
|
|
;;
|
|
esac
|
|
MINIOBJS="$MINIDLNOBJ"
|
|
|
|
case "$THREAD_MODEL" in
|
|
when(pthread)
|
|
AC_CHECK_HEADERS(pthread.h)
|
|
;;
|
|
when(win32)
|
|
;;
|
|
when(*)
|
|
AC_MSG_ERROR(unknown thread model $THREAD_MODEL)
|
|
;;
|
|
esac
|
|
|
|
case "$FIRSTMAKEFILE" in
|
|
when(*GNUmakefile:*)
|
|
gnumake=yes
|
|
;;
|
|
when(*)
|
|
AC_MSG_CHECKING([for 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
|
|
case "$gnumake" in
|
|
when(*yes*)
|
|
echo "include Makefile" > GNUmakefile
|
|
echo "-include uncommon.mk" >> GNUmakefile
|
|
gnumake=yes;;
|
|
when(*)
|
|
gnumake=no;;
|
|
esac
|
|
AC_MSG_RESULT($gnumake)
|
|
;;
|
|
esac
|
|
|
|
if test "${universal_binary-no}" = yes ; then
|
|
AC_MSG_CHECKING([for architecture macros])
|
|
mv confdefs.h confdefs1.h
|
|
: > confdefs.h
|
|
AC_TRY_COMPILE([@%:@if defined __`echo ${universal_archnames} |
|
|
sed 's/=[^ ]*//g;s/ /__ || defined __/g'`__
|
|
@%:@else
|
|
@%:@error
|
|
>>>>>><<<<<<
|
|
@%:@endif], [],
|
|
[
|
|
AC_MSG_RESULT(yes)
|
|
mv -f confdefs1.h confdefs.h
|
|
], [
|
|
AC_MSG_RESULT(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_TRY_COMPILE([@%:@ifndef ${archs}
|
|
@%:@error
|
|
@%:@endif], [], [AC_MSG_RESULT([yes])], [AC_MSG_RESULT([no])])
|
|
done
|
|
mv -f confdefs1.h confdefs.h
|
|
AC_MSG_ERROR([failed])
|
|
])
|
|
fi
|
|
|
|
CPPFLAGS="$CPPFLAGS "'$(DEFS)'
|
|
test -z "$CPPFLAGS" || CPPFLAGS="$CPPFLAGS "; CPPFLAGS="$CPPFLAGS"'${cppflags}'
|
|
if test -n "${cflags+set}"; then
|
|
cflagspat=`eval echo '"'"${cflags}"'"' | sed 's/[[][|.*]]/\\&/g;s/^ */ /;s/^ *$/ /'`
|
|
CFLAGS=`echo " $CFLAGS " | sed "s|$cflagspat"'|${cflags}|;s/^ *//;s/ *$//'`
|
|
fi
|
|
if test -n "${cxxflags+set}"; then
|
|
cxxflagspat=`eval echo '"'"${cxxflags}"'"' | sed 's/[[][|.*]]/\\&/g;s/^ */ /;s/^ *$/ /'`
|
|
CXXFLAGS=`echo " $CXXFLAGS " | sed "s|$cxxflagspat"'|${cxxflags}|;s/^ *//;s/ *$//'`
|
|
fi
|
|
if test "${ARCH_FLAG}"; then
|
|
archflagpat=`eval echo '"'"${ARCH_FLAG}"'"' | sed 's/[[][|.*]]/\\&/g'`
|
|
CFLAGS=`echo "$CFLAGS" | sed "s|$archflagpat"'|$(ARCH_FLAG)|'`
|
|
CXXFLAGS=`echo "$CXXFLAGS" | sed "s|$archflagpat"'|$(ARCH_FLAG)|'`
|
|
LDFLAGS=`echo "$LDFLAGS" | sed "s|$archflagpat"'|$(ARCH_FLAG)|'`
|
|
fi
|
|
AC_SUBST(cppflags, [])dnl
|
|
AC_SUBST(cflags, ["$orig_cflags "'${optflags} ${debugflags} ${warnflags}'])dnl
|
|
AC_SUBST(cxxflags, ["$orig_cxxflags "'${optflags} ${debugflags} ${warnflags}'])dnl
|
|
AC_SUBST(optflags)dnl
|
|
AC_SUBST(debugflags)dnl
|
|
AC_SUBST(warnflags)dnl
|
|
AC_SUBST(XCFLAGS)dnl
|
|
AC_SUBST(XLDFLAGS)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_ALIASES)
|
|
AC_SUBST(LIBRUBY)
|
|
AC_SUBST(LIBRUBYARG)
|
|
AC_SUBST(LIBRUBYARG_STATIC)
|
|
AC_SUBST(LIBRUBYARG_SHARED)
|
|
AC_SUBST(SOLIBS)
|
|
AC_SUBST(DLDLIBS)
|
|
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(MINIOBJS)
|
|
AC_SUBST(THREAD_MODEL)
|
|
|
|
MAKEFILES="Makefile `echo $FIRSTMAKEFILE | sed 's/:.*//'`"
|
|
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}"
|
|
case "$target_os" in
|
|
when(cygwin*|mingw*)
|
|
RUBYW_INSTALL_NAME="${ri_prefix}"'$(RUBYW_BASE_NAME)'"${ri_suffix}"
|
|
rubyw_install_name='$(RUBYW_INSTALL_NAME)'
|
|
;;
|
|
esac
|
|
|
|
rubylibprefix='${libdir}/${RUBY_BASE_NAME}'
|
|
AC_ARG_WITH(rubylibprefix,
|
|
AS_HELP_STRING([--with-rubylibprefix=DIR], [prefix for ruby libraries [[LIBDIR/RUBY_BASE_NAME]]]),
|
|
[rubylibprefix=$withval])
|
|
RUBY_LIB_PREFIX=`eval echo \\"${rubylibprefix}\\"`
|
|
AC_SUBST(rubylibprefix)
|
|
|
|
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])
|
|
RIDIR=`eval echo \\"${ridir}\\"`
|
|
AC_SUBST(ridir)
|
|
|
|
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
|
|
case "$ruby_version" in
|
|
when(full)
|
|
RUBY_LIB_VERSION_STYLE='3 /* full */'
|
|
;;
|
|
when(minor)
|
|
RUBY_LIB_VERSION_STYLE='2 /* minor */'
|
|
;;
|
|
esac
|
|
if test ${RUBY_LIB_VERSION_STYLE+set}; then
|
|
{
|
|
echo "#define RUBY_LIB_VERSION_STYLE $RUBY_LIB_VERSION_STYLE"
|
|
echo '#define STRINGIZE(x) x'
|
|
echo '#include "version.h"'
|
|
echo 'ruby_version=RUBY_LIB_VERSION'
|
|
} > conftest.c
|
|
ruby_version="`$CPP -I"${srcdir}" -I"${srcdir}/include" conftest.c | sed '/^ruby_version=/!d;s/ //g'`"
|
|
eval $ruby_version
|
|
else
|
|
RUBY_LIB_VERSION="\"${ruby_version}\""
|
|
fi
|
|
|
|
AC_ARG_WITH(sitedir,
|
|
AS_HELP_STRING([--with-sitedir=DIR], [site libraries in DIR [[RUBY_LIB_PREFIX/site_ruby]]]),
|
|
[sitedir=$withval],
|
|
[sitedir='${rubylibprefix}/site_ruby'])
|
|
dir="${sitedir}"
|
|
until SITE_DIR=`eval echo \\"${dir}\\"`; test "x${dir}" = "x${SITE_DIR}"; do
|
|
dir="${SITE_DIR}"
|
|
done
|
|
|
|
AC_ARG_WITH(vendordir,
|
|
AS_HELP_STRING([--with-vendordir=DIR], [vendor libraries in DIR [[RUBY_LIB_PREFIX/vendor_ruby]]]),
|
|
[vendordir=$withval],
|
|
[vendordir='${rubylibprefix}/vendor_ruby'])
|
|
dir="${vendordir}"
|
|
until VENDOR_DIR=`eval echo \\"${dir}\\"`; test "x${dir}" = "x${VENDOR_DIR}"; do
|
|
dir="${VENDOR_DIR}"
|
|
done
|
|
|
|
if test "${LOAD_RELATIVE+set}"; then
|
|
AC_DEFINE_UNQUOTED(LOAD_RELATIVE, $LOAD_RELATIVE)
|
|
RUBY_LIB_PREFIX="`eval echo "$RUBY_LIB_PREFIX" | sed 's|^NONE/|/|;s|^'"$prefix"'/|/|'`"
|
|
RUBY_SITE_LIB_PATH="`eval echo "$SITE_DIR" | sed 's|^NONE/|/|;s|^'"$prefix"'/|/|'`"
|
|
RUBY_VENDOR_LIB_PATH="`eval echo "$VENDOR_DIR" | sed 's|^NONE/|/|;s|^'"$prefix"'/|/|'`"
|
|
else
|
|
RUBY_LIB_PREFIX="`eval echo \\"$RUBY_LIB_PREFIX\\" | sed 's|^NONE/|'"$prefix"'/|'`"
|
|
RUBY_SITE_LIB_PATH="`eval echo \\"$SITE_DIR\\" | sed 's|^NONE/|'"$prefix"'/|'`"
|
|
RUBY_VENDOR_LIB_PATH="`eval echo \\"$VENDOR_DIR\\" | sed 's|^NONE/|'"$prefix"'/|'`"
|
|
fi
|
|
|
|
pat="$RUBY_LIB_PREFIX/"'\(.*\)'
|
|
RUBY_LIB_PATH='RUBY_LIB_PREFIX"/"RUBY_LIB_VERSION'
|
|
case "$RUBY_SITE_LIB_PATH" in
|
|
when("$RUBY_LIB_PREFIX/"*)
|
|
RUBY_SITE_LIB_PATH='RUBY_LIB_PREFIX"/'"`expr \"$RUBY_SITE_LIB_PATH\" : \"$pat\"`"'"'
|
|
;;
|
|
when(*)
|
|
RUBY_SITE_LIB_PATH="\"${RUBY_SITE_LIB_PATH}\""
|
|
;;
|
|
esac
|
|
RUBY_SITE_LIB_PATH2='RUBY_SITE_LIB"/"RUBY_LIB_VERSION'
|
|
case "$RUBY_VENDOR_LIB_PATH" in
|
|
when("$RUBY_LIB_PREFIX/"*)
|
|
RUBY_VENDOR_LIB_PATH='RUBY_LIB_PREFIX"/'"`expr \"$RUBY_VENDOR_LIB_PATH\" : \"$pat\"`"'"'
|
|
;;
|
|
when(*)
|
|
RUBY_VENDOR_LIB_PATH="\"${RUBY_VENDOR_LIB_PATH}\""
|
|
;;
|
|
esac
|
|
RUBY_VENDOR_LIB_PATH2='RUBY_VENDOR_LIB"/"RUBY_LIB_VERSION'
|
|
|
|
if test ${RUBY_LIB_VERSION_STYLE+set}; then
|
|
AC_DEFINE_UNQUOTED(RUBY_LIB_VERSION_STYLE, $RUBY_LIB_VERSION_STYLE)
|
|
else
|
|
AC_DEFINE_UNQUOTED(RUBY_LIB_VERSION, [$RUBY_LIB_VERSION])
|
|
fi
|
|
AC_DEFINE_UNQUOTED(RUBY_LIB_PREFIX, "${RUBY_LIB_PREFIX}")
|
|
AC_DEFINE_UNQUOTED(RUBY_LIB, ${RUBY_LIB_PATH})
|
|
AC_DEFINE_UNQUOTED(RUBY_SITE_LIB, ${RUBY_SITE_LIB_PATH})
|
|
AC_DEFINE_UNQUOTED(RUBY_SITE_LIB2, ${RUBY_SITE_LIB_PATH2})
|
|
AC_DEFINE_UNQUOTED(RUBY_VENDOR_LIB, ${RUBY_VENDOR_LIB_PATH})
|
|
AC_DEFINE_UNQUOTED(RUBY_VENDOR_LIB2, ${RUBY_VENDOR_LIB_PATH2})
|
|
|
|
AC_SUBST(arch)dnl
|
|
AC_SUBST(sitearch)dnl
|
|
AC_SUBST(ruby_version)dnl
|
|
AC_SUBST(sitedir)dnl
|
|
AC_SUBST(vendordir)dnl
|
|
|
|
configure_args=$ac_configure_args
|
|
AC_SUBST(configure_args)dnl
|
|
|
|
if test "${universal_binary-no}" = yes ; then
|
|
arch="universal-${target_os}"
|
|
AC_CACHE_CHECK(whether __ARCHITECTURE__ is available, rb_cv_architecture_available,
|
|
AC_TRY_COMPILE([const char arch[] = __ARCHITECTURE__;], [puts(arch);],
|
|
[rb_cv_architecture_available=yes], [rb_cv_architecture_available=no]))
|
|
if test "${rb_cv_architecture_available}" = yes; then
|
|
AC_DEFINE_UNQUOTED(RUBY_PLATFORM_CPU, __ARCHITECTURE__)
|
|
else
|
|
for archs in ${universal_archnames}; do
|
|
cpu=`echo $archs | sed 's/.*=//'`
|
|
archs=`echo $archs | sed 's/=.*//'`
|
|
RUBY_DEFINE_IF([defined __${archs}__], RUBY_PLATFORM_CPU, ["${cpu}"])
|
|
done
|
|
fi
|
|
ints='long int'
|
|
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)
|
|
AC_DEFINE_UNQUOTED(RUBY_THIN_ARCHLIB, RUBY_LIB"/"RUBY_PLATFORM_CPU"-"RUBY_PLATFORM_OS)
|
|
AC_DEFINE_UNQUOTED(RUBY_SITE_THIN_ARCHLIB, RUBY_SITE_LIB2"/"RUBY_PLATFORM_CPU"-"RUBY_PLATFORM_OS)
|
|
AC_DEFINE_UNQUOTED(RUBY_VENDOR_THIN_ARCHLIB, RUBY_VENDOR_LIB2"/"RUBY_PLATFORM_CPU"-"RUBY_PLATFORM_OS)
|
|
else
|
|
arch="${target_cpu}-${target_os}"
|
|
AC_DEFINE_UNQUOTED(RUBY_PLATFORM, "${arch}")
|
|
fi
|
|
|
|
unset sitearch
|
|
case "$target_os" in
|
|
when(mingw*) sitearch="$target_cpu-$rb_cv_msvcrt" ;;
|
|
esac
|
|
test ${sitearch+set} && AC_DEFINE_UNQUOTED(RUBY_SITEARCH, "${sitearch}")
|
|
|
|
AC_DEFINE_UNQUOTED(RUBY_ARCHLIB, RUBY_LIB"/"RUBY_ARCH)
|
|
AC_DEFINE_UNQUOTED(RUBY_SITE_ARCHLIB, RUBY_SITE_LIB2"/"RUBY_SITEARCH)
|
|
AC_DEFINE_UNQUOTED(RUBY_VENDOR_ARCHLIB, RUBY_VENDOR_LIB2"/"RUBY_SITEARCH)
|
|
|
|
AC_ARG_WITH(search-path,
|
|
AS_HELP_STRING([--with-search-path=DIR], [specify the additional search path]),
|
|
[search_path=$withval])
|
|
if test "$search_path" != ""; then
|
|
AC_DEFINE_UNQUOTED(RUBY_SEARCH_PATH,"$search_path")
|
|
fi
|
|
|
|
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_BASE_NAME}-${ruby_version}'])
|
|
|
|
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(vendorhdrdir,
|
|
AS_HELP_STRING([--with-vendorhdrdir=DIR], [ core vendor headers in DIR [RUBYHDRDIR/vendor_ruby]]),
|
|
[vendorhdrdir=$withval],
|
|
[vendorhdrdir='${rubyhdrdir}/vendor_ruby'])
|
|
|
|
AC_SUBST(rubyhdrdir)dnl
|
|
AC_SUBST(sitehdrdir)dnl
|
|
AC_SUBST(vendorhdrdir)dnl
|
|
|
|
AC_ARG_WITH(mantype,
|
|
AS_HELP_STRING([--with-mantype=TYPE], [specify man page type; TYPE is one of man and doc]),
|
|
[
|
|
case "$withval" in
|
|
when(man|doc)
|
|
MANTYPE=$withval
|
|
;;
|
|
when(*)
|
|
AC_MSG_ERROR(invalid man type: $withval)
|
|
;;
|
|
esac
|
|
])
|
|
if test -z "$MANTYPE"; then
|
|
AC_PATH_PROGS(NROFF, nroff awf, /bin/false, "/usr/bin:/usr/ucb")
|
|
if ${NROFF} -mdoc ${srcdir}/man/ruby.1 >/dev/null 2>&1; then
|
|
MANTYPE=doc
|
|
else
|
|
MANTYPE=man
|
|
fi
|
|
fi
|
|
AC_SUBST(MANTYPE)
|
|
|
|
arch_hdrdir="${EXTOUT}/include/${arch}/ruby"
|
|
$MAKEDIRS "${arch_hdrdir}"
|
|
config_h="${arch_hdrdir}/config.h"
|
|
if test -f "${config_h}" && tr -d '\015' < confdefs.h | cmp -s "${config_h}" -; then
|
|
echo "config.h unchanged"
|
|
else
|
|
echo "creating config.h"
|
|
tr -d '\015' < confdefs.h > "${config_h}"
|
|
fi
|
|
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 `basename $e .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 `basename $e .trans`"'.c';
|
|
BUILTIN_TRANSOBJS="$BUILTIN_TRANSOBJS `basename $e .trans`"'.$(OBJEXT)';
|
|
done
|
|
AC_SUBST(BUILTIN_TRANSSRCS)
|
|
AC_SUBST(BUILTIN_TRANSOBJS)
|
|
|
|
PACKAGE=$RUBY_BASE_NAME
|
|
AC_SUBST(PACKAGE)
|
|
AC_MSG_RESULT($PACKAGE library version = $ruby_version)
|
|
|
|
AC_CONFIG_FILES($FIRSTMAKEFILE)
|
|
AC_CONFIG_FILES(Makefile, [{
|
|
if test -d "$srcdir/.svn"; then
|
|
VCS='svn'
|
|
VCSUP='$(VCS) up $(SVNUPOPTIONS)'
|
|
elif test -d "$srcdir/.git/svn"; then
|
|
VCS='git svn'
|
|
VCSUP='$(VCS) rebase $(GITSVNREBASEOPTIONS)'
|
|
elif test -d "$srcdir/.git"; then
|
|
VCS='git'
|
|
VCSUP='$(VCS) pull $(GITPULLOPTIONS)'
|
|
else
|
|
VCS='echo cannot'
|
|
VCSUP='$(VCS)'
|
|
fi
|
|
sed '/^MISSING/s/\$U\././g;/^VCS *=/s#@VCS@#'"$VCS"'#;/^VCSUP *=/s#@VCSUP@#'"$VCSUP"'#' Makefile
|
|
echo; test x"$EXEEXT" = x || echo 'miniruby: miniruby$(EXEEXT)'
|
|
if test "$gnumake" != yes; then
|
|
echo ['$(MKFILES): $(srcdir)/common.mk']
|
|
sed ['s/{\$([^(){}]*)[^{}]*}//g'] ${srcdir}/common.mk
|
|
else
|
|
echo 'distclean-local::; @$(RM) GNUmakefile uncommon.mk'
|
|
fi
|
|
} > confmk$$.tmp && mv -f confmk$$.tmp Makefile &&
|
|
${MAKE-make} info-program | grep '^PROGRAM=ruby$' > /dev/null ||
|
|
echo 'ruby: $(PROGRAM);' >> Makefile],
|
|
[EXEEXT=$EXEEXT gnumake=$gnumake])
|
|
AC_OUTPUT
|
|
dnl }
|
|
dnl }
|