dnl -*- Mode: Autoconf; tab-width: 4; indent-tabs-mode: nil; -*-
dnl 
dnl The contents of this file are subject to the Mozilla Public
dnl License Version 1.1 (the "License"); you may not use this file
dnl except in compliance with the License. You may obtain a copy of
dnl the License at http://www.mozilla.org/MPL/
dnl 
dnl Software distributed under the License is distributed on an "AS
dnl IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
dnl implied. See the License for the specific language governing
dnl rights and limitations under the License.
dnl 
dnl The Original Code is the Netscape Portable Runtime (NSPR).
dnl 
dnl The Initial Developer of the Original Code is Netscape
dnl Communications Corporation.  Portions created by Netscape are 
dnl Copyright (C) 1998o-2000 Netscape Communications Corporation.  All
dnl Rights Reserved.
dnl 
dnl Contributor(s):
dnl     Christopher Seawood <cls@seawood.org>
dnl 
dnl Alternatively, the contents of this file may be used under the
dnl terms of the GNU General Public License Version 2 or later (the
dnl "GPL"), in which case the provisions of the GPL are applicable 
dnl instead of those above.  If you wish to allow use of your 
dnl version of this file only under the terms of the GPL and not to
dnl allow others to use your version of this file under the MPL,
dnl indicate your decision by deleting the provisions above and
dnl replace them with the notice and other provisions required by
dnl the GPL.  If you do not delete the provisions above, a recipient
dnl may use your version of this file under either the MPL or the
dnl GPL.
dnl 

AC_PREREQ(2.12)
AC_INIT(config/libc_r.h)

AC_CONFIG_AUX_DIR(${srcdir}/build/autoconf)
AC_CANONICAL_SYSTEM

dnl ========================================================
dnl = Defaults
dnl ========================================================
MOD_MAJOR_VERSION=4
MOD_MINOR_VERSION=2
MOD_REVISION_VERSION=0
NSPR_MODNAME=nspr20
_HAVE_PTHREADS=
USE_PTHREADS=
USE_USER_PTHREADS=
USE_NSPR_THREADS=
USE_N32=
USE_64=
USE_CPLUS=
USE_IPV6=
USE_MDUPDATE=
_OPTIMIZE_FLAGS=-O
_DEBUG_FLAGS=-g
MOZ_DEBUG=1
MOZ_OPTIMIZE=
OBJDIR=.
OBJDIR_NAME=.
NSINSTALL='$(MOD_DEPTH)/config/$(OBJDIR_NAME)/nsinstall'
NOSUCHFILE=/no-such-file
LIBNSPR='-L$(dist_libdir) -lnspr$(MOD_MAJOR_VERSION)'
LIBPLC='-L$(dist_libdir) -lplc$(MOD_MAJOR_VERSION)'

dnl Link in libraries necessary to resolve all symbols for shared libs
RESOLVE_LINK_SYMBOLS=

dnl ========================================================
dnl =
dnl = Dont change the following lines.  Doing so breaks:
dnl =
dnl = CFLAGS="-foo" ./configure
dnl =
dnl ========================================================
CFLAGS="${CFLAGS=}"
CXXFLAGS="${CXXFLAGS=}"
LDFLAGS="${LDFLAGS=}"
HOST_CFLAGS="${HOST_CFLAGS=}"
HOST_LDFLAGS="${HOST_LDFLAGS=}"

case "$target" in
*-cygwin*)
    # Check to see if we are really running in a msvc environemnt
    _WIN32_MSVC=
    if test "$CC" = "cl" || test "$CXX" = "cl"; then
        _WIN32_MSVC=1
    elif test -z "$CC"; then
        echo 'main() { return 0; }' > dummy.c
        cl -o dummy dummy.c
        if test $? = 0; then
            _WIN32_MSVC=1
        fi
        rm -f dummy dummy.o dummy.obj dummy.exe dummy.c
    fi
    ;;
*-msvc*)
    _WIN32_MSVC=1
    ;;
esac

if test -n "$_WIN32_MSVC"; then
    SKIP_PATH_CHECKS=1
    SKIP_COMPILER_CHECKS=1
    SKIP_LIBRARY_CHECKS=1
fi

dnl ========================================================
dnl =
dnl = Check options that may affect the compiler
dnl =
dnl ========================================================
dist_prefix='${MOD_DEPTH}/dist'
dist_bindir='${dist_prefix}/bin'
dist_includedir='${dist_prefix}/include'
dist_libdir='${dist_prefix}/lib'

AC_ARG_WITH(dist-prefix,
    [  --with-dist-prefix=DIST_PREFIX
                          place build files in DIST_PREFIX [dist]],
    dist_prefix=$withval)

AC_ARG_WITH(dist-bindir,
    [  --with-dist-bindir=DIR  build execuatables in DIR [DIST_PREFIX/bin]],
    dist_bindir=$withval)

AC_ARG_WITH(dist-includedir,
    [  --with-dist-includedir=DIR
                          build include files in DIR [DIST_PREFIX/include]],
    dist_includedir=$withval)

AC_ARG_WITH(dist-libdir,
    [  --with-dist-libdir=DIR  build library files in DIR [DIST_PREFIX/lib]],
    dist_libdir=$withval)

AC_SUBST(dist_prefix)
AC_SUBST(dist_bindir)
AC_SUBST(dist_includedir)
AC_SUBST(dist_libdir)

dnl Check if NSPR is being compiled for Mozilla
dnl Let --with-arg override environment setting
dnl
AC_ARG_WITH(mozilla,
    [  --with-mozilla          Compile NSPR with Mozilla support],
    [   if test "$withval" = "yes"; then
            AC_DEFINE(MOZILLA_CLIENT)
            MOZILLA_CLIENT=1
	    else
	        MOZILLA_CLIENT=
	    fi],
    [	if test -n "$MOZILLA_CLIENT"; then
	        AC_DEFINE(MOZILLA_CLIENT)
	    fi])

AC_ARG_ENABLE(optimize,
    [  --enable-optimize(=val) Enable code optimizations (val, ie. -O2) ],
    [ if test "$enableval" != "no"; then
        MOZ_OPTIMIZE=1
        if test -n "$enableval" && test "$enableval" != "yes"; then
    	    _OPTIMIZE_FLAGS=`echo $enableval | sed -e 's|\\\ | |g'`
            _SAVE_OPTIMIZE_FLAGS=$_OPTIMIZE_FLAGS
        fi
    fi ])

AC_ARG_ENABLE(debug,
    [  --disable-debug         Do not compile in debugging symbols],
    [	if test "$enableval" = "no"; then
    	    MOZ_DEBUG=
	    fi])

AC_ARG_ENABLE(win32-target,
    [  --enable-win32-target=\$t
                          Specify win32 flavor. (WIN95 or WINNT)],
    OS_TARGET=`echo $enableval | tr a-z A-Z`,
    OS_TARGET=)

AC_ARG_ENABLE(debug-rtl,
    [  --enable-debug-rtl      Use the MSVC debug runtime library],
    [ if test "$enableval" = "yes"; then
	    USE_DEBUG_RTL=1
      fi ])

AC_ARG_ENABLE(n32,
    [  --enable-n32            Enable n32 ABI support (IRIX only)],
    [ if test "$enableval" = "yes"; then
	USE_N32=1
      else if test "$enableval" = "no"; then
	USE_N32=
      fi
    fi ])

AC_ARG_ENABLE(64bit,
    [  --enable-64bit          Enable 64-bit support (on certain platforms)],
    [ if test "$enableval" = "yes"; then
	    USE_64=1
      fi ])

AC_ARG_ENABLE(mdupdate,
    [  --enable-mdupdate       Enable use of certain compilers' mdupdate feature],
    [ if test "$enableval" = "yes"; then
	    USE_MDUPDATE=1
      fi ])

dnl ========================================================
dnl =
dnl = Set the threading model
dnl =
dnl ========================================================
case "$target" in

*-aix*)
    case "${target_os}" in
    aix3.2*)
        USE_NSPR_THREADS=1
        ;;
    *)
        USE_PTHREADS=1
        ;;
    esac
    ;;

esac

dnl ========================================================
dnl =
dnl = Set the default C compiler
dnl =
dnl ========================================================
if test -z "$CC"; then
    case "$target" in

    *-aix*)
        if test -z "$USE_NSPR_THREADS"; then
            CC=xlC_r
        else
            CC=xlC
        fi
    ;;

    *-hpux*)
        CC=cc
    ;;

    *-irix*)
        CC=cc
    ;;

    *-osf*)
        CC=cc
    ;;

    *-solaris*)
        CC=cc
    ;;

    esac
fi

dnl ========================================================
dnl =
dnl = Set the default C++ compiler
dnl =
dnl ========================================================
if test -z "$CXX"; then
    case "$target" in

    *-aix*)
        if test -z "$USE_NSPR_THREADS"; then
            CXX=xlC_r
        else
            CXX=xlC
        fi
    ;;

    *-hpux*)
        case "${target_os}" in
        hpux10.30)
            CXX=aCC
            ;;
        hpux11.*)
            CXX=aCC
            ;;
        *)
            CXX=CC
            ;;
        esac
    ;;

    *-irix*)
        CXX=CC
    ;;

    *-osf*)
        CXX=cxx
    ;;

    *-solaris*)
        CXX=CC
    ;;

    esac
fi

if test -z "$SKIP_PATH_CHECKS"; then
    AC_PATH_PROG(WHOAMI, $WHOAMI whoami, echo not_whoami)
elif test -z "$WHOAMI"; then
    WHOAMI=whoami
fi

if test -n "$MOZ_DEBUG"; then
    AC_DEFINE(DEBUG)
    AC_DEFINE_UNQUOTED(DEBUG_`$WHOAMI`)
    DEFINES="$DEFINES -UNDEBUG"
else
    AC_DEFINE(NDEBUG)
    DEFINES="$DEFINES -UDEBUG"
fi

if test -z "$SKIP_COMPILER_CHECKS"; then
dnl ========================================================
dnl Checks for compilers.
dnl ========================================================
if test "$target" != "$host"; then
    echo "cross compiling from $host to $target"
    cross_compiling=yes

    _SAVE_CC="$CC"
    _SAVE_CFLAGS="$CFLAGS"
    _SAVE_LDFLAGS="$LDFLAGS"

    AC_MSG_CHECKING([for $host compiler])
    if test -z "$HOST_CC"; then
	    AC_CHECK_PROGS(HOST_CC, gcc cc /usr/ucb/cc, "")
	    if test -z "$HOST_CC"; then
	        AC_MSG_ERROR([no acceptable cc found in \$PATH])
	    fi
    fi
    AC_MSG_RESULT([$HOST_CC])
    if test -z "$HOST_CFLAGS"; then
	    HOST_CFLAGS="$CFLAGS"
    fi
    if test -z "$HOST_LDFLAGS"; then
	    HOST_LDFLAGS="$LDFLAGS"
    fi

    CC="$HOST_CC"
    CFLAGS="$HOST_CFLAGS"
    LDFLAGS="$HOST_LDFLAGS"

    AC_MSG_CHECKING([whether the $host compiler ($HOST_CC $HOST_CFLAGS $HOST_LDFLAGS) works])
    AC_TRY_COMPILE([], [return(0);], 
	[ac_cv_prog_host_cc_works=1 AC_MSG_RESULT([yes])],
	AC_MSG_ERROR([installation or configuration problem: $host compiler $HOST_CC cannot create executables.]) )
    
    CC=$_SAVE_CC
    CFLAGS=$_SAVE_CFLAGS
    LDFLAGS=$_SAVE_LDFLAGS

    if test -z "$CC"; then
	    AC_CHECK_PROGS(CC, "${target_alias}-gcc" "${target}-gcc", echo)
    fi
    unset ac_cv_prog_CC
    AC_PROG_CC
    if test -z "$CXX"; then
	    AC_CHECK_PROGS(CXX, "${target_alias}-g++" "${target}-g++", echo)
    fi
    unset ac_cv_prog_CXX
    AC_PROG_CXX
    if test -z "$RANLIB"; then
	    AC_CHECK_PROGS(RANLIB, "${target_alias}-ranlib" "${target}-ranlib", echo)
    fi
    if test -z "$AR"; then
	    AC_CHECK_PROGS(AR, "${target_alias}-ar" "${target}-ar", echo)
    fi
    if test -z "$AS"; then
	    AC_CHECK_PROGS(AS, "${target_alias}-as" "${target}-as", echo)
    fi
    if test -z "$LD"; then
	    AC_CHECK_PROGS(LD, "${target_alias}-ld" "${target}-ld", echo)
    fi
    if test -z "$STRIP"; then
	    AC_CHECK_PROGS(STRIP, "${target_alias}-strip" "${target}-strip", echo)
    fi
    if test -z "$DLLTOOL"; then
	    AC_CHECK_PROGS(DLLTOOL, "${target_alias}-dlltool" "${target}-dlltool", echo)
    fi
    if test -z "$WINDRES"; then
	    AC_CHECK_PROGS(WINDRES, "${target_alias}-windres" "${target}-windres", echo)
    fi

else
    AC_PROG_CXX
    if test "$CXX" = "cl" -a -z "$CC"; then
        CC=$CXX
    else        
        AC_PROG_CC
    fi
    AC_PROG_CPP
    AC_PROG_RANLIB
    AC_PATH_PROGS(AS, as, $CC)
    AC_PATH_PROGS(AR, ar, echo not_ar)
    AC_PATH_PROGS(LD, ld link, echo not_ld)
    AC_PATH_PROGS(STRIP, strip, echo not_strip)
    AC_PATH_PROGS(DLLTOOL, dlltool, echo not_dlltool)
    AC_PATH_PROGS(WINDRES, windres, echo not_windres)
    if test -z "$HOST_CC"; then
	    HOST_CC="$CC"
    fi
    if test -z "$HOST_CFLAGS"; then
	    HOST_CFLAGS="$CFLAGS"
    fi
fi

if test "$GCC" = "yes"; then
    GNU_CC=1
fi
if test "`echo | $AS -V 2>&1 | grep -c GNU`" != "0"; then
    GNU_AS=1
fi
rm -f a.out

if test "$cross_compiling"  = "yes"; then
    CROSS_COMPILE=1
else
    CROSS_COMPILE=
fi

fi # SKIP_COMPILER_CHECKS

dnl ========================================================
dnl Checks for programs.
dnl ========================================================
if test -z "$SKIP_PATH_CHECKS"; then
    AC_PATH_PROGS(PERL, perl5 perl, echo not_perl)
elif test -z "$PERL"; then
    PERL=perl
fi

dnl ========================================================
dnl Default platform specific options
dnl ========================================================
OBJ_SUFFIX=o
LIB_SUFFIX=a
DLL_SUFFIX=so
MKSHLIB='$(LD) $(DSO_LDOPTS) -o $@'
PR_MD_ASFILES=
PR_MD_CSRCS=
PR_MD_ARCH_DIR=unix
AR_FLAGS='cr $@'
AS='$(CC)'
ASFLAGS='$(CFLAGS)'

OS_ARCH=`uname -s | sed -e 's|/|_|g'`
OS_RELEASE=`uname -r`
OS_TEST=`uname -m`

if test "$OS_ARCH" = "IRIX64"; then
    OS_ARCH=IRIX
fi

if test "$OS_ARCH" = "POSIX_for_OpenVMS_AXP"; then
    OS_ARCH=OpenVMS
fi

#######################################################################
# Master "Core Components" macros for getting the OS target           #
#######################################################################

#
# Note: OS_TARGET should be specified on the command line for gmake.
# When OS_TARGET=WIN95 is specified, then a Windows 95 target is built.
# The difference between the Win95 target and the WinNT target is that
# the WinNT target uses Windows NT specific features not available
# in Windows 95. The Win95 target will run on Windows NT, but (supposedly)
# at lesser performance (the Win95 target uses threads; the WinNT target
# uses fibers).
#
# When OS_TARGET=WIN16 is specified, then a Windows 3.11 (16bit) target
# is built. See: win16_3.11.mk for lots more about the Win16 target.
#
# If OS_TARGET is not specified, it defaults to $(OS_ARCH), i.e., no
# cross-compilation.
#

#
# The following hack allows one to build on a WIN95 machine (as if
# s/he were cross-compiling on a WINNT host for a WIN95 target).
# It also accomodates for MKS's uname.exe.  If you never intend
# to do development on a WIN95 machine, you don't need this hack.
#
if test "$OS_ARCH" = "WIN95"; then
    OS_ARCH=WINNT
    OS_TARGET=WIN95
elif test "$OS_ARCH" = 'Windows_95'; then
    OS_ARCH=Windows_NT
    OS_TARGET=WIN95
elif test "$OS_ARCH" = 'Windows_98'; then
    OS_ARCH=Windows_NT
    OS_TARGET=WIN95
elif test "$OS_ARCH" = "CYGWIN_95-4.0"; then
    OS_ARCH='CYGWIN_NT-4.0'
    OS_TARGET=WIN95
elif test "$OS_ARCH" = "CYGWIN_98-4.10"; then
    OS_ARCH='CYGWIN_NT-4.0'
    OS_TARGET=WIN95
elif test "$OS_ARCH" = "OS_2"; then
    OS_ARCH=OS2
    OS_TARGET=OS2
fi

#
# On WIN32, we also define the variable CPU_ARCH.
#

if test "$OS_ARCH" = "WINNT"; then
    CPU_ARCH=`uname -p`
    if test "$CPU_ARCH" = "I386"; then
        CPU_ARCH=x86
    fi
elif test "$OS_ARCH" = "Windows_NT"; then
#
# If uname -s returns "Windows_NT", we assume that we are using
# the uname.exe in MKS toolkit.
#
# The -r option of MKS uname only returns the major version number.
# So we need to use its -v option to get the minor version number.
# Moreover, it doesn't have the -p option, so we need to use uname -m.
#
    OS_ARCH=WINNT
#    OS_MINOR_RELEASE=`uname -v`
    if test "$OS_MINOR_RELEASE" = "00"; then
        OS_MINOR_RELEASE=0
    fi
    OS_RELEASE="${OS_RELEASE}.${OS_MINOR_RELEASE}"
    CPU_ARCH=`uname -m`
    #
    # MKS's uname -m returns "586" on a Pentium machine.
    #
    if echo "$CPU_ARCH" | grep -c 86 >/dev/null; then
        CPU_ARCH=x86
    fi
elif echo "$OS_ARCH" | grep -c CYGWIN_NT >/dev/null; then
#
# If uname -s returns "CYGWIN_NT-4.0", we assume that we are using
# the uname.exe in the Cygwin tools.
#
    OS_RELEASE=`echo $OS_ARCH | sed 's|^CYGWIN_NT-||'`
    OS_ARCH=WINNT
    CPU_ARCH=`uname -m`
    #
    # Cygwin's uname -m returns "i686" on a Pentium Pro machine.
    #
    if echo "$CPU_ARCH" | grep -c 86 >/dev/null; then
        CPU_ARCH=x86
    fi
elif test "$OS_ARCH" = "CYGWIN32_NT"; then
#
# Prior to the Beta 20 release, Cygwin was called GNU-Win32.
# If uname -s returns "CYGWIN32/NT", we assume that we are using
# the uname.exe in the GNU-Win32 tools.
#
    OS_ARCH=WINNT
    CPU_ARCH=`uname -m`
    #
    # GNU-Win32's uname -m returns "i686" on a Pentium Pro machine.
    #
    if echo "$CPU_ARCH" | grep -c 86 >/dev/null; then
        CPU_ARCH=x86
    fi
fi

if test -n "$MOZILLA_CLIENT" && test "$OS_ARCH" = "WINNT"; then
    OS_TARGET=WIN95
    if test -n "$MOZ_DEBUG"; then
        USE_DEBUG_RTL=1
    fi
fi
if test -z "$OS_TARGET"; then
    OS_TARGET=$OS_ARCH
fi
if test "$OS_TARGET" = "WIN95"; then
    OS_RELEASE="4.0"
fi
if test "$OS_TARGET" = "WIN16"; then
    OS_RELEASE=
fi
OS_CONFIG="${OS_TARGET}${OS_RELEASE}"

dnl ========================================================

dnl ========================================================
dnl Override of system specific host options
dnl ========================================================
case "$host" in
*-mingw*|*-cygwin*|*-msvc*)
    ;;
*-beos*)
    HOST_CFLAGS="$HOST_CFLAGS -DXP_BEOS -DBeOS -DBEOS -D_POSIX_SOURCE"
    ;;
*os2*)
    ;;
*)
    HOST_CFLAGS="$HOST_CFLAGS -DXP_UNIX"
    ;;
esac

dnl ========================================================
dnl Override of system specific target options
dnl ========================================================
case "$target" in

*-aix*)
    AC_DEFINE(XP_UNIX)
    AC_DEFINE(AIX)
    AC_DEFINE(SYSV)
    DSO_LDOPTS='-brtl -bM:SRE -bnoentry -bexpall'
    AC_CHECK_HEADER(sys/atomic_op.h, AC_DEFINE(AIX_HAVE_ATOMIC_OP_H))
    case "${target_os}" in
    aix3.2*)
        AC_DEFINE(AIX_RENAME_SELECT)
        AC_DEFINE(_PR_NO_LARGE_FILES)
        AIX_LINK_OPTS='-bnso -berok'
        PR_MD_ASFILES=os_AIX.s
        ;;
    aix4.1*)
        AC_DEFINE(AIX_TIMERS)
        AC_DEFINE(_PR_NO_LARGE_FILES)
        AC_DEFINE(AIX4_1)
        MKSHLIB=
        DSO_LDOPTS=
        AIX_LINK_OPTS='-bnso -berok'
        LIBNSPR='-L$(dist_libdir) -lnspr$(MOD_MAJOR_VERSION)_shr'
        LIBPLC='-L$(dist_libdir) -lplc$(MOD_MAJOR_VERSION)_shr'
        ;;
    aix4.2*)
        AC_DEFINE(AIX_TIMERS)
        AC_DEFINE(_PR_HAVE_OFF64_T)
        AIX_LINK_OPTS='-brtl -bnso -berok'
        ;;
    aix4.3*)
        AC_DEFINE(AIX_TIMERS)
        AC_DEFINE(_PR_HAVE_OFF64_T)
        AC_DEFINE(AIX4_3)
        AC_DEFINE(HAVE_SOCKLEN_T)
        AC_DEFINE(HAVE_FCNTL_FILE_LOCKING)
        USE_IPV6=1
        AIX_LINK_OPTS='-brtl -bnso -berok'
        ;;
    *)
        AC_DEFINE(AIX_TIMERS)
        AC_DEFINE(_PR_HAVE_OFF64_T)
        AC_DEFINE(HAVE_SOCKLEN_T)
        AC_DEFINE(HAVE_FCNTL_FILE_LOCKING)
        USE_IPV6=1
        AIX_LINK_OPTS='-brtl -bnso -berok'
        ;;
    esac
    CFLAGS="$CFLAGS -qro -qroconst"
    if echo "$CC" | grep -c xlC_r; then
        CFLAGS="$CFLAGS -qarch=com"
    fi
    AIX_WRAP='$(DIST)/lib/aixwrap.o'
    AIX_TMP='./_aix_tmp.o'
    if test -n "$USE_64"; then
        MDCPUCFG_H=_aix64.cfg
        OBJECT_MODE=64
    else
        if test -n "$USE_IPV6"; then
            MDCPUCFG_H=_aix32in6.cfg
        else
            MDCPUCFG_H=_aix32.cfg
        fi
    fi
    PR_MD_CSRCS=aix.c
    RESOLVE_LINK_SYMBOLS=1
    ;;
        
*-beos*)
    AC_DEFINE(XP_BEOS)
    AC_DEFINE(BeOS)
    AC_DEFINE(BEOS)
    AC_DEFINE(_POSIX_SOURCE)
    DSO_LDOPTS=-nostart
    MDCPUCFG_H=_beos.cfg
    USE_BTHREADS=1
    PR_MD_ARCH_DIR=beos
    RESOLVE_LINK_SYMBOLS=1
    case "${target_cpu}" in
    i?86)
        _OPTIMIZE_FLAGS=-O2
        _DEBUG_FLAGS='-gdwarf-2 -O0'
        MKSHLIB='$(CCC) $(DSO_LDOPTS) -o $@'
        ;;
    powerpc)
        CC=mwcc
        CCC=mwcc
        LD=mwld
        DSO_LDOPTS='-xms -export pragma -init _init_routine_ -term _term_routine_ -lroot -lnet /boot/develop/lib/ppc/glue-noinit.a /boot/develop/lib/ppc/init_term_dyn.o /boot/develop/lib/ppc/start_dyn.o'
        _OPTIMIZE_FLAGS=-O2    
        _DEBUG_FLAGS='-g -O0'
        ;;
    esac
    ;;

*-bsdi*)
    AC_DEFINE(XP_UNIX)
    AC_DEFINE(BSDI)
    AC_DEFINE(NEED_BSDREGEX)

    CFLAGS="$CFLAGS -Wall -Wno-format"
    CXXFLAGS="$CXXFLAGS -Wall -Wno-format"

    if echo "$OS_TEST" | grep -c 86 >/dev/null; then
        CPU_ARCH=x86
    elif echo "$OS_TEST" | grep -c sparc >/dev/null; then 
        CPU_ARCH=sparc
    fi

    MDCPUCFG_H=_bsdi.cfg
    PR_MD_CSRCS=bsdi.c

    DSO_LDOPTS=-r

    case "$target_os" in
    bsdi1.1*)
        AC_DEFINE(_PR_BSDI_JMPBUF_IS_ARRAY)
        AC_DEFINE(_PR_STAT_HAS_ONLY_ST_ATIME)
        AC_DEFINE(_PR_NEED_H_ERRNO)
        MKSHLIB=
        DSO_CFLAGS=
        DSO_LDOPTS=
        ;;

    bsdi2.1*)
        AC_DEFINE(_PR_TIMESPEC_HAS_TS_SEC)
        AC_DEFINE(_PR_BSDI_JMPBUF_IS_ARRAY)
        AC_DEFINE(HAVE_DLL)
        AC_DEFINE(USE_DLFCN)
        AC_DEFINE(_PR_STAT_HAS_ST_ATIMESPEC)
        PR_MD_ASFILES=os_BSD_OS_386_2.s
        ;;

    bsdi4.*)
        AC_DEFINE(_PR_SELECT_CONST_TIMEVAL)
        AC_DEFINE(_PR_BSDI_JMPBUF_IS_STRUCT)
        AC_DEFINE(HAVE_DLL)
        AC_DEFINE(USE_DLFCN)
        AC_DEFINE(_PR_STAT_HAS_ST_ATIMESPEC)
        MKSHLIB='$(CC) -o $@ $(DSO_LDOPTS)'
        DSO_CFLAGS=-fPIC
        DSO_LDOPTS='-shared -Wl,-soname,$(@:$(OBJDIR)/%.so=%.so)'
        STRIP="$STRIP -d"
        case "$target_os" in
        bsdi4.2*)
            AC_DEFINE(_PR_HAVE_GETPROTO_R)
            AC_DEFINE(_PR_HAVE_GETPROTO_R_POINTER)
            ;;
        esac
        ;;
    *)
        AC_DEFINE(_PR_SELECT_CONST_TIMEVAL)
        AC_DEFINE(_PR_BSDI_JMPBUF_IS_STRUCT)
        AC_DEFINE(HAVE_DLL)
        AC_DEFINE(USE_DLFCN)
        AC_DEFINE(_PR_STAT_HAS_ST_ATIMESPEC)
        ;;
    esac

    ;;

*-dgux*)
    AC_DEFINE(XP_UNIX)
    AC_DEFINE(_PR_LOCAL_THREADS_ONLY)
    AC_DEFINE(SVR4)
    AC_DEFINE(SYSV)
    AC_DEFINE(DGUX)
    AC_DEFINE(_DGUX_SOURCE)
    AC_DEFINE(_POSIX4A_DRAFT6_SOURCE)
    DSO_LDOPTS=-G
    _OPTIMIZE_FLAGS=-O2
    _DEBUG_FLAGS=
    MDCPUCFG_H=_dgux.cfg
    PR_MD_CSRCS=dgux.c
    ;;

*-freebsd*)
    if test -z "$USE_USER_PTHREADS"; then
        USE_PTHREADS=1
    fi
    AC_DEFINE(XP_UNIX)
    AC_DEFINE(FREEBSD)
    AC_DEFINE(HAVE_BSD_FLOCK)
    CFLAGS="$CFLAGS $(DSO_CFLAGS) -ansi -Wall -pipe"
    MOZ_OBJFORMAT=`test -x /usr/bin/objformat && /usr/bin/objformat || echo aout`
    if test "$MOZ_OBJFORMAT" = "elf"; then
        DLL_SUFFIX=so
    else
        DLL_SUFFIX=so.1.0
    fi
    DSO_CFLAGS=-fPIC
    DSO_LDOPTS=-Bshareable
    MDCPUCFG_H=_freebsd.cfg
    PR_MD_CSRCS=freebsd.c
    ;;

*-hpux*)
    AC_DEFINE(XP_UNIX)
    AC_DEFINE(HPUX)
    AC_DEFINE(_HPUX_SOURCE)
    AC_DEFINE(hppa)
    DLL_SUFFIX=sl
    DSO_LDOPTS='-b +h $(notdir $@)'
    PR_MD_CSRCS=hpux.c
    PR_MD_ASFILES=os_HPUX.s
    if test -n "$USE_64"; then
        MDCPUCFG_H=_hpux64.cfg
    else
        MDCPUCFG_H=_hpux32.cfg
    fi
    if test -z "$GNU_CC"; then
        CC="$CC -Ae"
        CXX="$CXX -ext"
        CFLAGS="$CFLAGS +ESlit"
        CXXFLAGS="$CXXFLAGS +ESlit"
        DSO_CFLAGS=+Z
    else
        DSO_CFLAGS=-fPIC
    fi

    if test -n "$MOZILLA_CLIENT"; then
        DEFAULT_IMPL_STRATEGY=_EMU
    fi

    if echo "$OS_RELEASE" | grep ^A.09 >/dev/null; then
        AC_DEFINE(_PR_NEED_H_ERRNO)
        AC_DEFINE(HPUX9)
        DEFAULT_IMPL_STRATEGY=_EMU
    	USE_NSPR_THREADS=1
    fi

    if echo "$OS_RELEASE" | egrep '^(A.09|B.10)' >/dev/null; then
        AC_DEFINE(_PR_NO_LARGE_FILES)
    fi

    if echo "$OS_RELEASE" | egrep '^(B.10.10|B.10.20)' >/dev/null; then
        AC_DEFINE(_PR_NEED_H_ERRNO)
    fi

    if echo "$OS_RELEASE" | egrep '^(B.10.10|B.10.20)' >/dev/null; then
        AC_DEFINE(HAVE_INT_LOCALTIME_R)
    fi

    if echo "$OS_RELEASE" | egrep '^(B.10.30|B.11.00)' >/dev/null; then
        AC_DEFINE(HAVE_POINTER_LOCALTIME_R)
    fi

    if test "$OS_RELEASE" = "B.10.01"; then
        AC_DEFINE(HPUX10)
        DEFAULT_IMPL_STRATEGY=_EMU
    fi

    if test "$OS_RELEASE" = "B.10.10"; then
        AC_DEFINE(HPUX10)
        AC_DEFINE(HPUX10_10)
        DEFAULT_IMPL_STRATEGY=_PTH
    fi

    if test "$OS_RELEASE" = "B.10.20"; then
        AC_DEFINE(HPUX10)
        AC_DEFINE(HPUX10_20)
        if test -z "$GNU_CC"; then
            CFLAGS="$CFLAGS +DAportable +DS1.1"
            CXXFLAGS="$CXXFLAGS +DAportable +DS1.1"
        fi
        DEFAULT_IMPL_STRATEGY=_PTH
    fi

    if test "$OS_RELEASE" = "B.10.30"; then
        AC_DEFINE(HPUX10)
        AC_DEFINE(HPUX10_30)
        if test -z "$GNU_CC"; then
            CFLAGS="$CFLAGS +DAportable +DS1.1"
            CXXFLAGS="$CXXFLAGS +DAportable +DS1.1"
        fi
        DEFAULT_IMPL_STRATEGY=_PTH
    fi

    if test "$OS_RELEASE" = "B.11.00"; then
        AC_DEFINE(HPUX10)
        AC_DEFINE(HPUX11)
        AC_DEFINE(_LARGEFILE64_SOURCE)
        AC_DEFINE(_PR_HAVE_OFF64_T)
        AC_DEFINE(HAVE_FCNTL_FILE_LOCKING)
        if test -z "$GNU_CC"; then
            if test -z "$USE_64"; then
                CFLAGS="$CFLAGS +DAportable +DS2.0"
                CXXFLAGS="$CXXFLAGS +DAportable +DS2.0"
            else
                CFLAGS="$CFLAGS +DA2.0W +DS2.0"
                CXXFLAGS="$CXXFLAGS +DA2.0W +DS2.0"
            fi
        fi
        DEFAULT_IMPL_STRATEGY=_PTH
    fi

    if test "$DEFAULT_IMPL_STRATEGY" = "_EMU"; then
        USE_NSPR_THREADS=1
        USE_PTHREADS=
        USE_USER_THREADS=
    elif test "$DEFAULT_IMPL_STRATEGY" = "_PTH"; then
        USE_PTHREADS=1
        if test "$USE_NSPR_THREADS"; then
            USE_PTHREADS=
        fi
        if test "$USE_USER_PTHREADS"; then
            USE_PTHREADS=
        fi
    fi
    ;;

*-irix*)
    AC_DEFINE(XP_UNIX)
    AC_DEFINE(IRIX)
    AC_DEFINE(SVR4)
    AC_DEFINE(_SGI_MP_SOURCE)
    AC_DEFINE(HAVE_FCNTL_FILE_LOCKING)
    PR_MD_CSRCS=irix.c
    PR_MD_ASFILES=os_Irix.s
    MKSHLIB='$(LD) $(DSO_LDOPTS) -rdata_shared -shared -soname $(notdir $@) -o $@'
    STRIP="$STRIP -f"
    RESOLVE_LINK_SYMBOLS=1
    if test -n "$USE_64"; then
        MDCPUCFG_H=_irix64.cfg
    else
        MDCPUCFG_H=_irix32.cfg
    fi
    case "${target_os}" in
    irix6*)
        AC_DEFINE(IRIX6)
        USE_PTHREADS=1
        USE_N32=1
        ;;
    irix5*)
        AC_DEFINE(IRIX5)
        USE_NSPR_THREADS=1
        ;;
    *)
        USE_PTHREADS=1
        USE_N32=1
        ;;
    esac
    if test "$GNU_CC"; then
	    AS='$(CC) -x assembler-with-cpp -D_ASM -mips2 $(INCLUDES)'
	    CFLAGS="$CFLAGS -Wall -Wno-format"
	    _OPTIMIZE_FLAGS="-O6"
    else
	    if test -n "$USE_N32"; then
		AS='as -D_ASM $(INCLUDES) -n32'
	    else
		AS='as -D_ASM $(INCLUDES)'
	    fi
	    CFLAGS="$CFLAGS -fullwarn -xansi"
	    if test "$USE_N32"; then
	        _OPTIMIZE_FLAGS="-O -OPT:Olimit=4000"
	    else
	        _OPTIMIZE_FLAGS="-O -Olimit 4000"
	    fi
	    if test "$USE_MDUPDATE"; then
                CFLAGS="$CFLAGS -MDupdate \$(DEPENDENCIES)"
	    fi
	    case "$target}" in
	    *-irix6.*)
	        CFLAGS="$CFLAGS -multigot"
	        DSO_LDOPTS="-no_unresolved"
	        if test "$USE_N32"; then
		        CFLAGS="$CFLAGS -n32 -woff 1209"
		        DSO_LDOPTS="$DSO_LDOPTS -n32"
	        else
		        if test "$USE_64"; then
		            CFLAGS="$CFLAGS -64"
		        else
		            CFLAGS="$CFLAGS -32"
		        fi
	        fi
	        ;;
	    *)
	        CFLAGS="$CFLAGS -xgot"
	        ;;
	    esac
    fi
    if test "${target_os}" = "irix5.3"; then
	    AC_DEFINE(IRIX5_3)
    fi
    case "${target_os}" in
	irix6.5)
	    if test -z "$GNU_CC"; then
		    CFLAGS="$CFLAGS -mips3"
	    fi
	    AC_DEFINE(_PR_HAVE_GETPROTO_R)
	    AC_DEFINE(_PR_HAVE_GETPROTO_R_POINTER)
	    AC_DEFINE(_PR_HAVE_SGI_PRDA_PROCMASK)
	    ;;
	irix5*)
	    ;;
	*)
	    AC_DEFINE(_PR_HAVE_SGI_PRDA_PROCMASK)
	    ;;
	esac
    ;;

*-linux*)
    if test -z "$USE_USER_PTHREADS"; then
        USE_PTHREADS=1
    fi
    AC_DEFINE(XP_UNIX)
    AC_DEFINE(_POSIX_SOURCE)
    AC_DEFINE(_BSD_SOURCE)
    AC_DEFINE(_SVID_SOURCE)
    AC_DEFINE(HAVE_FCNTL_FILE_LOCKING)
    AC_DEFINE(LINUX)
    AC_DEFINE(linux)
    CFLAGS="$CFLAGS -ansi -Wall -pipe"
    CXXFLAGS="$CXXFLAGS -ansi -Wall -pipe"
    MDCPUCFG_H=_linux.cfg
    PR_MD_CSRCS=linux.c
    MKSHLIB='$(LD) $(DSO_LDOPTS) -soname $(notdir $@) -o $@'
    DSO_CFLAGS=-fPIC
    DSO_LDOPTS=-shared
    OS_LIBS="$OS_LIBS -lc"
    _OPTIMIZE_FLAGS=-O2
    case "${target_cpu}" in
    alpha)
        AC_DEFINE(_ALPHA_)
        AC_DEFINE(__alpha)
        CFLAGS="$CFLAGS -mieee"
        CXXFLAGS="$CXXFLAGS -mieee"
        ;;
    i?86)
        AC_DEFINE(i386)
        PR_MD_ASFILES=os_Linux_x86.s
        ;;
    ia64)
        PR_MD_ASFILES=os_Linux_ia64.s
        ;;
    m68k)
        CFLAGS="$CFLAGS -m68020-40"
        CXXFLAGS="$CXXFLAGS -m68020-40"
        #
        # gcc on Linux/m68k either has a bug or triggers a code-sequence
        # bug in the 68060 which causes gcc to crash.  The simplest way to
        # avoid this is to enable a minimum level of optimization.
        #
        _DEBUG_FLAGS="$_DEBUG_FLAGS -O"
        ;;
    esac    
    ;;

*-mingw*|*-cygwin*|*-msvc*)
    AC_DEFINE(XP_PC)
    AC_DEFINE(WIN32)
    PR_MD_ARCH_DIR=windows
    RESOLVE_LINK_SYMBOLS=1

    if test -n "$GNU_CC"; then
        AC_DEFINE(NONAMELESSUNION)
        MKSHLIB='$(DLLTOOL) --as=$(AS) -k --dllname $*.dll --output-lib $@'
    else
        CC=cl
        CXX=cl
        LD=link
        AR='lib -NOLOGO -OUT:"$@"'
        AR_FLAGS=
        RANLIB='echo not_ranlib'
        STRIP='echo not_strip'
        NSINSTALL=nsinstall
        RC=rc.exe
        GARBAGE='$(OBJDIR)/vc20.pdb $(OBJDIR)/vc40.pdb'
	    OBJ_SUFFIX=obj
	    LIB_SUFFIX=lib
	    DLL_SUFFIX=dll
        
        CFLAGS="$CFLAGS -W3 -nologo -GF -Gy"
        _DEBUG_FLAGS=

        if test -n "$MOZ_DEBUG"; then
            AC_DEFINE(_DEBUG)
        else
            DEFINES="$DEFINES -U_DEBUG"
        fi

        if test -n "$MOZ_OPTIMIZE"; then
            CFLAGS="$CFLAGS -MD"
            OPTIMIZER=-O2
            DLLFLAGS='-OUT:"$@"'
            OBJDIR_TAG=_OPT

            if test -n "$MOZ_PROFILE"; then
                OPTIMIZER="$OPTIMIZER -Z7"
                DLLFLAGS="$DLLFLAGS -DEBUG -DEBUGTYPE:CV"
                LDFLAGS="$LDFLAGS -DEBUG -DEBUGTYPE:CV"
            fi
        else
            if test -n "$USE_DEBUG_RTL"; then
                CFLAGS="$CFLAGS -MDd"
            else
                CFLAGS="$CFLAGS -MD"
            fi
            OPTIMIZER="-Od -Z7"
            DLLFLAGS='-DEBUG -DEBUGTYPE:CV -OUT:"$@"'
            if test -n "$GLOWCODE"; then
                DLLFLAGS='-DEBUG -DEBUGTYPE:both -INCLUDE:_GlowCode -OUT:"$@"'
                DLL_LIBS='$(GLOWDIR)/glowcode.lib'
            fi
            OBJDIR_TAG=_DBG
            LDFLAGS="-DEBUG -DEBUGTYPE:CV"
            if test -n "$PROFILE"; then
                LDFLAGS="$LDFLAGS -PROFILE -MAP"
                DLLFLAGS="$DLLFLAGS -PROFILE -MAP"
            fi
        fi
        
        if test "$OS_TARGET" = "WINNT"; then
            CFLAGS="$CFLAGS -GT"
            if test "$CPU_ARCH" = "x86"; then
                CFLAGS="$CFLAGS -G5"
            fi
            LIBNSPR='$(dist_libdir)/libnspr$(MOD_MAJOR_VERSION).$(LIB_SUFFIX)'
            LIBPLC='$(dist_libdir)/libplc$(MOD_MAJOR_VERSION).$(LIB_SUFFIX)'
        else
            LIBNSPR='$(dist_libdir)/nspr$(MOD_MAJOR_VERSION).$(LIB_SUFFIX)'
            LIBPLC='$(dist_libdir)/plc$(MOD_MAJOR_VERSION).$(LIB_SUFFIX)'
        fi
    fi # GNU_CC

    if test -n "$USE_STATIC_TLS"; then
        AC_DEFINE(_PR_USE_STATIC_TLS)
    fi

    if test "$OS_TARGET" = "WINNT"; then
        AC_DEFINE(WINNT)
    else
        AC_DEFINE(WIN95)
        AC_DEFINE(_PR_GLOBAL_THREADS_ONLY)
    fi

    if test "$CPU_ARCH" = "x86"; then
        CPU_ARCH_TAG=
    else
        CPU_ARCH_TAG=$CPU_ARCH
    fi

    if test -n "$USE_DEBUG_RTL"; then
        OBJDIR_SUFFIX=OBJD
    else
        OBJDIR_SUFFIX=OBJ
    fi

    #OBJDIR_NAME="${OS_CONFIG}${CPU_ARCH_TAG}${OBJDIR_TAG}.${OBJDIR_SUFFIX}"
    #OBJDIR='${OBJDIR_NAME}'

    OS_DLLFLAGS='-nologo -DLL -SUBSYSTEM:WINDOWS -PDB:NONE'

    case "$OS_TARGET" in
    WINNT)
	    MDCPUCFG_H=_winnt.cfg
	    ;;
    WIN95)
	    MDCPUCFG_H=_win95.cfg
	    ;;
    WIN16)
	    MDCPUCFG_H=_win16.cfg
	    ;;
    *)
	    AC_MSG_ERROR([Missing OS_TARGET for ${target}.  Use --enable-win32-target to set.])
   	;;
    esac

    case "$target_cpu" in
    i?86)
	    AC_DEFINE(_X86_)
        ;;
    alpha)
	    AC_DEFINE(_ALPHA_)
   	    ;;
    mips)
	    AC_DEFINE(_MIPS_)
	    ;;
    *)
	    AC_DEFINE(_CPU_ARCH_NOT_DEFINED)
	    ;;
    esac

    ;;

*-ncr-sysv*)
    AC_DEFINE(XP_UNIX)
    AC_DEFINE(SVR4)
    AC_DEFINE(SYSV)
    AC_DEFINE(NCR)
    USE_NSPR_THREADS=1
    if test "$OS_RELEASE" = "2.03"; then
        AC_DEFINE(_PR_STAT_HAS_ST_ATIM)
    else
        AC_DEFINE(_PR_STAT_HAS_ST_ATIM_UNION)
    fi

    if test -z "$GNU_CC"; then
        CFLAGS="$CFLAGS -Hnocopyr"
        CXXFLAGS="$CXXFLAGS -Hnocopyr"
    else
        CFLAGS="$CFLAGS -fPIC -Wall -pipe"
        CXXFLAGS="$CXXFLAGS -fPIC -Wall -pipe"
        DSO_LDOPTS=-G
    fi
    MDCPUCFG_H=_ncr.cfg
    PR_MD_CSRCS=ncr.c
    ;;

mips-nec-sysv*)
    AC_DEFINE(XP_UNIX)
    AC_DEFINE(SVR4)
    AC_DEFINE(__SVR4)
    AC_DEFINE(NEC)
    AC_DEFINE(nec_ews)
    USE_NSPR_THREADS=1
    if test -z "$GNU_CC"; then
        CC='$(NSDEPTH)/build/hcc cc -Xa -KGnum=0 -KOlimit=4000'
        CXX=g++
    fi
    OS_LIBS="$OS_LIBS -lsocket -lnsl -ldl"
    DSO_LDOPTS=-G
    MDCPUCFG_H=_nec.cfg
    PR_MD_CSRCS=nec.c
    ;;

*-netbsd*)
    AC_DEFINE(XP_UNIX)
    AC_DEFINE(NETBSD)
    AC_DEFINE(HAVE_BSD_FLOCK)
    if test -z "$OBJECT_FMT"; then
        if echo __ELF__ | ${CC-cc} -E - | grep -q __ELF__ 2>/dev/null; then
            OBJECT_FMT=a.out;
        else
            OBJECT_FMT=ELF
        fi
    fi
    if test "$OBJECT_FMT" = "ELF"; then
        DLL_SUFFIX=so
    else
        DLL_SUFFIX=so.1.0
    fi
    CFLAGS="$CFLAGS -ansi -Wall -pipe"
    CXXFLAGS="$CXXFLAGS -ansi -Wall -pipe"
    DSO_CFLAGS='-fPIC -DPIC'
    DSO_LDOPTS='-x -shared'
    if test "$LIBRUNPATH"; then
        DSO_LDOPTS="$DSO_LDOPTS -R$(LIBRUNPATH)"
    fi
    MDCPUCFG_H=_netbsd.cfg
    PR_MD_CSRCS=netbsd.c
    ;;

mips-sony-newsos*)
    AC_DEFINE(XP_UNIX)
    AC_DEFINE(SONY)
    AC_DEFINE(SYSV)
    AC_DEFINE(SVR4)
    AC_DEFINE(__svr4)
    AC_DEFINE(__svr4__)
    AC_DEFINE(HAVE_SVID_GETTOD)
    USE_NSPR_THREADS=1
    CFLAGS="$CFLAGS -Xa -fullwarn"
    CXXFLAGS="$CXXFLAGS -Xa -fullwarn"
    DSO_LDOPTS=-G
    MDCPUCFG_H=_sony.cfg
    PR_MD_CSRCS=sony.c
    ;;

*-nextstep*|*-openstep*)
    AC_DEFINE(XP_UNIX)
    AC_DEFINE(NEXTSTEP)
    AC_DEFINE(HAVE_BSD_FLOCK)
    AC_DEFINE(_POSIX_SOURCE)
    CFLAGS="$CFLAGS -Wall -fno-common -pipe -traditional-cpp -posix"
    CXXFLAGS="$CXXFLAGS -Wall -fno-common -pipe -traditional-cpp -posix"
    USE_NSPR_THREADS=1
    DLL_SUFFIX=dylib
    MDCPUCFG_H=_nextstep.cfg
    PR_MD_CSRCS=nextstep.c
    ;;


*-nto*)
    AC_DEFINE(XP_UNIX)
    AC_DEFINE(NTO)
    AC_DEFINE(_QNX_SOURCE)
    AC_DEFINE(HAVE_POINTER_LOCALTIME_R)
    MDCPUCFG_H=_nto.cfg
    PR_MD_CSRCS=nto.c
    MKSHLIB='qcc -Vgcc_ntox86 -shared -Wl,-h$(@:$(OBJDIR)/%.so=%.so) -M -o $(@:$(OBJDIR)/%.so=%.so)'
    CFLAGS="$CFLAGS -Wc,-Wall -Wc,-Wno-parentheses -shared"
    OS_LIBS="$OS_LIBS -lsocket"
    _OPTIMIZE_FLAGS="-O1"
    _DEBUG_FLAGS="-O1 -gstabs"
    COMPILER_TAG="_qcc"
    CC="qcc -Vgcc_ntox86 -w"
    CXX='$(CC)'
    LD="qcc -Vgcc_ntox86 -nostdlib"
    AR="qcc -Vgcc_ntox86 -M -a $@"
    AR_FLAGS=
	;;

*-openbsd*)
    AC_DEFINE(XP_UNIX)
    AC_DEFINE(OPENBSD)
    AC_DEFINE(HAVE_BSD_FLOCK)
    CFLAGS="$CFLAGS -ansi -Wall -pipe"
    CXXFLAGS="$CXXFLAGS -ansi -Wall -pipe"
    DLL_SUFFIX=so.1.0
    DSO_CFLAGS=-fPIC
    MDCPUCFG_H=_openbsd.cfg
    PR_MD_CSRCS=openbsd.c
    USE_NSPR_THREADS=1
    case "$OS_TEST" in
    alpha|mips|pmax)
        DSO_LDOPTS=-shared ;;
    *)
        DSO_LDOPTS=-Bshareable ;;
    esac
    ;;

*-openvms*)
    AC_DEFINE(XP_UNIX)
    AC_DEFINE(VMS)
    AC_DEFINE(VMS_AS_IS)
    AC_DEFINE(GENERIC_PTHREAD_REDEFINES)
    RESOLVE_LINK_SYMBOLS=1
    CROSS_COMPILE=1
    _HAVE_PTHREADS=1
    HOST_CC=c89
    HOST_CXX=cxx
    HOST_CFLAGS=-O
    HOST_CXXFLAGS=-O
    CC=ccc
    CXX=ccc
    CFLAGS="$CFLAGS -Wc,names=\(short,as\)"
    CXXFLAGS="$CXXFLAGS -Wc,names=\(short,as\)"
    MDCPUCFG_H=_openvms.cfg
    PR_MD_CSRCS=openvms.c
    MKSHLIB='vmsld $(OPTIMIZER)'
    ;;

*-osf*)
    SHELL_OVERRIDE="SHELL		= /usr/bin/ksh"
    AC_DEFINE(XP_UNIX)
    AC_DEFINE(OSF1)
    AC_DEFINE(_REENTRANT)
    AC_CHECK_HEADER(machine/builtins.h, AC_DEFINE(OSF1_HAVE_MACHINE_BUILTINS_H))

    if echo "$OS_RELEASE" | egrep -c '(V2.0|V3.2)' 2>/dev/null ; then
        USE_NSPR_THREADS=1
    fi

    if test -z "$GNU_CC"; then
        CC="$CC -std1 -ieee_with_inexact"
        if test "$OS_RELEASE" != "V2.0"; then
            CC="$CC -readonly_strings"
        fi
        _OPTIMIZE_FLAGS="$_OPTIMIZE_FLAGS -Olimit 4000"
    fi

    if echo $OS_RELEASE | egrep -c '(V2.0|V3.2)' 2>/dev/null; then
        AC_DEFINE(HAVE_INT_LOCALTIME_R)
    else
        AC_DEFINE(HAVE_FCNTL_FILE_LOCKING)
        AC_DEFINE(HAVE_POINTER_LOCALTIME_R)
    fi
    if echo $OS_RELEASE | grep -c V4.0 >/dev/null; then
        AC_DEFINE(OSF1V4_MAP_PRIVATE_BUG)
    fi
    DSO_LDOPTS='-shared -all -expect_unresolved "*" -soname $(notdir $@)'
    MDCPUCFG_H=_osf1.cfg
    PR_MD_CSRCS=osf1.c
    ;;

*-qnx*)
    AC_DEFINE(XP_UNIX)
    AC_DEFINE(QNX)
    AC_DEFINE(_PR_NEED_H_ERRNO)
    USE_NSPR_THREADS=1
    MDCPUCFG_H=_qnx.cfg
    PR_MD_CSRCS=qnx.c
    ;;

*-rhapsody*)
    AC_DEFINE(XP_UNIX)
    AC_DEFINE(RHAPSODY)
    AC_DEFINE(HAVE_BSD_FLOCK)
    CFLAGS="$CFLAGS -Wmost -fno-common -pipe"    
    if echo $OS_TEST | grep -c 86 2>/dev/null; then
        CFLAGS="$CFLAGS -mno-486"
        AC_DEFINE(i386)
        CPU_ARCH=i386
    else
        AC_DEFINE(ppc)
        CPU_ARCH=ppc
    fi
    DSO_LDOPTS='-dynamiclib -compatibility_version 1 -current_version 1 -all_load'
    MKSHLIB='$(CC) -arch $(CPU_ARCH) $(DSO_LDOPTS) -o $@'
    DLL_SUFFIX=dylib
    USE_PTHREADS=1
    MDCPUCFG_H=_rhapsody.cfg
    PR_MD_CSRCS=rhapsody.c
    ;;

*-*-sco*)
    AC_DEFINE(XP_UNIX)
    AC_DEFINE(SCO)
    AC_DEFINE(sco)
    AC_DEFINE(SYSV)
    AC_DEFINE(_SVID3)
    AC_DEFINE(_PR_NEED_H_ERRNO)
    CC='cc -b elf -KPIC'
    CXX='$(NSDEPTH)/build/hcpp CC +.cpp +w'
    USE_NSPR_THREADS=1
    CPU_ARCH=x86
    DSO_LDOPTS='-b elf -G'
    MDCPUCFG_H=_scoos.cfg
    PR_MD_SRCS=scoos.c
    ;;

*-sinix*)
    AC_DEFINE(XP_UNIX)
    AC_DEFINE(SVR4)
    AC_DEFINE(SNI)
    AC_DEFINE(RELIANTUNIX)
    AC_DEFINE(sinix)
    AC_DEFINE(HAVE_SVID_GETTOD)
    if echo "$OS_TEST" | grep -c 86 2>/dev/null; then
        AC_DEFINE(i386)
        CPU_ARCH=x86
    else
        CPU_ARCH=mips
    fi

    if test "$GNU_CC"; then
        AS='$(CC) -x assembler-with-cpp'
        if test "$CPU_ARCH" = "mips"; then
            LD=gld
            CFLAGS="$CFLAGS -pipe"
        fi
        CFLAGS="$CFLAGS -Wall -Wno-format"
    else
        AS='/usr/bin/cc'
        _OPTIMIZE_FLAGS='-O -F Olimit,4000'
    fi

    DSO_LDOPTS='-G -z defs -h $(@:$(OBJDIR)/%.so=%.so)'

    if test "$OS_RELEASE" = "5.43"; then
        AC_DEFINE(IP_MULTICAST)
    fi

    OS_LIBS="$OS_LIBS -lsocket -lnsl -lresolv -ldl -lc"
    USE_NSPR_THREADS=1
    MDCPUCFG_H=_reliantunix.cfg
    PR_MD_CSRCS=reliantunix.c
    if test "${OS_ARCH}" = "mips"; then
        PR_MD_ASFILES=os_ReliantUNIX.s
    fi
    ;;

*-sunos*)
    AC_DEFINE(XP_UNIX)
    AC_DEFINE(SUNOS4)
    CFLAGS="$CFLAGS -Wall -Wno-format"
    if test "$USE_MDUPDATE"; then
        CFLAGS="$CFLAGS -MDupdate \$(DEPENDENCIES)"
    fi
    CPU_ARCH=sparc
    DLL_SUFFIX=so.1.0
    DSO_LDOPTS=
    DSO_CFLAGS=-fPIC
    USE_NSPR_THREADS=1
    if test "$OS_RELEASE" = "4.1.3_U1"; then
        _OPTIMIZE_FLAGS=
        OS_LIBS="$OS_LIBS -lm"
    fi
    MDCPUCFG_H=_sunos4.cfg
    PR_MD_CSRCS=sunos4.c
    ;;

*-solaris*)
    if test -z "$USE_USER_THREADS" && test -z "$USE_NATIVE_THREADS"; then
        USE_PTHREADS=1
    fi
    AC_DEFINE(XP_UNIX)
    AC_DEFINE(SVR4)
    AC_DEFINE(SYSV)
    AC_DEFINE(__svr4)
    AC_DEFINE(__svr4__)
    AC_DEFINE(SOLARIS)
    AC_DEFINE(HAVE_FCNTL_FILE_LOCKING)
    if test -n "$USE_64"; then
        MDCPUCFG_H=_solaris64.cfg
    else
        MDCPUCFG_H=_solaris32.cfg
    fi
    PR_MD_CSRCS=solaris.c
    DSO_LDOPTS='-G -h $(notdir $@)'
    if test -n "$GNU_CC"; then
        DSO_CFLAGS=-fPIC
    else
        DSO_CFLAGS=-KPIC
    fi
    if test -z "$GNU_AS"; then
        ASFLAGS="$ASFLAGS -Wa,-P"
    fi
    if test -n "$GNU_CC"; then
        CFLAGS="$CFLAGS -Wall"
        CXXFLAGS="$CXXFLAGS -Wall"
        if test -n "$USE_MDUPDATE"; then
            CFLAGS="$CFLAGS -MDupdate \$(DEPENDENCIES)"
            CXXFLAGS="$CXXFLAGS -MDupdate \$(DEPENDENCIES)"
        fi
    else
        CC="$CC -xstrconst"
        CXX="$CXX -Qoption cg -xstrconst"
        if test -n "$BUILD_NUMBER" && test -z "$MOZ_OPTIMIZE"; then
            CFLAGS="$CFLAGS -xs"
            CXXFLAGS="$CXXFLAGS -xs"
        fi
    fi
    if test -n "$USE_64" && test -z "$GNU_CC"; then
        CC="$CC -xarch=v9"
        CXX="$CXX -xarch=v9"
    fi
    if test "$OS_TEST" = "i86pc"; then
        AC_DEFINE(i386)
        # The default debug format, DWARF (-g), is not supported by gcc
        # on i386-ANY-sysv4/solaris, but the stabs format is.  It is
        # assumed that the Solaris assembler /usr/ccs/bin/as is used.
        # If your gcc uses GNU as, you do not need the -Wa,-s option.
        if test -n "$MOZ_DEBUG" && test -n "$GNU_CC"; then
            _DEBUG_FLAGS=-gstabs
            if test -z "$GNU_AS"; then
                _DEBUG_FLAGS="$_DEBUG_FLAGS -Wa,-s"
            fi
        fi
    fi
    case "${target_os}" in
    solaris2.3*)
        AC_DEFINE(_PR_NO_LARGE_FILES)
        ;;
    solaris2.4*)
        AC_DEFINE(_PR_NO_LARGE_FILES)
        ;;
    solaris2.5*)
        AC_DEFINE(SOLARIS2_5)    
        ;;
    *)
        AC_DEFINE(_PR_HAVE_OFF64_T)
        # The lfcompile64(5) man page on Solaris 2.6 says:
        #     For applications that do not wish to conform to the POSIX or
        #     X/Open  specifications,  the  64-bit transitional interfaces
        #     are available by default.  No compile-time flags need to  be
        #     set.
        # But gcc 2.7.2.x fails to define _LARGEFILE64_SOURCE by default.
        # The native compiler, gcc 2.8.x, and egcs don't have this problem.
        if test -n "$GNU_CC"; then
            AC_DEFINE(_LARGEFILE64_SOURCE)
        fi
        ;;
    esac
    if test "$OS_TEST" = "sun4u"; then
        ULTRASPARC_LIBRARY=ultrasparc
        ULTRASPARC_FILTER_LIBRARY=libatomic.so
        DSO_LDOPTS="$DSO_LDOPTS -f "'$(ULTRASPARC_FILTER_LIBRARY)'
    fi
    ;;

*-sco-sysv5*)
    AC_DEFINE(XP_UNIX)
    AC_DEFINE(UNIXWARE)
    AC_DEFINE(SVR4)
    AC_DEFINE(SYSV)
    USE_NSPR_THREADS=1
    if echo $OS_RELEASE | grep -c 2.1 2>/dev/null; then
        AC_DEFINE(_PR_NO_LARGE_FILES)
        CC='$(NSDEPTH)/build/hcc cc'
        CXX='$(NSDEPTH)/build/hcpp CC'
        MDCPUCFG_H=_unixware.cfg
    else
        AC_DEFINE(_LARGEFILE64_SOURCE)
        AC_DEFINE(_PR_HAVE_OFF64_T)
        AC_DEFINE(_PR_HAVE_SOCKADDR_LEN)
        MDCPUCFG_H=_unixware7.cfg
    fi
    PR_MD_CSRCS=unixware.c
    DSO_LDOPTS=-G
    CPU_ARCH=x86
    ;;

*-os2*)
    AC_DEFINE(XP_OS2)
    AC_DEFINE(BSD_SELECT)
    AC_DEFINE(XP_PC)
    AC_DEFINE(_PR_GLOBAL_THREADS_ONLY)
    OBJ_SUFFIX=obj
    LIB_SUFFIX=lib
    DLL_SUFFIX=dll
    DLLTOOL=''
    RC=rc.exe
    PR_MD_ARCH_DIR=os2
    PROG_SUFFIX=.exe
    NSINSTALL=nsinstall
    MDCPUCFG_H=_os2.cfg
    RESOLVE_LINK_SYMBOLS=1

    case "$target" in
    *-os2_emx)
        AC_DEFINE(XP_OS2_EMX)
        AC_DEFINE(OS2)
        AR=emxomfar
        AR_FLAGS='-p256 r $@'
        CFLAGS="-Zmtd -Zomf"
        HOST_CFLAGS="$CFLAGS"
        CXXFLAGS="-Zmtd -Zomf"
        OS_LIBS="-lsocket -lemxio"
        LD='$(CC)'
        IMPLIB='emximp -o'
        FILTER='emxexp'
        OS_DLLFLAGS='$(DSO_LDOPTS) -o $@'
        _OPTIMIZE_FLAGS=-O3
        _DEBUG_FLAGS=-g
        if test -n "$MOZ_DEBUG"; then
          DLLFLAGS='-g'
          EXEFLAGS='-g $(OMF_FLAG) -Zmtd -L$(DIST)/lib -o $@'
          DSO_LDOPTS='-g -Zomf -Zdll -Zmt -Zcrtdll -Zlinker /NOO'
        else
          DLLFLAGS=
          EXEFLAGS='-Zmtd -o $@'
          DSO_LDOPTS='-Zomf -Zdll -Zmt -Zcrtdll -Zlinker /NOO'
        fi
        ;;
    *-os2_vacpp)
        AC_DEFINE(XP_OS2_VACPP)
        AC_DEFINE(OS2,4)
        AC_DEFINE(TCPV40HDRS)
        AC_DEFINE(_X86_)
        AR=-ilib
        AR_FLAGS='/NOL /NOI /O:$(subst /,\\,$@)'
        CFLAGS='/Q /qlibansi /Gd+ /Gm+ /Su4 /Mp /Tl-'
        HOST_CFLAGS="$CFLAGS"
        OS_CFLAGS='/Q /qlibansi /Gd+ /Gm+ /Su4 /Ge- /Tl-'
        OS_EXE_CFLAGS='/Q /qlibansi /Gd+ /Gm+ /Su4 /Ge+ /Tl-'
        CXXFLAGS='/Q /qlibansi /Gd+ /Gm+ /Su4 /Mp /Tl-'
        OS_LIBS='so32dll.lib tcp32dll.lib'
        LD='-ilink'
        LDFLAGS='/FREE /DE /NOE /LINENUMBERS /nologo'
        MKSHLIB='$(LD) $(DSO_LDOPTS)'
        IMPLIB='implib -nologo -noignorecase'
        FILTER='cppfilt -q -B -P'
        _OPTIMIZE_FLAGS=/O+
        _DEBUG_FLAGS=/Ti+ 
        if test -n "$MOZ_DEBUG"; then
          DLLFLAGS='/O:$@ /DLL /INC:_dllentry /MAP:$(@:.dll=.map) /nologo /DEBUG /NOE'
          EXEFLAGS='/OUT:$@ /PMTYPE:VIO /MAP:$(@:.exe=.map) /nologo /DEBUG /NOE'
        else
          DLLFLAGS='/O:$@ /DLL /INC:_dllentry /MAP:$(@:.dll=.map) /nologo'
          EXEFLAGS='/OUT:$@ /PMTYPE:VIO /MAP:$(@:.exe=.map) /nologo'
        fi
        LIBNSPR='$(dist_libdir)/nspr$(MOD_MAJOR_VERSION).$(LIB_SUFFIX)'
        LIBPLC='$(dist_libdir)/plc$(MOD_MAJOR_VERSION).$(LIB_SUFFIX)'
        ;;
    esac

    ;;

*)
    AC_DEFINE(XP_UNIX)
    ;;
   
esac

dnl Turn off shared libraries if asked to do so.
if test "$enable_shared" = no; then
    MKSHLIB=
fi

if test -z "$SKIP_LIBRARY_CHECKS"; then
dnl ========================================================
dnl Check for system libraries
dnl ========================================================
dnl AC_CHECK_LIB(C, main)
dnl AC_CHECK_LIB(C_r, main)
dnl AC_CHECK_LIB(c, main)
dnl AC_CHECK_LIB(c_r, main)
dnl AC_CHECK_LIB(dce, main)
dnl AC_CHECK_LIB(dl, main)
dnl AC_CHECK_LIB(dld, main)
dnl AC_CHECK_LIB(gen, main)
dnl AC_CHECK_LIB(ip6, main)
dnl AC_CHECK_LIB(l, main)
dnl AC_CHECK_LIB(m, main)
dnl AC_CHECK_LIB(nsl, main)
dnl AC_CHECK_LIB(posix4, main)
dnl AC_CHECK_LIB(prstrms, main)
dnl AC_CHECK_LIB(prstrms_shr, main)
dnl AC_CHECK_LIB(pthread, main)
dnl AC_CHECK_LIB(pthreads, main)
dnl AC_CHECK_LIB(resolv, main)
dnl AC_CHECK_LIB(rt, main)
dnl AC_CHECK_LIB(socket, main)
dnl AC_CHECK_LIB(svld, main)
dnl AC_CHECK_LIB(thread, main)
dnl AC_CHECK_LIB(vms_jackets, main)

AC_CHECK_FUNC(dlopen,,[
    AC_CHECK_LIB(dl, dlopen, [OS_LIBS="-ldl $OS_LIBS"])
])

dnl ========================================================
dnl Check for system header files.
dnl ========================================================
dnl AC_HEADER_DIRENT
dnl AC_HEADER_STDC
dnl AC_HEADER_SYS_WAIT
dnl AC_CHECK_HEADERS(fcntl.h limits.h sys/file.h sys/ioctl.h sys/time.h unistd.h)

dnl ========================================================
dnl Check for typedefs and structs
dnl ========================================================
dnl AC_C_CONST
dnl AC_TYPE_UID_T
dnl AC_TYPE_MODE_T
dnl AC_TYPE_OFF_T
dnl AC_TYPE_PID_T
dnl AC_TYPE_SIZE_T
dnl AC_STRUCT_ST_BLKSIZE
dnl AC_STRUCT_ST_BLOCKS
dnl AC_STRUCT_ST_RDEV
dnl AC_HEADER_TIME
dnl AC_STRUCT_TM

dnl ========================================================
dnl Checks for library functions.
dnl ========================================================
AC_PROG_GCC_TRADITIONAL
AC_CHECK_FUNCS(lchown strerror)

dnl AC_FUNC_MEMCMP
dnl AC_FUNC_MMAP
dnl AC_FUNC_SETVBUF_REVERSED
dnl AC_FUNC_STRCOLL
dnl AC_FUNC_STRFTIME
dnl AC_FUNC_UTIME_NULL
dnl AC_FUNC_VPRINTF
dnl AC_CHECK_FUNCS(ftime getcwd gethostname gettimeofday getwd mkdir mktime putenv rmdir select socket strdup strerror strstr strtol strtoul uname)

dnl ========================================================
dnl Check options
dnl ========================================================

dnl
dnl Apparently, some systems cannot properly check for the pthread
dnl library unless <pthread.h> is included so we need to test
dnl using it
dnl
dnl MOZ_CHECK_PTHREADS(lib, success, failure)
AC_DEFUN(MOZ_CHECK_PTHREADS,
[
AC_MSG_CHECKING([for pthread_create in -l$1])
echo "
    #include <pthread.h> 
    void *foo(void *v) { int a = 1;  } 
    int main() { 
        pthread_t t;
        if (!pthread_create(&t, 0, &foo, 0)) {
            pthread_join(t, 0);
        }
        exit(0);
    }" > dummy.c ;
    echo "${CC-cc} -o dummy${ac_exeext} dummy.c $CFLAGS $CPPFLAGS -l[$1] $LDFLAGS $LIBS" 1>&5;
    ${CC-cc} -o dummy${ac_exeext} dummy.c $CFLAGS $CPPFLAGS -l[$1] $LDFLAGS $LIBS 2>&5;
    _res=$? ;
    rm -f dummy.c dummy${ac_exeext} ;
    if test "$_res" = "0"; then
        AC_MSG_RESULT([yes])
        [$2]
    else
        AC_MSG_RESULT([no])
        [$3]
    fi
])

MOZ_CHECK_PTHREADS(pthreads,
    _HAVE_PTHREADS=1 _PTHREAD_LDFLAGS="-lpthreads",
    MOZ_CHECK_PTHREADS(pthread,
        _HAVE_PTHREADS=1 _PTHREAD_LDFLAGS="-lpthread",
        MOZ_CHECK_PTHREADS(c_r,
            _HAVE_PTHREADS=1 _PTHREAD_LDFLAGS="-lc_r",
            MOZ_CHECK_PTHREADS(c,
                _HAVE_PTHREADS=1
            )
        )
    )
)
                        
AC_ARG_WITH(pthreads,
    [  --with-pthreads         Use system pthreads library as thread subsystem],
    [ if test "$withval" = "yes"; then
	    if test -n "$_HAVE_PTHREADS"; then
		    USE_PTHREADS=1 
		    USE_USER_PTHREADS=
		    USE_NSPR_THREADS=
	    else
		    AC_MSG_ERROR([ --with-pthreads specified for a system without pthread support ]);
	    fi
	  else
	    USE_PTHREADS=
	    _PTHREAD_LDFLAGS=
	  fi],
	[ if test -n "$_HAVE_PTHREADS" && test -z "$USE_USER_PTHREADS" && test -z "$USER_NSPR_THREADS"; then
	    USE_PTHREADS=1
	    USE_USER_PTHREADS=
	    USE_NSPR_THREADS=
	  fi])

AC_ARG_ENABLE(user-pthreads,
    [  --enable-user-pthreads  Build using userland pthreads],
    [ if test "$enableval" = "yes"; then
        if test -n "$_HAVE_PTHREADS"; then
		    USE_PTHREADS=
		    USE_USER_PTHREADS=1
		    USE_NSPR_THREADS=
	    else
		    AC_MSG_ERROR([ --enable-user-pthreads specified for a system without pthread support ]);
	    fi
	  fi])

AC_ARG_ENABLE(nspr-threads,
    [  --enable-nspr-threads   Build using classic nspr threads],
    [ if test "$enableval" = "yes"; then
	    USE_PTHREADS=
	    USE_USER_PTHREADS=
	    USE_NSPR_THREADS=1
	  fi])

case "$target" in
*-beos*)
    AC_ARG_WITH(bthreads,
    [  --with-bthreads         Use system bthreads library as thread subsystem (BeOS only)],
    [	if test "$withval" = "yes"; then
    	    USE_BTHREADS=1
	        USE_USER_PTHREADS=
	        USE_PTHREADS=
	    fi])
    ;;

*-solaris*)
    AC_ARG_WITH(native-threads,
    [  --with-native-threads   Use native system threads as thread subsystem (Solaris only)],
    [ if test "$withval" = "yes"; then
	    USE_NATIVE_THREADS=1
	    USE_USER_PTHREADS=
	    USE_PTHREADS=
	  fi])
    ;;
esac

fi # SKIP_LIBRARY_CHECKS

AC_ARG_ENABLE(cplus,
    [  --enable-cplus          Enable some c++ api routines],
    [ if test "$enableval" = "yes"; then
	    USE_CPLUS=1
      fi]) 

AC_ARG_ENABLE(ipv6,
    [  --enable-ipv6           Compile ipv6 support],
    [ if test "$enableval" = "yes"; then
	    USE_IPV6=1
      fi])


AC_ARG_ENABLE(boehm,
    [  --enable-boehm          Enable the Boehm Garbage Collector],
    [ if test "$enableval" = "yes"; then
        AC_DEFINE(GC_LEAK_DETECTOR)
        GC_LEAK_DETECTOR=1
    fi])

if test -n "$USE_PTHREADS"; then
   dnl See if -pthread is supported.
   rm -f conftest*
   ac_cv_have_dash_pthread=no
   AC_MSG_CHECKING(whether ${CC-cc} accepts -pthread)
   echo 'int main() { return 0; }' | cat > conftest.c
   ${CC-cc} -pthread -o conftest conftest.c > conftest.out 2>&1
   if test $? -eq 0; then
	if test -z "`egrep -i '(unrecognize|unknown)' conftest.out | grep pthread`" && test -z "`egrep -i '(error|incorrect)' conftest.out`" ; then
	    ac_cv_have_dash_pthread=yes
	    CFLAGS="$CFLAGS -pthread"
	    CXXFLAGS="$CXXFLAGS -pthread"
	fi
    fi
    rm -f conftest*
    AC_MSG_RESULT($ac_cv_have_dash_pthread)

	dnl
	dnl See if -pthreads is supported.
	dnl
    ac_cv_have_dash_pthreads=no
    if test "$ac_cv_have_dash_pthread" = "no"; then
	    AC_MSG_CHECKING(whether ${CC-cc} accepts -pthreads)
    	echo 'int main() { return 0; }' | cat > conftest.c
	    ${CC-cc} -pthreads -o conftest conftest.c > conftest.out 2>&1
    	if test $? -eq 0; then
	    	if test -z "`egrep -i '(unrecognize|unknown)' conftest.out | grep pthreads`" && test -z "`egrep -i '(error|incorrect)' conftest.out`" ; then
			    ac_cv_have_dash_pthreads=yes
			    CFLAGS="$CFLAGS -pthreads"
			    CXXFLAGS="$CXXFLAGS -pthreads"
		    fi
	    fi
	    rm -f conftest*
    	AC_MSG_RESULT($ac_cv_have_dash_pthreads)
    fi

    case "$target" in
    *-solaris*)
	    AC_DEFINE(_REENTRANT)
        if test "$ac_cv_have_dash_pthreads" = "yes"; then
            _PTHREAD_LDFLAGS=
        fi
	    ;;
    *-freebsd*|*-openbsd*|*-bsdi*|*-netbsd*)
	    AC_DEFINE(_THREAD_SAFE)
	    dnl -pthread links in -lc_r, so don't specify it explicitly.
	    if test "$ac_cv_have_dash_pthread" = "yes"; then
	        _PTHREAD_LDFLAGS=
	    fi
	    ;;
    *-linux*)
        AC_DEFINE(_REENTRANT)
        ;;
    esac

else 
    if test -n "$USE_USER_PTHREADS"; then
	    USE_PTHREADS=
	    USE_NSPR_THREADS=
    else
        _PTHREAD_LDFLAGS=
    fi
fi
dnl Special thread exceptions

case "$target" in
*-aix*)
    if test -n "$USE_NSPR_THREADS"; then
        AC_DEFINE(-D_PR_LOCAL_THREADS_ONLY)
    fi
    case "$target_os" in
    aix4.1*)
        if test -z "$USE_PTHREADS"; then
            AC_DEFINE(AIX_RENAME_SELECT)
        fi
        ;;
    aix4.2*)
        if test -z "$USE_NSPR_THREADS"; then
            AC_DEFINE(HAVE_POINTER_LOCALTIME_R)
        fi
        ;;
    aix4.3*)
        if test -z "$USE_NSPR_THREADS"; then
            AC_DEFINE(HAVE_POINTER_LOCALTIME_R)
        fi
        if test -n "$USE_PTHREADS"; then
            AC_DEFINE(_PR_HAVE_THREADSAFE_GETHOST)
        fi
        ;;
    esac
    ;;
*-bsdi*)
    if test -n "$USE_PTHREADS"; then
        AC_DEFINE(_PR_NEED_PTHREAD_INIT)
    fi
    ;;
*-freebsd*)
    if test -n "$USE_NSPR_THREADS"; then
        AC_DEFINE(-D_PR_LOCAL_THREADS_ONLY)
    fi
    ;;
*-hpux*)
    if test -n "$USE_NSPR_THREADS"; then
        AC_DEFINE(_PR_LOCAL_THREADS_ONLY)
    fi 
    if test "$USE_PTHREADS"; then
        if echo "$OS_RELEASE" | egrep '^(B.10.10|B.10.20)' >/dev/null; then
            AC_DEFINE(_REENTRANT)
            AC_DEFINE(_PR_DCETHREADS)
        else
            AC_DEFINE_UNQUOTED(_POSIX_C_SOURCE,199506L)
            AC_DEFINE(_PR_HAVE_THREADSAFE_GETHOST)
        fi
    fi
    if test "$USE_USER_PTHREADS"; then
        AC_DEFINE_UNQUOTED(_POSIX_C_SOURCE,199506L)
    fi
    ;;
*-irix*)
    if test "${target_os}" = "irix6.5"; then
        if test -n "$USE_PTHREADS"; then
            AC_DEFINE(_PR_HAVE_GETHOST_R)
            AC_DEFINE(_PR_HAVE_GETHOST_R_POINTER)
        fi
    fi
    ;;
*-linux*)
    if test -n "$USE_NSPR_THREADS"; then
        AC_DEFINE(_PR_LOCAL_THREADS_ONLY)
    fi
    ;;
*-mingw*|*-cygwin*|*-uwin*|*-msvc*)
    dnl win32 does not use pthreads
    USE_PTHREADS=
    _PTHREAD_LDFLAGS=
    USE_USER_PTHREADS=
    ;;
*-netbsd*)
    if test -z "$USE_PTHREADS"; then
        OS_LIBS="$OS_LIBS -lc"
    fi
    ;;    
*-osf*)
    if test -n "$USE_NSPR_THREADS"; then
        AC_DEFINE(-D_PR_LOCAL_THREADS_ONLY)
    fi
    if test -n "$USE_PTHREADS"; then
        if echo $OS_RELEASE | egrep -c '(V2.0|V3.2)' 2>/dev/null; then
            true
        else
            AC_DEFINE(_PR_HAVE_THREADSAFE_GETHOST)
        fi
    fi
    ;;
*-solaris*)
    if test -n "$USE_NATIVE_THREADS"; then
        AC_DEFINE(_PR_GLOBAL_THREADS_ONLY)
    else
        if test -n "$USE_USER_PTHREADS"; then
            AC_DEFINE(_PR_LOCAL_THREADS_ONLY)
        fi
    fi
    if test -z "$USE_USER_PTHREADS"; then
        AC_DEFINE(_REENTRANT)
        AC_DEFINE(HAVE_POINTER_LOCALTIME_R)
        if test "$OS_TEST" = "i86pc"; then
            PR_MD_ASFILES=os_SunOS_x86.s
        else
            PR_MD_ASFILES=os_SunOS.s
            if test -z "$USE_64"; then
                PR_MD_ASFILES="$PR_MD_ASFILES os_SunOS_32.s"
            fi
        fi
    fi
    ;;
esac

OS_LIBS="$_PTHREAD_LDFLAGS $OS_LIBS"

dnl If the user passed in arg to --enable-optimize,
dnl make sure that we use it.
if test -n "$_SAVE_OPTIMIZE_FLAGS"; then
    _OPTIMIZE_FLAGS="$_SAVE_OPTIMIZE_FLAGS"
fi

if test -n "$MOZ_OPTIMIZE"; then
    CFLAGS="$CFLAGS $_OPTIMIZE_FLAGS"
    CXXFLAGS="$CXXFLAGS $_OPTIMIZE_FLAGS"
fi

if test -n "$MOZ_DEBUG"; then
    CFLAGS="$CFLAGS $_DEBUG_FLAGS"
    CXXFLAGS="$CXXFLAGS $_DEBUG_FLAGS"
fi

dnl ========================================================
dnl Substitution of found variables.
dnl ========================================================
AC_SUBST(SHELL_OVERRIDE)

AC_SUBST(MOZILLA_CLIENT)
AC_SUBST(CC)
AC_SUBST(CXX)
AC_SUBST(CFLAGS)
AC_SUBST(CXXFLAGS)
AC_SUBST(CPPFLAGS)
AC_SUBST(HOST_CC)
AC_SUBST(HOST_CFLAGS)
AC_SUBST(LDFLAGS)
AC_SUBST(GNU_CC)
AC_SUBST(CROSS_COMPILE)

AC_SUBST(MOZ_OPTIMIZE)

AC_SUBST(USE_CPLUS)
AC_SUBST(USE_IPV6)
AC_SUBST(USE_N32)
AC_SUBST(USE_64)
AC_SUBST(OBJECT_MODE)
AC_SUBST(GC_LEAK_DETECTOR)

AC_SUBST(USE_PTHREADS)
AC_SUBST(USE_BTHREADS)
AC_SUBST(USE_USER_PTHREADS)
AC_SUBST(USE_NATIVE_THREADS)
AC_SUBST(USE_NSPR_THREADS)

AC_SUBST(LIBNSPR)
AC_SUBST(LIBPLC)

AC_SUBST(MOD_MAJOR_VERSION)
AC_SUBST(MOD_MINOR_VERSION)
AC_SUBST(MOD_REVISION_VERSION)
AC_SUBST(NSPR_MODNAME)
AC_SUBST(MDCPUCFG_H)
AC_SUBST(PR_MD_CSRCS)
AC_SUBST(PR_MD_ASFILES)
AC_SUBST(PR_MD_ARCH_DIR)
AC_SUBST(CPU_ARCH)

AC_SUBST(OBJ_SUFFIX)
AC_SUBST(LIB_SUFFIX)
AC_SUBST(DLL_SUFFIX)
AC_SUBST(MKSHLIB)
AC_SUBST(DSO_CFLAGS)
AC_SUBST(DSO_LDOPTS)

AC_SUBST(OS_TARGET)
AC_SUBST(OS_ARCH)
AC_SUBST(OS_RELEASE)
AC_SUBST(OS_TEST)

AC_SUBST(DEFINES)
AC_SUBST(DEFS)
AC_SUBST(AR)
AC_SUBST(AR_FLAGS)
AC_SUBST(AS)
AC_SUBST(ASFLAGS)
AC_SUBST(LD)
AC_SUBST(DLLTOOL)
AC_SUBST(WINDRES)
AC_SUBST(RANLIB)
AC_SUBST(PERL)
AC_SUBST(STRIP)
AC_SUBST(FILTER)
AC_SUBST(IMPLIB)

AC_SUBST(OS_LIBS)
AC_SUBST(RESOLVE_LINK_SYMBOLS)
AC_SUBST(AIX_LINK_OPTS)
AC_SUBST(NOSUCHFILE)
AC_SUBST(MOZ_OBJFORMAT)
AC_SUBST(ULTRASPARC_LIBRARY)
AC_SUBST(ULTRASPARC_FILTER_LIBRARY)

AC_SUBST(OBJDIR)
AC_SUBST(OBJDIR_NAME)
AC_SUBST(NSINSTALL)
AC_SUBST(OPTIMIZER)
AC_SUBST(RC)
AC_SUBST(CPU_ARCH_TAG)
AC_SUBST(DLLFLAGS)
AC_SUBST(EXEFLAGS)
AC_SUBST(OS_DLLFLAGS)

dnl ========================================================
dnl Generate output files.
dnl ========================================================
MAKEFILES="
Makefile 
config/Makefile
config/autoconf.mk
config/nsprincl.mk
config/nsprincl.sh
config/nspr-config
lib/Makefile 
lib/ds/Makefile 
lib/libc/Makefile 
lib/libc/include/Makefile 
lib/libc/src/Makefile 
pr/Makefile 
pr/include/Makefile 
pr/include/md/Makefile 
pr/include/obsolete/Makefile 
pr/include/private/Makefile 
pr/src/Makefile 
pr/src/io/Makefile 
pr/src/linking/Makefile 
pr/src/malloc/Makefile 
pr/src/md/Makefile 
pr/src/md/${PR_MD_ARCH_DIR}/Makefile 
pr/src/memory/Makefile 
pr/src/misc/Makefile 
pr/src/threads/Makefile 
pr/tests/Makefile 
pr/tests/dll/Makefile 
"

dnl lib/tests/Makefile
dnl pr/tests/w16gui/Makefile
dnl tools/Makefile

if test -z "$USE_PTHREADS" && test -z "$USE_BTHREADS"; then
    MAKEFILES="$MAKEFILES pr/src/threads/combined/Makefile"
elif test -n "$USE_PTHREADS"; then
    MAKEFILES="$MAKEFILES pr/src/pthreads/Makefile"
elif test -n "$USE_BTHREADS"; then
    MAKEFILES="$MAKEFILES pr/src/bthreads/Makefile"
fi

if test -n "$USE_CPLUS"; then
    MAKEFILES="$MAKEFILES pr/src/cplus/Makefile pr/src/cplus/tests/Makefile"
fi

AC_OUTPUT([$MAKEFILES], [chmod +x config/nspr-config])