From d464704f111d211c1f1ff9ef23ef1d755054be00 Mon Sep 17 00:00:00 2001 From: shyouhei Date: Wed, 15 Aug 2007 19:08:43 +0000 Subject: add tag v1_8_5_54 git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/tags/v1_8_5_54@12952 b2dd03c8-39d4-4d8f-98ff-823fe69b080e --- ruby_1_8_5/configure.in | 1608 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1608 insertions(+) create mode 100644 ruby_1_8_5/configure.in (limited to 'ruby_1_8_5/configure.in') diff --git a/ruby_1_8_5/configure.in b/ruby_1_8_5/configure.in new file mode 100644 index 0000000000..b3288f8c03 --- /dev/null +++ b/ruby_1_8_5/configure.in @@ -0,0 +1,1608 @@ +dnl Process this file with autoconf to produce a configure script. +AC_INIT() + +AC_PREREQ(2.58) + +AC_DEFUN([RUBY_MINGW32], +[case "$host_os" in +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)]) + +rb_version=`grep RUBY_VERSION $srcdir/version.h` +MAJOR=`expr "$rb_version" : '#define RUBY_VERSION "\([0-9][0-9]*\)\.[0-9][0-9]*\.[0-9][0-9]*"'` +MINOR=`expr "$rb_version" : '#define RUBY_VERSION "[0-9][0-9]*\.\([0-9][0-9]*\)\.[0-9][0-9]*"'` +TEENY=`expr "$rb_version" : '#define RUBY_VERSION "[0-9][0-9]*\.[0-9][0-9]*\.\([0-9][0-9]*\)"'` +AC_SUBST(MAJOR) +AC_SUBST(MINOR) +AC_SUBST(TEENY) +dnl checks for alternative programs +AC_ARG_WITH(gcc, [ --without-gcc never use gcc], [ + case $withval in + no) : ${CC=cc} + ;; + yes) : ${CC=gcc} + ;; + *) 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 +AC_CANONICAL_TARGET +target_os=`echo $target_os | sed 's/linux-gnu$/linux/;s/linux-gnu/linux-/'` +ac_install_sh='' # unusable for extension libraries. + +dnl checks for fat-binary +AC_ARG_ENABLE(fat-binary, + [ --enable-fat-binary=ARCHS + build an Apple/NeXT Multi Architecture Binary (MAB); + ARCHS is a comma-delimited list of architectures for + which to build; if ARCHS is omitted, then the package + will be built for all architectures supported by the + platform ("ppc" for MacOS/X and Darwin; "ppc,i386" + for Rhapsody; "m68k,i386,sparc" for OpenStep; + "m68k,i386,sparc,hppa" for NextStep); if this option + is disabled or omitted entirely, then the package + will be built only for the target platform], + [fat_binary=$enableval], [fat_binary=no]) +if test "$fat_binary" != no; then + + AC_MSG_CHECKING([target architectures]) + + # Respect TARGET_ARCHS setting from environment if available. + if test -z "$TARGET_ARCHS"; then + # Respect ARCH given to --enable-fat-binary if present. + if test "$fat_binary" != yes; then + TARGET_ARCHS=`echo "$fat_binary" | tr ',' ' '` + else + # Choose a default set of architectures based upon platform. + case "$target_os" in + darwin*) + TARGET_ARCHS="ppc" + ;; + rhapsody*) + TARGET_ARCHS="ppc i386" + ;; + openstep*) + TARGET_ARCHS="m68k i386 sparc" + ;; + nextstep*) + TARGET_ARCHS="m68k i386 sparc hppa" + ;; + *) + TARGET_ARCHS=`arch` + esac + fi + fi + + AC_MSG_RESULT([$TARGET_ARCHS]) + + # /usr/lib/arch_tool -archify_list $TARGET_ARCHS + ARCH_FLAG= + for archs in $TARGET_ARCHS + do + ARCH_FLAG="$ARCH_FLAG -arch $archs" + done + AC_DEFINE(NEXT_FAT_BINARY) +fi + +case $target_cpu in + i?86) frame_address=yes;; + *) frame_address=no;; +esac +AC_ARG_ENABLE(frame-address, + [ --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_PROGRAM + +dnl Checks for programs. + +if test x"${build}" != x"${host}"; then + AC_CHECK_TOOL(CC, gcc) +fi +AC_PROG_CC +AC_PROG_GCC_TRADITIONAL + +RUBY_PROG_GNU_LD +RUBY_CPPOUTFILE + +: ${OUTFLAG='-o '} +AC_SUBST(OUTFLAG) + +RUBY_MINGW32 + +AC_PROG_YACC +if test "$YACC" = "yacc"; then + AC_DEFINE([OLD_YACC]) +fi + +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 +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 + mingw*) + test "$rb_cv_msvcrt" = "" && unset rb_cv_msvcrt + AC_CHECK_TOOL(OBJDUMP, objdump) + AC_CACHE_CHECK(for mingw32 runtime DLL, rb_cv_msvcrt, [ + AC_TRY_LINK([#include ], + [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]) + AC_ARG_WITH(winsock2, + [ --with-winsock2 link winsock2 (MinGW only)], [ + case $withval in + yes) with_winsock2=yes;; + *) with_winsock2=no;; + esac], [with_winsock2=no]) + if test "$with_winsock2" = yes; then + AC_DEFINE(USE_WINSOCK2) + fi + esac + : ${enable_shared=yes} + ;; +aix*) + AC_CHECK_TOOL(NM, nm, /usr/ccs/bin/nm, /usr/ccs/bin:$PATH) + ;; +hiuxmpp*) + # by TOYODA Eizi + 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_AIX +AC_MINIX + +AC_SUBST(RM, ['rm -f']) +AC_SUBST(CP, ['cp']) +if $as_mkdir_p; then + AC_SUBST(MAKEDIRS, ['mkdir -p']) +else + AC_SUBST(MAKEDIRS, ['install -d']) +fi + +dnl check for large file stuff +AC_SYS_LARGEFILE + +AC_CHECK_TYPES([long long, off_t]) + +AC_CHECK_SIZEOF(int, 4) +AC_CHECK_SIZEOF(short, 2) +AC_CHECK_SIZEOF(long, 4) +AC_CHECK_SIZEOF(long long, 0) +AC_CHECK_SIZEOF(__int64, 0) +AC_CHECK_SIZEOF(off_t, 0) +AC_CHECK_SIZEOF(void*, 4) +AC_CHECK_SIZEOF(float, 4) +AC_CHECK_SIZEOF(double, 8) +AC_CHECK_SIZEOF(time_t, 0) + +for id in pid_t gid_t uid_t; do + AC_CHECK_TYPE($id, [typ=$id], [typ=int]) + AC_DEFINE_UNQUOTED(rb_$id, $typ) +done + +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(for variable length prototypes and stdarg.h, rb_cv_stdarg, + [AC_TRY_COMPILE([ +#include +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 noreturn], rb_cv_noreturn, +[rb_cv_noreturn=x +for mac in "x __attribute__ ((noreturn))" "__declspec(noreturn) x" x; do + AC_TRY_COMPILE( + [#define NORETURN(x) $mac +NORETURN(void exit(int x));], + [], + [rb_cv_noreturn="$mac"; break]) +done]) +AC_DEFINE_UNQUOTED([NORETURN(x)], $rb_cv_noreturn) + +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) + +XCFLAGS="$XCFLAGS -DRUBY_EXPORT" + +dnl Check whether we need to define sys_nerr locally +AC_CHECK_DECLS([sys_nerr], [], [], [$ac_includes_default +#include ]) + +dnl whether link libc_r or not +AC_ARG_WITH(libc_r, + [ --with-libc_r link libc_r if possible (FreeBSD only)], [ + case $withval in + yes) with_libc_r=yes;; + *) with_libc_r=no;; + esac], [with_libc_r=no]) + +AC_ARG_ENABLE(pthread, + [ --enable-pthread use pthread library.], + [enable_pthread=$enableval], [enable_pthread=no]) + +dnl Checks for libraries. +case "$target_os" in +nextstep*) ;; +openstep*) ;; +rhapsody*) ;; +darwin*) LIBS="-lobjc $LIBS";; +hpux*) LIBS="-lm $LIBS" + ac_cv_c_inline=no;; +human*) ac_cv_func_getpgrp_void=yes + ac_cv_func_setitimer=no + ;; +beos*) ac_cv_func_link=no;; +cygwin*) rb_cv_have_daylight=no + ac_cv_var_tzname=no + ac_cv_func__setjmp=no + ac_cv_func_setitimer=no + ;; +mingw*) if test "$with_winsock2" = yes; then + LIBS="-lws2_32 $LIBS" + else + LIBS="-lwsock32 $LIBS" + fi + 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_func_times=yes + ac_cv_func_waitpid=yes + ac_cv_func_fsync=yes + ac_cv_func_vsnprintf=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_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 + enable_pthread=no + ;; +os2-emx*) LIBS="-lm $LIBS" + ac_cv_lib_dir_opendir=no;; +msdosdjgpp*) LIBS="-lm $LIBS" + ac_cv_func_getpgrp_void=yes + ac_cv_func_setitimer=no + ac_cv_sizeof_rlim_t=4 + ;; +bsdi*) LIBS="-lm $LIBS" + ac_cv_sizeof_rlim_t=8;; +freebsd*) LIBS="-lm $LIBS" + AC_CACHE_CHECK([whether -lxpg4 has to be linked], + rb_cv_lib_xpg4_needed, + [AC_TRY_CPP([ +#include +#if __FreeBSD_version < 400020 || \ + (__FreeBSD_version >= 500000 && __FreeBSD_version < 500005) +#error needs libxpg4 +#endif + ], + rb_cv_lib_xpg4_needed=no, + rb_cv_lib_xpg4_needed=yes, + rb_cv_lib_xpg4_needed=yes)]) + if test "$rb_cv_lib_xpg4_needed" = yes; then + AC_CHECK_LIB(xpg4, setlocale) + fi + if test "$with_libc_r" = yes; then + AC_CACHE_CHECK([whether libc_r is supplementary to libc], + rb_cv_supplementary_lib_c_r, + [AC_TRY_CPP([ +#include +#if 500016 <= __FreeBSD_version +#error libc_r is supplementary to libc +#endif + ], + rb_cv_supplementary_lib_c_r=no, + rb_cv_supplementary_lib_c_r=yes, + rb_cv_supplementary_lib_c_r=yes)]) + if test "$rb_cv_supplementary_lib_c_r" = yes; then + MAINLIBS="-lc_r $MAINLIBS" + fi + fi + ;; +dragonfly*) LIBS="-lm $LIBS" + ;; +bow) ac_cv_func_setitimer=no + ;; +superux*) ac_cv_func_setitimer=no + ;; +solaris*2.10) if test -z "$GCC"; then + ac_cv_func_isinf=yes + fi + LIBS="-lm $LIBS" + ;; +*) 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 + +case "$target_cpu" in +alpha*) case "$target_os"::"$GCC" in + *::yes) CFLAGS="-mieee $CFLAGS" ;; # gcc + osf*) CFLAGS="-ieee $CFLAGS" ;; # ccc + esac ;; +esac + +dnl Checks for header files. +AC_HEADER_DIRENT +AC_HEADER_STDC +AC_HEADER_SYS_WAIT +AC_CHECK_HEADERS(stdlib.h string.h unistd.h 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 memory.h direct.h sys/resource.h \ + sys/mkdev.h sys/utime.h netinet/in_systm.h float.h ieeefp.h pthread.h \ + ucontext.h intrinsics.h) + +dnl Check additional types. +AC_CHECK_SIZEOF(rlim_t, 0, [ + #ifdef HAVE_SYS_TYPES_H + # include + #endif + #ifdef HAVE_SYS_TIME_H + # include + #endif + #ifdef HAVE_SYS_RESOURCE_H + # include + #endif + #ifdef HAVE_UNISTD_H + # include + #endif + #include +]) + +dnl Checks for typedefs, structures, and compiler characteristics. +AC_TYPE_SIZE_T +AC_STRUCT_ST_BLKSIZE +AC_STRUCT_ST_BLOCKS +AC_STRUCT_ST_RDEV + +dnl Checks for library functions. +AC_TYPE_GETGROUPS +AC_TYPE_SIGNAL +AC_FUNC_ALLOCA +AC_FUNC_MEMCMP +AC_FUNC_FSEEKO +AC_CHECK_FUNCS(ftello) +AC_REPLACE_FUNCS(dup2 memmove strcasecmp strncasecmp strerror strftime\ + strchr strstr strtoul crypt flock vsnprintf\ + isnan finite isinf hypot acosh erf) +AC_CHECK_FUNCS(fmod killpg wait4 waitpid syscall chroot fsync getcwd eaccess\ + truncate chsize times utimes fcntl lockf lstat symlink link\ + readlink setitimer setruid seteuid setreuid setresuid\ + setproctitle setrgid setegid setregid setresgid issetugid pause\ + lchown lchmod getpgrp setpgrp getpgid setpgid initgroups\ + getgroups setgroups getpriority getrlimit setrlimit sysconf\ + dlopen sigprocmask\ + sigaction _setjmp setsid telldir seekdir fchmod mktime timegm\ + cosh sinh tanh setuid setgid setenv unsetenv) +AC_ARG_ENABLE(setreuid, + [ --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 ], + [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 + 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_CACHE_CHECK(for negative time_t for gmtime(3), rb_cv_negative_time_t, + [AC_TRY_RUN([ +#include + +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_CACHE_CHECK(for BSD signal semantics, rb_cv_bsd_signal, + [AC_TRY_RUN([ +#include +#include + +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=no)]) + 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 + +AC_CACHE_CHECK(whether right shift preserve sign bit, rb_cv_rshift_sign, + [AC_TRY_RUN([ +int +main() +{ + if (-1==(-1>>1)) + return 0; + return 1; +} +], + rb_cv_rshift_sign=yes, + rb_cv_rshift_sign=no, + rb_cv_rshift_sign=yes)]) +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 +], + [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 +; do + AC_TRY_COMPILE([#include +], + [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 + ; do + AC_TRY_COMPILE([#include + ], + [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 + +AC_DEFUN([RUBY_CHECK_IO_NEED], +[AC_CACHE_CHECK(whether need to [$1], [$2], + [AC_TRY_RUN([ +#include +#ifndef SEEK_SET +#define SEEK_SET 0 +#endif +#ifndef SEEK_CUR +#define SEEK_CUR 1 +#endif +#define before_seek(f) ]ifelse(index($2,flush_before_seek),-1,[fflush(f)],[(f,0)])[ +#define reset_rw(f) ]ifelse(index($2,seek_between_rw),-1,[do_seek(f,SEEK_CUR)],[(f,0)])[ +#define do_seek(f, w) (before_seek(f), fseek(f,0,w)) + +char *fn = "conftest.dat"; +char *wombat = "wombat\n"; +char *koara = "koara\n"; +char *kangaroo = "kangaroo\n"; + +int main() +{ + char buf[BUFSIZ]; + FILE *f; + int r = 1; + + if (!(f = fopen(fn, "w+"))) return 1; + fputs(wombat, f); + do_seek(f, SEEK_SET); + if (!fgets(buf, BUFSIZ, f) || strcmp(buf, wombat)) goto fail; + reset_rw(f); + fputs(koara, f); + fputs(kangaroo, f); + do_seek(f, SEEK_SET); + if (!fgets(buf, BUFSIZ, f) || strcmp(buf, wombat)) goto fail; + if (!fgets(buf, BUFSIZ, f) || strcmp(buf, koara)) goto fail; + if (!fgets(buf, BUFSIZ, f) || strcmp(buf, kangaroo)) goto fail; + do_seek(f, SEEK_SET); + if (!fgets(buf, BUFSIZ, f) || strcmp(buf, wombat)) goto fail; + reset_rw(f); + fputc('X', f); + reset_rw(f); + if (!fgets(buf, BUFSIZ, f) || strcmp(buf, koara+1)) goto fail; + if (!fgets(buf, BUFSIZ, f) || strcmp(buf, kangaroo)) goto fail; + do_seek(f, SEEK_SET); + if (!fgets(buf, BUFSIZ, f) || strcmp(buf, wombat)) goto fail; + if (!fgets(buf, BUFSIZ, f) || buf[0] != 'X' || strcmp(buf+1, koara+1)) goto fail; + if (!fgets(buf, BUFSIZ, f) || strcmp(buf, kangaroo)) goto fail; + r = 0; + fail: + fclose(f); + unlink(fn); + return r; +} +], [$2]=no, [$2]=yes, [$2]=[$3])])]) +RUBY_CHECK_IO_NEED(seek between R/W, rb_cv_need_io_seek_between_rw, yes) +if test "$rb_cv_need_io_seek_between_rw" = yes; then + AC_DEFINE(NEED_IO_SEEK_BETWEEN_RW, 1) +fi +dnl RUBY_CHECK_IO_NEED(flush before seek, rb_cv_need_io_flush_before_seek, no) +dnl if test "$rb_cv_need_io_flush_before_seek" = yes; then +dnl AC_DEFINE(NEED_IO_FLUSH_BEFORE_SEEK, 1) +dnl fi + +AC_CACHE_CHECK([whether st_ino is huge], rb_cv_huge_st_ino, +[AC_COMPILE_IFELSE([AC_LANG_BOOL_COMPILE_TRY([ +#include +struct stat test_stat; +], [sizeof(test_stat.st_ino)>sizeof(long)])], +rb_cv_huge_st_ino=yes, +rb_cv_huge_st_ino=no) +]) +if test $rb_cv_huge_st_ino = yes; then + AC_DEFINE(HUGE_ST_INO) +fi + +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 + ], + [_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 +m68*|i?86|ia64|sparc*|alpha*) rb_cv_stack_grow_dir=-1;; +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 pthread pthreads c c_r; 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 + c) + ;; + c_r) + MAINLIBS="-pthread $MAINLIBS" + ;; + *) + 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) + 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"$target_cpu" = xia64 -o x"$rb_with_pthread" = xyes; then + AC_CHECK_FUNCS(getcontext setcontext) + fi +fi + +dnl default value for $KANJI +DEFAULT_KCODE="KCODE_NONE" + +AC_ARG_WITH(default-kcode, + [ --with-default-kcode=CODE specify default value for \$KCODE (utf8|euc|sjis|none)], + [case $withval in + utf8) DEFAULT_KCODE="KCODE_UTF8";; + euc) DEFAULT_KCODE="KCODE_EUC";; + sjis) DEFAULT_KCODE="KCODE_SJIS";; + none) DEFAULT_KCODE="KCODE_NONE";; + *) AC_MSG_WARN($withval is not valid kcode; ignored);; + esac]) +AC_DEFINE_UNQUOTED(DEFAULT_KCODE, $DEFAULT_KCODE) + +dnl wheather use dln_a_out or not +AC_ARG_WITH(dln-a-out, + [ --with-dln-a-out use dln_a_out if possible], [ + case $withval in + yes) with_dln_a_out=yes;; + *) 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_RUN([ +/* Test for whether ELF binaries are produced */ +#include +#include +main() { + char buffer[4]; + int i=open("conftest",O_RDONLY); + if(i==-1) + exit(1); /* fail */ + if(read(i,&buffer[0],4)<4) + exit(1); /* fail */ + if(buffer[0] != 127 || buffer[1] != 'E' || + buffer[2] != 'L' || buffer[3] != 'F') + exit(1); /* fail */ + exit(0); /* succeed (yes, it's ELF) */ +} +], +rb_cv_binary_elf=yes, +rb_cv_binary_elf=no, +rb_cv_binary_elf=yes)]) + +if test "$rb_cv_binary_elf" = yes; then + AC_DEFINE(USE_ELF) +fi + +case "$target_os" in +linux* | gnu* | k*bsd*-gnu | bsdi*) + 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(DLEXT)dnl +AC_SUBST(DLEXT2)dnl +AC_SUBST(LIBEXT)dnl + +STATIC= +: ${LIBPATHFLAG=' -L"%s"'} +: ${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 + nextstep*) CCDLFLAGS="$CCDLFLAGS -fno-common";; + openstep*) CCDLFLAGS="$CCDLFLAGS -fno-common";; + rhapsody*) CCDLFLAGS="$CCDLFLAGS -fno-common";; + darwin*) CCDLFLAGS="$CCDLFLAGS -fno-common";; + human*|bsdi*|beos*|cygwin*|mingw*|aix*|interix*) ;; + *) CCDLFLAGS="$CCDLFLAGS -fPIC";; + esac + else + case "$target_os" in + hpux*) CCDLFLAGS="$CCDLFLAGS +Z";; + solaris*|irix*) CCDLFLAGS="$CCDLFLAGS -KPIC" ;; + sunos*) CCDLFLAGS="$CCDLFLAGS -PIC" ;; + esix*|uxpds*) CCDLFLAGS="$CCDLFLAGS -KPIC" ;; + *) : ${CCDLFLAGS=""} ;; + esac + fi + + case "$target_os" in + hpux*) DLDFLAGS="$DLDFLAGS -E" + : ${LDSHARED='ld -b'} + XLDFLAGS="$XLDFLAGS -Wl,-E" + : ${LIBPATHENV=SHLIB_PATH} + rb_cv_dlopen=yes;; + 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;; + 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="qcc -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*) case "$CC" in + *shlicc*) : ${LDSHARED="$CC -r"} + rb_cv_dlopen=yes ;; + esac ;; + linux* | gnu* | k*bsd*-gnu | netbsd* | bsdi*) + : ${LDSHARED='${CC} -shared'} + if test "$rb_cv_binary_elf" = yes; then + LDFLAGS="$LDFLAGS -Wl,-export-dynamic" + fi + 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"} + 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 ;; + openbsd*) : ${LDSHARED="\$(CC) -shared ${CCDLFLAGS}"} + if test "$rb_cv_binary_elf" = yes; then + LDFLAGS="$LDFLAGS -Wl,-E" + fi + rb_cv_dlopen=yes ;; + nextstep*) : ${LDSHARED='cc -r -nostdlib'} + LDFLAGS="$LDFLAGS -u libsys_s" + rb_cv_dlopen=yes ;; + openstep*) : ${LDSHARED='cc -dynamic -bundle -undefined suppress'} + : ${LDFLAGS=""} + rb_cv_dlopen=yes ;; + rhapsody*) : ${LDSHARED='cc -dynamic -bundle -undefined suppress'} + : ${LDFLAGS=""} + rb_cv_dlopen=yes ;; + darwin*) : ${LDSHARED='cc -dynamic -bundle -undefined suppress -flat_namespace'} + : ${LDFLAGS=""} + : ${LIBPATHENV=DYLD_LIBRARY_PATH} + rb_cv_dlopen=yes ;; + aix*) if test "$GCC" = yes; then + : ${LDSHARED='gcc -shared'} + DLDFLAGS='-Wl,-G -eInit_$(TARGET)' + LDFLAGS='-Wl,-brtl -Wl,-bE:ruby.imp' + else + : ${LDSHARED='/usr/ccs/bin/ld'} + DLDFLAGS='-G -eInit_$(TARGET)' + LDFLAGS="-brtl -bE:ruby.imp" + fi + : ${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} + rb_cv_dlopen=yes ;; + human*) : ${DLDFLAGS=''} + : ${LDSHARED=''} + : ${LDFLAGS=''} + : ${LINK_SO='ar cru $@ $(OBJS)'} + rb_cv_dlopen=yes ;; + beos*) case "$target_cpu" in + powerpc*) + : ${LDSHARED="ld -xms"} + DLDFLAGS="$DLDFLAGS "'-export Init_$(TARGET) -lbe -lroot glue-noinit.a init_term_dyn.o start_dyn.o' + ;; + i586*) + : ${LDSHARED="ld -shared"} + DLDFLAGS="$DLDFLAGS -L/boot/develop/lib/x86 -lbe -lroot" + ;; + esac + : ${LIBPATHENV=LIBRARY_PATH} + 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*|mingw*) : ${LDSHARED="${CC} -shared -s"} + XLDFLAGS="$XLDFLAGS -Wl,--stack,0x02000000" + DLDFLAGS="${DLDFLAGS} -Wl,--enable-auto-import,--export-all" + : ${LIBPATHENV=""} + rb_cv_dlopen=yes ;; + hiuxmpp) : ${LDSHARED='ld -r'} ;; + atheos*) : ${LDSHARED="$CC -shared"} + rb_cv_dlopen=yes ;; + os2-emx*) LDFLAGS="$LDFLAGS -Zbsd-signals" + ;; + *) : ${LDSHARED='ld'} ;; + esac + AC_MSG_RESULT($rb_cv_dlopen) + + AC_ARG_ENABLE(rpath, + [ --disable-rpath embed run path into extension libraries.], + [enable_rpath=$enableval], [enable_rpath="$rb_cv_binary_elf"]) + if test "$enable_rpath" = yes; then + LIBPATHFLAG=" -L'%1\$-s'" + if test "$GCC" = yes; then + RPATHFLAG=" -Wl,-R'%1\$-s'" + else + RPATHFLAG=" -R'%1\$-s'" + fi + fi +fi +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 + AC_DEFINE(DLEXT, ".so") + CCDLFLAGS= +else + case "$target_os" in + hpux*) DLEXT=sl + AC_DEFINE(DLEXT, ".sl");; + nextstep*) DLEXT=bundle + AC_DEFINE(DLEXT, ".bundle");; + openstep*) DLEXT=bundle + AC_DEFINE(DLEXT, ".bundle");; + rhapsody*) DLEXT=bundle + AC_DEFINE(DLEXT, ".bundle");; + darwin*) DLEXT=bundle + AC_DEFINE(DLEXT, ".bundle");; + os2-emx*) DLEXT=dll + AC_DEFINE(DLEXT, ".dll");; + cygwin*|mingw*) DLEXT=so + AC_DEFINE(DLEXT, ".so") + DLEXT2=dll + AC_DEFINE(DLEXT2, ".dll");; + *) DLEXT=so + AC_DEFINE(DLEXT, ".so");; + esac +fi + +AC_SUBST(STRIP)dnl +if test "$with_dln_a_out" = yes; then + STRIP=true +else + STRIP=strip +fi + +case "$target_os" in + linux* | gnu* | k*bsd*-gnu) + STRIP='strip -S -x';; + nextstep*) + STRIP='strip -A -n';; + openstep*) + STRIP='strip -A -n';; + rhapsody*) + STRIP='strip -A -n';; + darwin*) + STRIP='strip -A -n';; +esac + +EXTSTATIC= +AC_SUBST(EXTSTATIC)dnl +AC_ARG_WITH(static-linked-ext, + [ --with-static-linked-ext link external modules statically], + [case $withval in + yes) STATIC= + EXTSTATIC=static;; + *) ;; + esac]) + +case "$target_os" in + human*) + AC_CHECK_LIB(signal, _harderr) + AC_CHECK_LIB(hmem, hmemset) + AC_CHECK_FUNCS(select gettimeofday) + AC_CACHE_CHECK(whether PD libc _dtos18 fail to convert big number, + rb_cv_missing__dtos18, + [AC_TRY_RUN( +changequote(<<, >>)dnl +<< +#include +main () +{ + char buf[256]; + sprintf (buf, "%g", 1e+300); + exit (strcmp (buf, "1e+300") ? 0 : 1); +} +>>, +changequote([, ])dnl +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( +changequote(<<, >>)dnl +<< +#include +#include +main () +{ + char buf[256]; + sprintf (buf, "%f", log(exp(1.0))); + exit (strcmp (buf, "1.000000") ? 0 : 1); +} +>>, +changequote([, ])dnl +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 + AC_LIBOBJ([x68.o]) + CFLAGS="$CFLAGS -fansi-only" + XCFLAGS="$XCFLAGS -cc1-stack=262144 -cpp-stack=2694144" + EXEEXT=.x + OBJEXT=o + setup=Setup.x68 + ;; + dnl OS/2 environment w/ Autoconf 2.1x for EMX + os2-emx) + AC_LIBOBJ([os2]) + setup=Setup.emx + ;; + *djgpp*) + setup=Setup.dj + ;; + *) + setup=Setup + ;; +esac + +AC_SUBST(setup) + +if test "$prefix" = NONE; then + prefix=$ac_default_prefix +fi + +#if test "$fat_binary" != no ; then +# CFLAGS="$CFLAGS $ARCH_FLAG" +#fi + +if test x"$cross_compiling" = xyes; then + test x"$MINIRUBY" = x && MINIRUBY="${RUBY-ruby} -I`pwd` -rfake" + PREP=fake.rb + RUNRUBY='$(MINIRUBY) -I`cd $(srcdir)/lib; pwd`' +else + MINIRUBY='./miniruby$(EXEEXT)' + PREP='miniruby$(EXEEXT)' + RUNRUBY='$(MINIRUBY) $(srcdir)/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 + cygwin*|mingw*|beos*|openstep*|nextstep*|rhapsody*|darwin*|os2-emx*) + : ${DLDLIBS=""} + ;; + *) + DLDLIBS="$DLDLIBS -lc" + ;; +esac + +RUBY_SO_NAME='$(RUBY_INSTALL_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, + [ --enable-shared build a shared library for Ruby. ], + [enable_shared=$enableval]) +if test "$enable_shared" = 'yes'; then + LIBRUBY='$(LIBRUBY_SO)' + LIBRUBYARG_SHARED='-l$(RUBY_SO_NAME)' + LIBRUBYARG='$(LIBRUBYARG_SHARED)' + CFLAGS="$CFLAGS $CCDLFLAGS" + ENABLE_SHARED=yes + if test "$rb_cv_binary_elf" = yes; then + SOLIBS='$(LIBS)' + fi + case "$target_os" in + sunos4*) + LIBRUBY_ALIASES='lib$(RUBY_SO_NAME).so.$(MAJOR).$(MINOR) lib$(RUBY_SO_NAME).so' + ;; + linux* | gnu* | k*bsd*-gnu | atheos*) + 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' + ;; + 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 + ;; + 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 + ;; + openbsd*) + SOLIBS='$(LIBS)' + LIBRUBY_SO='lib$(RUBY_INSTALL_NAME).so.$(MAJOR).'`expr ${MINOR} \* 10 + ${TEENY}` + ;; + 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}' + ;; + 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' + ;; + aix*) + if test "$GCC" = yes; then + LIBRUBY_LDSHARED='$(CC) -shared' + LIBRUBY_DLDFLAGS='-Wl,-G -Wl,-bE:ruby.imp -Wl,-bnoentry' + else + LIBRUBY_LDSHARED='/usr/ccs/bin/ld' + LIBRUBY_DLDFLAGS='-G -bE:ruby.imp -bnoentry' + fi + LIBRUBYARG_SHARED='-L${libdir} -lruby' + SOLIBS='-lm -lc' + ;; + beos*) + case "$target_cpu" in + powerpc*) + LIBRUBY_DLDFLAGS='-f ruby.exp -lnet -lbe -lroot glue-noinit.a init_term_dyn.o start_dyn.o' + ;; + esac + ;; + darwin*) + LIBRUBY_SO='lib$(RUBY_SO_NAME).$(MAJOR).$(MINOR).$(TEENY).dylib' + LIBRUBY_LDSHARED='cc -dynamiclib -undefined suppress -flat_namespace' + LIBRUBY_DLDFLAGS='-install_name $(libdir)/lib$(RUBY_SO_NAME).dylib -current_version $(MAJOR).$(MINOR).$(TEENY) -compatibility_version $(MAJOR).$(MINOR)' + LIBRUBY_ALIASES='lib$(RUBY_SO_NAME).$(MAJOR).$(MINOR).dylib lib$(RUBY_SO_NAME).dylib' + ;; + interix*) + LIBRUBYARG_SHARED='-L${libdir} -L. -l$(RUBY_SO_NAME)' + ;; + *) + ;; + esac +fi +if test "$enable_rpath" = yes; then + if test "$GCC" = yes; then + LIBRUBYARG_SHARED='-Wl,-R -Wl,$(libdir) -L$(libdir) -L. '"$LIBRUBYARG_SHARED" + else + LIBRUBYARG_SHARED='-R $(libdir) -L$(libdir) -L. '"$LIBRUBYARG_SHARED" + fi +fi + +XLDFLAGS="$XLDFLAGS -L." +AC_SUBST(ARCHFILE) + +dnl build rdoc index if requested +RDOCTARGET="" +AC_ARG_ENABLE(install-doc, + [ --enable-install-doc build and install rdoc indexes during install ], + [install_doc=$enableval], [install_doc=no]) +if test "$install_doc" != no; then + RDOCTARGET="install-doc" +fi +AC_SUBST(RDOCTARGET) + +case "$target_os" in + netbsd*) + CFLAGS="$CFLAGS -pipe" + ;; + nextstep*|openstep*) + # 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. + CFLAGS="$CFLAGS -pipe -fno-common" + CPPFLAGS="$CPPFLAGS -I/usr/local/include" + ;; + rhapsody*) + CFLAGS="$CFLAGS -pipe -no-precomp -fno-common" + ;; + darwin*) + CFLAGS="$CFLAGS -pipe -fno-common" + ;; + os2-emx) + CFLAGS="$CFLAGS -DOS2 -Zmts" + 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//'` + ;; + 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 + */gemc_cc*) # we have the new DEC GEM CC + CFLAGS="$CFLAGS -oldc" + ;; + *) # we have the old MIPS CC + ;; + esac + # cleanup + rm -f /tmp/main.o + CFLAGS="$CFLAGS -std" + fi + ;; + beos*) + case "$target_cpu" in + powerpc*) + CFLAGS="$CFLAGS -relax_pointers" + ;; + esac + ;; + cygwin*|mingw*) + case "$target_os" in + cygwin*) + if test x"$enable_shared" = xyes; then + LIBRUBY_SO='cyg$(RUBY_SO_NAME)'${MAJOR}${MINOR}.dll + LIBRUBY='lib$(RUBY_SO_NAME).dll.a' + fi + AC_LIBOBJ([strftime]) + ;; + mingw*) + RUBY_SO_NAME=${rb_cv_msvcrt}-'$(RUBY_INSTALL_NAME)'${MAJOR}${MINOR} + if test x"$enable_shared" = xyes; then + LIBRUBY_SO='$(RUBY_SO_NAME)'.dll + LIBRUBY='lib$(LIBRUBY_SO).a' + fi + AC_LIBOBJ([win32]) + COMMON_LIBS=m +# COMMON_MACROS="WIN32_LEAN_AND_MEAN=" + COMMON_HEADERS="windows.h winsock.h" + ;; + esac + LIBRUBY_DLDFLAGS="${DLDFLAGS}"' -Wl,--out-implib=$(LIBRUBY)' + LIBRUBY_ALIASES='' + FIRSTMAKEFILE=GNUmakefile:cygwin/GNUmakefile.in + SOLIBS='$(LIBS)' + if test x"$enable_shared" = xno; then + LIBRUBY_SO=dummy + LIBRUBY='lib$(RUBY_SO_NAME).a' + LIBRUBYARG='-l$(RUBY_SO_NAME)' + fi + MINIOBJS=dmydln.o + ;; + hpux*) + case "$YACC" in + *yacc*) + XCFLAGS="$XCFLAGS -DYYMAXDEPTH=300" + YACC="$YACC -Nl40000 -Nm40000" + ;; + esac + MINIOBJS=dmydln.o + ;; + aix*) + PREINSTALL='@$(RM) -r $(prefix)/lib/$(LIBRUBY_A) $(prefix)/lib/$(LIBRUBY_SO) $(prefix)/lib/ruby/$(MAJOR).$(MINOR)/$(arch)' + ;; + *) + ;; +esac + +case "$build_os" in + *msdosdjgpp*) FIRSTMAKEFILE=GNUmakefile:djgpp/GNUmakefile.in;; +esac + +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(PREINSTALL) + +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${ri_suffix}" +case "$target_os" in + cygwin*|mingw*) + RUBYW_INSTALL_NAME="${ri_prefix}rubyw${ri_suffix}" + rubyw_install_name="$RUBYW_INSTALL_NAME" + ;; +esac +case "$target_os" in + cygwin*|mingw*|*djgpp*|os2-emx*) + RUBY_LIB_PREFIX="/lib/ruby" + ;; + *) + RUBY_LIB_PREFIX="${prefix}/lib/ruby" + ;; +esac +RUBY_LIB_PATH="${RUBY_LIB_PREFIX}/${MAJOR}.${MINOR}" + +AC_ARG_WITH(sitedir, + [ --with-sitedir=DIR site libraries in DIR [PREFIX/lib/ruby/site_ruby]], + [sitedir=$withval], + [sitedir='${prefix}/lib/ruby/site_ruby']) +SITE_DIR=`eval echo \\"${sitedir}\\"` +case "$target_os" in + cygwin*|mingw*|*djgpp*|os2-emx*) + RUBY_SITE_LIB_PATH="`expr "$SITE_DIR" : "$prefix\(/.*\)"`" || + RUBY_SITE_LIB_PATH="$SITE_DIR";; + *) + RUBY_SITE_LIB_PATH="$SITE_DIR";; +esac +RUBY_SITE_LIB_PATH2="${RUBY_SITE_LIB_PATH}/${MAJOR}.${MINOR}" + +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_SUBST(arch)dnl +AC_SUBST(sitearch)dnl +AC_SUBST(sitedir)dnl + +configure_args=$ac_configure_args +AC_SUBST(configure_args)dnl + +if test "$fat_binary" != no ; then + arch="fat-${target_os}" + + AC_DEFINE_UNQUOTED(RUBY_THIN_ARCHLIB, + "${RUBY_LIB_PATH}/" __ARCHITECTURE__ "-${target_os}") + + AC_DEFINE_UNQUOTED(RUBY_SITE_THIN_ARCHLIB, + "${RUBY_SITE_LIB_PATH}/" __ARCHITECTURE__ "-${target_os}") + AC_DEFINE_UNQUOTED(RUBY_PLATFORM, __ARCHITECTURE__ "-${target_os}") +else + arch="${target_cpu}-${target_os}" + AC_DEFINE_UNQUOTED(RUBY_PLATFORM, "${arch}") +fi + +case "$target_os" in + mingw*) sitearch="i386-$rb_cv_msvcrt" ;; + *) sitearch="${arch}" ;; +esac + +AC_DEFINE_UNQUOTED(RUBY_ARCHLIB, "${RUBY_LIB_PATH}/${arch}") +AC_DEFINE_UNQUOTED(RUBY_SITE_ARCHLIB, "${RUBY_SITE_LIB_PATH2}/${sitearch}") + +AC_ARG_WITH(search-path, + [ --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(mantype, + [ --with-mantype=TYPE specify man page type; TYPE is one of man and doc], + [ + case "$withval" in + man|doc) + MANTYPE=$withval + ;; + *) + 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}/ruby.1 >/dev/null 2>&1; then + MANTYPE=doc + else + MANTYPE=man + fi +fi +AC_SUBST(MANTYPE) + +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 +: > confdefs.h + +AC_CONFIG_FILES($FIRSTMAKEFILE) +AC_CONFIG_FILES(Makefile, [{ + echo; test x"$EXEEXT" = x || echo 'miniruby: miniruby$(EXEEXT)' + test "$RUBY_INSTALL_NAME$EXEEXT" = ruby || echo 'ruby: $(PROGRAM);' + sed ['s/{\$([^(){}]*)[^{}]*}//g'] ${srcdir}/common.mk +} >> Makefile], [RUBY_INSTALL_NAME=$RUBY_INSTALL_NAME EXEEXT=$EXEEXT]) +AC_OUTPUT -- cgit v1.2.3