path: root/configure.in

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

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=6
MOD_PATCH_VERSION=7
NSPR_MODNAME=nspr20
_HAVE_PTHREADS=
USE_PTHREADS=
USE_USER_PTHREADS=
USE_NSPR_THREADS=
USE_N32=
USE_64=
USE_CPLUS=
USE_IPV6=
USE_MDUPDATE=
_MACOSX_DEPLOYMENT_TARGET=
_OPTIMIZE_FLAGS=-O
_DEBUG_FLAGS=-g
MOZ_DEBUG=1
MOZ_OPTIMIZE=
OBJDIR=.
OBJDIR_NAME=.
OBJDIR_SUFFIX=OBJ
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)'
CYGWIN_WRAPPER=
MACOS_SDK_DIR=
NEXT_ROOT=

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*|*-mingw*)
    # Check to see if we are really running in a msvc environemnt
    _WIN32_MSVC=
    AC_CHECK_PROGS(CC, cl)
    if test "$CC" = "cl"; then
        echo 'main() { return 0; }' > dummy.c
        ${CC} -o dummy dummy.c >/dev/null 2>&1
        if test $? = 0; then
            _WIN32_MSVC=1
            CXX=$CC
        else
            AC_MSG_WARN([$(CC) test failed.  Using normal feature tests])
        fi
        rm -f dummy dummy.o dummy.obj dummy.exe dummy.c
    fi
    ;;
*-msvc*)
    _WIN32_MSVC=1
    ;;
*-mks*)
    _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/nspr'
dist_libdir='${dist_prefix}/lib'
if test "${includedir}" = '${prefix}/include'; then
    includedir='${prefix}/include/nspr'
fi

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/nspr]],
    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
      else
        MOZ_OPTIMIZE=
    fi ])

AC_ARG_ENABLE(debug,
    [  --disable-debug         Do not compile in debugging symbols
  --enable-debug(=val)    Enable debugging (debug flags val)],
    [	if test "$enableval" = "no"; then
    	    MOZ_DEBUG=
        else
            MOZ_DEBUG=1
            if test -n "$enableval" && test "$enableval" != "yes"; then
                _DEBUG_FLAGS=`echo $enableval | sed -e 's|\\\ | |g'`
                _SAVE_DEBUG_FLAGS=$_DEBUG_FLAGS
            fi
        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 = Mac OS X SDK support
dnl ========================================================
AC_ARG_WITH(macos-sdk,
    [  --with-macos-sdk=dir    Location of platform SDK to use (Mac OS X only)],
    MACOS_SDK_DIR=$withval)

AC_ARG_ENABLE(macos-target,
             [  --enable-macos-target=VER
                          Set the minimum MacOS version needed at runtime
                          [10.1 for ppc, 10.4 for x86]],
             [_MACOSX_DEPLOYMENT_TARGET=$enableval])

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
    ;;

    *-openvms*)
        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
    ;;

    *-openvms*)
        CXX=cxx
    ;;

    *-osf*)
        CXX=cxx
    ;;

    *-solaris*)
        CXX=CC
    ;;

    esac
fi

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

if test -n "$MOZ_DEBUG"; then
    AC_DEFINE(DEBUG)
    DEFINES="$DEFINES -UNDEBUG"

    case "${target_os}" in
    beos*)
        DEFINES="$DEFINES -DDEBUG_${USER}"
        ;;
    msvc*|mks*|cygwin*|mingw*|os2*)
        DEFINES="$DEFINES -DDEBUG_`echo ${USERNAME} | sed -e 's| |_|g'`"
        ;;
    *) 
        DEFINES="$DEFINES -DDEBUG_`$WHOAMI`"
        ;;
    esac
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])
    AC_CHECK_PROGS(HOST_CC, $HOST_CC gcc cc /usr/ucb/cc, "")
    if test -z "$HOST_CC"; then
        AC_MSG_ERROR([no acceptable cc found in \$PATH])
    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

    case "$build:$target" in 
      powerpc-apple-darwin8*:i?86-apple-darwin*)
        dnl The Darwin cross compiler doesn't necessarily point itself at a
        dnl root that has libraries for the proper architecture, it defaults
        dnl to the system root.  The libraries in the system root on current
        dnl versions of PPC OS X 10.4 aren't fat, so these target compiler
        dnl checks will fail.  Fake a working SDK in that case.
        _SAVE_CFLAGS=$CFLAGS 
        _SAVE_CXXFLAGS=$CXXLAGS
        CFLAGS="-isysroot /Developer/SDKs/MacOSX10.4u.sdk $CFLAGS"
        CXXFLAGS="-isysroot /Developer/SDKs/MacOSX10.4u.sdk $CXXFLAGS"
        ;;        
    esac            

    AC_CHECK_PROGS(CC, $CC "${target_alias}-gcc" "${target}-gcc", echo)
    unset ac_cv_prog_CC
    AC_PROG_CC
    AC_CHECK_PROGS(CXX, $CXX "${target_alias}-g++" "${target}-g++", echo)
    unset ac_cv_prog_CXX
    AC_PROG_CXX

    case "$build:$target" in
      powerpc-apple-darwin8*:i?86-apple-darwin*)
        dnl Revert the changes made above.  From this point on, the target
        dnl compiler will never be used without applying the SDK to CFLAGS
        dnl (see --with-macos-sdk below).
        CFLAGS=$_SAVE_CFLAGS
        CXXFLAGS=$_SAVE_CXXFLAGS
        ;;
    esac

    AC_CHECK_PROGS(RANLIB, $RANLIB "${target_alias}-ranlib" "${target}-ranlib", echo)
    AC_CHECK_PROGS(AR, $AR "${target_alias}-ar" "${target}-ar", echo)
    AC_CHECK_PROGS(AS, $AS "${target_alias}-as" "${target}-as", echo)
    AC_CHECK_PROGS(LD, $LD "${target_alias}-ld" "${target}-ld", echo)
    AC_CHECK_PROGS(STRIP, $STRIP "${target_alias}-strip" "${target}-strip", echo)
    AC_CHECK_PROGS(WINDRES, $WINDRES "${target_alias}-windres" "${target}-windres", echo)

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(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 "$GXX" = "yes"; then
    GNU_CXX=1
fi
if test "`echo | $AS -v 2>&1 | grep -c GNU`" != "0"; then
    GNU_AS=1
fi
rm -f a.out

case "$build:$target" in
    i?86-apple-darwin*:powerpc-apple-darwin*)
        dnl cross_compiling will have erroneously been set to "no" in this
        dnl case, because the x86 build host is able to run ppc code in a
        dnl translated environment, making a cross compiler appear native.
        cross_compiling=yes
        ;;
esac

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

dnl ========================================================
dnl Check for gcc -pipe support
dnl ========================================================
AC_MSG_CHECKING([for gcc -pipe support])
if test -n "$GNU_CC" && test -n "$GNU_CXX" && test -n "$GNU_AS"; then
    echo '#include <stdio.h>' > dummy-hello.c
    echo 'int main() { printf("Hello World\n"); return 0; }' >> dummy-hello.c
    ${CC} -S dummy-hello.c -o dummy-hello.s 2>&5
    cat dummy-hello.s | ${AS} -o dummy-hello.S - 2>&5
    if test $? = 0; then
        _res_as_stdin="yes"
    else
        _res_as_stdin="no"
    fi
    if test "$_res_as_stdin" = "yes"; then
        _SAVE_CFLAGS=$CFLAGS
        CFLAGS="$CFLAGS -pipe"
        AC_TRY_COMPILE( [ #include <stdio.h> ],
            [printf("Hello World\n");],
            [_res_gcc_pipe="yes"],
            [_res_gcc_pipe="no"] )
        CFLAGS=$_SAVE_CFLAGS
    fi
    if test "$_res_as_stdin" = "yes" && test "$_res_gcc_pipe" = "yes"; then
        _res="yes";
        CFLAGS="$CFLAGS -pipe"
        CXXFLAGS="$CXXFLAGS -pipe"
    else
        _res="no"
    fi
    rm -f dummy-hello.c dummy-hello.s dummy-hello.S dummy-hello a.out
    AC_MSG_RESULT([$_res])
else
    AC_MSG_RESULT([no])
fi

dnl ===============================================================
dnl Check for .hidden assembler directive and visibility attribute.
dnl Borrowed from glibc configure.in
dnl ===============================================================
if test "$GNU_CC"; then
    AC_CACHE_CHECK(for visibility(hidden) attribute,
        ac_cv_visibility_hidden,
        [cat > conftest.c <<EOF
        int foo __attribute__ ((visibility ("hidden"))) = 1;
EOF
        ac_cv_visibility_hidden=no
        if ${CC-cc} -Werror -S conftest.c -o conftest.s >/dev/null 2>&1; then
            if grep '\.hidden.*foo' conftest.s >/dev/null; then
                ac_cv_visibility_hidden=yes
            fi
        fi
        rm -f conftest.[cs]
        ])
    if test "$ac_cv_visibility_hidden" = "yes"; then
        AC_DEFINE(HAVE_VISIBILITY_HIDDEN_ATTRIBUTE)
        AC_CACHE_CHECK(for visibility pragma support,
            ac_cv_visibility_pragma,
            [cat > conftest.c <<EOF
#pragma GCC visibility push(hidden)
            int foo_hidden = 1;
#pragma GCC visibility push(default)
            int foo_default = 1;
EOF
            ac_cv_visibility_pragma=no
            if ${CC-cc} -Werror -S conftest.c -o conftest.s >/dev/null 2>&1; then
                if grep '\.hidden.*foo_hidden' conftest.s >/dev/null; then
                    if ! grep '\.hidden.*foo_default' conftest.s > /dev/null; then
                        ac_cv_visibility_pragma=yes
                    fi
                fi
            fi
            rm -f conftest.[cs]
            ])
        if test "$ac_cv_visibility_pragma" = "yes"; then
            AC_DEFINE(HAVE_VISIBILITY_PRAGMA)
            # To work around a build problem on Linux x86-64 (Bugzilla bug
            # 293438), we use the -fvisibility=hidden flag.  This flag is less
            # optimal than #pragma GCC visibility push(hidden) because the flag
            # assumes that symbols defined outside the current source file have
            # the default visibility.  This has the advantage that we don't need
            # to wrap system header files, but has the disadvantage that calls
            # to hidden symbols defined in other source files cannot be
            # optimized by the compiler.  The -fvisibility=hidden flag does
            # hide and export symbols correctly.
            #VISIBILITY_FLAGS='-I$(dist_includedir)/system_wrappers -include $(topsrcdir)/config/gcc_hidden.h'
            #WRAP_SYSTEM_INCLUDES=1
            VISIBILITY_FLAGS="-fvisibility=hidden"
            WRAP_SYSTEM_INCLUDES=
        fi
    fi
fi # GNU_CC

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
ASM_SUFFIX=s
MKSHLIB='$(LD) $(DSO_LDOPTS) -o $@'
PR_MD_ASFILES=
PR_MD_CSRCS=
PR_MD_ARCH_DIR=unix
AR_FLAGS='cr $@'
AS='$(CC)'
ASFLAGS='$(CFLAGS)'

if test -n "$CROSS_COMPILE"; then
    OS_ARCH=`echo $target_os | sed -e 's|/|_|g'`
    OS_RELEASE=
    OS_TEST="${target_cpu}"
    case "${target_os}" in
        linux*)       OS_ARCH=Linux ;;
        solaris*)     OS_ARCH=SunOS OS_RELEASE=5 ;;
        mingw*)       OS_ARCH=WINNT ;;
        darwin*)      OS_ARCH=Darwin ;;
    esac
else
    OS_ARCH=`uname -s | sed -e 's|/|_|g'`
    OS_RELEASE=`uname -r`
    OS_TEST=`uname -m`
fi

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

if test "$OS_ARCH" = "AIX"; then
    OS_RELEASE=`uname -v`.`uname -r`
fi

if test "$OS_ARCH" = "FreeBSD"; then
    OS_RELEASE=`echo $OS_RELEASE | sed 's/-.*//'`
fi

if test "$OS_ARCH" = "Linux"; then
    OS_RELEASE=`echo $OS_RELEASE | sed 's/-.*//'`
    OS_RELEASE=`echo $OS_RELEASE | awk -F\. '{ print $1 "." $2 }'`
fi

if test "$OS_ARCH" = "OpenVMS"; then
    OS_RELEASE=`uname -v`
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.
#
case "$OS_ARCH" in
WIN95)
    OS_ARCH=WINNT
    OS_TARGET=WIN95
    ;;
Windows_95)
    OS_ARCH=Windows_NT
    OS_TARGET=WIN95
    ;;
Windows_98)
    OS_ARCH=Windows_NT
    OS_TARGET=WIN95
    ;;
CYGWIN_9*|CYGWIN_ME*)
    OS_ARCH='CYGWIN_NT-4.0'
    OS_TARGET=WIN95
    ;;
OS_2)
    OS_ARCH=OS2
    OS_TARGET=OS2
    ;;
esac

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

case "$OS_ARCH" in
WINNT)
    CPU_ARCH=`uname -p`
    if test "$CPU_ARCH" = "I386"; then
        CPU_ARCH=x86
    fi
    ;;
Windows_NT)
#
# 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
    ;;
CYGWIN_NT*|MINGW*_NT*)
#
# If uname -s returns "CYGWIN_NT-4.0", we assume that we are using
# the uname.exe in the Cygwin tools.
# If uname -s returns MINGW32_NT-5.1, we assume that we are using
# the uname.exe in the MSYS tools.
#
    OS_RELEASE=`expr $OS_ARCH : '.*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
    ;;
esac

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*)
    NSINSTALL=nsinstall
    ;;
*-cygwin*|*-msvc*|*-mks*)
    NSINSTALL='$(CYGWIN_WRAPPER) nsinstall'
    if test `echo "${PATH}" | grep -c \;` = 0; then
        CYGWIN_WRAPPER='sh $(topsrcdir)/build/cygwin-wrapper'
    fi
    ;;
*-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 -bnortllib -bM:SRE -bnoentry -bexpall -blibpath:/usr/lib:/lib'
    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_PLUS)
        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(AIX4_3_PLUS)
        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"
    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
        MDCPUCFG_H=_aix32.cfg
    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 $@'
        AC_CHECK_LIB(bind, gethostbyaddr, [OS_LIBS="$OS_LIBS -lbind -lsocket"])
        ;;
    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.* | bsdi5.*)
        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* | bsdi4.3* | bsdi5.*)
            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

    ;;

*-darwin*)
    AC_DEFINE(XP_UNIX)
    AC_DEFINE(DARWIN)
    AC_DEFINE(HAVE_BSD_FLOCK)
    CFLAGS="$CFLAGS -Wmost -fno-common"
    case "${target_cpu}" in
        i*86*)
            AC_DEFINE(i386)
            CPU_ARCH=i386
            PR_MD_ASFILES=os_Darwin_x86.s
            ;;
        *)
            AC_DEFINE(ppc)
            CPU_ARCH=ppc
            PR_MD_ASFILES=os_Darwin_ppc.s
            ;;
    esac
    DSO_CFLAGS=-fPIC
    DSO_LDOPTS='-dynamiclib -compatibility_version 1 -current_version 1 -all_load -install_name @executable_path/$@ -headerpad_max_install_names'
    # Use the standard preprocessor (cpp)
    CFLAGS="$CFLAGS -no-cpp-precomp"
    MKSHLIB='$(CC) $(DSO_LDOPTS) -o $@'
    STRIP="$STRIP -x -S"
    DLL_SUFFIX=dylib
    USE_PTHREADS=1
    MDCPUCFG_H=_darwin.cfg
    PR_MD_CSRCS=darwin.c

    # Add Mac OS X support for loading CFM & CFBundle plugins
    if test -f /System/Library/Frameworks/Carbon.framework/Carbon; then
        AC_DEFINE(XP_MACOSX)
        OS_TARGET=MacOSX

        if test -n "$_MACOSX_DEPLOYMENT_TARGET" ; then
            dnl Use the specified value
            export MACOSX_DEPLOYMENT_TARGET=$_MACOSX_DEPLOYMENT_TARGET
        elif test -z "$MACOSX_DEPLOYMENT_TARGET" ; then
            dnl No value specified on the command line or in the environment,
            dnl use the lesser of the library's minimum or the architecture's
            dnl minimum.
            case "${target_cpu}" in
                powerpc*)
                    dnl Architecture minimum 10.1
                    export MACOSX_DEPLOYMENT_TARGET=10.1
                    ;;
                i*86*)
                    dnl Architecture minimum 10.4
                    export MACOSX_DEPLOYMENT_TARGET=10.4
                    ;;
            esac
        fi

        dnl MACOS_SDK_DIR will be set to the SDK location whenever one is
        dnl in use.  NEXT_ROOT will be set and exported if it's needed for
        dnl ld.

        if test "$MACOS_SDK_DIR"; then
            dnl Sync this section with the one in Mozilla's top level.

            if test ! -d "$MACOS_SDK_DIR"; then
                AC_MSG_ERROR([SDK not found.  When using --with-macos-sdk, you must
specify a valid SDK.  SDKs are installed when the optional cross-development
tools are selected during the Xcode/Developer Tools installation.])
            fi

            changequote(,)
            CC_VERSION=`$CC -v 2>&1 | grep 'gcc version'`
            GCC_VERSION_FULL=`echo $CC_VERSION | $PERL -pe 's/^.*gcc version ([^ ]*).*/$1/'`
            GCC_VERSION=`echo $GCC_VERSION_FULL | $PERL -pe '(split(/\./))[0]>=4&&s/(^\d*\.\d*).*/$1/;'`
            changequote([,])
            GCC_VERSION_MAJOR=`echo $GCC_VERSION_FULL | $PERL -pe 's/(^\d*).*/$1/;'`
            if test "$GCC_VERSION_MAJOR" -lt "4" ; then
                SDK_C_FRAMEWORK="-F${MACOS_SDK_DIR}/System/Library/Frameworks"
                if test -d "${MACOS_SDK_DIR}/Library/Frameworks" ; then
                    SDK_C_FRAMEWORK="$SDK_C_FRAMEWORK -F${MACOS_SDK_DIR}/Library/Frameworks"
                fi

                SDK_C_INCLUDE="-isystem ${MACOS_SDK_DIR}/usr/include/gcc/darwin/${GCC_VERSION} -isystem ${MACOS_SDK_DIR}/usr/include ${SDK_C_FRAMEWORK}"

                CFLAGS="$CFLAGS -nostdinc ${SDK_C_INCLUDE}"

                dnl CPP needs to be set for AC_CHECK_HEADER.
                CPP="$CPP -nostdinc ${SDK_C_INCLUDE}"

                dnl ld support for -syslibroot is compiler-agnostic, but only
                dnl available on Tiger.  Although it's possible to switch on
                dnl the build host's OS release to use ld -syslibroot when
                dnl available, ld -syslibroot cause warnings as long as
                dnl NEXT_ROOT is set.  NEXT_ROOT should be set because both
                dnl both the compiler and linker use it.
                dnl
                dnl LDFLAGS is for the utilities built in config (now and
                dnl nsinstall).  DSO_LDOPTS is used when linking shared
                dnl libraries.
                MACOS_SDK_LIBS="-L${MACOS_SDK_DIR}/usr/lib/gcc/darwin -L${MACOS_SDK_DIR}/usr/lib/gcc/darwin/${GCC_VERSION_FULL} -L${MACOS_SDK_DIR}/usr/lib ${SDK_C_FRAMEWORK}"
                LDFLAGS="${MACOS_SDK_LIBS} $LDFLAGS"
                DSO_LDOPTS="${MACOS_SDK_LIBS} $DSO_LDOPTS"
                export NEXT_ROOT=$MACOS_SDK_DIR

                if test -n "$CROSS_COMPILE" ; then
                    dnl NEXT_ROOT will be in the environment, but it
                    dnl shouldn't be set for the build host.  HOST_CXX is
                    dnl presently unused.
                    HOST_CC="NEXT_ROOT= $HOST_CC"
                    HOST_CXX="NEXT_ROOT= $HOST_CXX"
                fi
            else
                dnl gcc >= 4.0 uses different paths than above, but knows
                dnl how to find them itself.
                CFLAGS="$CFLAGS -isysroot ${MACOS_SDK_DIR}"

                dnl CPP needs to be set for AC_CHECK_HEADER.
                CPP="$CPP -isysroot ${MACOS_SDK_DIR}"

                dnl If gcc >= 4.0.0, we're guaranteed to be on Tiger, which
                dnl has an ld that supports -syslibroot.  Don't set
                dnl NEXT_ROOT because it will be ignored and cause
                dnl warnings when -syslibroot is specified.
                dnl
                dnl Both LDFLAGS and DSO_LDOPTS are set here, see the
                dnl gcc < 4.0 case for the explanation.
                if test "$GCC_VERSION_FULL" != "4.0.0" ; then
                    dnl gcc > 4.0.0 will pass -syslibroot to ld automatically
                    dnl based on the -isysroot it receives.
                    LDFLAGS="$LDFLAGS -isysroot ${MACOS_SDK_DIR}"
                    DSO_LDOPTS="$DSO_LDOPTS -isysroot ${MACOS_SDK_DIR}"
                else
                    dnl gcc 4.0.0 doesn't pass -syslibroot to ld, it needs
                    dnl to be explicit.
                    LDFLAGS="$LDFLAGS -Wl,-syslibroot,${MACOS_SDK_DIR}"
                    DSO_LDOPTS="$DSO_LDOPTS -Wl,-syslibroot,${MACOS_SDK_DIR}"
                fi
            fi
        fi
    fi
    ;;

*-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_NSPR_THREADS"; then
        USE_PTHREADS=1
    fi
    AC_DEFINE(XP_UNIX)
    AC_DEFINE(FREEBSD)
    AC_DEFINE(HAVE_BSD_FLOCK)
    AC_DEFINE(HAVE_SOCKLEN_T)
    CFLAGS="$CFLAGS $(DSO_CFLAGS) -ansi -Wall"
    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
    MKSHLIB='$(CC) $(DSO_LDOPTS) -o $@'
    DSO_CFLAGS=-fPIC
    DSO_LDOPTS='-shared -Wl,-soname -Wl,$(notdir $@)'
    MDCPUCFG_H=_freebsd.cfg
    PR_MD_CSRCS=freebsd.c
    ;;

*-hpux*)
    AC_DEFINE(XP_UNIX)
    AC_DEFINE(HPUX)
    AC_DEFINE(_HPUX_SOURCE)
    # OSF1 and HPUX report the POLLHUP event for a socket when the
    # shutdown(SHUT_WR) operation is called for the remote end, even though
    # the socket is still writeable. Use select(), instead of poll(), to
    # workaround this problem.
    AC_DEFINE(_PR_POLL_WITH_SELECT)
    AC_DEFINE(_USE_BIG_FDS)
    DSO_LDOPTS='-b +h $(notdir $@)'
    PR_MD_CSRCS=hpux.c
    if test "$OS_TEST" = "ia64"; then
        DLL_SUFFIX=so
        DSO_LDOPTS="$DSO_LDOPTS +b '\$\$ORIGIN'"
        CPU_ARCH_TAG=_$OS_TEST 
        if test -z "$USE_64"; then
            COMPILER_TAG=_32
        fi
        PR_MD_ASFILES=os_HPUX_ia64.s
    else
        AC_DEFINE(hppa)
        DLL_SUFFIX=sl
        PR_MD_ASFILES=os_HPUX.s
    fi
    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"
        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)' >/dev/null; then
        AC_DEFINE(HAVE_POINTER_LOCALTIME_R)
    fi

    # HP-UX 11i v2 (B.11.23) or higher
    changequote(<<,>>)
    case "$OS_RELEASE" in
    [C-Z]*|B.[2-9]*|B.1[2-9]*|B.11.[3-9]*|B.11.2[3-9]*)
        USE_IPV6=1
        ;;
    esac
    changequote([,])

    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 echo "$OS_RELEASE" | grep ^B.11 >/dev/null; 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
                if test "$OS_TEST" = "ia64"; then
                    CFLAGS="$CFLAGS +DD32"
                    CXXFLAGS="$CXXFLAGS +DD32"
                else
                    CFLAGS="$CFLAGS +DAportable +DS2.0"
                    CXXFLAGS="$CXXFLAGS +DAportable +DS2.0"
                fi
            else
                if test "$OS_TEST" = "ia64"; then
                    CFLAGS="$CFLAGS +DD64"
                    CXXFLAGS="$CXXFLAGS +DD64"
                else
                    CFLAGS="$CFLAGS +DA2.0W +DS2.0"
                    CXXFLAGS="$CXXFLAGS +DA2.0W +DS2.0"
                fi
            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
        COMPILER_TAG=_n32
        IMPL_STRATEGY=_PTH
        ;;
    irix5*)
        AC_DEFINE(IRIX5)
        USE_NSPR_THREADS=1
        ;;
    *)
        USE_PTHREADS=1
        USE_N32=1
        ;;
    esac
    if test "$GNU_CC"; then
        dnl
        dnl If we are using gcc with native binutils, we need to
        dnl suppress the
        dnl #lineno "filename" num num
        dnl lines, which confuse IRIX native as.  Add -Wp,-P to the
        dnl gcc command line, which passes -P to the preprocessor.
        dnl
	    AS='$(CC) -Wp,-P -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_NSPR_THREADS"; then
        USE_PTHREADS=1
        IMPL_STRATEGY=_PTH
    fi
    AC_DEFINE(XP_UNIX)
    AC_DEFINE(_GNU_SOURCE)
    AC_DEFINE(HAVE_FCNTL_FILE_LOCKING)
    AC_DEFINE(LINUX)
    CFLAGS="$CFLAGS -Wall"
    CXXFLAGS="$CXXFLAGS -Wall"
    MDCPUCFG_H=_linux.cfg
    PR_MD_CSRCS=linux.c
    MKSHLIB='$(CC) $(DSO_LDOPTS) -o $@'
    DSO_CFLAGS=-fPIC
    DSO_LDOPTS='-shared -Wl,-soname -Wl,$(notdir $@)'
    _OPTIMIZE_FLAGS=-O2
    _DEBUG_FLAGS="-g -fno-inline"  # most people on linux use gcc/gdb, and that
                                   # combo is not yet good at debugging inlined
                                   # functions (even when using DWARF2 as the
                                   # debugging format)
    COMPILER_TAG=_glibc
    if echo "$OS_TEST" | grep -c 86 >/dev/null; then
        CPU_ARCH=x86
    else
        CPU_ARCH=$OS_TEST
    fi
    CPU_ARCH_TAG=_${CPU_ARCH}
    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
        ;;
    x86_64)
        if test -n "$USE_64"; then
            PR_MD_ASFILES=os_Linux_x86_64.s
        else
            AC_DEFINE(i386)
            PR_MD_ASFILES=os_Linux_x86.s
            CC="$CC -m32"
            CXX="$CXX -m32"
        fi
        ;;
    powerpc64)
        if test -n "$USE_64"; then
            CC="$CC -m64"
            CXX="$CXX -m64"
        fi
        ;;
    m68k)
        CFLAGS="$CFLAGS -m68020-60"
        CXXFLAGS="$CXXFLAGS -m68020-60"
        ;;
    esac    
    ;;

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

    if test -n "$GNU_CC"; then
        CC="$CC -mno-cygwin"
        CXX="$CXX -mno-cygwin"
        DLL_SUFFIX=dll
        MKSHLIB='$(CC) -shared -Wl,--export-all-symbols -Wl,--out-implib -Wl,$(IMPORT_LIBRARY) $(DLLBASE) -o $(subst $(OBJDIR)/,,$(SHARED_LIBRARY))'
        RC=$WINDRES
        # Use temp file for windres (bug 213281)
        RCFLAGS='-O coff --use-temp-file'
    else
        CC=cl
        CXX=cl
        LD=link
        AR='lib -NOLOGO -OUT:"$@"'
        AR_FLAGS=
        RANLIB='echo not_ranlib'
        STRIP='echo not_strip'
        RC=rc.exe
        GARBAGE='$(OBJDIR)/vc20.pdb $(OBJDIR)/vc40.pdb'
        OBJ_SUFFIX=obj
        LIB_SUFFIX=lib
        DLL_SUFFIX=dll

        # Determine compiler version
        CC_VERSION=`"${CC}" -v 2>&1 | grep Version | sed -e 's|.* Version ||' -e 's| .*||'`
        _CC_MAJOR_VERSION=`echo $CC_VERSION | awk -F\. '{ print $1 }'`
        _CC_MINOR_VERSION=`echo $CC_VERSION | awk -F\. '{ print $2 }'`
        MSC_VER=${_CC_MAJOR_VERSION}${_CC_MINOR_VERSION}
        
        CFLAGS="$CFLAGS -W3 -nologo -GF -Gy"
        DLLFLAGS='-OUT:"$@"'
        _DEBUG_FLAGS=-Z7
        _OPTIMIZE_FLAGS=-O2
        if test -z "$MOZ_OPTIMIZE"; then
            CFLAGS="$CFLAGS -Od"
        fi

        if test -n "$USE_DEBUG_RTL"; then
            CFLAGS="$CFLAGS -MDd"
        else
            CFLAGS="$CFLAGS -MD"
        fi

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

        if test -n "$MOZ_OPTIMIZE"; then
            if test -n "$MOZ_PROFILE"; then
                _OPTIMIZE_FLAGS="$_OPTIMIZE_FLAGS -Z7"
            fi
            if test -n "$MOZ_DEBUG_SYMBOLS"; then
                _OPTIMIZE_FLAGS="$_OPTIMIZE_FLAGS -Zi"
            fi
            if test -n "$MOZ_PROFILE" -o -n "$MOZ_DEBUG_SYMBOLS"; then
                DLLFLAGS="$DLLFLAGS -DEBUG -OPT:REF"
                LDFLAGS="$LDFLAGS -DEBUG -OPT:REF"
            fi
        fi

        if test -n "$MOZ_DEBUG"; then
            DLLFLAGS="$DLLFLAGS -DEBUG"
            LDFLAGS="$LDFLAGS -DEBUG"
        fi

        OS_DLLFLAGS="-nologo -DLL -SUBSYSTEM:WINDOWS"
        if test "$MSC_VER" -le "1200" -a -z "$MOZ_DEBUG_SYMBOLS"; then
            OS_DLLFLAGS="$OS_DLLFLAGS -PDB:NONE"
        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)
        # undefine WINNT as some versions of mingw gcc define it by default
        DEFINES="$DEFINES -UWINNT"
        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
    fi

    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"
        CXXFLAGS="$CXXFLAGS -fPIC -Wall"
        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)
    USE_NSPR_THREADS=1
    MDCPUCFG_H=_netbsd.cfg
    PR_MD_CSRCS=netbsd.c

    DSO_CFLAGS='-fPIC -DPIC'
    CFLAGS="$CFLAGS -ansi -Wall"
    CXXFLAGS="$CXXFLAGS -ansi -Wall"
    MKSHLIB='$(CC) -o $@ $(DSO_LDOPTS)'

    if test -z "$OBJECT_FMT"; then
        if echo __ELF__ | ${CC-cc} -E - | grep -q __ELF__ 2>/dev/null; then
            OBJECT_FMT=a.out
            DLL_SUFFIX=so.1.0
            DSO_LDOPTS='-shared'
        else
            OBJECT_FMT=ELF
            DLL_SUFFIX=so
            DSO_LDOPTS='-shared -Wl,-soname,$(notdir $@)'
        fi
    fi

    if test "$LIBRUNPATH"; then
        DSO_LDOPTS="$DSO_LDOPTS -Wl,-R$LIBRUNPATH"
    fi
    ;;

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 -traditional-cpp -posix"
    CXXFLAGS="$CXXFLAGS -Wall -fno-common -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='$(CC) $(DSO_LDOPTS) -Wl,-soname -Wl,$(notdir $@) -o $@'
    DSO_CFLAGS=-fPIC
    DSO_LDOPTS=-shared
    OS_LIBS="$OS_LIBS -lsocket"
    _OPTIMIZE_FLAGS="-O1"
    _DEBUG_FLAGS="-gstabs"
	;;

*-openbsd*)
    AC_DEFINE(XP_UNIX)
    AC_DEFINE(OPENBSD)
    AC_DEFINE(HAVE_BSD_FLOCK)
    AC_DEFINE(HAVE_SOCKLEN_T)
    CFLAGS="$CFLAGS -ansi -Wall"
    CXXFLAGS="$CXXFLAGS -ansi -Wall"
    DLL_SUFFIX=so.1.0
    DSO_CFLAGS=-fPIC
    MDCPUCFG_H=_openbsd.cfg
    PR_MD_CSRCS=openbsd.c
    if test -z "$USE_NSPR_THREADS"; then
        USE_PTHREADS=1
    fi
    DSO_LDOPTS='-shared -fPIC'
    MKSHLIB='$(CC) $(DSO_LDOPTS) -o $@'
    ;;

*-openvms*)
    AC_DEFINE(XP_UNIX)
    AC_DEFINE(VMS)
    AC_DEFINE(PR_GETIPNODE_NOT_THREADSAFE)
    RESOLVE_LINK_SYMBOLS=1
    AR_FLAGS='c $@'
    MDCPUCFG_H=_openvms.cfg
    PR_MD_CSRCS=openvms.c
    DSO_LDOPTS='-shared -auto_symvec $(LDFLAGS)'
    if test -n "$MOZ_DEBUG"; then
      DSO_LDOPTS="$DSO_LDOPTS $_DEBUG_FLAGS"
    else
      DSO_LDOPTS="$DSO_LDOPTS $_OPTIMIZE_FLAGS"
    fi
    ;;

*-osf*)
    SHELL_OVERRIDE="SHELL		= /usr/bin/ksh"
    AC_DEFINE(XP_UNIX)
    AC_DEFINE(OSF1)
    AC_DEFINE(_REENTRANT)
    # OSF1 and HPUX report the POLLHUP event for a socket when the
    # shutdown(SHUT_WR) operation is called for the remote end, even though
    # the socket is still writeable. Use select(), instead of poll(), to
    # workaround this problem.
    AC_DEFINE(_PR_POLL_WITH_SELECT)

    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"
        AC_CHECK_HEADER(machine/builtins.h, AC_DEFINE(OSF1_HAVE_MACHINE_BUILTINS_H))
    else
        CFLAGS="$CFLAGS -mieee"
        CXXFLAGS="$CXXFLAGS -mieee"
    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
    ;;

*-riscos*)
    AC_DEFINE(XP_UNIX)
    AC_DEFINE(RISCOS)
    AC_DEFINE(_PR_NEED_H_ERRNO)
    USE_PTHREADS=1
    MDCPUCFG_H=_riscos.cfg
    PR_MD_CSRCS=riscos.c
    DLL_SUFFIX=a
    LD="/home/riscos/env/ro-ar cr"
    ;;

*-*-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
        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)
    MDCPUCFG_H=_solaris.cfg
    PR_MD_CSRCS=solaris.c
    LD=/usr/ccs/bin/ld
    MKSHLIB='$(CC) $(DSO_LDOPTS) -o $@'
    RESOLVE_LINK_SYMBOLS=1
    if test -n "$GNU_CC"; then
        DSO_CFLAGS=-fPIC
        if `$CC -print-prog-name=ld` -v 2>&1 | grep -c GNU >/dev/null; then
            GCC_USE_GNU_LD=1
        fi
        DSO_LDOPTS='-shared -Wl,-h,$(notdir $@),-z,combreloc,-z,defs' 
    else
        DSO_CFLAGS=-KPIC
        DSO_LDOPTS='-G -h $(notdir $@) -z combreloc -z defs'
    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
        GCC_AS=`$CC -print-prog-name=as`
        if test "`echo | $GCC_AS -v 2>&1 | grep -c GNU`" != "0"; then
            GNU_AS=1
        fi
    else
        CFLAGS="$CFLAGS -xstrconst"
        CXXFLAGS="$CXXFLAGS -Qoption cg -xstrconst -features=tmplife"
        if test -z "$MOZ_OPTIMIZE"; then
            CFLAGS="$CFLAGS -xs"
            CXXFLAGS="$CXXFLAGS -xs"
        fi
        _OPTIMIZE_FLAGS=-xO4
    fi
    if test -z "$GNU_AS"; then
        ASFLAGS="$ASFLAGS -Wa,-P"
    fi
    if test -n "$USE_64"; then
        if test -n "$GNU_CC"; then
            CC="$CC -m64"
            CXX="$CXX -m64"
        else
            if test "$OS_TEST" = "i86pc"; then
                CC="$CC -xarch=amd64"
                CXX="$CXX -xarch=amd64"
            else
                CC="$CC -xarch=v9"
                CXX="$CXX -xarch=v9"
            fi
        fi
    fi
    if test "$OS_TEST" = "i86pc"; then
        if test -z "$USE_64"; then
            AC_DEFINE(i386)
        fi
        CPU_ARCH_TAG=_$OS_TEST
        # 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
    case "${target_os}" in
    solaris2.3*)
        ;;
    solaris2.4*)
        ;;
    solaris2.5*)
        ;;
    solaris2.6*)
        ;;
    solaris2.7*)
        ;;
    *)
        # Solaris 8 or higher has IPv6.
        AC_DEFINE(_PR_INET6)
        ;;
    esac
    if test "$OS_TEST" = "sun4u"; then
        # 64-bit Solaris requires SPARC V9 architecture, so the following
        # is not needed.
        if test -z "$USE_64"; then
            ULTRASPARC_LIBRARY=nspr_flt
        fi
    fi
    # Purify requires that binaries linked against nspr also
    # be linked against -lrt (or -lposix4) so add it to OS_LIBS
    _rev=`uname -r`
    _librt=`echo $_rev 5.6 | awk '{ if ($1 > $2) print "-lrt"; else print "-lposix4" }'`
    OS_LIBS="$OS_LIBS $_librt"
    ;;

*-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(XP_PC)
    AC_DEFINE(BSD_SELECT)
    AC_DEFINE(TCPV40HDRS)
    LIB_SUFFIX=lib
    DLL_SUFFIX=dll
    RC=rc.exe
    PR_MD_ARCH_DIR=os2
    PROG_SUFFIX=.exe
    NSINSTALL=nsinstall
    MDCPUCFG_H=_os2.cfg
    RESOLVE_LINK_SYMBOLS=1

    # EMX/GCC build
    if test -n "$GNU_CC"; then
        AC_DEFINE(XP_OS2_EMX)
        AC_DEFINE(OS2)
        AR=emxomfar
        AR_FLAGS='r $@'
        CFLAGS="$CFLAGS -Wall -Zomf"
        CXXFLAGS="$CFLAGS -Wall -Zomf"
        MKSHLIB='$(CC) $(DSO_LDOPTS) -o $@'
        DSO_CFLAGS=
        DSO_LDOPTS='-Zomf -Zdll -Zmap'
        LDFLAGS='-Zmap'
        _OPTIMIZE_FLAGS="-O2 -s"
        _DEBUG_FLAGS="-g -fno-inline"
        if test -n "$MOZ_OPTIMIZE"; then
          DSO_LDOPTS="$DSO_LDOPTS -Zlinker /EXEPACK:2 -Zlinker /PACKCODE -Zlinker /PACKDATA"
        fi
        OS_LIBS="-lsocket"
        IMPLIB='emximp -o'
        FILTER='emxexp -o'

        # GCC for OS/2 currently predefines these, but we don't want them
        DEFINES="$DEFINES -Uunix -U__unix -U__unix__"

    # Visual Age C++ build
    elif test "$VACPP" = "yes"; then
        AC_DEFINE(XP_OS2_VACPP)
        AC_DEFINE(OS2,4)
        AC_DEFINE(_X86_)
        OBJ_SUFFIX=obj
        AS=alp
        ASFLAGS='-Mb'
        ASM_SUFFIX=asm
        AR=-ilib
        AR_FLAGS='/NOL /NOI /O:$(subst /,\\,$@)'
        CFLAGS='/Q /qlibansi /Gd+ /Gm+ /Su4 /Mp /Tl9'
        HOST_CFLAGS="$CFLAGS"
        OS_CFLAGS='/Q /qlibansi /Gd+ /Gm+ /Su4 /Mp /Tl9'
        OS_EXE_CFLAGS='/Q /qlibansi /Gd+ /Gm+ /Su4 /Mp /Tl9'
        CXXFLAGS='/Q /qlibansi /Gd+ /Gm+ /Su4 /Mp /Tl9'
        OS_LIBS='so32dll.lib tcp32dll.lib'
        LD='-ilink'
        MKSHLIB='$(LD) $(DSO_LDOPTS)'
        IMPLIB='implib -nologo -noignorecase'
        FILTER='cppfilt -q -B -P'
        _OPTIMIZE_FLAGS='/O+ /Gl+ /qtune=pentium /qarch=pentium'
        _DEBUG_FLAGS='/Ti+ '
        LDFLAGS='/NOL /M /L'
        DLLFLAGS='/O:$@ /DLL /INC:_dllentry /MAP:$(@:.dll=.map) /L /NOL'
        EXEFLAGS='/OUT:$@ /PMTYPE:VIO /MAP:$(@:.exe=.map) /L /NOL'
        if test -n "$MOZ_DEBUG"; then
          LDFLAGS="$LDFLAGS /DE"
          DLLFLAGS="$DLLFLAGS /DE"
          EXEFLAGS="$EXEFLAGS /DE"
        fi
        if test -n "$MOZ_OPTIMIZE"; then
          LDFLAGS="$LDFLAGS /OPTFUNC /EXEPACK:2 /PACKCODE /PACKDATA"
          DLLFLAGS="$DLLFLAGS /OPTFUNC /EXEPACK:2 /PACKCODE /PACKDATA"
          EXEFLAGS="$EXEFLAGS /OPTFUNC /EXEPACK:2 /PACKCODE /PACKDATA"
        fi
        LIBNSPR='$(dist_libdir)/nspr$(MOD_MAJOR_VERSION).$(LIB_SUFFIX)'
        LIBPLC='$(dist_libdir)/plc$(MOD_MAJOR_VERSION).$(LIB_SUFFIX)'
    fi
    ;;

*)
    AC_DEFINE(XP_UNIX)
    ;;
   
esac

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)


dnl We don't want anything to link with libdl even if it's present on OS X, 
dnl since it's not used and not part of the default installation.

case $target in
*-darwin*)
    ;;
*)
    AC_CHECK_LIB(dl, dlopen,
        AC_CHECK_HEADER(dlfcn.h,
            OS_LIBS="-ldl $OS_LIBS"))
    ;;
esac


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 =
dnl = --enable-strip
dnl = 
dnl = Enable stripping of libs and executables
dnl = 
dnl ========================================================
AC_ARG_ENABLE(strip,
    [  --enable-strip          Enable stripping of shared libs and programs],
    [ if test "$enableval" = "yes"; then
	    ENABLE_STRIP=1
      fi ])

dnl Check for hpux options
case "${target_os}" in
hpux*)
if test -z "$GNU_CC"; then

    AC_CACHE_CHECK(for +Olit support,
        ac_cv_hpux_usable_olit_option,
        dnl since aCC doesn't throw an error on invalid options,
        dnl we have to test this the hard way
        [ac_cv_hpux_usable_olit_option=no
        rm -f conftest*
        echo 'int main() { return 0; }' | cat > conftest.c
        ${CC-cc} ${CFLAGS} +Olit=all -o conftest conftest.c > conftest.out 2>&1
        if test $? -eq 0; then
            if test -z "`egrep -i '(unrecognize|unknown)' conftest.out`"; then
                ac_cv_hpux_usable_olit_option=yes
            fi
        fi
        rm -f conftest*
        ])

    if test "$ac_cv_hpux_usable_olit_option" = "yes"; then
        CFLAGS="$CFLAGS +Olit=all"
        CXXFLAGS="$CXXFLAGS +Olit=all"
    else
        CFLAGS="$CFLAGS +ESlit"
        CXXFLAGS="$CXXFLAGS +ESlit"
    fi
fi
;;
esac

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) { return v; } 
    int main() { 
        pthread_t t;
        if (!pthread_create(&t, 0, &foo, 0)) {
            pthread_join(t, 0);
        }
        return 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
])

case "$target_os" in
darwin*)
    _HAVE_PTHREADS=1
    ;;
*)
    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
                )
            )
        )
    )
    ;;
esac

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 "$USE_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
      else
	    USE_IPV6=
      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
		case "$target_os" in
	    freebsd*)
# Freebsd doesn't use -pthread for compiles, it uses them for linking
            ;;
	    *)
            CFLAGS="$CFLAGS -pthread"
            CXXFLAGS="$CXXFLAGS -pthread"
            ;;
        esac
	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*)
        if test "$ac_cv_have_dash_pthreads" = "yes"; then
            _PTHREAD_LDFLAGS=
        fi
	    ;;
    *-freebsd*)
	    AC_DEFINE(_REENTRANT)
	    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="-pthread"
	    else
	        _PTHREAD_LDFLAGS="-lc_r"
	    fi
	    ;;
    *-netbsd*)
	    if test "$ac_cv_have_dash_pthread" = "yes"; then
	        _PTHREAD_LDFLAGS="-pthread"
	    fi
	    ;;
    *-bsdi*)
	    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
	    ;;
    *-openbsd*)
        if test "$ac_cv_have_dash_pthread" = "yes"; then
            _PTHREAD_LDFLAGS=-pthread
        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(_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
        ;;
    *)
        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(_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*|*-msvc*|*-mks*)
    dnl win32 does not use pthreads
    USE_PTHREADS=
    _PTHREAD_LDFLAGS=
    USE_USER_PTHREADS=
    ;;
*-netbsd*|*-openbsd*)
    if test -n "$USE_NSPR_THREADS"; then
        AC_DEFINE(_PR_LOCAL_THREADS_ONLY)
    fi
    ;;
*-osf*)
    if test -n "$USE_NSPR_THREADS"; then
        AC_DEFINE(_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
            :
        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_NSPR_THREADS"; then
            AC_DEFINE(_PR_LOCAL_THREADS_ONLY)
        fi
    fi
    if test -z "$USE_NSPR_THREADS"; then
        AC_DEFINE(_REENTRANT)
        AC_DEFINE(HAVE_POINTER_LOCALTIME_R)
        if test "$OS_TEST" = "i86pc"; then
            if test -n "$USE_64"; then
               PR_MD_ASFILES=os_SunOS_x86_64.s
            else
               PR_MD_ASFILES=os_SunOS_x86.s
            fi
        else
            if test -n "$USE_64"; then
                PR_MD_ASFILES=os_SunOS_sparcv9.s
            fi
            if test -n "$USE_NATIVE_THREADS"; then
                PR_MD_ASFILES="$PR_MD_ASFILES os_SunOS.s"
            fi
        fi
    fi
    ;;
*-nto*)
    if test -n "$USE_PTHREADS"; then
        AC_DEFINE(_PR_HAVE_GETHOST_R)
        AC_DEFINE(_PR_HAVE_GETHOST_R_POINTER)
    fi
    ;;
esac

OS_LIBS="$_PTHREAD_LDFLAGS $OS_LIBS"

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

if test -n "$_SAVE_DEBUG_FLAGS"; then
    _DEBUG_FLAGS="$_SAVE_DEBUG_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

if test -n "$MOZ_OPTIMIZE"; then
    OBJDIR_TAG=_OPT
else
    OBJDIR_TAG=_DBG
fi

if test -n "$USE_64"; then
    COMPILER_TAG=_64
fi

RELEASE_OBJDIR_NAME="${OS_CONFIG}${CPU_ARCH_TAG}${COMPILER_TAG}${IMPL_STRATEGY}${OBJDIR_TAG}.${OBJDIR_SUFFIX}"

dnl ========================================================
dnl Use cygwin wrapper for win32 builds, except MSYS/MinGW
dnl ========================================================
case "$target_os" in
cygwin*|msvc*|mks*)
    CC="\$(CYGWIN_WRAPPER) $CC"
    CXX="\$(CYGWIN_WRAPPER) $CXX"
    RC="\$(CYGWIN_WRAPPER) $RC"
    ;;
esac

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(HOST_LDFLAGS)
AC_SUBST(GNU_CC)
AC_SUBST(GCC_USE_GNU_LD)
AC_SUBST(MSC_VER)
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(ENABLE_STRIP)

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_PATCH_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(ASM_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(MACOSX_DEPLOYMENT_TARGET)

AC_SUBST(DEFINES)
AC_SUBST(DEFS)
AC_SUBST(AR)
AC_SUBST(AR_FLAGS)
AC_SUBST(AS)
AC_SUBST(ASFLAGS)
AC_SUBST(LD)
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(OBJDIR)
AC_SUBST(OBJDIR_NAME)
AC_SUBST(RELEASE_OBJDIR_NAME)
AC_SUBST(NSINSTALL)
AC_SUBST(OPTIMIZER)
AC_SUBST(RC)
AC_SUBST(RCFLAGS)
AC_SUBST(DLLFLAGS)
AC_SUBST(EXEFLAGS)
AC_SUBST(OS_DLLFLAGS)
AC_SUBST(CYGWIN_WRAPPER)
AC_SUBST(VISIBILITY_FLAGS)
AC_SUBST(WRAP_SYSTEM_INCLUDES)
AC_SUBST(MACOS_SDK_DIR)
AC_SUBST(NEXT_ROOT)

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 
lib/tests/Makefile
pkg/Makefile
pkg/linux/Makefile
pkg/solaris/Makefile
pkg/solaris/SUNWpr/Makefile
pkg/solaris/SUNWprd/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

echo $MAKEFILES > unallmakefiles

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