configure.in

dnl Process this file with autoconf to produce a configure script.
AC_INIT(ruby.h)

MAJOR=1
MINOR=3
TEENY=1
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
		without_gcc=yes;;
	yes)	CC=gcc
		without_gcc=no;;
	*)	CC=$withval
		without_gcc=$withval;;
	esac], [without_gcc=no])
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_ERROR(cached CC is different -- throw away $cache_file
(it is also a good idea to do 'make clean' before compiling))
fi

dnl checks for thread
rb_thread=yes
AC_ARG_ENABLE(thread, [--disable-thread          never use user-level thread], [
	rb_thread=$enableval
])
if test $rb_thread = yes; then
  AC_DEFINE(USE_THREAD)
fi

AC_CANONICAL_HOST

dnl checks for fat-binary
fat_binary=no
AC_ARG_ENABLE( fat-binary,
       [--enable-fat-binary       build a NeXT/Apple Multi Architecture Binary. ],
       [ fat_binary=$enableval ] )
 if test "$fat_binary" = yes ; then

    AC_MSG_CHECKING( target architecture )

    case "$host_os" in
    rhapsody*)
        echo -n "MacOS X Server: "
  	if test "$TARGET_ARCHS" = "" ; then
           TARGET_ARCHS="ppc i386"
  	fi
	;;
    nextstep*|openstep*)
  	echo -n "NeXTSTEP/OPENSTEP: "

        if test "$host_os" = "rhapsody" ; then
            echo -n "Rhapsody: "
	    if test "$TARGET_ARCHS" = "" ; then
               TARGET_ARCHS="ppc i486"
  	    fi
        else
  	    echo -n "NeXTSTEP/OPENSTEP: "
	    if test "$TARGET_ARCHS" = "" ; then
	       if test `/usr/bin/arch` = "m68k" ; then
		   TARGET_ARCHS="m68k i486"
	       else # Black and Native one
		   TARGET_ARCHS="m68k `/usr/bin/arch`"
	       fi
	    fi
        fi
        ;;
    esac
    # /usr/lib/arch_tool -archify_list $TARGET_ARCHS
    for archs in $TARGET_ARCHS 
    do
        ARCH_FLAG="$ARCH_FLAG -arch $archs "
        echo -n " $archs"
    done
    AC_DEFINE( NEXT_FAT_BINARY )
    echo "."
fi 

AC_ARG_PROGRAM

dnl Checks for programs.
AC_PROG_CC
AC_PROG_GCC_TRADITIONAL
AC_PROG_YACC
AC_PROG_RANLIB
AC_SUBST(AR)
AC_CHECK_PROGS(AR, ar aal, ar)
AC_PROG_INSTALL
AC_PROG_LN_S
AC_PROG_MAKE_SET

# checks for UNIX variants that set C preprocessor variables
AC_MINIX

AC_CHECK_SIZEOF(int)
AC_CHECK_SIZEOF(long)
AC_CHECK_SIZEOF(void*)
AC_CHECK_SIZEOF(float)
AC_CHECK_SIZEOF(double)

AC_MSG_CHECKING(for prototypes)
AC_CACHE_VAL(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)])
AC_MSG_RESULT($rb_cv_have_prototypes)
if test "$rb_cv_have_prototypes" = yes; then
  AC_DEFINE(HAVE_PROTOTYPES)
fi

AC_MSG_CHECKING(for variable length prototypes and stdarg.h)
AC_CACHE_VAL(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)])
AC_MSG_RESULT($rb_cv_stdarg)
if test "$rb_cv_stdarg" = yes; then
  AC_DEFINE(HAVE_STDARG_PROTOTYPES)
fi

AC_MSG_CHECKING(for gcc attribute noreturn)
AC_CACHE_VAL(rb_cv_have_attr_noreturn,
  [AC_TRY_COMPILE([void exit(int x) __attribute__ ((noreturn));], [],
	rb_cv_have_attr_noreturn=yes,
	rb_cv_have_attr_noreturn=no)])
AC_MSG_RESULT($rb_cv_have_attr_noreturn)
if test "$rb_cv_have_attr_noreturn" = yes; then
  AC_DEFINE(HAVE_ATTR_NORETURN)
fi

dnl Checks for libraries.
case "$host_os" in
nextstep*)	;;
openstep*)	;;
rhapsody*)	;;
human*)		;;
beos*)		;;
*) 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(xpg4, setlocale)	# FreeBSD needs this

dnl Checks for header files.
AC_HEADER_DIRENT
AC_HEADER_STDC
AC_CHECK_HEADERS(stdlib.h unistd.h limits.h sys/file.h sys/ioctl.h pwd.h \
		 sys/select.h sys/time.h sys/times.h sys/param.h sys/wait.h\
		 syscall.h a.out.h string.h utime.h memory.h direct.h)

dnl Checks for typedefs, structures, and compiler characteristics.
AC_TYPE_UID_T
AC_TYPE_SIZE_T
AC_STRUCT_ST_BLKSIZE
save_LIBOJBS="$LIBOBJS"
AC_STRUCT_ST_BLOCKS
LIBOBJS="$save_LIBOBJS"
AC_STRUCT_ST_RDEV

dnl Checks for library functions.
AC_TYPE_GETGROUPS
AC_TYPE_SIGNAL
AC_FUNC_ALLOCA
AC_FUNC_VFORK
AC_FUNC_MEMCMP
AC_REPLACE_FUNCS(dup2 memmove mkdir strcasecmp strerror strftime\
		 strchr strstr strtoul strdup crypt flock vsnprintf)
AC_CHECK_FUNCS(fmod killpg drand48 random wait4 waitpid syscall getcwd\
	      truncate chsize times utimes fcntl lockf setitimer\
	      setruid seteuid setreuid setrgid setegid setregid\
	      setpgrp2 getpgid setpgid getgroups getpriority\
	      dlopen sigprocmask sigaction _setjmp setpgrp setsid)
if test "$ac_cv_func_strftime" = no; then
    AC_STRUCT_TIMEZONE
    AC_TRY_LINK([],
	 [extern int daylight; int i = daylight;], AC_DEFINE(HAVE_DAYLIGHT))
fi

if test "$ac_cv_func_sigprocmask" = yes && test "$ac_cv_func_sigaction" = yes; then
   AC_DEFINE(POSIX_SIGNAL)
else
  AC_MSG_CHECKING(for BSD signal semantics)
  AC_CACHE_VAL(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)])
  AC_MSG_RESULT($rb_cv_bsd_signal)
  if test "$rb_cv_bsd_signal" = yes; then
    AC_DEFINE(BSD_SIGNAL)
  fi
fi

if test "$ac_cv_func_setpgrp2" = yes; then
  AC_DEFINE(BSD_GETPGRP, getpgrp2)
  AC_DEFINE(BSD_SETPGRP, setpgrp2)
else
  AC_MSG_CHECKING(whether getpgrp() has arg)
  AC_CACHE_VAL(rb_cv_bsdgetpgrp,
    [AC_TRY_COMPILE([#include <unistd.h>], [getpgrp(0);],
      rb_cv_bsdgetpgrp=yes,
      rb_cv_bsdgetpgrp=no)])
  AC_MSG_RESULT($rb_cv_bsdgetpgrp)
  if test "$rb_cv_bsdgetpgrp" = yes; then
    AC_DEFINE(BSD_GETPGRP, getpgrp)
  fi

  AC_MSG_CHECKING(whether setpgrp() has args)
  AC_CACHE_VAL(rb_cv_bsdsetpgrp,
    [AC_TRY_COMPILE([#include <unistd.h>], [setpgrp(1, 1);],
	rb_cv_bsdsetpgrp=yes,
	rb_cv_bsdsetpgrp=no)])
  AC_MSG_RESULT($rb_cv_bsdsetpgrp)
  if test "$rb_cv_bsdsetpgrp" = yes; then
    AC_DEFINE(BSD_SETPGRP, setpgrp)
  fi
fi

AC_C_BIGENDIAN
AC_CHAR_UNSIGNED

AC_MSG_CHECKING(whether right shift preserve sign bit)
AC_CACHE_VAL(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)])
  AC_MSG_RESULT($rb_cv_rshift_sign)
if test "$rb_cv_rshift_sign" = yes; then
  AC_DEFINE(RSHIFT(x,y), ((x)>>y))
else
  AC_DEFINE(RSHIFT(x,y), (((x)<0) ? ~((~(x))>>y) : (x)>>y))
fi

AC_MSG_CHECKING([count field in FILE structures])
AC_CACHE_VAL(rb_cv_fcnt,
[AC_TRY_COMPILE([#include <stdio.h>],
	[FILE *f = stdin; f->_cnt = 0;], rb_cv_fcnt="_cnt", )
if test "$rb_cv_fcnt" = ""; then
    AC_TRY_COMPILE([#include <stdio.h>],
	[FILE *f = stdin; f->__cnt = 0;], rb_cv_fcnt="__cnt", )
fi
if test "$rb_cv_fcnt" = ""; then
    AC_TRY_COMPILE([#include <stdio.h>],
	[FILE *f = stdin; f->_r = 0;], rb_cv_fcnt="_r", )
fi
if test "$rb_cv_fcnt" = ""; then
    AC_TRY_COMPILE([#include <stdio.h>],
	[FILE *f = stdin; f->readCount = 0;],
	rb_cv_fcnt="readCount", rb_cv_fcnt="not found")
fi])
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

dnl wheather use dln_a_out ot 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])

case "$host_os" in
    linux*)
  AC_MSG_CHECKING(whether ELF binaries are produced)
  AC_CACHE_VAL(rb_cv_binary_elf,
  [AC_TRY_RUN([
/* Test for whether ELF binaries are produced */
#include <fcntl.h>
#include <stdlib.h>
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,
	[:])])
  AC_MSG_RESULT($rb_cv_binary_elf)
  if test "$rb_cv_binary_elf" = no; then
    with_dln_a_out=yes
    host_os=${host_os}-a_out
  else
    LDFLAGS="-rdynamic"
  fi;;
esac

AC_SUBST(DLDFLAGS)dnl

AC_SUBST(STATIC)dnl
AC_SUBST(CCDLFLAGS)dnl
AC_SUBST(LDSHARED)dnl
AC_SUBST(DLEXT)dnl

STATIC=

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 "$host_os" in
    nextstep*)	;;
    openstep*)	;;
    rhapsody*)	;;
    human*)	;;
    cygwin*)	CCDLFLAGS=-DDLLIMPORT;;
    *) CCDLFLAGS=-fpic;;
    esac
  else
    case "$host_os" in
	hpux*)		CCDLFLAGS='+z';;
	solaris*|irix*)	CCDLFLAGS='-K pic' ;;
	sunos*)		CCDLFLAGS='-pic' ;;
	esix*|uxpds*)   CCDLFLAGS='-Kpic' ;;
	*)		CCDLFLAGS='' ;;
    esac
  fi

  case "$host_os" in
	hpux*)		DLDFLAGS="-E"
			LDSHARED='ld -b'
			LDFLAGS="-Wl,-E"
			rb_cv_dlopen=yes;;
	solaris*) 	LDSHARED='ld -G'
			rb_cv_dlopen=yes;;
	sunos*) 	LDSHARED='ld -assert nodefinitions'
			rb_cv_dlopen=yes;;
	irix*) 	 	LDSHARED='ld -ignore_unresolved'
			rb_cv_dlopen=yes;;
	sysv4*) 	LDSHARED='ld -G'
			rb_cv_dlopen=yes;;
	esix*|uxpds*) 	LDSHARED="ld -G"
			rb_cv_dlopen=yes ;;
	linux*) 	LDSHARED="gcc -shared"
			rb_cv_dlopen=yes ;;
	freebsd*)       LDSHARED="gcc -shared"   
			test -x /usr/bin/objformat && LDFLAGS="-rdynamic"
			rb_cv_dlopen=yes ;;
	netbsd*) 	LDSHARED="ld -Bshareable"
			rb_cv_dlopen=yes ;;
	openbsd*) 	LDSHARED="ld -Bforcearchive -Bshareable"
			CCDLFLAGS=-fPIC
			rb_cv_dlopen=yes ;;
	nextstep*)	LDSHARED='cc -r'
			LDFLAGS="-u libsys_s"
			DLDFLAGS="$ARCH_FLAG" 
			rb_cv_dlopen=yes ;;
	openstep*)	LDSHARED='cc -dynamic -bundle -undefined suppress'
			LDFLAGS=""
			DLDFLAGS="$ARCH_FLAG"
			rb_cv_dlopen=yes ;;
	rhapsody*)	LDSHARED='cc -dynamic -bundle -undefined suppress'
			LDFLAGS=""
			DLDFLAGS="$ARCH_FLAG"
			rb_cv_dlopen=yes ;;
	aix*)		LDSHARED='../../miniruby ../aix_ld.rb $(TARGET)'
			rb_cv_dlopen=yes ;;
	human*)		DLDFLAGS=''
			LDSHARED=''
			LDFLAGS='' ;;
	beos*) 		LDSHARED="ld -xms"
			case "$host_cpu" in
			  powerpc*)
			    DLDFLAGS="-f ruby.exp -lbe -lroot glue-noinit.a init_term_dyn.o start_dyn.o"
                            ;;
			  *)
			    DLDFLAGS="ruby.def -lbe -lroot glue-noinit.a init_term_dyn.o start_dyn.o"
			    ;;
			esac
			rb_cv_dlopen=yes ;;
	cygwin*)	LDSHARED='../../miniruby ../cygwin32_ld.rb' ;;
	*) 		LDSHARED='ld' ;;
  esac
  AC_MSG_RESULT($rb_cv_dlopen)
fi

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
    AC_MSG_CHECKING(whether matz's dln works)
    cat confdefs.h > config.h
    AC_CACHE_VAL(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)])
    AC_MSG_RESULT($rb_cv_dln_a_out)
    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=o
  AC_DEFINE(DLEXT, ".o")
  CCDLFLAGS=
else
  case "$host_os" in
    hpux*)	DLEXT=sl
	 	AC_DEFINE(DLEXT, ".sl");;
    nextstep*)	DLEXT=o
	 	AC_DEFINE(DLEXT, ".o");;
    openstep*)	DLEXT=bundle
	 	AC_DEFINE(DLEXT, ".bundle");;
    rhapsody*)	DLEXT=bundle
	 	AC_DEFINE(DLEXT, ".bundle");;
    cygwin*)	DLEXT=dll
	 	AC_DEFINE(DLEXT, ".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 "$host_os" in
  linux*)
	STRIP='strip -S -x';;
  nextstep*)
	STRIP='strip -A -n';;
  openstep*)
	STRIP='strip -A -n';;
  rhapsody*)
	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 "$host_os" in
  human*)
    AC_CHECK_LIB(signal, _harderr)
    AC_CHECK_LIB(hmem, hmemset)
    AC_CHECK_FUNCS(select)
    AC_MSG_CHECKING(whether PD libc _dtos18 fail to convert big number)
    AC_CACHE_VAL(rb_cv_missing__dtos18,
    [AC_TRY_RUN(
changequote(<<, >>)dnl
<<
#include <stdio.h>
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)])
    AC_MSG_RESULT($rb_cv_missing__dtos18)
    if test "$rb_cv_missing__dtos18" = yes; then
      AC_DEFINE(MISSING__DTOS18)
    fi
    AC_MSG_CHECKING(whether PD libc fconvert fail to round)
    AC_CACHE_VAL(rb_cv_missing_fconvert,
    [AC_TRY_RUN(
changequote(<<, >>)dnl
<<
#include <stdio.h>
#include <math.h>
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)])
    AC_MSG_RESULT($rb_cv_missing_fconvert)
    if test "$rb_cv_missing_fconvert" = yes; then
      AC_DEFINE(MISSING_FCONVERT)
    fi
    LIBOBJS="$LIBOBJS x68.o"
    CFLAGS="$CFLAGS -fansi-only -cc1-stack=196608 -cpp-stack=2694144"
    binsuffix=.x
    setup=Setup.x68
    ;;
  cygwin*)
    binsuffix=.exe
    setup=Setup
    ;;
  *)
    binsuffix=
    setup=Setup
    ;;
esac



AC_SUBST(binsuffix)
AC_SUBST(setup)

if test "$prefix" = NONE; then
  prefix=$ac_default_prefix
fi

if test "$fat_binary" = yes ; then
  CFLAGS="$CFLAGS $ARCH_FLAG"
fi

LIBRUBY_A='libruby.a'
LIBRUBY='$(LIBRUBY_A)'
LIBRUBYARG='$(LIBRUBY_A)'
SOLIBS=
if test "$host_os" = "beos"; then
  CFLAGS="$CFLAGS -relax_pointers"
  LIBRUBY='$(LIBRUBY_SO)'
  LIBRUBYARG='-lruby'
  SOLIBS='-lnet'
  echo creating ruby.def
  case "$host_cpu" in
    powerpc*)
      cp beos/ruby.def.in ruby.exp
      ;;
    *)
      echo EXPORTS > ruby.def
      cat beos/ruby.def.in >> ruby.def
      ;;
  esac
fi

AC_SUBST(LIBSUFFIX)

LIBRUBY_SO='libruby.so.$(MAJOR).$(MINOR).$(TEENY)'
LIBRUBY_ALIASES='libruby.so'
if test "$enable_shared" = 'yes'; then
  LIBRUBY='$(LIBRUBY_SO)'
  LIBRUBYARG='-L./ -lruby'
  CFLAGS="$CFLAGS $CCDLFLAGS"
  case "$host_os" in
    freebsd2*|sunos4*)
	LIBRUBY_ALIASES='libruby.so.$(MAJOR).$(MINOR) libruby.so'
	;;
    hpux*)
	LIBRUBY_SO='libruby.sl.$(MAJOR).$(MINOR).$(TEENY)'
	LIBRUBY_ALIASES='libruby.sl.$(MAJOR).$(MINOR) libruby.sl'
	;;
    *)
	;;
  esac
fi

case "$host_os" in
	nextstep*)
    	CFLAGS="$CFLAGS -pipe"
		;;
	openstep*)
    	CFLAGS="$CFLAGS -pipe"
		;;
	rhasody*)
    	CFLAGS="$CFLAGS -pipe -no-precomp"
		;;
	*)
		;;	
esac


AC_SUBST(LIBRUBY_A)
AC_SUBST(LIBRUBY_SO)
AC_SUBST(LIBRUBY_ALIASES)
AC_SUBST(LIBRUBY)
AC_SUBST(LIBRUBYARG)
AC_SUBST(SOLIBS)

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}"
AC_DEFINE_UNQUOTED(RUBY_LIB, "${prefix}/lib/${RUBY_INSTALL_NAME}")
AC_DEFINE_UNQUOTED(RUBY_SITE_LIB, "${prefix}/lib/${RUBY_INSTALL_NAME}/site_ruby")
AC_SUBST(arch)dnl

if test "$fat_binary" = yes ; then
    arch="fat-${host_os}"

    AC_DEFINE_UNQUOTED(RUBY_THIN_ARCHLIB,
                 "${prefix}/lib/${RUBY_INSTALL_NAME}/" __ARCHITECTURE__ "-${host_os}" )

    AC_DEFINE_UNQUOTED(RUBY_SITE_THIN_ARCHLIB,
                 "${prefix}/lib/${RUBY_INSTALL_NAME}/" __ARCHITECTURE__ "-${host_os}" )

    AC_DEFINE_UNQUOTED(RUBY_ARCHLIB, "${prefix}/lib/${RUBY_INSTALL_NAME}/${arch}")
    AC_DEFINE_UNQUOTED(RUBY_SITE_ARCHLIB, "${prefix}/lib/${RUBY_INSTALL_NAME}/site_ruby/${arch}")
    AC_DEFINE_UNQUOTED(RUBY_PLATFORM,  __ARCHITECTURE__ "-${host_os}" )
else
    arch="${host_cpu}-${host_os}"
    AC_DEFINE_UNQUOTED(RUBY_ARCHLIB, "${prefix}/lib/${RUBY_INSTALL_NAME}/${arch}")
    AC_DEFINE_UNQUOTED(RUBY_SITE_ARCHLIB, "${prefix}/lib/${RUBY_INSTALL_NAME}/site_ruby/${arch}")
    AC_DEFINE_UNQUOTED(RUBY_PLATFORM, "${arch}")
fi

echo "creating config.h"
cat confdefs.h > config.h

AC_OUTPUT(Makefile ext/extmk.rb)