OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [binutils-2.20.1/] [config/] [tcl.m4] - Diff between revs 816 and 818

Go to most recent revision | Only display areas with differences | Details | Blame | View Log

Rev 816 Rev 818
#------------------------------------------------------------------------
#------------------------------------------------------------------------
# SC_PATH_TCLCONFIG --
# SC_PATH_TCLCONFIG --
#
#
#       Locate the tclConfig.sh file and perform a sanity check on
#       Locate the tclConfig.sh file and perform a sanity check on
#       the Tcl compile flags
#       the Tcl compile flags
#
#
# Arguments:
# Arguments:
#       none
#       none
#
#
# Results:
# Results:
#
#
#       Adds the following arguments to configure:
#       Adds the following arguments to configure:
#               --with-tcl=...
#               --with-tcl=...
#
#
#       Defines the following vars:
#       Defines the following vars:
#               TCL_BIN_DIR     Full path to the directory containing
#               TCL_BIN_DIR     Full path to the directory containing
#                               the tclConfig.sh file
#                               the tclConfig.sh file
#------------------------------------------------------------------------
#------------------------------------------------------------------------
 
 
AC_DEFUN([SC_PATH_TCLCONFIG], [
AC_DEFUN([SC_PATH_TCLCONFIG], [
    #
    #
    # Ok, lets find the tcl configuration
    # Ok, lets find the tcl configuration
    # First, look for one uninstalled.
    # First, look for one uninstalled.
    # the alternative search directory is invoked by --with-tcl
    # the alternative search directory is invoked by --with-tcl
    #
    #
 
 
    if test x"${no_tcl}" = x ; then
    if test x"${no_tcl}" = x ; then
        # we reset no_tcl in case something fails here
        # we reset no_tcl in case something fails here
        no_tcl=true
        no_tcl=true
        AC_ARG_WITH(tcl, [  --with-tcl              directory containing tcl configuration (tclConfig.sh)], with_tclconfig=${withval})
        AC_ARG_WITH(tcl, [  --with-tcl              directory containing tcl configuration (tclConfig.sh)], with_tclconfig=${withval})
        AC_MSG_CHECKING([for Tcl configuration])
        AC_MSG_CHECKING([for Tcl configuration])
        AC_CACHE_VAL(ac_cv_c_tclconfig,[
        AC_CACHE_VAL(ac_cv_c_tclconfig,[
 
 
            # First check to see if --with-tcl was specified.
            # First check to see if --with-tcl was specified.
            case "${host}" in
            case "${host}" in
                *-*-cygwin*) platDir="win" ;;
                *-*-cygwin*) platDir="win" ;;
                *) platDir="unix" ;;
                *) platDir="unix" ;;
            esac
            esac
            if test x"${with_tclconfig}" != x ; then
            if test x"${with_tclconfig}" != x ; then
                if test -f "${with_tclconfig}/tclConfig.sh" ; then
                if test -f "${with_tclconfig}/tclConfig.sh" ; then
                    ac_cv_c_tclconfig=`(cd ${with_tclconfig}; pwd)`
                    ac_cv_c_tclconfig=`(cd ${with_tclconfig}; pwd)`
                else
                else
                    AC_MSG_ERROR([${with_tclconfig} directory doesn't contain tclConfig.sh])
                    AC_MSG_ERROR([${with_tclconfig} directory doesn't contain tclConfig.sh])
                fi
                fi
            fi
            fi
 
 
            # then check for a private Tcl installation
            # then check for a private Tcl installation
            if test x"${ac_cv_c_tclconfig}" = x ; then
            if test x"${ac_cv_c_tclconfig}" = x ; then
                for i in \
                for i in \
                        ../tcl \
                        ../tcl \
                        `ls -dr ../tcl[[8-9]].[[0-9]].[[0-9]]* 2>/dev/null` \
                        `ls -dr ../tcl[[8-9]].[[0-9]].[[0-9]]* 2>/dev/null` \
                        `ls -dr ../tcl[[8-9]].[[0-9]] 2>/dev/null` \
                        `ls -dr ../tcl[[8-9]].[[0-9]] 2>/dev/null` \
                        `ls -dr ../tcl[[8-9]].[[0-9]]* 2>/dev/null` \
                        `ls -dr ../tcl[[8-9]].[[0-9]]* 2>/dev/null` \
                        ../../tcl \
                        ../../tcl \
                        `ls -dr ../../tcl[[8-9]].[[0-9]].[[0-9]]* 2>/dev/null` \
                        `ls -dr ../../tcl[[8-9]].[[0-9]].[[0-9]]* 2>/dev/null` \
                        `ls -dr ../../tcl[[8-9]].[[0-9]] 2>/dev/null` \
                        `ls -dr ../../tcl[[8-9]].[[0-9]] 2>/dev/null` \
                        `ls -dr ../../tcl[[8-9]].[[0-9]]* 2>/dev/null` \
                        `ls -dr ../../tcl[[8-9]].[[0-9]]* 2>/dev/null` \
                        ../../../tcl \
                        ../../../tcl \
                        `ls -dr ../../../tcl[[8-9]].[[0-9]].[[0-9]]* 2>/dev/null` \
                        `ls -dr ../../../tcl[[8-9]].[[0-9]].[[0-9]]* 2>/dev/null` \
                        `ls -dr ../../../tcl[[8-9]].[[0-9]] 2>/dev/null` \
                        `ls -dr ../../../tcl[[8-9]].[[0-9]] 2>/dev/null` \
                        `ls -dr ../../../tcl[[8-9]].[[0-9]]* 2>/dev/null` ; do
                        `ls -dr ../../../tcl[[8-9]].[[0-9]]* 2>/dev/null` ; do
                    if test -f "$i/$platDir/tclConfig.sh" ; then
                    if test -f "$i/$platDir/tclConfig.sh" ; then
                        ac_cv_c_tclconfig=`(cd $i/$platDir; pwd)`
                        ac_cv_c_tclconfig=`(cd $i/$platDir; pwd)`
                        break
                        break
                    fi
                    fi
                done
                done
            fi
            fi
 
 
            # on Darwin, check in Framework installation locations
            # on Darwin, check in Framework installation locations
            if test "`uname -s`" = "Darwin" -a x"${ac_cv_c_tclconfig}" = x ; then
            if test "`uname -s`" = "Darwin" -a x"${ac_cv_c_tclconfig}" = x ; then
                for i in `ls -d ~/Library/Frameworks 2>/dev/null` \
                for i in `ls -d ~/Library/Frameworks 2>/dev/null` \
                        `ls -d /Library/Frameworks 2>/dev/null` \
                        `ls -d /Library/Frameworks 2>/dev/null` \
                        `ls -d /Network/Library/Frameworks 2>/dev/null` \
                        `ls -d /Network/Library/Frameworks 2>/dev/null` \
                        `ls -d /System/Library/Frameworks 2>/dev/null` \
                        `ls -d /System/Library/Frameworks 2>/dev/null` \
                        ; do
                        ; do
                    if test -f "$i/Tcl.framework/tclConfig.sh" ; then
                    if test -f "$i/Tcl.framework/tclConfig.sh" ; then
                        ac_cv_c_tclconfig=`(cd $i/Tcl.framework; pwd)`
                        ac_cv_c_tclconfig=`(cd $i/Tcl.framework; pwd)`
                        break
                        break
                    fi
                    fi
                done
                done
            fi
            fi
 
 
            # check in a few common install locations
            # check in a few common install locations
            if test x"${ac_cv_c_tclconfig}" = x ; then
            if test x"${ac_cv_c_tclconfig}" = x ; then
                for i in `ls -d ${libdir} 2>/dev/null` \
                for i in `ls -d ${libdir} 2>/dev/null` \
                        `ls -d ${exec_prefix}/lib 2>/dev/null` \
                        `ls -d ${exec_prefix}/lib 2>/dev/null` \
                        `ls -d ${prefix}/lib 2>/dev/null` \
                        `ls -d ${prefix}/lib 2>/dev/null` \
                        `ls -d /usr/local/lib 2>/dev/null` \
                        `ls -d /usr/local/lib 2>/dev/null` \
                        `ls -d /usr/contrib/lib 2>/dev/null` \
                        `ls -d /usr/contrib/lib 2>/dev/null` \
                        `ls -d /usr/lib 2>/dev/null` \
                        `ls -d /usr/lib 2>/dev/null` \
                        ; do
                        ; do
                    if test -f "$i/tclConfig.sh" ; then
                    if test -f "$i/tclConfig.sh" ; then
                        ac_cv_c_tclconfig=`(cd $i; pwd)`
                        ac_cv_c_tclconfig=`(cd $i; pwd)`
                        break
                        break
                    fi
                    fi
                done
                done
            fi
            fi
 
 
            # check in a few other private locations
            # check in a few other private locations
            if test x"${ac_cv_c_tclconfig}" = x ; then
            if test x"${ac_cv_c_tclconfig}" = x ; then
                for i in \
                for i in \
                        ${srcdir}/../tcl \
                        ${srcdir}/../tcl \
                        `ls -dr ${srcdir}/../tcl[[8-9]].[[0-9]].[[0-9]]* 2>/dev/null` \
                        `ls -dr ${srcdir}/../tcl[[8-9]].[[0-9]].[[0-9]]* 2>/dev/null` \
                        `ls -dr ${srcdir}/../tcl[[8-9]].[[0-9]] 2>/dev/null` \
                        `ls -dr ${srcdir}/../tcl[[8-9]].[[0-9]] 2>/dev/null` \
                        `ls -dr ${srcdir}/../tcl[[8-9]].[[0-9]]* 2>/dev/null` ; do
                        `ls -dr ${srcdir}/../tcl[[8-9]].[[0-9]]* 2>/dev/null` ; do
                    if test -f "$i/$platDir/tclConfig.sh" ; then
                    if test -f "$i/$platDir/tclConfig.sh" ; then
                    ac_cv_c_tclconfig=`(cd $i/$platDir; pwd)`
                    ac_cv_c_tclconfig=`(cd $i/$platDir; pwd)`
                    break
                    break
                fi
                fi
                done
                done
            fi
            fi
        ])
        ])
 
 
        if test x"${ac_cv_c_tclconfig}" = x ; then
        if test x"${ac_cv_c_tclconfig}" = x ; then
            TCL_BIN_DIR="# no Tcl configs found"
            TCL_BIN_DIR="# no Tcl configs found"
            AC_MSG_WARN([Can't find Tcl configuration definitions])
            AC_MSG_WARN([Can't find Tcl configuration definitions])
        else
        else
            no_tcl=
            no_tcl=
            TCL_BIN_DIR=${ac_cv_c_tclconfig}
            TCL_BIN_DIR=${ac_cv_c_tclconfig}
            AC_MSG_RESULT([found ${TCL_BIN_DIR}/tclConfig.sh])
            AC_MSG_RESULT([found ${TCL_BIN_DIR}/tclConfig.sh])
        fi
        fi
    fi
    fi
])
])
 
 
#------------------------------------------------------------------------
#------------------------------------------------------------------------
# SC_PATH_TKCONFIG --
# SC_PATH_TKCONFIG --
#
#
#       Locate the tkConfig.sh file
#       Locate the tkConfig.sh file
#
#
# Arguments:
# Arguments:
#       none
#       none
#
#
# Results:
# Results:
#
#
#       Adds the following arguments to configure:
#       Adds the following arguments to configure:
#               --with-tk=...
#               --with-tk=...
#
#
#       Defines the following vars:
#       Defines the following vars:
#               TK_BIN_DIR      Full path to the directory containing
#               TK_BIN_DIR      Full path to the directory containing
#                               the tkConfig.sh file
#                               the tkConfig.sh file
#------------------------------------------------------------------------
#------------------------------------------------------------------------
 
 
AC_DEFUN([SC_PATH_TKCONFIG], [
AC_DEFUN([SC_PATH_TKCONFIG], [
    #
    #
    # Ok, lets find the tk configuration
    # Ok, lets find the tk configuration
    # First, look for one uninstalled.
    # First, look for one uninstalled.
    # the alternative search directory is invoked by --with-tk
    # the alternative search directory is invoked by --with-tk
    #
    #
 
 
    if test x"${no_tk}" = x ; then
    if test x"${no_tk}" = x ; then
        # we reset no_tk in case something fails here
        # we reset no_tk in case something fails here
        no_tk=true
        no_tk=true
        AC_ARG_WITH(tk, [  --with-tk               directory containing tk configuration (tkConfig.sh)], with_tkconfig=${withval})
        AC_ARG_WITH(tk, [  --with-tk               directory containing tk configuration (tkConfig.sh)], with_tkconfig=${withval})
        AC_MSG_CHECKING([for Tk configuration])
        AC_MSG_CHECKING([for Tk configuration])
        AC_CACHE_VAL(ac_cv_c_tkconfig,[
        AC_CACHE_VAL(ac_cv_c_tkconfig,[
 
 
            # First check to see if --with-tkconfig was specified.
            # First check to see if --with-tkconfig was specified.
            if test x"${with_tkconfig}" != x ; then
            if test x"${with_tkconfig}" != x ; then
                if test -f "${with_tkconfig}/tkConfig.sh" ; then
                if test -f "${with_tkconfig}/tkConfig.sh" ; then
                    ac_cv_c_tkconfig=`(cd ${with_tkconfig}; pwd)`
                    ac_cv_c_tkconfig=`(cd ${with_tkconfig}; pwd)`
                else
                else
                    AC_MSG_ERROR([${with_tkconfig} directory doesn't contain tkConfig.sh])
                    AC_MSG_ERROR([${with_tkconfig} directory doesn't contain tkConfig.sh])
                fi
                fi
            fi
            fi
 
 
            # then check for a private Tk library
            # then check for a private Tk library
            case "${host}" in
            case "${host}" in
                *-*-cygwin*) platDir="win" ;;
                *-*-cygwin*) platDir="win" ;;
                *) platDir="unix" ;;
                *) platDir="unix" ;;
            esac
            esac
            if test x"${ac_cv_c_tkconfig}" = x ; then
            if test x"${ac_cv_c_tkconfig}" = x ; then
                for i in \
                for i in \
                        ../tk \
                        ../tk \
                        `ls -dr ../tk[[8-9]].[[0-9]].[[0-9]]* 2>/dev/null` \
                        `ls -dr ../tk[[8-9]].[[0-9]].[[0-9]]* 2>/dev/null` \
                        `ls -dr ../tk[[8-9]].[[0-9]] 2>/dev/null` \
                        `ls -dr ../tk[[8-9]].[[0-9]] 2>/dev/null` \
                        `ls -dr ../tk[[8-9]].[[0-9]]* 2>/dev/null` \
                        `ls -dr ../tk[[8-9]].[[0-9]]* 2>/dev/null` \
                        ../../tk \
                        ../../tk \
                        `ls -dr ../../tk[[8-9]].[[0-9]].[[0-9]]* 2>/dev/null` \
                        `ls -dr ../../tk[[8-9]].[[0-9]].[[0-9]]* 2>/dev/null` \
                        `ls -dr ../../tk[[8-9]].[[0-9]] 2>/dev/null` \
                        `ls -dr ../../tk[[8-9]].[[0-9]] 2>/dev/null` \
                        `ls -dr ../../tk[[8-9]].[[0-9]]* 2>/dev/null` \
                        `ls -dr ../../tk[[8-9]].[[0-9]]* 2>/dev/null` \
                        ../../../tk \
                        ../../../tk \
                        `ls -dr ../../../tk[[8-9]].[[0-9]].[[0-9]]* 2>/dev/null` \
                        `ls -dr ../../../tk[[8-9]].[[0-9]].[[0-9]]* 2>/dev/null` \
                        `ls -dr ../../../tk[[8-9]].[[0-9]] 2>/dev/null` \
                        `ls -dr ../../../tk[[8-9]].[[0-9]] 2>/dev/null` \
                        `ls -dr ../../../tk[[8-9]].[[0-9]]* 2>/dev/null` ; do
                        `ls -dr ../../../tk[[8-9]].[[0-9]]* 2>/dev/null` ; do
                    if test -f "$i/$platDir/tkConfig.sh" ; then
                    if test -f "$i/$platDir/tkConfig.sh" ; then
                        ac_cv_c_tkconfig=`(cd $i/$platDir; pwd)`
                        ac_cv_c_tkconfig=`(cd $i/$platDir; pwd)`
                        break
                        break
                    fi
                    fi
                done
                done
            fi
            fi
 
 
            # on Darwin, check in Framework installation locations
            # on Darwin, check in Framework installation locations
            if test "`uname -s`" = "Darwin" -a x"${ac_cv_c_tkconfig}" = x ; then
            if test "`uname -s`" = "Darwin" -a x"${ac_cv_c_tkconfig}" = x ; then
                for i in `ls -d ~/Library/Frameworks 2>/dev/null` \
                for i in `ls -d ~/Library/Frameworks 2>/dev/null` \
                        `ls -d /Library/Frameworks 2>/dev/null` \
                        `ls -d /Library/Frameworks 2>/dev/null` \
                        `ls -d /Network/Library/Frameworks 2>/dev/null` \
                        `ls -d /Network/Library/Frameworks 2>/dev/null` \
                        `ls -d /System/Library/Frameworks 2>/dev/null` \
                        `ls -d /System/Library/Frameworks 2>/dev/null` \
                        ; do
                        ; do
                    if test -f "$i/Tk.framework/tkConfig.sh" ; then
                    if test -f "$i/Tk.framework/tkConfig.sh" ; then
                        ac_cv_c_tkconfig=`(cd $i/Tk.framework; pwd)`
                        ac_cv_c_tkconfig=`(cd $i/Tk.framework; pwd)`
                        break
                        break
                    fi
                    fi
                done
                done
            fi
            fi
 
 
            # check in a few common install locations
            # check in a few common install locations
            if test x"${ac_cv_c_tkconfig}" = x ; then
            if test x"${ac_cv_c_tkconfig}" = x ; then
                for i in `ls -d ${libdir} 2>/dev/null` \
                for i in `ls -d ${libdir} 2>/dev/null` \
                        `ls -d ${exec_prefix}/lib 2>/dev/null` \
                        `ls -d ${exec_prefix}/lib 2>/dev/null` \
                        `ls -d ${prefix}/lib 2>/dev/null` \
                        `ls -d ${prefix}/lib 2>/dev/null` \
                        `ls -d /usr/local/lib 2>/dev/null` \
                        `ls -d /usr/local/lib 2>/dev/null` \
                        `ls -d /usr/contrib/lib 2>/dev/null` \
                        `ls -d /usr/contrib/lib 2>/dev/null` \
                        `ls -d /usr/lib 2>/dev/null` \
                        `ls -d /usr/lib 2>/dev/null` \
                        ; do
                        ; do
                    if test -f "$i/tkConfig.sh" ; then
                    if test -f "$i/tkConfig.sh" ; then
                        ac_cv_c_tkconfig=`(cd $i; pwd)`
                        ac_cv_c_tkconfig=`(cd $i; pwd)`
                        break
                        break
                    fi
                    fi
                done
                done
            fi
            fi
            # check in a few other private locations
            # check in a few other private locations
            if test x"${ac_cv_c_tkconfig}" = x ; then
            if test x"${ac_cv_c_tkconfig}" = x ; then
                for i in \
                for i in \
                        ${srcdir}/../tk \
                        ${srcdir}/../tk \
                        `ls -dr ${srcdir}/../tk[[8-9]].[[0-9]].[[0-9]]* 2>/dev/null` \
                        `ls -dr ${srcdir}/../tk[[8-9]].[[0-9]].[[0-9]]* 2>/dev/null` \
                        `ls -dr ${srcdir}/../tk[[8-9]].[[0-9]] 2>/dev/null` \
                        `ls -dr ${srcdir}/../tk[[8-9]].[[0-9]] 2>/dev/null` \
                        `ls -dr ${srcdir}/../tk[[8-9]].[[0-9]]* 2>/dev/null` ; do
                        `ls -dr ${srcdir}/../tk[[8-9]].[[0-9]]* 2>/dev/null` ; do
                    if test -f "$i/$platDir/tkConfig.sh" ; then
                    if test -f "$i/$platDir/tkConfig.sh" ; then
                        ac_cv_c_tkconfig=`(cd $i/$platDir; pwd)`
                        ac_cv_c_tkconfig=`(cd $i/$platDir; pwd)`
                        break
                        break
                    fi
                    fi
                done
                done
            fi
            fi
        ])
        ])
 
 
        if test x"${ac_cv_c_tkconfig}" = x ; then
        if test x"${ac_cv_c_tkconfig}" = x ; then
            TK_BIN_DIR="# no Tk configs found"
            TK_BIN_DIR="# no Tk configs found"
            AC_MSG_WARN([Can't find Tk configuration definitions])
            AC_MSG_WARN([Can't find Tk configuration definitions])
        else
        else
            no_tk=
            no_tk=
            TK_BIN_DIR=${ac_cv_c_tkconfig}
            TK_BIN_DIR=${ac_cv_c_tkconfig}
            AC_MSG_RESULT([found ${TK_BIN_DIR}/tkConfig.sh])
            AC_MSG_RESULT([found ${TK_BIN_DIR}/tkConfig.sh])
        fi
        fi
    fi
    fi
])
])
 
 
#------------------------------------------------------------------------
#------------------------------------------------------------------------
# SC_LOAD_TCLCONFIG --
# SC_LOAD_TCLCONFIG --
#
#
#       Load the tclConfig.sh file
#       Load the tclConfig.sh file
#
#
# Arguments:
# Arguments:
#
#
#       Requires the following vars to be set:
#       Requires the following vars to be set:
#               TCL_BIN_DIR
#               TCL_BIN_DIR
#
#
# Results:
# Results:
#
#
#       Subst the following vars:
#       Subst the following vars:
#               TCL_BIN_DIR
#               TCL_BIN_DIR
#               TCL_SRC_DIR
#               TCL_SRC_DIR
#               TCL_LIB_FILE
#               TCL_LIB_FILE
#
#
#------------------------------------------------------------------------
#------------------------------------------------------------------------
 
 
AC_DEFUN([SC_LOAD_TCLCONFIG], [
AC_DEFUN([SC_LOAD_TCLCONFIG], [
    AC_MSG_CHECKING([for existence of ${TCL_BIN_DIR}/tclConfig.sh])
    AC_MSG_CHECKING([for existence of ${TCL_BIN_DIR}/tclConfig.sh])
 
 
    if test -f "${TCL_BIN_DIR}/tclConfig.sh" ; then
    if test -f "${TCL_BIN_DIR}/tclConfig.sh" ; then
        AC_MSG_RESULT([loading])
        AC_MSG_RESULT([loading])
        . ${TCL_BIN_DIR}/tclConfig.sh
        . ${TCL_BIN_DIR}/tclConfig.sh
    else
    else
        AC_MSG_RESULT([could not find ${TCL_BIN_DIR}/tclConfig.sh])
        AC_MSG_RESULT([could not find ${TCL_BIN_DIR}/tclConfig.sh])
    fi
    fi
 
 
    # eval is required to do the TCL_DBGX substitution
    # eval is required to do the TCL_DBGX substitution
    eval "TCL_LIB_FILE=\"${TCL_LIB_FILE}\""
    eval "TCL_LIB_FILE=\"${TCL_LIB_FILE}\""
    eval "TCL_STUB_LIB_FILE=\"${TCL_STUB_LIB_FILE}\""
    eval "TCL_STUB_LIB_FILE=\"${TCL_STUB_LIB_FILE}\""
 
 
    # If the TCL_BIN_DIR is the build directory (not the install directory),
    # If the TCL_BIN_DIR is the build directory (not the install directory),
    # then set the common variable name to the value of the build variables.
    # then set the common variable name to the value of the build variables.
    # For example, the variable TCL_LIB_SPEC will be set to the value
    # For example, the variable TCL_LIB_SPEC will be set to the value
    # of TCL_BUILD_LIB_SPEC. An extension should make use of TCL_LIB_SPEC
    # of TCL_BUILD_LIB_SPEC. An extension should make use of TCL_LIB_SPEC
    # instead of TCL_BUILD_LIB_SPEC since it will work with both an
    # instead of TCL_BUILD_LIB_SPEC since it will work with both an
    # installed and uninstalled version of Tcl.
    # installed and uninstalled version of Tcl.
    if test -f "${TCL_BIN_DIR}/Makefile" ; then
    if test -f "${TCL_BIN_DIR}/Makefile" ; then
        TCL_LIB_SPEC=${TCL_BUILD_LIB_SPEC}
        TCL_LIB_SPEC=${TCL_BUILD_LIB_SPEC}
        TCL_STUB_LIB_SPEC=${TCL_BUILD_STUB_LIB_SPEC}
        TCL_STUB_LIB_SPEC=${TCL_BUILD_STUB_LIB_SPEC}
        TCL_STUB_LIB_PATH=${TCL_BUILD_STUB_LIB_PATH}
        TCL_STUB_LIB_PATH=${TCL_BUILD_STUB_LIB_PATH}
    elif test "`uname -s`" = "Darwin"; then
    elif test "`uname -s`" = "Darwin"; then
        # If Tcl was built as a framework, attempt to use the libraries
        # If Tcl was built as a framework, attempt to use the libraries
        # from the framework at the given location so that linking works
        # from the framework at the given location so that linking works
        # against Tcl.framework installed in an arbitary location.
        # against Tcl.framework installed in an arbitary location.
        case ${TCL_DEFS} in
        case ${TCL_DEFS} in
            *TCL_FRAMEWORK*)
            *TCL_FRAMEWORK*)
                if test -f "${TCL_BIN_DIR}/${TCL_LIB_FILE}"; then
                if test -f "${TCL_BIN_DIR}/${TCL_LIB_FILE}"; then
                    for i in "`cd ${TCL_BIN_DIR}; pwd`" \
                    for i in "`cd ${TCL_BIN_DIR}; pwd`" \
                             "`cd ${TCL_BIN_DIR}/../..; pwd`"; do
                             "`cd ${TCL_BIN_DIR}/../..; pwd`"; do
                        if test "`basename "$i"`" = "${TCL_LIB_FILE}.framework"; then
                        if test "`basename "$i"`" = "${TCL_LIB_FILE}.framework"; then
                            TCL_LIB_SPEC="-F`dirname "$i"` -framework ${TCL_LIB_FILE}"
                            TCL_LIB_SPEC="-F`dirname "$i"` -framework ${TCL_LIB_FILE}"
                            break
                            break
                        fi
                        fi
                    done
                    done
                fi
                fi
                if test -f "${TCL_BIN_DIR}/${TCL_STUB_LIB_FILE}"; then
                if test -f "${TCL_BIN_DIR}/${TCL_STUB_LIB_FILE}"; then
                    TCL_STUB_LIB_SPEC="-L${TCL_BIN_DIR} ${TCL_STUB_LIB_FLAG}"
                    TCL_STUB_LIB_SPEC="-L${TCL_BIN_DIR} ${TCL_STUB_LIB_FLAG}"
                    TCL_STUB_LIB_PATH="${TCL_BIN_DIR}/${TCL_STUB_LIB_FILE}"
                    TCL_STUB_LIB_PATH="${TCL_BIN_DIR}/${TCL_STUB_LIB_FILE}"
                fi
                fi
                ;;
                ;;
        esac
        esac
    fi
    fi
 
 
    # eval is required to do the TCL_DBGX substitution
    # eval is required to do the TCL_DBGX substitution
    eval "TCL_LIB_FLAG=\"${TCL_LIB_FLAG}\""
    eval "TCL_LIB_FLAG=\"${TCL_LIB_FLAG}\""
    eval "TCL_LIB_SPEC=\"${TCL_LIB_SPEC}\""
    eval "TCL_LIB_SPEC=\"${TCL_LIB_SPEC}\""
    eval "TCL_STUB_LIB_FLAG=\"${TCL_STUB_LIB_FLAG}\""
    eval "TCL_STUB_LIB_FLAG=\"${TCL_STUB_LIB_FLAG}\""
    eval "TCL_STUB_LIB_SPEC=\"${TCL_STUB_LIB_SPEC}\""
    eval "TCL_STUB_LIB_SPEC=\"${TCL_STUB_LIB_SPEC}\""
 
 
    AC_SUBST(TCL_VERSION)
    AC_SUBST(TCL_VERSION)
    AC_SUBST(TCL_PATCH_LEVEL)
    AC_SUBST(TCL_PATCH_LEVEL)
    AC_SUBST(TCL_BIN_DIR)
    AC_SUBST(TCL_BIN_DIR)
    AC_SUBST(TCL_SRC_DIR)
    AC_SUBST(TCL_SRC_DIR)
 
 
    AC_SUBST(TCL_LIB_FILE)
    AC_SUBST(TCL_LIB_FILE)
    AC_SUBST(TCL_LIB_FLAG)
    AC_SUBST(TCL_LIB_FLAG)
    AC_SUBST(TCL_LIB_SPEC)
    AC_SUBST(TCL_LIB_SPEC)
 
 
    AC_SUBST(TCL_STUB_LIB_FILE)
    AC_SUBST(TCL_STUB_LIB_FILE)
    AC_SUBST(TCL_STUB_LIB_FLAG)
    AC_SUBST(TCL_STUB_LIB_FLAG)
    AC_SUBST(TCL_STUB_LIB_SPEC)
    AC_SUBST(TCL_STUB_LIB_SPEC)
])
])
 
 
#------------------------------------------------------------------------
#------------------------------------------------------------------------
# SC_LOAD_TKCONFIG --
# SC_LOAD_TKCONFIG --
#
#
#       Load the tkConfig.sh file
#       Load the tkConfig.sh file
#
#
# Arguments:
# Arguments:
#
#
#       Requires the following vars to be set:
#       Requires the following vars to be set:
#               TK_BIN_DIR
#               TK_BIN_DIR
#
#
# Results:
# Results:
#
#
#       Sets the following vars that should be in tkConfig.sh:
#       Sets the following vars that should be in tkConfig.sh:
#               TK_BIN_DIR
#               TK_BIN_DIR
#------------------------------------------------------------------------
#------------------------------------------------------------------------
 
 
AC_DEFUN([SC_LOAD_TKCONFIG], [
AC_DEFUN([SC_LOAD_TKCONFIG], [
    AC_MSG_CHECKING([for existence of ${TK_BIN_DIR}/tkConfig.sh])
    AC_MSG_CHECKING([for existence of ${TK_BIN_DIR}/tkConfig.sh])
 
 
    if test -f "${TK_BIN_DIR}/tkConfig.sh" ; then
    if test -f "${TK_BIN_DIR}/tkConfig.sh" ; then
        AC_MSG_RESULT([loading])
        AC_MSG_RESULT([loading])
        . ${TK_BIN_DIR}/tkConfig.sh
        . ${TK_BIN_DIR}/tkConfig.sh
    else
    else
        AC_MSG_RESULT([could not find ${TK_BIN_DIR}/tkConfig.sh])
        AC_MSG_RESULT([could not find ${TK_BIN_DIR}/tkConfig.sh])
    fi
    fi
 
 
    # eval is required to do the TK_DBGX substitution
    # eval is required to do the TK_DBGX substitution
    eval "TK_LIB_FILE=\"${TK_LIB_FILE}\""
    eval "TK_LIB_FILE=\"${TK_LIB_FILE}\""
    eval "TK_STUB_LIB_FILE=\"${TK_STUB_LIB_FILE}\""
    eval "TK_STUB_LIB_FILE=\"${TK_STUB_LIB_FILE}\""
 
 
    # If the TK_BIN_DIR is the build directory (not the install directory),
    # If the TK_BIN_DIR is the build directory (not the install directory),
    # then set the common variable name to the value of the build variables.
    # then set the common variable name to the value of the build variables.
    # For example, the variable TK_LIB_SPEC will be set to the value
    # For example, the variable TK_LIB_SPEC will be set to the value
    # of TK_BUILD_LIB_SPEC. An extension should make use of TK_LIB_SPEC
    # of TK_BUILD_LIB_SPEC. An extension should make use of TK_LIB_SPEC
    # instead of TK_BUILD_LIB_SPEC since it will work with both an
    # instead of TK_BUILD_LIB_SPEC since it will work with both an
    # installed and uninstalled version of Tcl.
    # installed and uninstalled version of Tcl.
    if test -f "${TK_BIN_DIR}/Makefile" ; then
    if test -f "${TK_BIN_DIR}/Makefile" ; then
        TK_LIB_SPEC=${TK_BUILD_LIB_SPEC}
        TK_LIB_SPEC=${TK_BUILD_LIB_SPEC}
        TK_STUB_LIB_SPEC=${TK_BUILD_STUB_LIB_SPEC}
        TK_STUB_LIB_SPEC=${TK_BUILD_STUB_LIB_SPEC}
        TK_STUB_LIB_PATH=${TK_BUILD_STUB_LIB_PATH}
        TK_STUB_LIB_PATH=${TK_BUILD_STUB_LIB_PATH}
    elif test "`uname -s`" = "Darwin"; then
    elif test "`uname -s`" = "Darwin"; then
        # If Tk was built as a framework, attempt to use the libraries
        # If Tk was built as a framework, attempt to use the libraries
        # from the framework at the given location so that linking works
        # from the framework at the given location so that linking works
        # against Tk.framework installed in an arbitary location.
        # against Tk.framework installed in an arbitary location.
        case ${TK_DEFS} in
        case ${TK_DEFS} in
            *TK_FRAMEWORK*)
            *TK_FRAMEWORK*)
                if test -f "${TK_BIN_DIR}/${TK_LIB_FILE}"; then
                if test -f "${TK_BIN_DIR}/${TK_LIB_FILE}"; then
                    for i in "`cd ${TK_BIN_DIR}; pwd`" \
                    for i in "`cd ${TK_BIN_DIR}; pwd`" \
                             "`cd ${TK_BIN_DIR}/../..; pwd`"; do
                             "`cd ${TK_BIN_DIR}/../..; pwd`"; do
                        if test "`basename "$i"`" = "${TK_LIB_FILE}.framework"; then
                        if test "`basename "$i"`" = "${TK_LIB_FILE}.framework"; then
                            TK_LIB_SPEC="-F`dirname "$i"` -framework ${TK_LIB_FILE}"
                            TK_LIB_SPEC="-F`dirname "$i"` -framework ${TK_LIB_FILE}"
                            break
                            break
                        fi
                        fi
                    done
                    done
                fi
                fi
                if test -f "${TK_BIN_DIR}/${TK_STUB_LIB_FILE}"; then
                if test -f "${TK_BIN_DIR}/${TK_STUB_LIB_FILE}"; then
                    TK_STUB_LIB_SPEC="-L${TK_BIN_DIR} ${TK_STUB_LIB_FLAG}"
                    TK_STUB_LIB_SPEC="-L${TK_BIN_DIR} ${TK_STUB_LIB_FLAG}"
                    TK_STUB_LIB_PATH="${TK_BIN_DIR}/${TK_STUB_LIB_FILE}"
                    TK_STUB_LIB_PATH="${TK_BIN_DIR}/${TK_STUB_LIB_FILE}"
                fi
                fi
                ;;
                ;;
        esac
        esac
    fi
    fi
 
 
    # eval is required to do the TK_DBGX substitution
    # eval is required to do the TK_DBGX substitution
    eval "TK_LIB_FLAG=\"${TK_LIB_FLAG}\""
    eval "TK_LIB_FLAG=\"${TK_LIB_FLAG}\""
    eval "TK_LIB_SPEC=\"${TK_LIB_SPEC}\""
    eval "TK_LIB_SPEC=\"${TK_LIB_SPEC}\""
    eval "TK_STUB_LIB_FLAG=\"${TK_STUB_LIB_FLAG}\""
    eval "TK_STUB_LIB_FLAG=\"${TK_STUB_LIB_FLAG}\""
    eval "TK_STUB_LIB_SPEC=\"${TK_STUB_LIB_SPEC}\""
    eval "TK_STUB_LIB_SPEC=\"${TK_STUB_LIB_SPEC}\""
 
 
    AC_SUBST(TK_VERSION)
    AC_SUBST(TK_VERSION)
    AC_SUBST(TK_BIN_DIR)
    AC_SUBST(TK_BIN_DIR)
    AC_SUBST(TK_SRC_DIR)
    AC_SUBST(TK_SRC_DIR)
 
 
    AC_SUBST(TK_LIB_FILE)
    AC_SUBST(TK_LIB_FILE)
    AC_SUBST(TK_LIB_FLAG)
    AC_SUBST(TK_LIB_FLAG)
    AC_SUBST(TK_LIB_SPEC)
    AC_SUBST(TK_LIB_SPEC)
 
 
    AC_SUBST(TK_STUB_LIB_FILE)
    AC_SUBST(TK_STUB_LIB_FILE)
    AC_SUBST(TK_STUB_LIB_FLAG)
    AC_SUBST(TK_STUB_LIB_FLAG)
    AC_SUBST(TK_STUB_LIB_SPEC)
    AC_SUBST(TK_STUB_LIB_SPEC)
])
])
 
 
#------------------------------------------------------------------------
#------------------------------------------------------------------------
# SC_PROG_TCLSH
# SC_PROG_TCLSH
#       Locate a tclsh shell installed on the system path. This macro
#       Locate a tclsh shell installed on the system path. This macro
#       will only find a Tcl shell that already exists on the system.
#       will only find a Tcl shell that already exists on the system.
#       It will not find a Tcl shell in the Tcl build directory or
#       It will not find a Tcl shell in the Tcl build directory or
#       a Tcl shell that has been installed from the Tcl build directory.
#       a Tcl shell that has been installed from the Tcl build directory.
#       If a Tcl shell can't be located on the PATH, then TCLSH_PROG will
#       If a Tcl shell can't be located on the PATH, then TCLSH_PROG will
#       be set to "". Extensions should take care not to create Makefile
#       be set to "". Extensions should take care not to create Makefile
#       rules that are run by default and depend on TCLSH_PROG. An
#       rules that are run by default and depend on TCLSH_PROG. An
#       extension can't assume that an executable Tcl shell exists at
#       extension can't assume that an executable Tcl shell exists at
#       build time.
#       build time.
#
#
# Arguments
# Arguments
#       none
#       none
#
#
# Results
# Results
#       Subst's the following values:
#       Subst's the following values:
#               TCLSH_PROG
#               TCLSH_PROG
#------------------------------------------------------------------------
#------------------------------------------------------------------------
 
 
AC_DEFUN([SC_PROG_TCLSH], [
AC_DEFUN([SC_PROG_TCLSH], [
    AC_MSG_CHECKING([for tclsh])
    AC_MSG_CHECKING([for tclsh])
    AC_CACHE_VAL(ac_cv_path_tclsh, [
    AC_CACHE_VAL(ac_cv_path_tclsh, [
        search_path=`echo ${PATH} | sed -e 's/:/ /g'`
        search_path=`echo ${PATH} | sed -e 's/:/ /g'`
        for dir in $search_path ; do
        for dir in $search_path ; do
            for j in `ls -r $dir/tclsh[[8-9]]* 2> /dev/null` \
            for j in `ls -r $dir/tclsh[[8-9]]* 2> /dev/null` \
                    `ls -r $dir/tclsh* 2> /dev/null` ; do
                    `ls -r $dir/tclsh* 2> /dev/null` ; do
                if test x"$ac_cv_path_tclsh" = x ; then
                if test x"$ac_cv_path_tclsh" = x ; then
                    if test -f "$j" ; then
                    if test -f "$j" ; then
                        ac_cv_path_tclsh=$j
                        ac_cv_path_tclsh=$j
                        break
                        break
                    fi
                    fi
                fi
                fi
            done
            done
        done
        done
    ])
    ])
 
 
    if test -f "$ac_cv_path_tclsh" ; then
    if test -f "$ac_cv_path_tclsh" ; then
        TCLSH_PROG="$ac_cv_path_tclsh"
        TCLSH_PROG="$ac_cv_path_tclsh"
        AC_MSG_RESULT([$TCLSH_PROG])
        AC_MSG_RESULT([$TCLSH_PROG])
    else
    else
        # It is not an error if an installed version of Tcl can't be located.
        # It is not an error if an installed version of Tcl can't be located.
        TCLSH_PROG=""
        TCLSH_PROG=""
        AC_MSG_RESULT([No tclsh found on PATH])
        AC_MSG_RESULT([No tclsh found on PATH])
    fi
    fi
    AC_SUBST(TCLSH_PROG)
    AC_SUBST(TCLSH_PROG)
])
])
 
 
#------------------------------------------------------------------------
#------------------------------------------------------------------------
# SC_BUILD_TCLSH
# SC_BUILD_TCLSH
#       Determine the fully qualified path name of the tclsh executable
#       Determine the fully qualified path name of the tclsh executable
#       in the Tcl build directory. This macro will correctly determine
#       in the Tcl build directory. This macro will correctly determine
#       the name of the tclsh executable even if tclsh has not yet
#       the name of the tclsh executable even if tclsh has not yet
#       been built in the build directory. The build tclsh must be used
#       been built in the build directory. The build tclsh must be used
#       when running tests from an extension build directory. It is not
#       when running tests from an extension build directory. It is not
#       correct to use the TCLSH_PROG in cases like this.
#       correct to use the TCLSH_PROG in cases like this.
#
#
# Arguments
# Arguments
#       none
#       none
#
#
# Results
# Results
#       Subst's the following values:
#       Subst's the following values:
#               BUILD_TCLSH
#               BUILD_TCLSH
#------------------------------------------------------------------------
#------------------------------------------------------------------------
 
 
AC_DEFUN([SC_BUILD_TCLSH], [
AC_DEFUN([SC_BUILD_TCLSH], [
    AC_MSG_CHECKING([for tclsh in Tcl build directory])
    AC_MSG_CHECKING([for tclsh in Tcl build directory])
    BUILD_TCLSH=${TCL_BIN_DIR}/tclsh
    BUILD_TCLSH=${TCL_BIN_DIR}/tclsh
    AC_MSG_RESULT([$BUILD_TCLSH])
    AC_MSG_RESULT([$BUILD_TCLSH])
    AC_SUBST(BUILD_TCLSH)
    AC_SUBST(BUILD_TCLSH)
])
])
 
 
#------------------------------------------------------------------------
#------------------------------------------------------------------------
# SC_ENABLE_SHARED --
# SC_ENABLE_SHARED --
#
#
#       Allows the building of shared libraries
#       Allows the building of shared libraries
#
#
# Arguments:
# Arguments:
#       none
#       none
#
#
# Results:
# Results:
#
#
#       Adds the following arguments to configure:
#       Adds the following arguments to configure:
#               --enable-shared=yes|no
#               --enable-shared=yes|no
#
#
#       Defines the following vars:
#       Defines the following vars:
#               STATIC_BUILD    Used for building import/export libraries
#               STATIC_BUILD    Used for building import/export libraries
#                               on Windows.
#                               on Windows.
#
#
#       Sets the following vars:
#       Sets the following vars:
#               SHARED_BUILD    Value of 1 or 0
#               SHARED_BUILD    Value of 1 or 0
#------------------------------------------------------------------------
#------------------------------------------------------------------------
 
 
AC_DEFUN([SC_ENABLE_SHARED], [
AC_DEFUN([SC_ENABLE_SHARED], [
    AC_MSG_CHECKING([how to build libraries])
    AC_MSG_CHECKING([how to build libraries])
    AC_ARG_ENABLE(shared,
    AC_ARG_ENABLE(shared,
        [  --enable-shared         build and link with shared libraries [--enable-shared]],
        [  --enable-shared         build and link with shared libraries [--enable-shared]],
        [tcl_ok=$enableval], [tcl_ok=yes])
        [tcl_ok=$enableval], [tcl_ok=yes])
 
 
    if test "${enable_shared+set}" = set; then
    if test "${enable_shared+set}" = set; then
        enableval="$enable_shared"
        enableval="$enable_shared"
        tcl_ok=$enableval
        tcl_ok=$enableval
    else
    else
        tcl_ok=yes
        tcl_ok=yes
    fi
    fi
 
 
    if test "$tcl_ok" = "yes" ; then
    if test "$tcl_ok" = "yes" ; then
        AC_MSG_RESULT([shared])
        AC_MSG_RESULT([shared])
        SHARED_BUILD=1
        SHARED_BUILD=1
    else
    else
        AC_MSG_RESULT([static])
        AC_MSG_RESULT([static])
        SHARED_BUILD=0
        SHARED_BUILD=0
        AC_DEFINE(STATIC_BUILD)
        AC_DEFINE(STATIC_BUILD)
    fi
    fi
])
])
 
 
#------------------------------------------------------------------------
#------------------------------------------------------------------------
# SC_ENABLE_FRAMEWORK --
# SC_ENABLE_FRAMEWORK --
#
#
#       Allows the building of shared libraries into frameworks
#       Allows the building of shared libraries into frameworks
#
#
# Arguments:
# Arguments:
#       none
#       none
#
#
# Results:
# Results:
#
#
#       Adds the following arguments to configure:
#       Adds the following arguments to configure:
#               --enable-framework=yes|no
#               --enable-framework=yes|no
#
#
#       Sets the following vars:
#       Sets the following vars:
#               FRAMEWORK_BUILD Value of 1 or 0
#               FRAMEWORK_BUILD Value of 1 or 0
#------------------------------------------------------------------------
#------------------------------------------------------------------------
 
 
AC_DEFUN([SC_ENABLE_FRAMEWORK], [
AC_DEFUN([SC_ENABLE_FRAMEWORK], [
    if test "`uname -s`" = "Darwin" ; then
    if test "`uname -s`" = "Darwin" ; then
        AC_MSG_CHECKING([how to package libraries])
        AC_MSG_CHECKING([how to package libraries])
        AC_ARG_ENABLE(framework,
        AC_ARG_ENABLE(framework,
            [  --enable-framework      package shared libraries in MacOSX frameworks [--disable-framework]],
            [  --enable-framework      package shared libraries in MacOSX frameworks [--disable-framework]],
            [enable_framework=$enableval], [enable_framework=no])
            [enable_framework=$enableval], [enable_framework=no])
        if test $enable_framework = yes; then
        if test $enable_framework = yes; then
            if test $SHARED_BUILD = 0; then
            if test $SHARED_BUILD = 0; then
                AC_MSG_WARN([Frameworks can only be built if --enable-shared is yes])
                AC_MSG_WARN([Frameworks can only be built if --enable-shared is yes])
                enable_framework=no
                enable_framework=no
            fi
            fi
            if test $tcl_corefoundation = no; then
            if test $tcl_corefoundation = no; then
                AC_MSG_WARN([Frameworks can only be used when CoreFoundation is available])
                AC_MSG_WARN([Frameworks can only be used when CoreFoundation is available])
                enable_framework=no
                enable_framework=no
            fi
            fi
        fi
        fi
        if test $enable_framework = yes; then
        if test $enable_framework = yes; then
            AC_MSG_RESULT([framework])
            AC_MSG_RESULT([framework])
            FRAMEWORK_BUILD=1
            FRAMEWORK_BUILD=1
        else
        else
            if test $SHARED_BUILD = 1; then
            if test $SHARED_BUILD = 1; then
                AC_MSG_RESULT([shared library])
                AC_MSG_RESULT([shared library])
            else
            else
                AC_MSG_RESULT([static library])
                AC_MSG_RESULT([static library])
            fi
            fi
            FRAMEWORK_BUILD=0
            FRAMEWORK_BUILD=0
        fi
        fi
    fi
    fi
])
])
 
 
#------------------------------------------------------------------------
#------------------------------------------------------------------------
# SC_ENABLE_THREADS --
# SC_ENABLE_THREADS --
#
#
#       Specify if thread support should be enabled.  TCL_THREADS is
#       Specify if thread support should be enabled.  TCL_THREADS is
#       checked so that if you are compiling an extension against a
#       checked so that if you are compiling an extension against a
#       threaded core, your extension must be compiled threaded as well.
#       threaded core, your extension must be compiled threaded as well.
#
#
# Arguments:
# Arguments:
#       none
#       none
#
#
# Results:
# Results:
#
#
#       Adds the following arguments to configure:
#       Adds the following arguments to configure:
#               --enable-threads
#               --enable-threads
#
#
#       Sets the following vars:
#       Sets the following vars:
#               THREADS_LIBS    Thread library(s)
#               THREADS_LIBS    Thread library(s)
#
#
#       Defines the following vars:
#       Defines the following vars:
#               TCL_THREADS
#               TCL_THREADS
#               _REENTRANT
#               _REENTRANT
#               _THREAD_SAFE
#               _THREAD_SAFE
#
#
#------------------------------------------------------------------------
#------------------------------------------------------------------------
 
 
AC_DEFUN([SC_ENABLE_THREADS], [
AC_DEFUN([SC_ENABLE_THREADS], [
    AC_ARG_ENABLE(threads, [  --enable-threads        build with threads],
    AC_ARG_ENABLE(threads, [  --enable-threads        build with threads],
        [tcl_ok=$enableval], [tcl_ok=no])
        [tcl_ok=$enableval], [tcl_ok=no])
 
 
    if test "${TCL_THREADS}" = 1; then
    if test "${TCL_THREADS}" = 1; then
        tcl_threaded_core=1;
        tcl_threaded_core=1;
    fi
    fi
 
 
    if test "$tcl_ok" = "yes" -o "${TCL_THREADS}" = 1; then
    if test "$tcl_ok" = "yes" -o "${TCL_THREADS}" = 1; then
        TCL_THREADS=1
        TCL_THREADS=1
        # USE_THREAD_ALLOC tells us to try the special thread-based
        # USE_THREAD_ALLOC tells us to try the special thread-based
        # allocator that significantly reduces lock contention
        # allocator that significantly reduces lock contention
        AC_DEFINE(USE_THREAD_ALLOC)
        AC_DEFINE(USE_THREAD_ALLOC)
        AC_DEFINE(_REENTRANT)
        AC_DEFINE(_REENTRANT)
        if test "`uname -s`" = "SunOS" ; then
        if test "`uname -s`" = "SunOS" ; then
            AC_DEFINE(_POSIX_PTHREAD_SEMANTICS)
            AC_DEFINE(_POSIX_PTHREAD_SEMANTICS)
        fi
        fi
        AC_DEFINE(_THREAD_SAFE)
        AC_DEFINE(_THREAD_SAFE)
        AC_CHECK_LIB(pthread,pthread_mutex_init,tcl_ok=yes,tcl_ok=no)
        AC_CHECK_LIB(pthread,pthread_mutex_init,tcl_ok=yes,tcl_ok=no)
        if test "$tcl_ok" = "no"; then
        if test "$tcl_ok" = "no"; then
            # Check a little harder for __pthread_mutex_init in the same
            # Check a little harder for __pthread_mutex_init in the same
            # library, as some systems hide it there until pthread.h is
            # library, as some systems hide it there until pthread.h is
            # defined.  We could alternatively do an AC_TRY_COMPILE with
            # defined.  We could alternatively do an AC_TRY_COMPILE with
            # pthread.h, but that will work with libpthread really doesn't
            # pthread.h, but that will work with libpthread really doesn't
            # exist, like AIX 4.2.  [Bug: 4359]
            # exist, like AIX 4.2.  [Bug: 4359]
            AC_CHECK_LIB(pthread, __pthread_mutex_init,
            AC_CHECK_LIB(pthread, __pthread_mutex_init,
                tcl_ok=yes, tcl_ok=no)
                tcl_ok=yes, tcl_ok=no)
        fi
        fi
 
 
        if test "$tcl_ok" = "yes"; then
        if test "$tcl_ok" = "yes"; then
            # The space is needed
            # The space is needed
            THREADS_LIBS=" -lpthread"
            THREADS_LIBS=" -lpthread"
        else
        else
            AC_CHECK_LIB(pthreads, pthread_mutex_init,
            AC_CHECK_LIB(pthreads, pthread_mutex_init,
                tcl_ok=yes, tcl_ok=no)
                tcl_ok=yes, tcl_ok=no)
            if test "$tcl_ok" = "yes"; then
            if test "$tcl_ok" = "yes"; then
                # The space is needed
                # The space is needed
                THREADS_LIBS=" -lpthreads"
                THREADS_LIBS=" -lpthreads"
            else
            else
                AC_CHECK_LIB(c, pthread_mutex_init,
                AC_CHECK_LIB(c, pthread_mutex_init,
                    tcl_ok=yes, tcl_ok=no)
                    tcl_ok=yes, tcl_ok=no)
                if test "$tcl_ok" = "no"; then
                if test "$tcl_ok" = "no"; then
                    AC_CHECK_LIB(c_r, pthread_mutex_init,
                    AC_CHECK_LIB(c_r, pthread_mutex_init,
                        tcl_ok=yes, tcl_ok=no)
                        tcl_ok=yes, tcl_ok=no)
                    if test "$tcl_ok" = "yes"; then
                    if test "$tcl_ok" = "yes"; then
                        # The space is needed
                        # The space is needed
                        THREADS_LIBS=" -pthread"
                        THREADS_LIBS=" -pthread"
                    else
                    else
                        TCL_THREADS=0
                        TCL_THREADS=0
                        AC_MSG_WARN([Don't know how to find pthread lib on your system - you must disable thread support or edit the LIBS in the Makefile...])
                        AC_MSG_WARN([Don't know how to find pthread lib on your system - you must disable thread support or edit the LIBS in the Makefile...])
                    fi
                    fi
                fi
                fi
            fi
            fi
        fi
        fi
 
 
        # Does the pthread-implementation provide
        # Does the pthread-implementation provide
        # 'pthread_attr_setstacksize' ?
        # 'pthread_attr_setstacksize' ?
 
 
        ac_saved_libs=$LIBS
        ac_saved_libs=$LIBS
        LIBS="$LIBS $THREADS_LIBS"
        LIBS="$LIBS $THREADS_LIBS"
        AC_CHECK_FUNCS(pthread_attr_setstacksize)
        AC_CHECK_FUNCS(pthread_attr_setstacksize)
        AC_CHECK_FUNCS(pthread_atfork)
        AC_CHECK_FUNCS(pthread_atfork)
        LIBS=$ac_saved_libs
        LIBS=$ac_saved_libs
    else
    else
        TCL_THREADS=0
        TCL_THREADS=0
    fi
    fi
    # Do checking message here to not mess up interleaved configure output
    # Do checking message here to not mess up interleaved configure output
    AC_MSG_CHECKING([for building with threads])
    AC_MSG_CHECKING([for building with threads])
    if test "${TCL_THREADS}" = 1; then
    if test "${TCL_THREADS}" = 1; then
        AC_DEFINE(TCL_THREADS, 1, [Are we building with threads enabled?])
        AC_DEFINE(TCL_THREADS, 1, [Are we building with threads enabled?])
        if test "${tcl_threaded_core}" = 1; then
        if test "${tcl_threaded_core}" = 1; then
            AC_MSG_RESULT([yes (threaded core)])
            AC_MSG_RESULT([yes (threaded core)])
        else
        else
            AC_MSG_RESULT([yes])
            AC_MSG_RESULT([yes])
        fi
        fi
    else
    else
        AC_MSG_RESULT([no (default)])
        AC_MSG_RESULT([no (default)])
    fi
    fi
 
 
    AC_SUBST(TCL_THREADS)
    AC_SUBST(TCL_THREADS)
])
])
 
 
#------------------------------------------------------------------------
#------------------------------------------------------------------------
# SC_ENABLE_SYMBOLS --
# SC_ENABLE_SYMBOLS --
#
#
#       Specify if debugging symbols should be used.
#       Specify if debugging symbols should be used.
#       Memory (TCL_MEM_DEBUG) and compile (TCL_COMPILE_DEBUG) debugging
#       Memory (TCL_MEM_DEBUG) and compile (TCL_COMPILE_DEBUG) debugging
#       can also be enabled.
#       can also be enabled.
#
#
# Arguments:
# Arguments:
#       none
#       none
#
#
#       Requires the following vars to be set in the Makefile:
#       Requires the following vars to be set in the Makefile:
#               CFLAGS_DEBUG
#               CFLAGS_DEBUG
#               CFLAGS_OPTIMIZE
#               CFLAGS_OPTIMIZE
#               LDFLAGS_DEBUG
#               LDFLAGS_DEBUG
#               LDFLAGS_OPTIMIZE
#               LDFLAGS_OPTIMIZE
#
#
# Results:
# Results:
#
#
#       Adds the following arguments to configure:
#       Adds the following arguments to configure:
#               --enable-symbols
#               --enable-symbols
#
#
#       Defines the following vars:
#       Defines the following vars:
#               CFLAGS_DEFAULT  Sets to $(CFLAGS_DEBUG) if true
#               CFLAGS_DEFAULT  Sets to $(CFLAGS_DEBUG) if true
#                               Sets to $(CFLAGS_OPTIMIZE) if false
#                               Sets to $(CFLAGS_OPTIMIZE) if false
#               LDFLAGS_DEFAULT Sets to $(LDFLAGS_DEBUG) if true
#               LDFLAGS_DEFAULT Sets to $(LDFLAGS_DEBUG) if true
#                               Sets to $(LDFLAGS_OPTIMIZE) if false
#                               Sets to $(LDFLAGS_OPTIMIZE) if false
#               DBGX            Debug library extension
#               DBGX            Debug library extension
#
#
#------------------------------------------------------------------------
#------------------------------------------------------------------------
 
 
AC_DEFUN([SC_ENABLE_SYMBOLS], [
AC_DEFUN([SC_ENABLE_SYMBOLS], [
    AC_MSG_CHECKING([for build with symbols])
    AC_MSG_CHECKING([for build with symbols])
    AC_ARG_ENABLE(symbols, [  --enable-symbols        build with debugging symbols [--disable-symbols]],    [tcl_ok=$enableval], [tcl_ok=no])
    AC_ARG_ENABLE(symbols, [  --enable-symbols        build with debugging symbols [--disable-symbols]],    [tcl_ok=$enableval], [tcl_ok=no])
# FIXME: Currently, LDFLAGS_DEFAULT is not used, it should work like CFLAGS_DEFAULT.
# FIXME: Currently, LDFLAGS_DEFAULT is not used, it should work like CFLAGS_DEFAULT.
    if test "$tcl_ok" = "no"; then
    if test "$tcl_ok" = "no"; then
        CFLAGS_DEFAULT='$(CFLAGS_OPTIMIZE)'
        CFLAGS_DEFAULT='$(CFLAGS_OPTIMIZE)'
        LDFLAGS_DEFAULT='$(LDFLAGS_OPTIMIZE)'
        LDFLAGS_DEFAULT='$(LDFLAGS_OPTIMIZE)'
        DBGX=""
        DBGX=""
        AC_MSG_RESULT([no])
        AC_MSG_RESULT([no])
    else
    else
        CFLAGS_DEFAULT='$(CFLAGS_DEBUG)'
        CFLAGS_DEFAULT='$(CFLAGS_DEBUG)'
        LDFLAGS_DEFAULT='$(LDFLAGS_DEBUG)'
        LDFLAGS_DEFAULT='$(LDFLAGS_DEBUG)'
        DBGX=g
        DBGX=g
        if test "$tcl_ok" = "yes"; then
        if test "$tcl_ok" = "yes"; then
            AC_MSG_RESULT([yes (standard debugging)])
            AC_MSG_RESULT([yes (standard debugging)])
        fi
        fi
    fi
    fi
    AC_SUBST(CFLAGS_DEFAULT)
    AC_SUBST(CFLAGS_DEFAULT)
    AC_SUBST(LDFLAGS_DEFAULT)
    AC_SUBST(LDFLAGS_DEFAULT)
 
 
    if test "$tcl_ok" = "mem" -o "$tcl_ok" = "all"; then
    if test "$tcl_ok" = "mem" -o "$tcl_ok" = "all"; then
        AC_DEFINE(TCL_MEM_DEBUG)
        AC_DEFINE(TCL_MEM_DEBUG)
    fi
    fi
 
 
    if test "$tcl_ok" = "compile" -o "$tcl_ok" = "all"; then
    if test "$tcl_ok" = "compile" -o "$tcl_ok" = "all"; then
        AC_DEFINE(TCL_COMPILE_DEBUG)
        AC_DEFINE(TCL_COMPILE_DEBUG)
        AC_DEFINE(TCL_COMPILE_STATS)
        AC_DEFINE(TCL_COMPILE_STATS)
    fi
    fi
 
 
    if test "$tcl_ok" != "yes" -a "$tcl_ok" != "no"; then
    if test "$tcl_ok" != "yes" -a "$tcl_ok" != "no"; then
        if test "$tcl_ok" = "all"; then
        if test "$tcl_ok" = "all"; then
            AC_MSG_RESULT([enabled symbols mem compile debugging])
            AC_MSG_RESULT([enabled symbols mem compile debugging])
        else
        else
            AC_MSG_RESULT([enabled $tcl_ok debugging])
            AC_MSG_RESULT([enabled $tcl_ok debugging])
        fi
        fi
    fi
    fi
])
])
 
 
#------------------------------------------------------------------------
#------------------------------------------------------------------------
# SC_ENABLE_LANGINFO --
# SC_ENABLE_LANGINFO --
#
#
#       Allows use of modern nl_langinfo check for better l10n.
#       Allows use of modern nl_langinfo check for better l10n.
#       This is only relevant for Unix.
#       This is only relevant for Unix.
#
#
# Arguments:
# Arguments:
#       none
#       none
#
#
# Results:
# Results:
#
#
#       Adds the following arguments to configure:
#       Adds the following arguments to configure:
#               --enable-langinfo=yes|no (default is yes)
#               --enable-langinfo=yes|no (default is yes)
#
#
#       Defines the following vars:
#       Defines the following vars:
#               HAVE_LANGINFO   Triggers use of nl_langinfo if defined.
#               HAVE_LANGINFO   Triggers use of nl_langinfo if defined.
#
#
#------------------------------------------------------------------------
#------------------------------------------------------------------------
 
 
AC_DEFUN([SC_ENABLE_LANGINFO], [
AC_DEFUN([SC_ENABLE_LANGINFO], [
    AC_ARG_ENABLE(langinfo,
    AC_ARG_ENABLE(langinfo,
        [  --enable-langinfo      use nl_langinfo if possible to determine
        [  --enable-langinfo      use nl_langinfo if possible to determine
                          encoding at startup, otherwise use old heuristic],
                          encoding at startup, otherwise use old heuristic],
        [langinfo_ok=$enableval], [langinfo_ok=yes])
        [langinfo_ok=$enableval], [langinfo_ok=yes])
 
 
    HAVE_LANGINFO=0
    HAVE_LANGINFO=0
    if test "$langinfo_ok" = "yes"; then
    if test "$langinfo_ok" = "yes"; then
        AC_CHECK_HEADER(langinfo.h,[langinfo_ok=yes],[langinfo_ok=no])
        AC_CHECK_HEADER(langinfo.h,[langinfo_ok=yes],[langinfo_ok=no])
    fi
    fi
    AC_MSG_CHECKING([whether to use nl_langinfo])
    AC_MSG_CHECKING([whether to use nl_langinfo])
    if test "$langinfo_ok" = "yes"; then
    if test "$langinfo_ok" = "yes"; then
        AC_CACHE_VAL(tcl_cv_langinfo_h, [
        AC_CACHE_VAL(tcl_cv_langinfo_h, [
            AC_TRY_COMPILE([#include <langinfo.h>], [nl_langinfo(CODESET);],
            AC_TRY_COMPILE([#include <langinfo.h>], [nl_langinfo(CODESET);],
                    [tcl_cv_langinfo_h=yes],[tcl_cv_langinfo_h=no])])
                    [tcl_cv_langinfo_h=yes],[tcl_cv_langinfo_h=no])])
        AC_MSG_RESULT([$tcl_cv_langinfo_h])
        AC_MSG_RESULT([$tcl_cv_langinfo_h])
        if test $tcl_cv_langinfo_h = yes; then
        if test $tcl_cv_langinfo_h = yes; then
            AC_DEFINE(HAVE_LANGINFO)
            AC_DEFINE(HAVE_LANGINFO)
        fi
        fi
    else
    else
        AC_MSG_RESULT([$langinfo_ok])
        AC_MSG_RESULT([$langinfo_ok])
    fi
    fi
])
])
 
 
#--------------------------------------------------------------------
#--------------------------------------------------------------------
# SC_CONFIG_MANPAGES
# SC_CONFIG_MANPAGES
#
#
#       Decide whether to use symlinks for linking the manpages,
#       Decide whether to use symlinks for linking the manpages,
#       whether to compress the manpages after installation, and
#       whether to compress the manpages after installation, and
#       whether to add a package name suffix to the installed
#       whether to add a package name suffix to the installed
#       manpages to avoidfile name clashes.
#       manpages to avoidfile name clashes.
#       If compression is enabled also find out what file name suffix
#       If compression is enabled also find out what file name suffix
#       the given compression program is using.
#       the given compression program is using.
#
#
# Arguments:
# Arguments:
#       none
#       none
#
#
# Results:
# Results:
#
#
#       Adds the following arguments to configure:
#       Adds the following arguments to configure:
#               --enable-man-symlinks
#               --enable-man-symlinks
#               --enable-man-compression=PROG
#               --enable-man-compression=PROG
#               --enable-man-suffix[=STRING]
#               --enable-man-suffix[=STRING]
#
#
#       Defines the following variable:
#       Defines the following variable:
#
#
#       MAN_FLAGS -     The apropriate flags for installManPage
#       MAN_FLAGS -     The apropriate flags for installManPage
#                       according to the user's selection.
#                       according to the user's selection.
#
#
#--------------------------------------------------------------------
#--------------------------------------------------------------------
 
 
AC_DEFUN([SC_CONFIG_MANPAGES], [
AC_DEFUN([SC_CONFIG_MANPAGES], [
    AC_MSG_CHECKING([whether to use symlinks for manpages])
    AC_MSG_CHECKING([whether to use symlinks for manpages])
    AC_ARG_ENABLE(man-symlinks,
    AC_ARG_ENABLE(man-symlinks,
            [  --enable-man-symlinks   use symlinks for the manpages],
            [  --enable-man-symlinks   use symlinks for the manpages],
        test "$enableval" != "no" && MAN_FLAGS="$MAN_FLAGS --symlinks",
        test "$enableval" != "no" && MAN_FLAGS="$MAN_FLAGS --symlinks",
        enableval="no")
        enableval="no")
    AC_MSG_RESULT([$enableval])
    AC_MSG_RESULT([$enableval])
 
 
    AC_MSG_CHECKING([whether to compress the manpages])
    AC_MSG_CHECKING([whether to compress the manpages])
    AC_ARG_ENABLE(man-compression,
    AC_ARG_ENABLE(man-compression,
            [  --enable-man-compression=PROG
            [  --enable-man-compression=PROG
                      compress the manpages with PROG],
                      compress the manpages with PROG],
        [case $enableval in
        [case $enableval in
            yes) AC_MSG_ERROR([missing argument to --enable-man-compression]);;
            yes) AC_MSG_ERROR([missing argument to --enable-man-compression]);;
            no)  ;;
            no)  ;;
            *)   MAN_FLAGS="$MAN_FLAGS --compress $enableval";;
            *)   MAN_FLAGS="$MAN_FLAGS --compress $enableval";;
        esac],
        esac],
        enableval="no")
        enableval="no")
    AC_MSG_RESULT([$enableval])
    AC_MSG_RESULT([$enableval])
    if test "$enableval" != "no"; then
    if test "$enableval" != "no"; then
        AC_MSG_CHECKING([for compressed file suffix])
        AC_MSG_CHECKING([for compressed file suffix])
        touch TeST
        touch TeST
        $enableval TeST
        $enableval TeST
        Z=`ls TeST* | sed 's/^....//'`
        Z=`ls TeST* | sed 's/^....//'`
        rm -f TeST*
        rm -f TeST*
        MAN_FLAGS="$MAN_FLAGS --extension $Z"
        MAN_FLAGS="$MAN_FLAGS --extension $Z"
        AC_MSG_RESULT([$Z])
        AC_MSG_RESULT([$Z])
    fi
    fi
 
 
    AC_MSG_CHECKING([whether to add a package name suffix for the manpages])
    AC_MSG_CHECKING([whether to add a package name suffix for the manpages])
    AC_ARG_ENABLE(man-suffix,
    AC_ARG_ENABLE(man-suffix,
            [  --enable-man-suffix=STRING
            [  --enable-man-suffix=STRING
                      use STRING as a suffix to manpage file names
                      use STRING as a suffix to manpage file names
                      (default: $1)],
                      (default: $1)],
        [case $enableval in
        [case $enableval in
            yes) enableval="$1" MAN_FLAGS="$MAN_FLAGS --suffix $enableval";;
            yes) enableval="$1" MAN_FLAGS="$MAN_FLAGS --suffix $enableval";;
            no)  ;;
            no)  ;;
            *)   MAN_FLAGS="$MAN_FLAGS --suffix $enableval";;
            *)   MAN_FLAGS="$MAN_FLAGS --suffix $enableval";;
        esac],
        esac],
        enableval="no")
        enableval="no")
    AC_MSG_RESULT([$enableval])
    AC_MSG_RESULT([$enableval])
 
 
    AC_SUBST(MAN_FLAGS)
    AC_SUBST(MAN_FLAGS)
])
])
 
 
#--------------------------------------------------------------------
#--------------------------------------------------------------------
# SC_CONFIG_SYSTEM
# SC_CONFIG_SYSTEM
#
#
#       Determine what the system is (some things cannot be easily checked
#       Determine what the system is (some things cannot be easily checked
#       on a feature-driven basis, alas). This can usually be done via the
#       on a feature-driven basis, alas). This can usually be done via the
#       "uname" command, but there are a few systems, like Next, where
#       "uname" command, but there are a few systems, like Next, where
#       this doesn't work.
#       this doesn't work.
#
#
# Arguments:
# Arguments:
#       none
#       none
#
#
# Results:
# Results:
#       Defines the following var:
#       Defines the following var:
#
#
#       system -        System/platform/version identification code.
#       system -        System/platform/version identification code.
#
#
#--------------------------------------------------------------------
#--------------------------------------------------------------------
 
 
AC_DEFUN([SC_CONFIG_SYSTEM], [
AC_DEFUN([SC_CONFIG_SYSTEM], [
    AC_CACHE_CHECK([system version], tcl_cv_sys_version, [
    AC_CACHE_CHECK([system version], tcl_cv_sys_version, [
        if test -f /usr/lib/NextStep/software_version; then
        if test -f /usr/lib/NextStep/software_version; then
            tcl_cv_sys_version=NEXTSTEP-`awk '/3/,/3/' /usr/lib/NextStep/software_version`
            tcl_cv_sys_version=NEXTSTEP-`awk '/3/,/3/' /usr/lib/NextStep/software_version`
        else
        else
            tcl_cv_sys_version=`uname -s`-`uname -r`
            tcl_cv_sys_version=`uname -s`-`uname -r`
            if test "$?" -ne 0 ; then
            if test "$?" -ne 0 ; then
                AC_MSG_WARN([can't find uname command])
                AC_MSG_WARN([can't find uname command])
                tcl_cv_sys_version=unknown
                tcl_cv_sys_version=unknown
            else
            else
                # Special check for weird MP-RAS system (uname returns weird
                # Special check for weird MP-RAS system (uname returns weird
                # results, and the version is kept in special file).
                # results, and the version is kept in special file).
 
 
                if test -r /etc/.relid -a "X`uname -n`" = "X`uname -s`" ; then
                if test -r /etc/.relid -a "X`uname -n`" = "X`uname -s`" ; then
                    tcl_cv_sys_version=MP-RAS-`awk '{print $[3]}' /etc/.relid`
                    tcl_cv_sys_version=MP-RAS-`awk '{print $[3]}' /etc/.relid`
                fi
                fi
                if test "`uname -s`" = "AIX" ; then
                if test "`uname -s`" = "AIX" ; then
                    tcl_cv_sys_version=AIX-`uname -v`.`uname -r`
                    tcl_cv_sys_version=AIX-`uname -v`.`uname -r`
                fi
                fi
            fi
            fi
        fi
        fi
    ])
    ])
    system=$tcl_cv_sys_version
    system=$tcl_cv_sys_version
])
])
 
 
#--------------------------------------------------------------------
#--------------------------------------------------------------------
# SC_CONFIG_CFLAGS
# SC_CONFIG_CFLAGS
#
#
#       Try to determine the proper flags to pass to the compiler
#       Try to determine the proper flags to pass to the compiler
#       for building shared libraries and other such nonsense.
#       for building shared libraries and other such nonsense.
#
#
# Arguments:
# Arguments:
#       none
#       none
#
#
# Results:
# Results:
#
#
#       Defines and substitutes the following vars:
#       Defines and substitutes the following vars:
#
#
#       DL_OBJS -       Name of the object file that implements dynamic
#       DL_OBJS -       Name of the object file that implements dynamic
#                       loading for Tcl on this system.
#                       loading for Tcl on this system.
#       DL_LIBS -       Library file(s) to include in tclsh and other base
#       DL_LIBS -       Library file(s) to include in tclsh and other base
#                       applications in order for the "load" command to work.
#                       applications in order for the "load" command to work.
#       LDFLAGS -      Flags to pass to the compiler when linking object
#       LDFLAGS -      Flags to pass to the compiler when linking object
#                       files into an executable application binary such
#                       files into an executable application binary such
#                       as tclsh.
#                       as tclsh.
#       LD_SEARCH_FLAGS-Flags to pass to ld, such as "-R /usr/local/tcl/lib",
#       LD_SEARCH_FLAGS-Flags to pass to ld, such as "-R /usr/local/tcl/lib",
#                       that tell the run-time dynamic linker where to look
#                       that tell the run-time dynamic linker where to look
#                       for shared libraries such as libtcl.so.  Depends on
#                       for shared libraries such as libtcl.so.  Depends on
#                       the variable LIB_RUNTIME_DIR in the Makefile. Could
#                       the variable LIB_RUNTIME_DIR in the Makefile. Could
#                       be the same as CC_SEARCH_FLAGS if ${CC} is used to link.
#                       be the same as CC_SEARCH_FLAGS if ${CC} is used to link.
#       CC_SEARCH_FLAGS-Flags to pass to ${CC}, such as "-Wl,-rpath,/usr/local/tcl/lib",
#       CC_SEARCH_FLAGS-Flags to pass to ${CC}, such as "-Wl,-rpath,/usr/local/tcl/lib",
#                       that tell the run-time dynamic linker where to look
#                       that tell the run-time dynamic linker where to look
#                       for shared libraries such as libtcl.so.  Depends on
#                       for shared libraries such as libtcl.so.  Depends on
#                       the variable LIB_RUNTIME_DIR in the Makefile.
#                       the variable LIB_RUNTIME_DIR in the Makefile.
#       MAKE_LIB -      Command to execute to build the a library;
#       MAKE_LIB -      Command to execute to build the a library;
#                       differs when building shared or static.
#                       differs when building shared or static.
#       MAKE_STUB_LIB -
#       MAKE_STUB_LIB -
#                       Command to execute to build a stub library.
#                       Command to execute to build a stub library.
#       INSTALL_LIB -   Command to execute to install a library;
#       INSTALL_LIB -   Command to execute to install a library;
#                       differs when building shared or static.
#                       differs when building shared or static.
#       INSTALL_STUB_LIB -
#       INSTALL_STUB_LIB -
#                       Command to execute to install a stub library.
#                       Command to execute to install a stub library.
#       STLIB_LD -      Base command to use for combining object files
#       STLIB_LD -      Base command to use for combining object files
#                       into a static library.
#                       into a static library.
#       SHLIB_CFLAGS -  Flags to pass to cc when compiling the components
#       SHLIB_CFLAGS -  Flags to pass to cc when compiling the components
#                       of a shared library (may request position-independent
#                       of a shared library (may request position-independent
#                       code, among other things).
#                       code, among other things).
#       SHLIB_LD -      Base command to use for combining object files
#       SHLIB_LD -      Base command to use for combining object files
#                       into a shared library.
#                       into a shared library.
#       SHLIB_LD_LIBS - Dependent libraries for the linker to scan when
#       SHLIB_LD_LIBS - Dependent libraries for the linker to scan when
#                       creating shared libraries.  This symbol typically
#                       creating shared libraries.  This symbol typically
#                       goes at the end of the "ld" commands that build
#                       goes at the end of the "ld" commands that build
#                       shared libraries. The value of the symbol is
#                       shared libraries. The value of the symbol is
#                       "${LIBS}" if all of the dependent libraries should
#                       "${LIBS}" if all of the dependent libraries should
#                       be specified when creating a shared library.  If
#                       be specified when creating a shared library.  If
#                       dependent libraries should not be specified (as on
#                       dependent libraries should not be specified (as on
#                       SunOS 4.x, where they cause the link to fail, or in
#                       SunOS 4.x, where they cause the link to fail, or in
#                       general if Tcl and Tk aren't themselves shared
#                       general if Tcl and Tk aren't themselves shared
#                       libraries), then this symbol has an empty string
#                       libraries), then this symbol has an empty string
#                       as its value.
#                       as its value.
#       SHLIB_SUFFIX -  Suffix to use for the names of dynamically loadable
#       SHLIB_SUFFIX -  Suffix to use for the names of dynamically loadable
#                       extensions.  An empty string means we don't know how
#                       extensions.  An empty string means we don't know how
#                       to use shared libraries on this platform.
#                       to use shared libraries on this platform.
# TCL_SHLIB_LD_EXTRAS - Additional element which are added to SHLIB_LD_LIBS
# TCL_SHLIB_LD_EXTRAS - Additional element which are added to SHLIB_LD_LIBS
#  TK_SHLIB_LD_EXTRAS   for the build of Tcl and Tk, but not recorded in the
#  TK_SHLIB_LD_EXTRAS   for the build of Tcl and Tk, but not recorded in the
#                       tclConfig.sh, since they are only used for the build
#                       tclConfig.sh, since they are only used for the build
#                       of Tcl and Tk.
#                       of Tcl and Tk.
#                       Examples: MacOS X records the library version and
#                       Examples: MacOS X records the library version and
#                       compatibility version in the shared library.  But
#                       compatibility version in the shared library.  But
#                       of course the Tcl version of this is only used for Tcl.
#                       of course the Tcl version of this is only used for Tcl.
#       LIB_SUFFIX -    Specifies everything that comes after the "libfoo"
#       LIB_SUFFIX -    Specifies everything that comes after the "libfoo"
#                       in a static or shared library name, using the $VERSION variable
#                       in a static or shared library name, using the $VERSION variable
#                       to put the version in the right place.  This is used
#                       to put the version in the right place.  This is used
#                       by platforms that need non-standard library names.
#                       by platforms that need non-standard library names.
#                       Examples:  ${VERSION}.so.1.1 on NetBSD, since it needs
#                       Examples:  ${VERSION}.so.1.1 on NetBSD, since it needs
#                       to have a version after the .so, and ${VERSION}.a
#                       to have a version after the .so, and ${VERSION}.a
#                       on AIX, since a shared library needs to have
#                       on AIX, since a shared library needs to have
#                       a .a extension whereas shared objects for loadable
#                       a .a extension whereas shared objects for loadable
#                       extensions have a .so extension.  Defaults to
#                       extensions have a .so extension.  Defaults to
#                       ${VERSION}${SHLIB_SUFFIX}.
#                       ${VERSION}${SHLIB_SUFFIX}.
#       TCL_NEEDS_EXP_FILE -
#       TCL_NEEDS_EXP_FILE -
#                       1 means that an export file is needed to link to a
#                       1 means that an export file is needed to link to a
#                       shared library.
#                       shared library.
#       TCL_EXP_FILE -  The name of the installed export / import file which
#       TCL_EXP_FILE -  The name of the installed export / import file which
#                       should be used to link to the Tcl shared library.
#                       should be used to link to the Tcl shared library.
#                       Empty if Tcl is unshared.
#                       Empty if Tcl is unshared.
#       TCL_BUILD_EXP_FILE -
#       TCL_BUILD_EXP_FILE -
#                       The name of the built export / import file which
#                       The name of the built export / import file which
#                       should be used to link to the Tcl shared library.
#                       should be used to link to the Tcl shared library.
#                       Empty if Tcl is unshared.
#                       Empty if Tcl is unshared.
#       CFLAGS_DEBUG -
#       CFLAGS_DEBUG -
#                       Flags used when running the compiler in debug mode
#                       Flags used when running the compiler in debug mode
#       CFLAGS_OPTIMIZE -
#       CFLAGS_OPTIMIZE -
#                       Flags used when running the compiler in optimize mode
#                       Flags used when running the compiler in optimize mode
#       CFLAGS -        Additional CFLAGS added as necessary (usually 64-bit)
#       CFLAGS -        Additional CFLAGS added as necessary (usually 64-bit)
#
#
#--------------------------------------------------------------------
#--------------------------------------------------------------------
 
 
AC_DEFUN([SC_CONFIG_CFLAGS], [
AC_DEFUN([SC_CONFIG_CFLAGS], [
 
 
    # Step 0.a: Enable 64 bit support?
    # Step 0.a: Enable 64 bit support?
 
 
    AC_MSG_CHECKING([if 64bit support is requested])
    AC_MSG_CHECKING([if 64bit support is requested])
    AC_ARG_ENABLE(64bit,[  --enable-64bit          enable 64bit support (where applicable)],
    AC_ARG_ENABLE(64bit,[  --enable-64bit          enable 64bit support (where applicable)],
        [do64bit=$enableval], [do64bit=no])
        [do64bit=$enableval], [do64bit=no])
    AC_MSG_RESULT([$do64bit])
    AC_MSG_RESULT([$do64bit])
 
 
    # Step 0.b: Enable Solaris 64 bit VIS support?
    # Step 0.b: Enable Solaris 64 bit VIS support?
 
 
    AC_MSG_CHECKING([if 64bit Sparc VIS support is requested])
    AC_MSG_CHECKING([if 64bit Sparc VIS support is requested])
    AC_ARG_ENABLE(64bit-vis,[  --enable-64bit-vis      enable 64bit Sparc VIS support],
    AC_ARG_ENABLE(64bit-vis,[  --enable-64bit-vis      enable 64bit Sparc VIS support],
        [do64bitVIS=$enableval], [do64bitVIS=no])
        [do64bitVIS=$enableval], [do64bitVIS=no])
    AC_MSG_RESULT([$do64bitVIS])
    AC_MSG_RESULT([$do64bitVIS])
 
 
    if test "$do64bitVIS" = "yes"; then
    if test "$do64bitVIS" = "yes"; then
        # Force 64bit on with VIS
        # Force 64bit on with VIS
        do64bit=yes
        do64bit=yes
    fi
    fi
 
 
    # Step 1: set the variable "system" to hold the name and version number
    # Step 1: set the variable "system" to hold the name and version number
    # for the system.
    # for the system.
 
 
    SC_CONFIG_SYSTEM
    SC_CONFIG_SYSTEM
 
 
    # Step 2: check for existence of -ldl library.  This is needed because
    # Step 2: check for existence of -ldl library.  This is needed because
    # Linux can use either -ldl or -ldld for dynamic loading.
    # Linux can use either -ldl or -ldld for dynamic loading.
 
 
    AC_CHECK_LIB(dl, dlopen, have_dl=yes, have_dl=no)
    AC_CHECK_LIB(dl, dlopen, have_dl=yes, have_dl=no)
 
 
    # Require ranlib early so we can override it in special cases below.
    # Require ranlib early so we can override it in special cases below.
 
 
    AC_REQUIRE([AC_PROG_RANLIB])
    AC_REQUIRE([AC_PROG_RANLIB])
 
 
    # Step 3: set configuration options based on system name and version.
    # Step 3: set configuration options based on system name and version.
 
 
    do64bit_ok=no
    do64bit_ok=no
    LDFLAGS_ORIG="$LDFLAGS"
    LDFLAGS_ORIG="$LDFLAGS"
    TCL_EXPORT_FILE_SUFFIX=""
    TCL_EXPORT_FILE_SUFFIX=""
    UNSHARED_LIB_SUFFIX=""
    UNSHARED_LIB_SUFFIX=""
    TCL_TRIM_DOTS='`echo ${VERSION} | tr -d .`'
    TCL_TRIM_DOTS='`echo ${VERSION} | tr -d .`'
    ECHO_VERSION='`echo ${VERSION}`'
    ECHO_VERSION='`echo ${VERSION}`'
    TCL_LIB_VERSIONS_OK=ok
    TCL_LIB_VERSIONS_OK=ok
    CFLAGS_DEBUG=-g
    CFLAGS_DEBUG=-g
    CFLAGS_OPTIMIZE=-O
    CFLAGS_OPTIMIZE=-O
    if test "$GCC" = "yes" ; then
    if test "$GCC" = "yes" ; then
        CFLAGS_WARNING="-Wall -Wno-implicit-int -fno-strict-aliasing"
        CFLAGS_WARNING="-Wall -Wno-implicit-int -fno-strict-aliasing"
    else
    else
        CFLAGS_WARNING=""
        CFLAGS_WARNING=""
    fi
    fi
    TCL_NEEDS_EXP_FILE=0
    TCL_NEEDS_EXP_FILE=0
    TCL_BUILD_EXP_FILE=""
    TCL_BUILD_EXP_FILE=""
    TCL_EXP_FILE=""
    TCL_EXP_FILE=""
dnl FIXME: Replace AC_CHECK_PROG with AC_CHECK_TOOL once cross compiling is fixed.
dnl FIXME: Replace AC_CHECK_PROG with AC_CHECK_TOOL once cross compiling is fixed.
dnl AC_CHECK_TOOL(AR, ar)
dnl AC_CHECK_TOOL(AR, ar)
    AC_CHECK_PROG(AR, ar, ar)
    AC_CHECK_PROG(AR, ar, ar)
    if test "${AR}" = "" ; then
    if test "${AR}" = "" ; then
        AC_MSG_ERROR([Required archive tool 'ar' not found on PATH.])
        AC_MSG_ERROR([Required archive tool 'ar' not found on PATH.])
    fi
    fi
    STLIB_LD='${AR} cr'
    STLIB_LD='${AR} cr'
    LD_LIBRARY_PATH_VAR="LD_LIBRARY_PATH"
    LD_LIBRARY_PATH_VAR="LD_LIBRARY_PATH"
    PLAT_OBJS=""
    PLAT_OBJS=""
    PLAT_SRCS=""
    PLAT_SRCS=""
    case $system in
    case $system in
        AIX-*)
        AIX-*)
            if test "${TCL_THREADS}" = "1" -a "$GCC" != "yes" ; then
            if test "${TCL_THREADS}" = "1" -a "$GCC" != "yes" ; then
                # AIX requires the _r compiler when gcc isn't being used
                # AIX requires the _r compiler when gcc isn't being used
                case "${CC}" in
                case "${CC}" in
                    *_r)
                    *_r)
                        # ok ...
                        # ok ...
                        ;;
                        ;;
                    *)
                    *)
                        CC=${CC}_r
                        CC=${CC}_r
                        ;;
                        ;;
                esac
                esac
                AC_MSG_RESULT([Using $CC for compiling with threads])
                AC_MSG_RESULT([Using $CC for compiling with threads])
            fi
            fi
            LIBS="$LIBS -lc"
            LIBS="$LIBS -lc"
            SHLIB_CFLAGS=""
            SHLIB_CFLAGS=""
            # Note: need the LIBS below, otherwise Tk won't find Tcl's
            # Note: need the LIBS below, otherwise Tk won't find Tcl's
            # symbols when dynamically loaded into tclsh.
            # symbols when dynamically loaded into tclsh.
            SHLIB_LD_LIBS='${LIBS}'
            SHLIB_LD_LIBS='${LIBS}'
            SHLIB_SUFFIX=".so"
            SHLIB_SUFFIX=".so"
 
 
            DL_OBJS="tclLoadDl.o"
            DL_OBJS="tclLoadDl.o"
            LD_LIBRARY_PATH_VAR="LIBPATH"
            LD_LIBRARY_PATH_VAR="LIBPATH"
 
 
            # Check to enable 64-bit flags for compiler/linker on AIX 4+
            # Check to enable 64-bit flags for compiler/linker on AIX 4+
            if test "$do64bit" = "yes" -a "`uname -v`" -gt "3" ; then
            if test "$do64bit" = "yes" -a "`uname -v`" -gt "3" ; then
                if test "$GCC" = "yes" ; then
                if test "$GCC" = "yes" ; then
                    AC_MSG_WARN([64bit mode not supported with GCC on $system])
                    AC_MSG_WARN([64bit mode not supported with GCC on $system])
                else
                else
                    do64bit_ok=yes
                    do64bit_ok=yes
                    CFLAGS="$CFLAGS -q64"
                    CFLAGS="$CFLAGS -q64"
                    LDFLAGS="$LDFLAGS -q64"
                    LDFLAGS="$LDFLAGS -q64"
                    RANLIB="${RANLIB} -X64"
                    RANLIB="${RANLIB} -X64"
                    AR="${AR} -X64"
                    AR="${AR} -X64"
                    SHLIB_LD_FLAGS="-b64"
                    SHLIB_LD_FLAGS="-b64"
                fi
                fi
            fi
            fi
 
 
            if test "`uname -m`" = "ia64" ; then
            if test "`uname -m`" = "ia64" ; then
                # AIX-5 uses ELF style dynamic libraries on IA-64, but not PPC
                # AIX-5 uses ELF style dynamic libraries on IA-64, but not PPC
                SHLIB_LD="/usr/ccs/bin/ld -G -z text"
                SHLIB_LD="/usr/ccs/bin/ld -G -z text"
                # AIX-5 has dl* in libc.so
                # AIX-5 has dl* in libc.so
                DL_LIBS=""
                DL_LIBS=""
                if test "$GCC" = "yes" ; then
                if test "$GCC" = "yes" ; then
                    CC_SEARCH_FLAGS='-Wl,-R,${LIB_RUNTIME_DIR}'
                    CC_SEARCH_FLAGS='-Wl,-R,${LIB_RUNTIME_DIR}'
                else
                else
                    CC_SEARCH_FLAGS='-R${LIB_RUNTIME_DIR}'
                    CC_SEARCH_FLAGS='-R${LIB_RUNTIME_DIR}'
                fi
                fi
                LD_SEARCH_FLAGS='-R ${LIB_RUNTIME_DIR}'
                LD_SEARCH_FLAGS='-R ${LIB_RUNTIME_DIR}'
            else
            else
                if test "$GCC" = "yes" ; then
                if test "$GCC" = "yes" ; then
                    SHLIB_LD="gcc -shared"
                    SHLIB_LD="gcc -shared"
                else
                else
                    SHLIB_LD="/bin/ld -bhalt:4 -bM:SRE -bE:lib.exp -H512 -T512 -bnoentry"
                    SHLIB_LD="/bin/ld -bhalt:4 -bM:SRE -bE:lib.exp -H512 -T512 -bnoentry"
                fi
                fi
                SHLIB_LD="${TCL_SRC_DIR}/unix/ldAix ${SHLIB_LD} ${SHLIB_LD_FLAGS}"
                SHLIB_LD="${TCL_SRC_DIR}/unix/ldAix ${SHLIB_LD} ${SHLIB_LD_FLAGS}"
                DL_LIBS="-ldl"
                DL_LIBS="-ldl"
                CC_SEARCH_FLAGS='-L${LIB_RUNTIME_DIR}'
                CC_SEARCH_FLAGS='-L${LIB_RUNTIME_DIR}'
                LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS}
                LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS}
                TCL_NEEDS_EXP_FILE=1
                TCL_NEEDS_EXP_FILE=1
                TCL_EXPORT_FILE_SUFFIX='${VERSION}\$\{DBGX\}.exp'
                TCL_EXPORT_FILE_SUFFIX='${VERSION}\$\{DBGX\}.exp'
            fi
            fi
 
 
            # AIX v<=4.1 has some different flags than 4.2+
            # AIX v<=4.1 has some different flags than 4.2+
            if test "$system" = "AIX-4.1" -o "`uname -v`" -lt "4" ; then
            if test "$system" = "AIX-4.1" -o "`uname -v`" -lt "4" ; then
                LIBOBJS="$LIBOBJS tclLoadAix.o"
                LIBOBJS="$LIBOBJS tclLoadAix.o"
                DL_LIBS="-lld"
                DL_LIBS="-lld"
            fi
            fi
 
 
            # On AIX <=v4 systems, libbsd.a has to be linked in to support
            # On AIX <=v4 systems, libbsd.a has to be linked in to support
            # non-blocking file IO.  This library has to be linked in after
            # non-blocking file IO.  This library has to be linked in after
            # the MATH_LIBS or it breaks the pow() function.  The way to
            # the MATH_LIBS or it breaks the pow() function.  The way to
            # insure proper sequencing, is to add it to the tail of MATH_LIBS.
            # insure proper sequencing, is to add it to the tail of MATH_LIBS.
            # This library also supplies gettimeofday.
            # This library also supplies gettimeofday.
            #
            #
            # AIX does not have a timezone field in struct tm. When the AIX
            # AIX does not have a timezone field in struct tm. When the AIX
            # bsd library is used, the timezone global and the gettimeofday
            # bsd library is used, the timezone global and the gettimeofday
            # methods are to be avoided for timezone deduction instead, we
            # methods are to be avoided for timezone deduction instead, we
            # deduce the timezone by comparing the localtime result on a
            # deduce the timezone by comparing the localtime result on a
            # known GMT value.
            # known GMT value.
 
 
            AC_CHECK_LIB(bsd, gettimeofday, libbsd=yes, libbsd=no)
            AC_CHECK_LIB(bsd, gettimeofday, libbsd=yes, libbsd=no)
            if test $libbsd = yes; then
            if test $libbsd = yes; then
                MATH_LIBS="$MATH_LIBS -lbsd"
                MATH_LIBS="$MATH_LIBS -lbsd"
                AC_DEFINE(USE_DELTA_FOR_TZ)
                AC_DEFINE(USE_DELTA_FOR_TZ)
            fi
            fi
            ;;
            ;;
        BeOS*)
        BeOS*)
            SHLIB_CFLAGS="-fPIC"
            SHLIB_CFLAGS="-fPIC"
            SHLIB_LD="${CC} -nostart"
            SHLIB_LD="${CC} -nostart"
            SHLIB_LD_LIBS='${LIBS}'
            SHLIB_LD_LIBS='${LIBS}'
            SHLIB_SUFFIX=".so"
            SHLIB_SUFFIX=".so"
            DL_OBJS="tclLoadDl.o"
            DL_OBJS="tclLoadDl.o"
            DL_LIBS="-ldl"
            DL_LIBS="-ldl"
 
 
            #-----------------------------------------------------------
            #-----------------------------------------------------------
            # Check for inet_ntoa in -lbind, for BeOS (which also needs
            # Check for inet_ntoa in -lbind, for BeOS (which also needs
            # -lsocket, even if the network functions are in -lnet which
            # -lsocket, even if the network functions are in -lnet which
            # is always linked to, for compatibility.
            # is always linked to, for compatibility.
            #-----------------------------------------------------------
            #-----------------------------------------------------------
            AC_CHECK_LIB(bind, inet_ntoa, [LIBS="$LIBS -lbind -lsocket"])
            AC_CHECK_LIB(bind, inet_ntoa, [LIBS="$LIBS -lbind -lsocket"])
            ;;
            ;;
        BSD/OS-2.1*|BSD/OS-3*)
        BSD/OS-2.1*|BSD/OS-3*)
            SHLIB_CFLAGS=""
            SHLIB_CFLAGS=""
            SHLIB_LD="shlicc -r"
            SHLIB_LD="shlicc -r"
            SHLIB_LD_LIBS='${LIBS}'
            SHLIB_LD_LIBS='${LIBS}'
            SHLIB_SUFFIX=".so"
            SHLIB_SUFFIX=".so"
            DL_OBJS="tclLoadDl.o"
            DL_OBJS="tclLoadDl.o"
            DL_LIBS="-ldl"
            DL_LIBS="-ldl"
            CC_SEARCH_FLAGS=""
            CC_SEARCH_FLAGS=""
            LD_SEARCH_FLAGS=""
            LD_SEARCH_FLAGS=""
            ;;
            ;;
        BSD/OS-4.*)
        BSD/OS-4.*)
            SHLIB_CFLAGS="-export-dynamic -fPIC"
            SHLIB_CFLAGS="-export-dynamic -fPIC"
            SHLIB_LD="cc -shared"
            SHLIB_LD="cc -shared"
            SHLIB_LD_LIBS='${LIBS}'
            SHLIB_LD_LIBS='${LIBS}'
            SHLIB_SUFFIX=".so"
            SHLIB_SUFFIX=".so"
            DL_OBJS="tclLoadDl.o"
            DL_OBJS="tclLoadDl.o"
            DL_LIBS="-ldl"
            DL_LIBS="-ldl"
            LDFLAGS="$LDFLAGS -export-dynamic"
            LDFLAGS="$LDFLAGS -export-dynamic"
            CC_SEARCH_FLAGS=""
            CC_SEARCH_FLAGS=""
            LD_SEARCH_FLAGS=""
            LD_SEARCH_FLAGS=""
            ;;
            ;;
        dgux*)
        dgux*)
            SHLIB_CFLAGS="-K PIC"
            SHLIB_CFLAGS="-K PIC"
            SHLIB_LD="cc -G"
            SHLIB_LD="cc -G"
            SHLIB_LD_LIBS=""
            SHLIB_LD_LIBS=""
            SHLIB_SUFFIX=".so"
            SHLIB_SUFFIX=".so"
            DL_OBJS="tclLoadDl.o"
            DL_OBJS="tclLoadDl.o"
            DL_LIBS="-ldl"
            DL_LIBS="-ldl"
            CC_SEARCH_FLAGS=""
            CC_SEARCH_FLAGS=""
            LD_SEARCH_FLAGS=""
            LD_SEARCH_FLAGS=""
            ;;
            ;;
        HP-UX-*.11.*)
        HP-UX-*.11.*)
            # Use updated header definitions where possible
            # Use updated header definitions where possible
            AC_DEFINE(_XOPEN_SOURCE)          # Use the XOPEN network library
            AC_DEFINE(_XOPEN_SOURCE)          # Use the XOPEN network library
            AC_DEFINE(_XOPEN_SOURCE_EXTENDED) # Use the XOPEN network library
            AC_DEFINE(_XOPEN_SOURCE_EXTENDED) # Use the XOPEN network library
            LIBS="$LIBS -lxnet"               # Use the XOPEN network library
            LIBS="$LIBS -lxnet"               # Use the XOPEN network library
 
 
            if test "`uname -m`" = "ia64" ; then
            if test "`uname -m`" = "ia64" ; then
                SHLIB_SUFFIX=".so"
                SHLIB_SUFFIX=".so"
            else
            else
                SHLIB_SUFFIX=".sl"
                SHLIB_SUFFIX=".sl"
            fi
            fi
            AC_CHECK_LIB(dld, shl_load, tcl_ok=yes, tcl_ok=no)
            AC_CHECK_LIB(dld, shl_load, tcl_ok=yes, tcl_ok=no)
            if test "$tcl_ok" = yes; then
            if test "$tcl_ok" = yes; then
                SHLIB_CFLAGS="+z"
                SHLIB_CFLAGS="+z"
                SHLIB_LD="ld -b"
                SHLIB_LD="ld -b"
                SHLIB_LD_LIBS='${LIBS}'
                SHLIB_LD_LIBS='${LIBS}'
                DL_OBJS="tclLoadShl.o"
                DL_OBJS="tclLoadShl.o"
                DL_LIBS="-ldld"
                DL_LIBS="-ldld"
                LDFLAGS="$LDFLAGS -Wl,-E"
                LDFLAGS="$LDFLAGS -Wl,-E"
                CC_SEARCH_FLAGS='-Wl,+s,+b,${LIB_RUNTIME_DIR}:.'
                CC_SEARCH_FLAGS='-Wl,+s,+b,${LIB_RUNTIME_DIR}:.'
                LD_SEARCH_FLAGS='+s +b ${LIB_RUNTIME_DIR}:.'
                LD_SEARCH_FLAGS='+s +b ${LIB_RUNTIME_DIR}:.'
                LD_LIBRARY_PATH_VAR="SHLIB_PATH"
                LD_LIBRARY_PATH_VAR="SHLIB_PATH"
            fi
            fi
            if test "$GCC" = "yes" ; then
            if test "$GCC" = "yes" ; then
                SHLIB_LD="gcc -shared"
                SHLIB_LD="gcc -shared"
                SHLIB_LD_LIBS='${LIBS}'
                SHLIB_LD_LIBS='${LIBS}'
                LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS}
                LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS}
            fi
            fi
 
 
            # Users may want PA-RISC 1.1/2.0 portable code - needs HP cc
            # Users may want PA-RISC 1.1/2.0 portable code - needs HP cc
            #CFLAGS="$CFLAGS +DAportable"
            #CFLAGS="$CFLAGS +DAportable"
 
 
            # Check to enable 64-bit flags for compiler/linker
            # Check to enable 64-bit flags for compiler/linker
            if test "$do64bit" = "yes" ; then
            if test "$do64bit" = "yes" ; then
                if test "$GCC" = "yes" ; then
                if test "$GCC" = "yes" ; then
                    hpux_arch=`${CC} -dumpmachine`
                    hpux_arch=`${CC} -dumpmachine`
                    case $hpux_arch in
                    case $hpux_arch in
                        hppa64*)
                        hppa64*)
                            # 64-bit gcc in use.  Fix flags for GNU ld.
                            # 64-bit gcc in use.  Fix flags for GNU ld.
                            do64bit_ok=yes
                            do64bit_ok=yes
                            SHLIB_LD="${CC} -shared"
                            SHLIB_LD="${CC} -shared"
                            SHLIB_LD_LIBS='${LIBS}'
                            SHLIB_LD_LIBS='${LIBS}'
                            CC_SEARCH_FLAGS='-Wl,-rpath,${LIB_RUNTIME_DIR}'
                            CC_SEARCH_FLAGS='-Wl,-rpath,${LIB_RUNTIME_DIR}'
                            LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS}
                            LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS}
                            ;;
                            ;;
                        *)
                        *)
                            AC_MSG_WARN([64bit mode not supported with GCC on $system])
                            AC_MSG_WARN([64bit mode not supported with GCC on $system])
                            ;;
                            ;;
                    esac
                    esac
                else
                else
                    do64bit_ok=yes
                    do64bit_ok=yes
                    CFLAGS="$CFLAGS +DD64"
                    CFLAGS="$CFLAGS +DD64"
                    LDFLAGS="$LDFLAGS +DD64"
                    LDFLAGS="$LDFLAGS +DD64"
                fi
                fi
            fi
            fi
            ;;
            ;;
        HP-UX-*.08.*|HP-UX-*.09.*|HP-UX-*.10.*)
        HP-UX-*.08.*|HP-UX-*.09.*|HP-UX-*.10.*)
            SHLIB_SUFFIX=".sl"
            SHLIB_SUFFIX=".sl"
            AC_CHECK_LIB(dld, shl_load, tcl_ok=yes, tcl_ok=no)
            AC_CHECK_LIB(dld, shl_load, tcl_ok=yes, tcl_ok=no)
            if test "$tcl_ok" = yes; then
            if test "$tcl_ok" = yes; then
                SHLIB_CFLAGS="+z"
                SHLIB_CFLAGS="+z"
                SHLIB_LD="ld -b"
                SHLIB_LD="ld -b"
                SHLIB_LD_LIBS=""
                SHLIB_LD_LIBS=""
                DL_OBJS="tclLoadShl.o"
                DL_OBJS="tclLoadShl.o"
                DL_LIBS="-ldld"
                DL_LIBS="-ldld"
                LDFLAGS="$LDFLAGS -Wl,-E"
                LDFLAGS="$LDFLAGS -Wl,-E"
                CC_SEARCH_FLAGS='-Wl,+s,+b,${LIB_RUNTIME_DIR}:.'
                CC_SEARCH_FLAGS='-Wl,+s,+b,${LIB_RUNTIME_DIR}:.'
                LD_SEARCH_FLAGS='+s +b ${LIB_RUNTIME_DIR}:.'
                LD_SEARCH_FLAGS='+s +b ${LIB_RUNTIME_DIR}:.'
                LD_LIBRARY_PATH_VAR="SHLIB_PATH"
                LD_LIBRARY_PATH_VAR="SHLIB_PATH"
            fi
            fi
            ;;
            ;;
        IRIX-4.*)
        IRIX-4.*)
            SHLIB_CFLAGS="-G 0"
            SHLIB_CFLAGS="-G 0"
            SHLIB_SUFFIX=".a"
            SHLIB_SUFFIX=".a"
            SHLIB_LD="echo tclLdAout $CC \{$SHLIB_CFLAGS\} | `pwd`/tclsh -r -G 0"
            SHLIB_LD="echo tclLdAout $CC \{$SHLIB_CFLAGS\} | `pwd`/tclsh -r -G 0"
            SHLIB_LD_LIBS='${LIBS}'
            SHLIB_LD_LIBS='${LIBS}'
            DL_OBJS="tclLoadAout.o"
            DL_OBJS="tclLoadAout.o"
            DL_LIBS=""
            DL_LIBS=""
            LDFLAGS="$LDFLAGS -Wl,-D,08000000"
            LDFLAGS="$LDFLAGS -Wl,-D,08000000"
            CC_SEARCH_FLAGS='-L${LIB_RUNTIME_DIR}'
            CC_SEARCH_FLAGS='-L${LIB_RUNTIME_DIR}'
            LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS}
            LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS}
            SHARED_LIB_SUFFIX='${VERSION}\$\{DBGX\}.a'
            SHARED_LIB_SUFFIX='${VERSION}\$\{DBGX\}.a'
            ;;
            ;;
        IRIX-5.*)
        IRIX-5.*)
            SHLIB_CFLAGS=""
            SHLIB_CFLAGS=""
            SHLIB_LD="ld -shared -rdata_shared"
            SHLIB_LD="ld -shared -rdata_shared"
            SHLIB_LD_LIBS='${LIBS}'
            SHLIB_LD_LIBS='${LIBS}'
            SHLIB_SUFFIX=".so"
            SHLIB_SUFFIX=".so"
            DL_OBJS="tclLoadDl.o"
            DL_OBJS="tclLoadDl.o"
            DL_LIBS=""
            DL_LIBS=""
            CC_SEARCH_FLAGS='-Wl,-rpath,${LIB_RUNTIME_DIR}'
            CC_SEARCH_FLAGS='-Wl,-rpath,${LIB_RUNTIME_DIR}'
            LD_SEARCH_FLAGS='-rpath ${LIB_RUNTIME_DIR}'
            LD_SEARCH_FLAGS='-rpath ${LIB_RUNTIME_DIR}'
            ;;
            ;;
        IRIX-6.*)
        IRIX-6.*)
            SHLIB_CFLAGS=""
            SHLIB_CFLAGS=""
            SHLIB_LD="ld -n32 -shared -rdata_shared"
            SHLIB_LD="ld -n32 -shared -rdata_shared"
            SHLIB_LD_LIBS='${LIBS}'
            SHLIB_LD_LIBS='${LIBS}'
            SHLIB_SUFFIX=".so"
            SHLIB_SUFFIX=".so"
            DL_OBJS="tclLoadDl.o"
            DL_OBJS="tclLoadDl.o"
            DL_LIBS=""
            DL_LIBS=""
            CC_SEARCH_FLAGS='-Wl,-rpath,${LIB_RUNTIME_DIR}'
            CC_SEARCH_FLAGS='-Wl,-rpath,${LIB_RUNTIME_DIR}'
            LD_SEARCH_FLAGS='-rpath ${LIB_RUNTIME_DIR}'
            LD_SEARCH_FLAGS='-rpath ${LIB_RUNTIME_DIR}'
            if test "$GCC" = "yes" ; then
            if test "$GCC" = "yes" ; then
                CFLAGS="$CFLAGS -mabi=n32"
                CFLAGS="$CFLAGS -mabi=n32"
                LDFLAGS="$LDFLAGS -mabi=n32"
                LDFLAGS="$LDFLAGS -mabi=n32"
            else
            else
                case $system in
                case $system in
                    IRIX-6.3)
                    IRIX-6.3)
                        # Use to build 6.2 compatible binaries on 6.3.
                        # Use to build 6.2 compatible binaries on 6.3.
                        CFLAGS="$CFLAGS -n32 -D_OLD_TERMIOS"
                        CFLAGS="$CFLAGS -n32 -D_OLD_TERMIOS"
                        ;;
                        ;;
                    *)
                    *)
                        CFLAGS="$CFLAGS -n32"
                        CFLAGS="$CFLAGS -n32"
                        ;;
                        ;;
                esac
                esac
                LDFLAGS="$LDFLAGS -n32"
                LDFLAGS="$LDFLAGS -n32"
            fi
            fi
            ;;
            ;;
        IRIX64-6.*)
        IRIX64-6.*)
            SHLIB_CFLAGS=""
            SHLIB_CFLAGS=""
            SHLIB_LD="ld -n32 -shared -rdata_shared"
            SHLIB_LD="ld -n32 -shared -rdata_shared"
            SHLIB_LD_LIBS='${LIBS}'
            SHLIB_LD_LIBS='${LIBS}'
            SHLIB_SUFFIX=".so"
            SHLIB_SUFFIX=".so"
            DL_OBJS="tclLoadDl.o"
            DL_OBJS="tclLoadDl.o"
            DL_LIBS=""
            DL_LIBS=""
            CC_SEARCH_FLAGS='-Wl,-rpath,${LIB_RUNTIME_DIR}'
            CC_SEARCH_FLAGS='-Wl,-rpath,${LIB_RUNTIME_DIR}'
            LD_SEARCH_FLAGS='-rpath ${LIB_RUNTIME_DIR}'
            LD_SEARCH_FLAGS='-rpath ${LIB_RUNTIME_DIR}'
 
 
            # Check to enable 64-bit flags for compiler/linker
            # Check to enable 64-bit flags for compiler/linker
 
 
            if test "$do64bit" = "yes" ; then
            if test "$do64bit" = "yes" ; then
                if test "$GCC" = "yes" ; then
                if test "$GCC" = "yes" ; then
                    AC_MSG_WARN([64bit mode not supported by gcc])
                    AC_MSG_WARN([64bit mode not supported by gcc])
                else
                else
                    do64bit_ok=yes
                    do64bit_ok=yes
                    SHLIB_LD="ld -64 -shared -rdata_shared"
                    SHLIB_LD="ld -64 -shared -rdata_shared"
                    CFLAGS="$CFLAGS -64"
                    CFLAGS="$CFLAGS -64"
                    LDFLAGS="$LDFLAGS -64"
                    LDFLAGS="$LDFLAGS -64"
                fi
                fi
            fi
            fi
            ;;
            ;;
        Linux*)
        Linux*)
            SHLIB_CFLAGS="-fPIC"
            SHLIB_CFLAGS="-fPIC"
            SHLIB_LD_LIBS='${LIBS}'
            SHLIB_LD_LIBS='${LIBS}'
            SHLIB_SUFFIX=".so"
            SHLIB_SUFFIX=".so"
 
 
            CFLAGS_OPTIMIZE=-O2
            CFLAGS_OPTIMIZE=-O2
            # egcs-2.91.66 on Redhat Linux 6.0 generates lots of warnings
            # egcs-2.91.66 on Redhat Linux 6.0 generates lots of warnings
            # when you inline the string and math operations.  Turn this off to
            # when you inline the string and math operations.  Turn this off to
            # get rid of the warnings.
            # get rid of the warnings.
            #CFLAGS_OPTIMIZE="${CFLAGS_OPTIMIZE} -D__NO_STRING_INLINES -D__NO_MATH_INLINES"
            #CFLAGS_OPTIMIZE="${CFLAGS_OPTIMIZE} -D__NO_STRING_INLINES -D__NO_MATH_INLINES"
 
 
            if test "$have_dl" = yes; then
            if test "$have_dl" = yes; then
                SHLIB_LD='${CC} -shared ${CFLAGS} ${LDFLAGS}'
                SHLIB_LD='${CC} -shared ${CFLAGS} ${LDFLAGS}'
                DL_OBJS="tclLoadDl.o"
                DL_OBJS="tclLoadDl.o"
                DL_LIBS="-ldl"
                DL_LIBS="-ldl"
                LDFLAGS="$LDFLAGS -Wl,--export-dynamic"
                LDFLAGS="$LDFLAGS -Wl,--export-dynamic"
                CC_SEARCH_FLAGS='-Wl,-rpath,${LIB_RUNTIME_DIR}'
                CC_SEARCH_FLAGS='-Wl,-rpath,${LIB_RUNTIME_DIR}'
                LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS}
                LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS}
            else
            else
                AC_CHECK_HEADER(dld.h, [
                AC_CHECK_HEADER(dld.h, [
                    SHLIB_LD="ld -shared"
                    SHLIB_LD="ld -shared"
                    DL_OBJS="tclLoadDld.o"
                    DL_OBJS="tclLoadDld.o"
                    DL_LIBS="-ldld"
                    DL_LIBS="-ldld"
                    CC_SEARCH_FLAGS=""
                    CC_SEARCH_FLAGS=""
                    LD_SEARCH_FLAGS=""])
                    LD_SEARCH_FLAGS=""])
            fi
            fi
            if test "`uname -m`" = "alpha" ; then
            if test "`uname -m`" = "alpha" ; then
                CFLAGS="$CFLAGS -mieee"
                CFLAGS="$CFLAGS -mieee"
            fi
            fi
            if test $do64bit = yes; then
            if test $do64bit = yes; then
                AC_CACHE_CHECK([if compiler accepts -m64 flag], tcl_cv_cc_m64, [
                AC_CACHE_CHECK([if compiler accepts -m64 flag], tcl_cv_cc_m64, [
                    hold_cflags=$CFLAGS
                    hold_cflags=$CFLAGS
                    CFLAGS="$CFLAGS -m64"
                    CFLAGS="$CFLAGS -m64"
                    AC_TRY_LINK(,, tcl_cv_cc_m64=yes, tcl_cv_cc_m64=no)
                    AC_TRY_LINK(,, tcl_cv_cc_m64=yes, tcl_cv_cc_m64=no)
                    CFLAGS=$hold_cflags])
                    CFLAGS=$hold_cflags])
                if test $tcl_cv_cc_m64 = yes; then
                if test $tcl_cv_cc_m64 = yes; then
                    CFLAGS="$CFLAGS -m64"
                    CFLAGS="$CFLAGS -m64"
                    do64bit_ok=yes
                    do64bit_ok=yes
                fi
                fi
            fi
            fi
 
 
            # The combo of gcc + glibc has a bug related
            # The combo of gcc + glibc has a bug related
            # to inlining of functions like strtod(). The
            # to inlining of functions like strtod(). The
            # -fno-builtin flag should address this problem
            # -fno-builtin flag should address this problem
            # but it does not work. The -fno-inline flag
            # but it does not work. The -fno-inline flag
            # is kind of overkill but it works.
            # is kind of overkill but it works.
            # Disable inlining only when one of the
            # Disable inlining only when one of the
            # files in compat/*.c is being linked in.
            # files in compat/*.c is being linked in.
            if test x"${LIBOBJS}" != x ; then
            if test x"${LIBOBJS}" != x ; then
                CFLAGS="$CFLAGS -fno-inline"
                CFLAGS="$CFLAGS -fno-inline"
            fi
            fi
 
 
            # XIM peeking works under XFree86.
            # XIM peeking works under XFree86.
            AC_DEFINE(PEEK_XCLOSEIM)
            AC_DEFINE(PEEK_XCLOSEIM)
 
 
            ;;
            ;;
        GNU*)
        GNU*)
            SHLIB_CFLAGS="-fPIC"
            SHLIB_CFLAGS="-fPIC"
            SHLIB_LD_LIBS='${LIBS}'
            SHLIB_LD_LIBS='${LIBS}'
            SHLIB_SUFFIX=".so"
            SHLIB_SUFFIX=".so"
 
 
            if test "$have_dl" = yes; then
            if test "$have_dl" = yes; then
                SHLIB_LD="${CC} -shared"
                SHLIB_LD="${CC} -shared"
                DL_OBJS=""
                DL_OBJS=""
                DL_LIBS="-ldl"
                DL_LIBS="-ldl"
                LDFLAGS="$LDFLAGS -Wl,--export-dynamic"
                LDFLAGS="$LDFLAGS -Wl,--export-dynamic"
                CC_SEARCH_FLAGS=""
                CC_SEARCH_FLAGS=""
                LD_SEARCH_FLAGS=""
                LD_SEARCH_FLAGS=""
            else
            else
                AC_CHECK_HEADER(dld.h, [
                AC_CHECK_HEADER(dld.h, [
                    SHLIB_LD="ld -shared"
                    SHLIB_LD="ld -shared"
                    DL_OBJS=""
                    DL_OBJS=""
                    DL_LIBS="-ldld"
                    DL_LIBS="-ldld"
                    CC_SEARCH_FLAGS=""
                    CC_SEARCH_FLAGS=""
                    LD_SEARCH_FLAGS=""])
                    LD_SEARCH_FLAGS=""])
            fi
            fi
            if test "`uname -m`" = "alpha" ; then
            if test "`uname -m`" = "alpha" ; then
                CFLAGS="$CFLAGS -mieee"
                CFLAGS="$CFLAGS -mieee"
            fi
            fi
            ;;
            ;;
        Lynx*)
        Lynx*)
            SHLIB_CFLAGS="-fPIC"
            SHLIB_CFLAGS="-fPIC"
            SHLIB_LD_LIBS='${LIBS}'
            SHLIB_LD_LIBS='${LIBS}'
            SHLIB_SUFFIX=".so"
            SHLIB_SUFFIX=".so"
            CFLAGS_OPTIMIZE=-02
            CFLAGS_OPTIMIZE=-02
            SHLIB_LD="${CC} -shared "
            SHLIB_LD="${CC} -shared "
            DL_OBJS="tclLoadDl.o"
            DL_OBJS="tclLoadDl.o"
            DL_LIBS="-mshared -ldl"
            DL_LIBS="-mshared -ldl"
            LD_FLAGS="-Wl,--export-dynamic"
            LD_FLAGS="-Wl,--export-dynamic"
            CC_SEARCH_FLAGS='-Wl,-rpath,${LIB_RUNTIME_DIR}'
            CC_SEARCH_FLAGS='-Wl,-rpath,${LIB_RUNTIME_DIR}'
            LD_SEARCH_FLAGS='-Wl,-rpath,${LIB_RUNTIME_DIR}'
            LD_SEARCH_FLAGS='-Wl,-rpath,${LIB_RUNTIME_DIR}'
            ;;
            ;;
        MP-RAS-02*)
        MP-RAS-02*)
            SHLIB_CFLAGS="-K PIC"
            SHLIB_CFLAGS="-K PIC"
            SHLIB_LD="cc -G"
            SHLIB_LD="cc -G"
            SHLIB_LD_LIBS=""
            SHLIB_LD_LIBS=""
            SHLIB_SUFFIX=".so"
            SHLIB_SUFFIX=".so"
            DL_OBJS="tclLoadDl.o"
            DL_OBJS="tclLoadDl.o"
            DL_LIBS="-ldl"
            DL_LIBS="-ldl"
            CC_SEARCH_FLAGS=""
            CC_SEARCH_FLAGS=""
            LD_SEARCH_FLAGS=""
            LD_SEARCH_FLAGS=""
            ;;
            ;;
        MP-RAS-*)
        MP-RAS-*)
            SHLIB_CFLAGS="-K PIC"
            SHLIB_CFLAGS="-K PIC"
            SHLIB_LD="cc -G"
            SHLIB_LD="cc -G"
            SHLIB_LD_LIBS=""
            SHLIB_LD_LIBS=""
            SHLIB_SUFFIX=".so"
            SHLIB_SUFFIX=".so"
            DL_OBJS="tclLoadDl.o"
            DL_OBJS="tclLoadDl.o"
            DL_LIBS="-ldl"
            DL_LIBS="-ldl"
            LDFLAGS="$LDFLAGS -Wl,-Bexport"
            LDFLAGS="$LDFLAGS -Wl,-Bexport"
            CC_SEARCH_FLAGS=""
            CC_SEARCH_FLAGS=""
            LD_SEARCH_FLAGS=""
            LD_SEARCH_FLAGS=""
            ;;
            ;;
        NetBSD-*|FreeBSD-[[1-2]].*)
        NetBSD-*|FreeBSD-[[1-2]].*)
            # Not available on all versions:  check for include file.
            # Not available on all versions:  check for include file.
            AC_CHECK_HEADER(dlfcn.h, [
            AC_CHECK_HEADER(dlfcn.h, [
                # NetBSD/SPARC needs -fPIC, -fpic will not do.
                # NetBSD/SPARC needs -fPIC, -fpic will not do.
                SHLIB_CFLAGS="-fPIC"
                SHLIB_CFLAGS="-fPIC"
                SHLIB_LD="ld -Bshareable -x"
                SHLIB_LD="ld -Bshareable -x"
                SHLIB_LD_LIBS='${LIBS}'
                SHLIB_LD_LIBS='${LIBS}'
                SHLIB_SUFFIX=".so"
                SHLIB_SUFFIX=".so"
                DL_OBJS="tclLoadDl.o"
                DL_OBJS="tclLoadDl.o"
                DL_LIBS=""
                DL_LIBS=""
                CC_SEARCH_FLAGS='-Wl,-rpath,${LIB_RUNTIME_DIR}'
                CC_SEARCH_FLAGS='-Wl,-rpath,${LIB_RUNTIME_DIR}'
                LD_SEARCH_FLAGS='-rpath ${LIB_RUNTIME_DIR}'
                LD_SEARCH_FLAGS='-rpath ${LIB_RUNTIME_DIR}'
                AC_CACHE_CHECK([for ELF], tcl_cv_ld_elf, [
                AC_CACHE_CHECK([for ELF], tcl_cv_ld_elf, [
                    AC_EGREP_CPP(yes, [
                    AC_EGREP_CPP(yes, [
#ifdef __ELF__
#ifdef __ELF__
        yes
        yes
#endif
#endif
                    ], tcl_cv_ld_elf=yes, tcl_cv_ld_elf=no)])
                    ], tcl_cv_ld_elf=yes, tcl_cv_ld_elf=no)])
                if test $tcl_cv_ld_elf = yes; then
                if test $tcl_cv_ld_elf = yes; then
                    SHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}\$\{DBGX\}.so'
                    SHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}\$\{DBGX\}.so'
                else
                else
                    SHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}\$\{DBGX\}.so.1.0'
                    SHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}\$\{DBGX\}.so.1.0'
                fi
                fi
            ], [
            ], [
                SHLIB_CFLAGS=""
                SHLIB_CFLAGS=""
                SHLIB_LD="echo tclLdAout $CC \{$SHLIB_CFLAGS\} | `pwd`/tclsh -r"
                SHLIB_LD="echo tclLdAout $CC \{$SHLIB_CFLAGS\} | `pwd`/tclsh -r"
                SHLIB_LD_LIBS='${LIBS}'
                SHLIB_LD_LIBS='${LIBS}'
                SHLIB_SUFFIX=".a"
                SHLIB_SUFFIX=".a"
                DL_OBJS="tclLoadAout.o"
                DL_OBJS="tclLoadAout.o"
                DL_LIBS=""
                DL_LIBS=""
                CC_SEARCH_FLAGS='-L${LIB_RUNTIME_DIR}'
                CC_SEARCH_FLAGS='-L${LIB_RUNTIME_DIR}'
                LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS}
                LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS}
                SHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}\$\{DBGX\}.a'
                SHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}\$\{DBGX\}.a'
            ])
            ])
 
 
            # FreeBSD doesn't handle version numbers with dots.
            # FreeBSD doesn't handle version numbers with dots.
 
 
            UNSHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}\$\{DBGX\}.a'
            UNSHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}\$\{DBGX\}.a'
            TCL_LIB_VERSIONS_OK=nodots
            TCL_LIB_VERSIONS_OK=nodots
            ;;
            ;;
        OpenBSD-*)
        OpenBSD-*)
            case `arch -s` in
            case `arch -s` in
            m88k|vax)
            m88k|vax)
                SHLIB_CFLAGS=""
                SHLIB_CFLAGS=""
                SHLIB_LD="echo tclLdAout $CC \{$SHLIB_CFLAGS\} | `pwd`/tclsh -r"
                SHLIB_LD="echo tclLdAout $CC \{$SHLIB_CFLAGS\} | `pwd`/tclsh -r"
                SHLIB_LD_LIBS='${LIBS}'
                SHLIB_LD_LIBS='${LIBS}'
                SHLIB_SUFFIX=".a"
                SHLIB_SUFFIX=".a"
                DL_OBJS="tclLoadAout.o"
                DL_OBJS="tclLoadAout.o"
                DL_LIBS=""
                DL_LIBS=""
                LDFLAGS=""
                LDFLAGS=""
                CC_SEARCH_FLAGS='-L${LIB_RUNTIME_DIR}'
                CC_SEARCH_FLAGS='-L${LIB_RUNTIME_DIR}'
                LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS}
                LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS}
                SHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}\$\{DBGX\}.a'
                SHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}\$\{DBGX\}.a'
                ;;
                ;;
            *)
            *)
                # OpenBSD/SPARC[64] needs -fPIC, -fpic will not do.
                # OpenBSD/SPARC[64] needs -fPIC, -fpic will not do.
                case `machine` in
                case `machine` in
                sparc|sparc64)
                sparc|sparc64)
                    SHLIB_CFLAGS="-fPIC";;
                    SHLIB_CFLAGS="-fPIC";;
                *)
                *)
                    SHLIB_CFLAGS="-fpic";;
                    SHLIB_CFLAGS="-fpic";;
                esac
                esac
                SHLIB_LD="${CC} -shared ${SHLIB_CFLAGS}"
                SHLIB_LD="${CC} -shared ${SHLIB_CFLAGS}"
                SHLIB_LD_LIBS='${LIBS}'
                SHLIB_LD_LIBS='${LIBS}'
                SHLIB_SUFFIX=".so"
                SHLIB_SUFFIX=".so"
                DL_OBJS="tclLoadDl.o"
                DL_OBJS="tclLoadDl.o"
                DL_LIBS=""
                DL_LIBS=""
                CC_SEARCH_FLAGS='-Wl,-rpath,${LIB_RUNTIME_DIR}'
                CC_SEARCH_FLAGS='-Wl,-rpath,${LIB_RUNTIME_DIR}'
                LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS}
                LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS}
                SHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}\$\{DBGX\}.so.1.0'
                SHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}\$\{DBGX\}.so.1.0'
                AC_CACHE_CHECK([for ELF], tcl_cv_ld_elf, [
                AC_CACHE_CHECK([for ELF], tcl_cv_ld_elf, [
                    AC_EGREP_CPP(yes, [
                    AC_EGREP_CPP(yes, [
#ifdef __ELF__
#ifdef __ELF__
        yes
        yes
#endif
#endif
                    ], tcl_cv_ld_elf=yes, tcl_cv_ld_elf=no)])
                    ], tcl_cv_ld_elf=yes, tcl_cv_ld_elf=no)])
                if test $tcl_cv_ld_elf = yes; then
                if test $tcl_cv_ld_elf = yes; then
                    LDFLAGS=-Wl,-export-dynamic
                    LDFLAGS=-Wl,-export-dynamic
                else
                else
                    LDFLAGS=""
                    LDFLAGS=""
                fi
                fi
                ;;
                ;;
            esac
            esac
 
 
            # OpenBSD doesn't do version numbers with dots.
            # OpenBSD doesn't do version numbers with dots.
            UNSHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}\$\{DBGX\}.a'
            UNSHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}\$\{DBGX\}.a'
            TCL_LIB_VERSIONS_OK=nodots
            TCL_LIB_VERSIONS_OK=nodots
            ;;
            ;;
        FreeBSD-*)
        FreeBSD-*)
            # FreeBSD 3.* and greater have ELF.
            # FreeBSD 3.* and greater have ELF.
            SHLIB_CFLAGS="-fPIC"
            SHLIB_CFLAGS="-fPIC"
            SHLIB_LD="ld -Bshareable -x"
            SHLIB_LD="ld -Bshareable -x"
            SHLIB_LD_LIBS='${LIBS}'
            SHLIB_LD_LIBS='${LIBS}'
            SHLIB_SUFFIX=".so"
            SHLIB_SUFFIX=".so"
            DL_OBJS="tclLoadDl.o"
            DL_OBJS="tclLoadDl.o"
            DL_LIBS=""
            DL_LIBS=""
            LDFLAGS="$LDFLAGS -export-dynamic"
            LDFLAGS="$LDFLAGS -export-dynamic"
            CC_SEARCH_FLAGS='-Wl,-rpath,${LIB_RUNTIME_DIR}'
            CC_SEARCH_FLAGS='-Wl,-rpath,${LIB_RUNTIME_DIR}'
            LD_SEARCH_FLAGS='-rpath ${LIB_RUNTIME_DIR}'
            LD_SEARCH_FLAGS='-rpath ${LIB_RUNTIME_DIR}'
            if test "${TCL_THREADS}" = "1" ; then
            if test "${TCL_THREADS}" = "1" ; then
                # The -pthread needs to go in the CFLAGS, not LIBS
                # The -pthread needs to go in the CFLAGS, not LIBS
                LIBS=`echo $LIBS | sed s/-pthread//`
                LIBS=`echo $LIBS | sed s/-pthread//`
                CFLAGS="$CFLAGS -pthread"
                CFLAGS="$CFLAGS -pthread"
                LDFLAGS="$LDFLAGS -pthread"
                LDFLAGS="$LDFLAGS -pthread"
            fi
            fi
            case $system in
            case $system in
            FreeBSD-3.*)
            FreeBSD-3.*)
                # FreeBSD-3 doesn't handle version numbers with dots.
                # FreeBSD-3 doesn't handle version numbers with dots.
                UNSHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}\$\{DBGX\}.a'
                UNSHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}\$\{DBGX\}.a'
                SHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}\$\{DBGX\}.so'
                SHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}\$\{DBGX\}.so'
                TCL_LIB_VERSIONS_OK=nodots
                TCL_LIB_VERSIONS_OK=nodots
                ;;
                ;;
            esac
            esac
            ;;
            ;;
        Darwin-*)
        Darwin-*)
            CFLAGS_OPTIMIZE="-Os"
            CFLAGS_OPTIMIZE="-Os"
            SHLIB_CFLAGS="-fno-common"
            SHLIB_CFLAGS="-fno-common"
            # To avoid discrepancies between what headers configure sees during
            # To avoid discrepancies between what headers configure sees during
            # preprocessing tests and compiling tests, move any -isysroot and
            # preprocessing tests and compiling tests, move any -isysroot and
            # -mmacosx-version-min flags from CFLAGS to CPPFLAGS:
            # -mmacosx-version-min flags from CFLAGS to CPPFLAGS:
            CPPFLAGS="${CPPFLAGS} `echo " ${CFLAGS}" | \
            CPPFLAGS="${CPPFLAGS} `echo " ${CFLAGS}" | \
                awk 'BEGIN {FS=" +-";ORS=" "}; {for (i=2;i<=NF;i++) \
                awk 'BEGIN {FS=" +-";ORS=" "}; {for (i=2;i<=NF;i++) \
                if ([$]i~/^(isysroot|mmacosx-version-min)/) print "-"[$]i}'`"
                if ([$]i~/^(isysroot|mmacosx-version-min)/) print "-"[$]i}'`"
            CFLAGS="`echo " ${CFLAGS}" | \
            CFLAGS="`echo " ${CFLAGS}" | \
                awk 'BEGIN {FS=" +-";ORS=" "}; {for (i=2;i<=NF;i++) \
                awk 'BEGIN {FS=" +-";ORS=" "}; {for (i=2;i<=NF;i++) \
                if (!([$]i~/^(isysroot|mmacosx-version-min)/)) print "-"[$]i}'`"
                if (!([$]i~/^(isysroot|mmacosx-version-min)/)) print "-"[$]i}'`"
            if test $do64bit = yes; then
            if test $do64bit = yes; then
                case `arch` in
                case `arch` in
                    ppc)
                    ppc)
                        AC_CACHE_CHECK([if compiler accepts -arch ppc64 flag],
                        AC_CACHE_CHECK([if compiler accepts -arch ppc64 flag],
                                tcl_cv_cc_arch_ppc64, [
                                tcl_cv_cc_arch_ppc64, [
                            hold_cflags=$CFLAGS
                            hold_cflags=$CFLAGS
                            CFLAGS="$CFLAGS -arch ppc64 -mpowerpc64 -mcpu=G5"
                            CFLAGS="$CFLAGS -arch ppc64 -mpowerpc64 -mcpu=G5"
                            AC_TRY_LINK(,, tcl_cv_cc_arch_ppc64=yes,
                            AC_TRY_LINK(,, tcl_cv_cc_arch_ppc64=yes,
                                    tcl_cv_cc_arch_ppc64=no)
                                    tcl_cv_cc_arch_ppc64=no)
                            CFLAGS=$hold_cflags])
                            CFLAGS=$hold_cflags])
                        if test $tcl_cv_cc_arch_ppc64 = yes; then
                        if test $tcl_cv_cc_arch_ppc64 = yes; then
                            CFLAGS="$CFLAGS -arch ppc64 -mpowerpc64 -mcpu=G5"
                            CFLAGS="$CFLAGS -arch ppc64 -mpowerpc64 -mcpu=G5"
                            do64bit_ok=yes
                            do64bit_ok=yes
                        fi;;
                        fi;;
                    i386)
                    i386)
                        AC_CACHE_CHECK([if compiler accepts -arch x86_64 flag],
                        AC_CACHE_CHECK([if compiler accepts -arch x86_64 flag],
                                tcl_cv_cc_arch_x86_64, [
                                tcl_cv_cc_arch_x86_64, [
                            hold_cflags=$CFLAGS
                            hold_cflags=$CFLAGS
                            CFLAGS="$CFLAGS -arch x86_64"
                            CFLAGS="$CFLAGS -arch x86_64"
                            AC_TRY_LINK(,, tcl_cv_cc_arch_x86_64=yes,
                            AC_TRY_LINK(,, tcl_cv_cc_arch_x86_64=yes,
                                    tcl_cv_cc_arch_x86_64=no)
                                    tcl_cv_cc_arch_x86_64=no)
                            CFLAGS=$hold_cflags])
                            CFLAGS=$hold_cflags])
                        if test $tcl_cv_cc_arch_x86_64 = yes; then
                        if test $tcl_cv_cc_arch_x86_64 = yes; then
                            CFLAGS="$CFLAGS -arch x86_64"
                            CFLAGS="$CFLAGS -arch x86_64"
                            do64bit_ok=yes
                            do64bit_ok=yes
                        fi;;
                        fi;;
                    *)
                    *)
                        AC_MSG_WARN([Don't know how enable 64-bit on architecture `arch`]);;
                        AC_MSG_WARN([Don't know how enable 64-bit on architecture `arch`]);;
                esac
                esac
            else
            else
                # Check for combined 32-bit and 64-bit fat build
                # Check for combined 32-bit and 64-bit fat build
                echo "$CFLAGS " | grep -E -q -- '-arch (ppc64|x86_64) ' && \
                echo "$CFLAGS " | grep -E -q -- '-arch (ppc64|x86_64) ' && \
                    echo "$CFLAGS " | grep -E -q -- '-arch (ppc|i386) ' && \
                    echo "$CFLAGS " | grep -E -q -- '-arch (ppc|i386) ' && \
                    fat_32_64=yes
                    fat_32_64=yes
            fi
            fi
            SHLIB_LD='${CC} -dynamiclib ${CFLAGS} ${LDFLAGS}'
            SHLIB_LD='${CC} -dynamiclib ${CFLAGS} ${LDFLAGS}'
            AC_CACHE_CHECK([if ld accepts -single_module flag], tcl_cv_ld_single_module, [
            AC_CACHE_CHECK([if ld accepts -single_module flag], tcl_cv_ld_single_module, [
                hold_ldflags=$LDFLAGS
                hold_ldflags=$LDFLAGS
                LDFLAGS="$LDFLAGS -dynamiclib -Wl,-single_module"
                LDFLAGS="$LDFLAGS -dynamiclib -Wl,-single_module"
                AC_TRY_LINK(, [int i;], tcl_cv_ld_single_module=yes, tcl_cv_ld_single_module=no)
                AC_TRY_LINK(, [int i;], tcl_cv_ld_single_module=yes, tcl_cv_ld_single_module=no)
                LDFLAGS=$hold_ldflags])
                LDFLAGS=$hold_ldflags])
            if test $tcl_cv_ld_single_module = yes; then
            if test $tcl_cv_ld_single_module = yes; then
                SHLIB_LD="${SHLIB_LD} -Wl,-single_module"
                SHLIB_LD="${SHLIB_LD} -Wl,-single_module"
            fi
            fi
            SHLIB_LD_LIBS='${LIBS}'
            SHLIB_LD_LIBS='${LIBS}'
            SHLIB_SUFFIX=".dylib"
            SHLIB_SUFFIX=".dylib"
            DL_OBJS="tclLoadDyld.o"
            DL_OBJS="tclLoadDyld.o"
            DL_LIBS=""
            DL_LIBS=""
            # Don't use -prebind when building for Mac OS X 10.4 or later only:
            # Don't use -prebind when building for Mac OS X 10.4 or later only:
            test "`echo "${MACOSX_DEPLOYMENT_TARGET}" | awk -F '10\\.' '{print int([$]2)}'`" -lt 4 -a \
            test "`echo "${MACOSX_DEPLOYMENT_TARGET}" | awk -F '10\\.' '{print int([$]2)}'`" -lt 4 -a \
                "`echo "${CPPFLAGS}" | awk -F '-mmacosx-version-min=10\\.' '{print int([$]2)}'`" -lt 4 && \
                "`echo "${CPPFLAGS}" | awk -F '-mmacosx-version-min=10\\.' '{print int([$]2)}'`" -lt 4 && \
                LDFLAGS="$LDFLAGS -prebind"
                LDFLAGS="$LDFLAGS -prebind"
            LDFLAGS="$LDFLAGS -headerpad_max_install_names"
            LDFLAGS="$LDFLAGS -headerpad_max_install_names"
            AC_CACHE_CHECK([if ld accepts -search_paths_first flag], tcl_cv_ld_search_paths_first, [
            AC_CACHE_CHECK([if ld accepts -search_paths_first flag], tcl_cv_ld_search_paths_first, [
                hold_ldflags=$LDFLAGS
                hold_ldflags=$LDFLAGS
                LDFLAGS="$LDFLAGS -Wl,-search_paths_first"
                LDFLAGS="$LDFLAGS -Wl,-search_paths_first"
                AC_TRY_LINK(, [int i;], tcl_cv_ld_search_paths_first=yes, tcl_cv_ld_search_paths_first=no)
                AC_TRY_LINK(, [int i;], tcl_cv_ld_search_paths_first=yes, tcl_cv_ld_search_paths_first=no)
                LDFLAGS=$hold_ldflags])
                LDFLAGS=$hold_ldflags])
            if test $tcl_cv_ld_search_paths_first = yes; then
            if test $tcl_cv_ld_search_paths_first = yes; then
                LDFLAGS="$LDFLAGS -Wl,-search_paths_first"
                LDFLAGS="$LDFLAGS -Wl,-search_paths_first"
            fi
            fi
            CC_SEARCH_FLAGS=""
            CC_SEARCH_FLAGS=""
            LD_SEARCH_FLAGS=""
            LD_SEARCH_FLAGS=""
            LD_LIBRARY_PATH_VAR="DYLD_LIBRARY_PATH"
            LD_LIBRARY_PATH_VAR="DYLD_LIBRARY_PATH"
            PLAT_OBJS=\$\(MAC\_OSX_OBJS\)
            PLAT_OBJS=\$\(MAC\_OSX_OBJS\)
            PLAT_SRCS=\$\(MAC\_OSX_SRCS\)
            PLAT_SRCS=\$\(MAC\_OSX_SRCS\)
            AC_MSG_CHECKING([whether to use CoreFoundation])
            AC_MSG_CHECKING([whether to use CoreFoundation])
            AC_ARG_ENABLE(corefoundation, [  --enable-corefoundation use CoreFoundation API [--enable-corefoundation]],
            AC_ARG_ENABLE(corefoundation, [  --enable-corefoundation use CoreFoundation API [--enable-corefoundation]],
                [tcl_corefoundation=$enableval], [tcl_corefoundation=yes])
                [tcl_corefoundation=$enableval], [tcl_corefoundation=yes])
            AC_MSG_RESULT([$tcl_corefoundation])
            AC_MSG_RESULT([$tcl_corefoundation])
            if test $tcl_corefoundation = yes; then
            if test $tcl_corefoundation = yes; then
                AC_CACHE_CHECK([for CoreFoundation.framework], tcl_cv_lib_corefoundation, [
                AC_CACHE_CHECK([for CoreFoundation.framework], tcl_cv_lib_corefoundation, [
                    hold_libs=$LIBS
                    hold_libs=$LIBS
                    if test "$fat_32_64" = yes; then for v in CFLAGS CPPFLAGS LDFLAGS; do
                    if test "$fat_32_64" = yes; then for v in CFLAGS CPPFLAGS LDFLAGS; do
                        # On Tiger there is no 64-bit CF, so remove 64-bit archs
                        # On Tiger there is no 64-bit CF, so remove 64-bit archs
                        # from CFLAGS et al. while testing for presence of CF.
                        # from CFLAGS et al. while testing for presence of CF.
                        # 64-bit CF is disabled in tclUnixPort.h if necessary.
                        # 64-bit CF is disabled in tclUnixPort.h if necessary.
                        eval 'hold_'$v'="$'$v'";'$v'="`echo "$'$v' "|sed -e "s/-arch ppc64 / /g" -e "s/-arch x86_64 / /g"`"'
                        eval 'hold_'$v'="$'$v'";'$v'="`echo "$'$v' "|sed -e "s/-arch ppc64 / /g" -e "s/-arch x86_64 / /g"`"'
                    done; fi
                    done; fi
                    LIBS="$LIBS -framework CoreFoundation"
                    LIBS="$LIBS -framework CoreFoundation"
                    AC_TRY_LINK([#include <CoreFoundation/CoreFoundation.h>],
                    AC_TRY_LINK([#include <CoreFoundation/CoreFoundation.h>],
                        [CFBundleRef b = CFBundleGetMainBundle();],
                        [CFBundleRef b = CFBundleGetMainBundle();],
                        tcl_cv_lib_corefoundation=yes, tcl_cv_lib_corefoundation=no)
                        tcl_cv_lib_corefoundation=yes, tcl_cv_lib_corefoundation=no)
                    if test "$fat_32_64" = yes; then for v in CFLAGS CPPFLAGS LDFLAGS; do
                    if test "$fat_32_64" = yes; then for v in CFLAGS CPPFLAGS LDFLAGS; do
                        eval $v'="$hold_'$v'"'
                        eval $v'="$hold_'$v'"'
                    done; fi; LIBS=$hold_libs])
                    done; fi; LIBS=$hold_libs])
                if test $tcl_cv_lib_corefoundation = yes; then
                if test $tcl_cv_lib_corefoundation = yes; then
                    LIBS="$LIBS -framework CoreFoundation"
                    LIBS="$LIBS -framework CoreFoundation"
                    AC_DEFINE(HAVE_COREFOUNDATION)
                    AC_DEFINE(HAVE_COREFOUNDATION)
                else
                else
                    tcl_corefoundation=no
                    tcl_corefoundation=no
                fi
                fi
                if test "$fat_32_64" = yes -a $tcl_corefoundation = yes; then
                if test "$fat_32_64" = yes -a $tcl_corefoundation = yes; then
                    AC_CACHE_CHECK([for 64-bit CoreFoundation], tcl_cv_lib_corefoundation_64, [
                    AC_CACHE_CHECK([for 64-bit CoreFoundation], tcl_cv_lib_corefoundation_64, [
                        for v in CFLAGS CPPFLAGS LDFLAGS; do
                        for v in CFLAGS CPPFLAGS LDFLAGS; do
                            eval 'hold_'$v'="$'$v'";'$v'="`echo "$'$v' "|sed -e "s/-arch ppc / /g" -e "s/-arch i386 / /g"`"'
                            eval 'hold_'$v'="$'$v'";'$v'="`echo "$'$v' "|sed -e "s/-arch ppc / /g" -e "s/-arch i386 / /g"`"'
                        done
                        done
                        AC_TRY_LINK([#include <CoreFoundation/CoreFoundation.h>],
                        AC_TRY_LINK([#include <CoreFoundation/CoreFoundation.h>],
                            [CFBundleRef b = CFBundleGetMainBundle();],
                            [CFBundleRef b = CFBundleGetMainBundle();],
                            tcl_cv_lib_corefoundation_64=yes, tcl_cv_lib_corefoundation_64=no)
                            tcl_cv_lib_corefoundation_64=yes, tcl_cv_lib_corefoundation_64=no)
                        for v in CFLAGS CPPFLAGS LDFLAGS; do
                        for v in CFLAGS CPPFLAGS LDFLAGS; do
                            eval $v'="$hold_'$v'"'
                            eval $v'="$hold_'$v'"'
                        done])
                        done])
                    if test $tcl_cv_lib_corefoundation_64 = no; then
                    if test $tcl_cv_lib_corefoundation_64 = no; then
                        AC_DEFINE(NO_COREFOUNDATION_64)
                        AC_DEFINE(NO_COREFOUNDATION_64)
                    fi
                    fi
                fi
                fi
            fi
            fi
            AC_DEFINE(MAC_OSX_TCL)
            AC_DEFINE(MAC_OSX_TCL)
            ;;
            ;;
        NEXTSTEP-*)
        NEXTSTEP-*)
            SHLIB_CFLAGS=""
            SHLIB_CFLAGS=""
            SHLIB_LD="cc -nostdlib -r"
            SHLIB_LD="cc -nostdlib -r"
            SHLIB_LD_LIBS=""
            SHLIB_LD_LIBS=""
            SHLIB_SUFFIX=".so"
            SHLIB_SUFFIX=".so"
            DL_OBJS="tclLoadNext.o"
            DL_OBJS="tclLoadNext.o"
            DL_LIBS=""
            DL_LIBS=""
            CC_SEARCH_FLAGS=""
            CC_SEARCH_FLAGS=""
            LD_SEARCH_FLAGS=""
            LD_SEARCH_FLAGS=""
            ;;
            ;;
        OS/390-*)
        OS/390-*)
            CFLAGS_OPTIMIZE=""          # Optimizer is buggy
            CFLAGS_OPTIMIZE=""          # Optimizer is buggy
            AC_DEFINE(_OE_SOCKETS)      # needed in sys/socket.h
            AC_DEFINE(_OE_SOCKETS)      # needed in sys/socket.h
            ;;
            ;;
        OSF1-1.0|OSF1-1.1|OSF1-1.2)
        OSF1-1.0|OSF1-1.1|OSF1-1.2)
            # OSF/1 1.[012] from OSF, and derivatives, including Paragon OSF/1
            # OSF/1 1.[012] from OSF, and derivatives, including Paragon OSF/1
            SHLIB_CFLAGS=""
            SHLIB_CFLAGS=""
            # Hack: make package name same as library name
            # Hack: make package name same as library name
            SHLIB_LD='ld -R -export $@:'
            SHLIB_LD='ld -R -export $@:'
            SHLIB_LD_LIBS=""
            SHLIB_LD_LIBS=""
            SHLIB_SUFFIX=".so"
            SHLIB_SUFFIX=".so"
            DL_OBJS="tclLoadOSF.o"
            DL_OBJS="tclLoadOSF.o"
            DL_LIBS=""
            DL_LIBS=""
            CC_SEARCH_FLAGS=""
            CC_SEARCH_FLAGS=""
            LD_SEARCH_FLAGS=""
            LD_SEARCH_FLAGS=""
            ;;
            ;;
        OSF1-1.*)
        OSF1-1.*)
            # OSF/1 1.3 from OSF using ELF, and derivatives, including AD2
            # OSF/1 1.3 from OSF using ELF, and derivatives, including AD2
            SHLIB_CFLAGS="-fPIC"
            SHLIB_CFLAGS="-fPIC"
            if test "$SHARED_BUILD" = "1" ; then
            if test "$SHARED_BUILD" = "1" ; then
                SHLIB_LD="ld -shared"
                SHLIB_LD="ld -shared"
            else
            else
                SHLIB_LD="ld -non_shared"
                SHLIB_LD="ld -non_shared"
            fi
            fi
            SHLIB_LD_LIBS=""
            SHLIB_LD_LIBS=""
            SHLIB_SUFFIX=".so"
            SHLIB_SUFFIX=".so"
            DL_OBJS="tclLoadDl.o"
            DL_OBJS="tclLoadDl.o"
            DL_LIBS=""
            DL_LIBS=""
            CC_SEARCH_FLAGS=""
            CC_SEARCH_FLAGS=""
            LD_SEARCH_FLAGS=""
            LD_SEARCH_FLAGS=""
            ;;
            ;;
        OSF1-V*)
        OSF1-V*)
            # Digital OSF/1
            # Digital OSF/1
            SHLIB_CFLAGS=""
            SHLIB_CFLAGS=""
            if test "$SHARED_BUILD" = "1" ; then
            if test "$SHARED_BUILD" = "1" ; then
                SHLIB_LD='ld -shared -expect_unresolved "*"'
                SHLIB_LD='ld -shared -expect_unresolved "*"'
            else
            else
                SHLIB_LD='ld -non_shared -expect_unresolved "*"'
                SHLIB_LD='ld -non_shared -expect_unresolved "*"'
            fi
            fi
            SHLIB_LD_LIBS=""
            SHLIB_LD_LIBS=""
            SHLIB_SUFFIX=".so"
            SHLIB_SUFFIX=".so"
            DL_OBJS="tclLoadDl.o"
            DL_OBJS="tclLoadDl.o"
            DL_LIBS=""
            DL_LIBS=""
            CC_SEARCH_FLAGS='-Wl,-rpath,${LIB_RUNTIME_DIR}'
            CC_SEARCH_FLAGS='-Wl,-rpath,${LIB_RUNTIME_DIR}'
            LD_SEARCH_FLAGS='-rpath ${LIB_RUNTIME_DIR}'
            LD_SEARCH_FLAGS='-rpath ${LIB_RUNTIME_DIR}'
            if test "$GCC" = "yes" ; then
            if test "$GCC" = "yes" ; then
                CFLAGS="$CFLAGS -mieee"
                CFLAGS="$CFLAGS -mieee"
            else
            else
                CFLAGS="$CFLAGS -DHAVE_TZSET -std1 -ieee"
                CFLAGS="$CFLAGS -DHAVE_TZSET -std1 -ieee"
            fi
            fi
            # see pthread_intro(3) for pthread support on osf1, k.furukawa
            # see pthread_intro(3) for pthread support on osf1, k.furukawa
            if test "${TCL_THREADS}" = "1" ; then
            if test "${TCL_THREADS}" = "1" ; then
                CFLAGS="$CFLAGS -DHAVE_PTHREAD_ATTR_SETSTACKSIZE"
                CFLAGS="$CFLAGS -DHAVE_PTHREAD_ATTR_SETSTACKSIZE"
                CFLAGS="$CFLAGS -DTCL_THREAD_STACK_MIN=PTHREAD_STACK_MIN*64"
                CFLAGS="$CFLAGS -DTCL_THREAD_STACK_MIN=PTHREAD_STACK_MIN*64"
                LIBS=`echo $LIBS | sed s/-lpthreads//`
                LIBS=`echo $LIBS | sed s/-lpthreads//`
                if test "$GCC" = "yes" ; then
                if test "$GCC" = "yes" ; then
                    LIBS="$LIBS -lpthread -lmach -lexc"
                    LIBS="$LIBS -lpthread -lmach -lexc"
                else
                else
                    CFLAGS="$CFLAGS -pthread"
                    CFLAGS="$CFLAGS -pthread"
                    LDFLAGS="$LDFLAGS -pthread"
                    LDFLAGS="$LDFLAGS -pthread"
                fi
                fi
            fi
            fi
 
 
            ;;
            ;;
        QNX-6*)
        QNX-6*)
            # QNX RTP
            # QNX RTP
            # This may work for all QNX, but it was only reported for v6.
            # This may work for all QNX, but it was only reported for v6.
            SHLIB_CFLAGS="-fPIC"
            SHLIB_CFLAGS="-fPIC"
            SHLIB_LD="ld -Bshareable -x"
            SHLIB_LD="ld -Bshareable -x"
            SHLIB_LD_LIBS=""
            SHLIB_LD_LIBS=""
            SHLIB_SUFFIX=".so"
            SHLIB_SUFFIX=".so"
            DL_OBJS="tclLoadDl.o"
            DL_OBJS="tclLoadDl.o"
            # dlopen is in -lc on QNX
            # dlopen is in -lc on QNX
            DL_LIBS=""
            DL_LIBS=""
            CC_SEARCH_FLAGS=""
            CC_SEARCH_FLAGS=""
            LD_SEARCH_FLAGS=""
            LD_SEARCH_FLAGS=""
            ;;
            ;;
        RISCos-*)
        RISCos-*)
            SHLIB_CFLAGS="-G 0"
            SHLIB_CFLAGS="-G 0"
            SHLIB_LD="echo tclLdAout $CC \{$SHLIB_CFLAGS\} | `pwd`/tclsh -r -G 0"
            SHLIB_LD="echo tclLdAout $CC \{$SHLIB_CFLAGS\} | `pwd`/tclsh -r -G 0"
            SHLIB_LD_LIBS='${LIBS}'
            SHLIB_LD_LIBS='${LIBS}'
            SHLIB_SUFFIX=".a"
            SHLIB_SUFFIX=".a"
            DL_OBJS="tclLoadAout.o"
            DL_OBJS="tclLoadAout.o"
            DL_LIBS=""
            DL_LIBS=""
            LDFLAGS="$LDFLAGS -Wl,-D,08000000"
            LDFLAGS="$LDFLAGS -Wl,-D,08000000"
            CC_SEARCH_FLAGS='-L${LIB_RUNTIME_DIR}'
            CC_SEARCH_FLAGS='-L${LIB_RUNTIME_DIR}'
            LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS}
            LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS}
            ;;
            ;;
        SCO_SV-3.2*)
        SCO_SV-3.2*)
            # Note, dlopen is available only on SCO 3.2.5 and greater. However,
            # Note, dlopen is available only on SCO 3.2.5 and greater. However,
            # this test works, since "uname -s" was non-standard in 3.2.4 and
            # this test works, since "uname -s" was non-standard in 3.2.4 and
            # below.
            # below.
            if test "$GCC" = "yes" ; then
            if test "$GCC" = "yes" ; then
                SHLIB_CFLAGS="-fPIC -melf"
                SHLIB_CFLAGS="-fPIC -melf"
                LDFLAGS="$LDFLAGS -melf -Wl,-Bexport"
                LDFLAGS="$LDFLAGS -melf -Wl,-Bexport"
            else
            else
                SHLIB_CFLAGS="-Kpic -belf"
                SHLIB_CFLAGS="-Kpic -belf"
                LDFLAGS="$LDFLAGS -belf -Wl,-Bexport"
                LDFLAGS="$LDFLAGS -belf -Wl,-Bexport"
            fi
            fi
            SHLIB_LD="ld -G"
            SHLIB_LD="ld -G"
            SHLIB_LD_LIBS=""
            SHLIB_LD_LIBS=""
            SHLIB_SUFFIX=".so"
            SHLIB_SUFFIX=".so"
            DL_OBJS="tclLoadDl.o"
            DL_OBJS="tclLoadDl.o"
            DL_LIBS=""
            DL_LIBS=""
            CC_SEARCH_FLAGS=""
            CC_SEARCH_FLAGS=""
            LD_SEARCH_FLAGS=""
            LD_SEARCH_FLAGS=""
            ;;
            ;;
        SINIX*5.4*)
        SINIX*5.4*)
            SHLIB_CFLAGS="-K PIC"
            SHLIB_CFLAGS="-K PIC"
            SHLIB_LD="cc -G"
            SHLIB_LD="cc -G"
            SHLIB_LD_LIBS=""
            SHLIB_LD_LIBS=""
            SHLIB_SUFFIX=".so"
            SHLIB_SUFFIX=".so"
            DL_OBJS="tclLoadDl.o"
            DL_OBJS="tclLoadDl.o"
            DL_LIBS="-ldl"
            DL_LIBS="-ldl"
            CC_SEARCH_FLAGS=""
            CC_SEARCH_FLAGS=""
            LD_SEARCH_FLAGS=""
            LD_SEARCH_FLAGS=""
            ;;
            ;;
        SunOS-4*)
        SunOS-4*)
            SHLIB_CFLAGS="-PIC"
            SHLIB_CFLAGS="-PIC"
            SHLIB_LD="ld"
            SHLIB_LD="ld"
            SHLIB_LD_LIBS=""
            SHLIB_LD_LIBS=""
            SHLIB_SUFFIX=".so"
            SHLIB_SUFFIX=".so"
            DL_OBJS="tclLoadDl.o"
            DL_OBJS="tclLoadDl.o"
            DL_LIBS="-ldl"
            DL_LIBS="-ldl"
            CC_SEARCH_FLAGS='-L${LIB_RUNTIME_DIR}'
            CC_SEARCH_FLAGS='-L${LIB_RUNTIME_DIR}'
            LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS}
            LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS}
 
 
            # SunOS can't handle version numbers with dots in them in library
            # SunOS can't handle version numbers with dots in them in library
            # specs, like -ltcl7.5, so use -ltcl75 instead.  Also, it
            # specs, like -ltcl7.5, so use -ltcl75 instead.  Also, it
            # requires an extra version number at the end of .so file names.
            # requires an extra version number at the end of .so file names.
            # So, the library has to have a name like libtcl75.so.1.0
            # So, the library has to have a name like libtcl75.so.1.0
 
 
            SHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}\$\{DBGX\}.so.1.0'
            SHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}\$\{DBGX\}.so.1.0'
            UNSHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}\$\{DBGX\}.a'
            UNSHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}\$\{DBGX\}.a'
            TCL_LIB_VERSIONS_OK=nodots
            TCL_LIB_VERSIONS_OK=nodots
            ;;
            ;;
        SunOS-5.[[0-6]])
        SunOS-5.[[0-6]])
            # Careful to not let 5.10+ fall into this case
            # Careful to not let 5.10+ fall into this case
 
 
            # Note: If _REENTRANT isn't defined, then Solaris
            # Note: If _REENTRANT isn't defined, then Solaris
            # won't define thread-safe library routines.
            # won't define thread-safe library routines.
 
 
            AC_DEFINE(_REENTRANT)
            AC_DEFINE(_REENTRANT)
            AC_DEFINE(_POSIX_PTHREAD_SEMANTICS)
            AC_DEFINE(_POSIX_PTHREAD_SEMANTICS)
 
 
            SHLIB_CFLAGS="-KPIC"
            SHLIB_CFLAGS="-KPIC"
 
 
            # Note: need the LIBS below, otherwise Tk won't find Tcl's
            # Note: need the LIBS below, otherwise Tk won't find Tcl's
            # symbols when dynamically loaded into tclsh.
            # symbols when dynamically loaded into tclsh.
 
 
            SHLIB_LD_LIBS='${LIBS}'
            SHLIB_LD_LIBS='${LIBS}'
            SHLIB_SUFFIX=".so"
            SHLIB_SUFFIX=".so"
            DL_OBJS="tclLoadDl.o"
            DL_OBJS="tclLoadDl.o"
            DL_LIBS="-ldl"
            DL_LIBS="-ldl"
            if test "$GCC" = "yes" ; then
            if test "$GCC" = "yes" ; then
                SHLIB_LD="$CC -shared"
                SHLIB_LD="$CC -shared"
                CC_SEARCH_FLAGS='-Wl,-R,${LIB_RUNTIME_DIR}'
                CC_SEARCH_FLAGS='-Wl,-R,${LIB_RUNTIME_DIR}'
                LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS}
                LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS}
            else
            else
                SHLIB_LD="/usr/ccs/bin/ld -G -z text"
                SHLIB_LD="/usr/ccs/bin/ld -G -z text"
                CC_SEARCH_FLAGS='-R ${LIB_RUNTIME_DIR}'
                CC_SEARCH_FLAGS='-R ${LIB_RUNTIME_DIR}'
                LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS}
                LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS}
            fi
            fi
            ;;
            ;;
        SunOS-5*)
        SunOS-5*)
            # Note: If _REENTRANT isn't defined, then Solaris
            # Note: If _REENTRANT isn't defined, then Solaris
            # won't define thread-safe library routines.
            # won't define thread-safe library routines.
 
 
            AC_DEFINE(_REENTRANT)
            AC_DEFINE(_REENTRANT)
            AC_DEFINE(_POSIX_PTHREAD_SEMANTICS)
            AC_DEFINE(_POSIX_PTHREAD_SEMANTICS)
 
 
            SHLIB_CFLAGS="-KPIC"
            SHLIB_CFLAGS="-KPIC"
 
 
            # Check to enable 64-bit flags for compiler/linker
            # Check to enable 64-bit flags for compiler/linker
            if test "$do64bit" = "yes" ; then
            if test "$do64bit" = "yes" ; then
                arch=`isainfo`
                arch=`isainfo`
                if test "$arch" = "sparcv9 sparc" ; then
                if test "$arch" = "sparcv9 sparc" ; then
                        if test "$GCC" = "yes" ; then
                        if test "$GCC" = "yes" ; then
                            if test "`gcc -dumpversion | awk -F. '{print [$]1}'`" -lt "3" ; then
                            if test "`gcc -dumpversion | awk -F. '{print [$]1}'`" -lt "3" ; then
                                AC_MSG_WARN([64bit mode not supported with GCC < 3.2 on $system])
                                AC_MSG_WARN([64bit mode not supported with GCC < 3.2 on $system])
                            else
                            else
                                do64bit_ok=yes
                                do64bit_ok=yes
                                CFLAGS="$CFLAGS -m64 -mcpu=v9"
                                CFLAGS="$CFLAGS -m64 -mcpu=v9"
                                LDFLAGS="$LDFLAGS -m64 -mcpu=v9"
                                LDFLAGS="$LDFLAGS -m64 -mcpu=v9"
                                SHLIB_CFLAGS="-fPIC"
                                SHLIB_CFLAGS="-fPIC"
                            fi
                            fi
                        else
                        else
                            do64bit_ok=yes
                            do64bit_ok=yes
                            if test "$do64bitVIS" = "yes" ; then
                            if test "$do64bitVIS" = "yes" ; then
                                CFLAGS="$CFLAGS -xarch=v9a"
                                CFLAGS="$CFLAGS -xarch=v9a"
                                LDFLAGS="$LDFLAGS -xarch=v9a"
                                LDFLAGS="$LDFLAGS -xarch=v9a"
                            else
                            else
                                CFLAGS="$CFLAGS -xarch=v9"
                                CFLAGS="$CFLAGS -xarch=v9"
                                LDFLAGS="$LDFLAGS -xarch=v9"
                                LDFLAGS="$LDFLAGS -xarch=v9"
                            fi
                            fi
                            # Solaris 64 uses this as well
                            # Solaris 64 uses this as well
                            #LD_LIBRARY_PATH_VAR="LD_LIBRARY_PATH_64"
                            #LD_LIBRARY_PATH_VAR="LD_LIBRARY_PATH_64"
                        fi
                        fi
                elif test "$arch" = "amd64 i386" ; then
                elif test "$arch" = "amd64 i386" ; then
                    if test "$GCC" = "yes" ; then
                    if test "$GCC" = "yes" ; then
                        AC_MSG_WARN([64bit mode not supported with GCC on $system])
                        AC_MSG_WARN([64bit mode not supported with GCC on $system])
                    else
                    else
                        do64bit_ok=yes
                        do64bit_ok=yes
                        CFLAGS="$CFLAGS -xarch=amd64"
                        CFLAGS="$CFLAGS -xarch=amd64"
                        LDFLAGS="$LDFLAGS -xarch=amd64"
                        LDFLAGS="$LDFLAGS -xarch=amd64"
                    fi
                    fi
                else
                else
                    AC_MSG_WARN([64bit mode not supported for $arch])
                    AC_MSG_WARN([64bit mode not supported for $arch])
                fi
                fi
            fi
            fi
 
 
            # Note: need the LIBS below, otherwise Tk won't find Tcl's
            # Note: need the LIBS below, otherwise Tk won't find Tcl's
            # symbols when dynamically loaded into tclsh.
            # symbols when dynamically loaded into tclsh.
 
 
            SHLIB_LD_LIBS='${LIBS}'
            SHLIB_LD_LIBS='${LIBS}'
            SHLIB_SUFFIX=".so"
            SHLIB_SUFFIX=".so"
            DL_OBJS="tclLoadDl.o"
            DL_OBJS="tclLoadDl.o"
            DL_LIBS="-ldl"
            DL_LIBS="-ldl"
            if test "$GCC" = "yes" ; then
            if test "$GCC" = "yes" ; then
                SHLIB_LD="$CC -shared"
                SHLIB_LD="$CC -shared"
                CC_SEARCH_FLAGS='-Wl,-R,${LIB_RUNTIME_DIR}'
                CC_SEARCH_FLAGS='-Wl,-R,${LIB_RUNTIME_DIR}'
                LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS}
                LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS}
                if test "$do64bit_ok" = "yes" ; then
                if test "$do64bit_ok" = "yes" ; then
                    # We need to specify -static-libgcc or we need to
                    # We need to specify -static-libgcc or we need to
                    # add the path to the sparv9 libgcc.
                    # add the path to the sparv9 libgcc.
                    SHLIB_LD="$SHLIB_LD -m64 -mcpu=v9 -static-libgcc"
                    SHLIB_LD="$SHLIB_LD -m64 -mcpu=v9 -static-libgcc"
                    # for finding sparcv9 libgcc, get the regular libgcc
                    # for finding sparcv9 libgcc, get the regular libgcc
                    # path, remove so name and append 'sparcv9'
                    # path, remove so name and append 'sparcv9'
                    #v9gcclibdir="`gcc -print-file-name=libgcc_s.so` | ..."
                    #v9gcclibdir="`gcc -print-file-name=libgcc_s.so` | ..."
                    #CC_SEARCH_FLAGS="${CC_SEARCH_FLAGS},-R,$v9gcclibdir"
                    #CC_SEARCH_FLAGS="${CC_SEARCH_FLAGS},-R,$v9gcclibdir"
                fi
                fi
            else
            else
                case $system in
                case $system in
                    SunOS-5.[[1-9]][[0-9]]*)
                    SunOS-5.[[1-9]][[0-9]]*)
                        SHLIB_LD='${CC} -G -z text';;
                        SHLIB_LD='${CC} -G -z text';;
                    *)
                    *)
                        SHLIB_LD="/usr/ccs/bin/ld -G -z text";;
                        SHLIB_LD="/usr/ccs/bin/ld -G -z text";;
                esac
                esac
                CC_SEARCH_FLAGS='-Wl,-R,${LIB_RUNTIME_DIR}'
                CC_SEARCH_FLAGS='-Wl,-R,${LIB_RUNTIME_DIR}'
                LD_SEARCH_FLAGS='-R ${LIB_RUNTIME_DIR}'
                LD_SEARCH_FLAGS='-R ${LIB_RUNTIME_DIR}'
            fi
            fi
            ;;
            ;;
        ULTRIX-4.*)
        ULTRIX-4.*)
            SHLIB_CFLAGS="-G 0"
            SHLIB_CFLAGS="-G 0"
            SHLIB_SUFFIX=".a"
            SHLIB_SUFFIX=".a"
            SHLIB_LD="echo tclLdAout $CC \{$SHLIB_CFLAGS\} | `pwd`/tclsh -r -G 0"
            SHLIB_LD="echo tclLdAout $CC \{$SHLIB_CFLAGS\} | `pwd`/tclsh -r -G 0"
            SHLIB_LD_LIBS='${LIBS}'
            SHLIB_LD_LIBS='${LIBS}'
            DL_OBJS="tclLoadAout.o"
            DL_OBJS="tclLoadAout.o"
            DL_LIBS=""
            DL_LIBS=""
            LDFLAGS="$LDFLAGS -Wl,-D,08000000"
            LDFLAGS="$LDFLAGS -Wl,-D,08000000"
            CC_SEARCH_FLAGS='-L${LIB_RUNTIME_DIR}'
            CC_SEARCH_FLAGS='-L${LIB_RUNTIME_DIR}'
            LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS}
            LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS}
            if test "$GCC" != "yes" ; then
            if test "$GCC" != "yes" ; then
                CFLAGS="$CFLAGS -DHAVE_TZSET -std1"
                CFLAGS="$CFLAGS -DHAVE_TZSET -std1"
            fi
            fi
            ;;
            ;;
        UNIX_SV* | UnixWare-5*)
        UNIX_SV* | UnixWare-5*)
            SHLIB_CFLAGS="-KPIC"
            SHLIB_CFLAGS="-KPIC"
            SHLIB_LD="cc -G"
            SHLIB_LD="cc -G"
            SHLIB_LD_LIBS=""
            SHLIB_LD_LIBS=""
            SHLIB_SUFFIX=".so"
            SHLIB_SUFFIX=".so"
            DL_OBJS="tclLoadDl.o"
            DL_OBJS="tclLoadDl.o"
            DL_LIBS="-ldl"
            DL_LIBS="-ldl"
            # Some UNIX_SV* systems (unixware 1.1.2 for example) have linkers
            # Some UNIX_SV* systems (unixware 1.1.2 for example) have linkers
            # that don't grok the -Bexport option.  Test that it does.
            # that don't grok the -Bexport option.  Test that it does.
            AC_CACHE_CHECK([for ld accepts -Bexport flag], tcl_cv_ld_Bexport, [
            AC_CACHE_CHECK([for ld accepts -Bexport flag], tcl_cv_ld_Bexport, [
                hold_ldflags=$LDFLAGS
                hold_ldflags=$LDFLAGS
                LDFLAGS="$LDFLAGS -Wl,-Bexport"
                LDFLAGS="$LDFLAGS -Wl,-Bexport"
                AC_TRY_LINK(, [int i;], tcl_cv_ld_Bexport=yes, tcl_cv_ld_Bexport=no)
                AC_TRY_LINK(, [int i;], tcl_cv_ld_Bexport=yes, tcl_cv_ld_Bexport=no)
                LDFLAGS=$hold_ldflags])
                LDFLAGS=$hold_ldflags])
            if test $tcl_cv_ld_Bexport = yes; then
            if test $tcl_cv_ld_Bexport = yes; then
                LDFLAGS="$LDFLAGS -Wl,-Bexport"
                LDFLAGS="$LDFLAGS -Wl,-Bexport"
            fi
            fi
            CC_SEARCH_FLAGS=""
            CC_SEARCH_FLAGS=""
            LD_SEARCH_FLAGS=""
            LD_SEARCH_FLAGS=""
            ;;
            ;;
    esac
    esac
 
 
    if test "$do64bit" = "yes" -a "$do64bit_ok" = "no" ; then
    if test "$do64bit" = "yes" -a "$do64bit_ok" = "no" ; then
        AC_MSG_WARN([64bit support being disabled -- don't know magic for this platform])
        AC_MSG_WARN([64bit support being disabled -- don't know magic for this platform])
    fi
    fi
 
 
dnl # Add any CPPFLAGS set in the environment to our CFLAGS, but delay doing so
dnl # Add any CPPFLAGS set in the environment to our CFLAGS, but delay doing so
dnl # until the end of configure, as configure's compile and link tests use
dnl # until the end of configure, as configure's compile and link tests use
dnl # both CPPFLAGS and CFLAGS (unlike our compile and link) but configure's
dnl # both CPPFLAGS and CFLAGS (unlike our compile and link) but configure's
dnl # preprocessing tests use only CPPFLAGS.
dnl # preprocessing tests use only CPPFLAGS.
    SC_CONFIG_COMMANDS_PRE([CFLAGS="${CFLAGS} ${CPPFLAGS}"; CPPFLAGS=""])
    SC_CONFIG_COMMANDS_PRE([CFLAGS="${CFLAGS} ${CPPFLAGS}"; CPPFLAGS=""])
 
 
    # Step 4: If pseudo-static linking is in use (see K. B. Kenny, "Dynamic
    # Step 4: If pseudo-static linking is in use (see K. B. Kenny, "Dynamic
    # Loading for Tcl -- What Became of It?".  Proc. 2nd Tcl/Tk Workshop,
    # Loading for Tcl -- What Became of It?".  Proc. 2nd Tcl/Tk Workshop,
    # New Orleans, LA, Computerized Processes Unlimited, 1994), then we need
    # New Orleans, LA, Computerized Processes Unlimited, 1994), then we need
    # to determine which of several header files defines the a.out file
    # to determine which of several header files defines the a.out file
    # format (a.out.h, sys/exec.h, or sys/exec_aout.h).  At present, we
    # format (a.out.h, sys/exec.h, or sys/exec_aout.h).  At present, we
    # support only a file format that is more or less version-7-compatible.
    # support only a file format that is more or less version-7-compatible.
    # In particular,
    # In particular,
    #   - a.out files must begin with `struct exec'.
    #   - a.out files must begin with `struct exec'.
    #   - the N_TXTOFF on the `struct exec' must compute the seek address
    #   - the N_TXTOFF on the `struct exec' must compute the seek address
    #     of the text segment
    #     of the text segment
    #   - The `struct exec' must contain a_magic, a_text, a_data, a_bss
    #   - The `struct exec' must contain a_magic, a_text, a_data, a_bss
    #     and a_entry fields.
    #     and a_entry fields.
    # The following compilation should succeed if and only if either sys/exec.h
    # The following compilation should succeed if and only if either sys/exec.h
    # or a.out.h is usable for the purpose.
    # or a.out.h is usable for the purpose.
    #
    #
    # Note that the modified COFF format used on MIPS Ultrix 4.x is usable; the
    # Note that the modified COFF format used on MIPS Ultrix 4.x is usable; the
    # `struct exec' includes a second header that contains information that
    # `struct exec' includes a second header that contains information that
    # duplicates the v7 fields that are needed.
    # duplicates the v7 fields that are needed.
 
 
    if test "x$DL_OBJS" = "xtclLoadAout.o" ; then
    if test "x$DL_OBJS" = "xtclLoadAout.o" ; then
        AC_CACHE_CHECK([sys/exec.h], tcl_cv_sysexec_h, [
        AC_CACHE_CHECK([sys/exec.h], tcl_cv_sysexec_h, [
        AC_TRY_COMPILE([#include <sys/exec.h>],[
        AC_TRY_COMPILE([#include <sys/exec.h>],[
            struct exec foo;
            struct exec foo;
            unsigned long seek;
            unsigned long seek;
            int flag;
            int flag;
#if defined(__mips) || defined(mips)
#if defined(__mips) || defined(mips)
            seek = N_TXTOFF (foo.ex_f, foo.ex_o);
            seek = N_TXTOFF (foo.ex_f, foo.ex_o);
#else
#else
            seek = N_TXTOFF (foo);
            seek = N_TXTOFF (foo);
#endif
#endif
            flag = (foo.a_magic == OMAGIC);
            flag = (foo.a_magic == OMAGIC);
            return foo.a_text + foo.a_data + foo.a_bss + foo.a_entry;
            return foo.a_text + foo.a_data + foo.a_bss + foo.a_entry;
    ], tcl_cv_sysexec_h=usable, tcl_cv_sysexec_h=unusable)])
    ], tcl_cv_sysexec_h=usable, tcl_cv_sysexec_h=unusable)])
        if test $tcl_cv_sysexec_h = usable; then
        if test $tcl_cv_sysexec_h = usable; then
            AC_DEFINE(USE_SYS_EXEC_H)
            AC_DEFINE(USE_SYS_EXEC_H)
        else
        else
            AC_CACHE_CHECK([a.out.h], tcl_cv_aout_h, [
            AC_CACHE_CHECK([a.out.h], tcl_cv_aout_h, [
            AC_TRY_COMPILE([#include <a.out.h>],[
            AC_TRY_COMPILE([#include <a.out.h>],[
                struct exec foo;
                struct exec foo;
                unsigned long seek;
                unsigned long seek;
                int flag;
                int flag;
#if defined(__mips) || defined(mips)
#if defined(__mips) || defined(mips)
                seek = N_TXTOFF (foo.ex_f, foo.ex_o);
                seek = N_TXTOFF (foo.ex_f, foo.ex_o);
#else
#else
                seek = N_TXTOFF (foo);
                seek = N_TXTOFF (foo);
#endif
#endif
                flag = (foo.a_magic == OMAGIC);
                flag = (foo.a_magic == OMAGIC);
                return foo.a_text + foo.a_data + foo.a_bss + foo.a_entry;
                return foo.a_text + foo.a_data + foo.a_bss + foo.a_entry;
            ], tcl_cv_aout_h=usable, tcl_cv_aout_h=unusable)])
            ], tcl_cv_aout_h=usable, tcl_cv_aout_h=unusable)])
            if test $tcl_cv_aout_h = usable; then
            if test $tcl_cv_aout_h = usable; then
                AC_DEFINE(USE_A_OUT_H)
                AC_DEFINE(USE_A_OUT_H)
            else
            else
                AC_CACHE_CHECK([sys/exec_aout.h], tcl_cv_sysexecaout_h, [
                AC_CACHE_CHECK([sys/exec_aout.h], tcl_cv_sysexecaout_h, [
                AC_TRY_COMPILE([#include <sys/exec_aout.h>],[
                AC_TRY_COMPILE([#include <sys/exec_aout.h>],[
                    struct exec foo;
                    struct exec foo;
                    unsigned long seek;
                    unsigned long seek;
                    int flag;
                    int flag;
#if defined(__mips) || defined(mips)
#if defined(__mips) || defined(mips)
                    seek = N_TXTOFF (foo.ex_f, foo.ex_o);
                    seek = N_TXTOFF (foo.ex_f, foo.ex_o);
#else
#else
                    seek = N_TXTOFF (foo);
                    seek = N_TXTOFF (foo);
#endif
#endif
                    flag = (foo.a_midmag == OMAGIC);
                    flag = (foo.a_midmag == OMAGIC);
                    return foo.a_text + foo.a_data + foo.a_bss + foo.a_entry;
                    return foo.a_text + foo.a_data + foo.a_bss + foo.a_entry;
                ], tcl_cv_sysexecaout_h=usable, tcl_cv_sysexecaout_h=unusable)])
                ], tcl_cv_sysexecaout_h=usable, tcl_cv_sysexecaout_h=unusable)])
                if test $tcl_cv_sysexecaout_h = usable; then
                if test $tcl_cv_sysexecaout_h = usable; then
                    AC_DEFINE(USE_SYS_EXEC_AOUT_H)
                    AC_DEFINE(USE_SYS_EXEC_AOUT_H)
                else
                else
                    DL_OBJS=""
                    DL_OBJS=""
                fi
                fi
            fi
            fi
        fi
        fi
    fi
    fi
 
 
    # Step 5: disable dynamic loading if requested via a command-line switch.
    # Step 5: disable dynamic loading if requested via a command-line switch.
 
 
    AC_ARG_ENABLE(load, [  --disable-load          disallow dynamic loading and "load" command],
    AC_ARG_ENABLE(load, [  --disable-load          disallow dynamic loading and "load" command],
        [tcl_ok=$enableval], [tcl_ok=yes])
        [tcl_ok=$enableval], [tcl_ok=yes])
    if test "$tcl_ok" = "no"; then
    if test "$tcl_ok" = "no"; then
        DL_OBJS=""
        DL_OBJS=""
    fi
    fi
 
 
    if test "x$DL_OBJS" != "x" ; then
    if test "x$DL_OBJS" != "x" ; then
        BUILD_DLTEST="\$(DLTEST_TARGETS)"
        BUILD_DLTEST="\$(DLTEST_TARGETS)"
    else
    else
        echo "Can't figure out how to do dynamic loading or shared libraries"
        echo "Can't figure out how to do dynamic loading or shared libraries"
        echo "on this system."
        echo "on this system."
        SHLIB_CFLAGS=""
        SHLIB_CFLAGS=""
        SHLIB_LD=""
        SHLIB_LD=""
        SHLIB_SUFFIX=""
        SHLIB_SUFFIX=""
        DL_OBJS="tclLoadNone.o"
        DL_OBJS="tclLoadNone.o"
        DL_LIBS=""
        DL_LIBS=""
        LDFLAGS="$LDFLAGS_ORIG"
        LDFLAGS="$LDFLAGS_ORIG"
        CC_SEARCH_FLAGS=""
        CC_SEARCH_FLAGS=""
        LD_SEARCH_FLAGS=""
        LD_SEARCH_FLAGS=""
        BUILD_DLTEST=""
        BUILD_DLTEST=""
    fi
    fi
 
 
    # If we're running gcc, then change the C flags for compiling shared
    # If we're running gcc, then change the C flags for compiling shared
    # libraries to the right flags for gcc, instead of those for the
    # libraries to the right flags for gcc, instead of those for the
    # standard manufacturer compiler.
    # standard manufacturer compiler.
 
 
    if test "$DL_OBJS" != "tclLoadNone.o" ; then
    if test "$DL_OBJS" != "tclLoadNone.o" ; then
        if test "$GCC" = "yes" ; then
        if test "$GCC" = "yes" ; then
            case $system in
            case $system in
                AIX-*)
                AIX-*)
                    ;;
                    ;;
                BSD/OS*)
                BSD/OS*)
                    ;;
                    ;;
                IRIX*)
                IRIX*)
                    ;;
                    ;;
                NetBSD-*|FreeBSD-*|OpenBSD-*)
                NetBSD-*|FreeBSD-*|OpenBSD-*)
                    ;;
                    ;;
                Darwin-*)
                Darwin-*)
                    ;;
                    ;;
                RISCos-*)
                RISCos-*)
                    ;;
                    ;;
                SCO_SV-3.2*)
                SCO_SV-3.2*)
                    ;;
                    ;;
                ULTRIX-4.*)
                ULTRIX-4.*)
                    ;;
                    ;;
                *)
                *)
                    SHLIB_CFLAGS="-fPIC"
                    SHLIB_CFLAGS="-fPIC"
                    ;;
                    ;;
            esac
            esac
        fi
        fi
    fi
    fi
 
 
    if test "$SHARED_LIB_SUFFIX" = "" ; then
    if test "$SHARED_LIB_SUFFIX" = "" ; then
        SHARED_LIB_SUFFIX='${VERSION}\$\{DBGX\}${SHLIB_SUFFIX}'
        SHARED_LIB_SUFFIX='${VERSION}\$\{DBGX\}${SHLIB_SUFFIX}'
    fi
    fi
    if test "$UNSHARED_LIB_SUFFIX" = "" ; then
    if test "$UNSHARED_LIB_SUFFIX" = "" ; then
        UNSHARED_LIB_SUFFIX='${VERSION}\$\{DBGX\}.a'
        UNSHARED_LIB_SUFFIX='${VERSION}\$\{DBGX\}.a'
    fi
    fi
 
 
    if test "${SHARED_BUILD}" = "1" && test "${SHLIB_SUFFIX}" != "" ; then
    if test "${SHARED_BUILD}" = "1" && test "${SHLIB_SUFFIX}" != "" ; then
        LIB_SUFFIX=${SHARED_LIB_SUFFIX}
        LIB_SUFFIX=${SHARED_LIB_SUFFIX}
        MAKE_LIB='${SHLIB_LD} -o [$]@ ${OBJS} ${SHLIB_LD_LIBS} ${TCL_SHLIB_LD_EXTRAS} ${TK_SHLIB_LD_EXTRAS} ${LD_SEARCH_FLAGS}'
        MAKE_LIB='${SHLIB_LD} -o [$]@ ${OBJS} ${SHLIB_LD_LIBS} ${TCL_SHLIB_LD_EXTRAS} ${TK_SHLIB_LD_EXTRAS} ${LD_SEARCH_FLAGS}'
        INSTALL_LIB='$(INSTALL_LIBRARY) $(LIB_FILE) $(LIB_INSTALL_DIR)/$(LIB_FILE)'
        INSTALL_LIB='$(INSTALL_LIBRARY) $(LIB_FILE) $(LIB_INSTALL_DIR)/$(LIB_FILE)'
    else
    else
        LIB_SUFFIX=${UNSHARED_LIB_SUFFIX}
        LIB_SUFFIX=${UNSHARED_LIB_SUFFIX}
 
 
        if test "$RANLIB" = "" ; then
        if test "$RANLIB" = "" ; then
            MAKE_LIB='$(STLIB_LD) [$]@ ${OBJS}'
            MAKE_LIB='$(STLIB_LD) [$]@ ${OBJS}'
            INSTALL_LIB='$(INSTALL_LIBRARY) $(LIB_FILE) $(LIB_INSTALL_DIR)/$(LIB_FILE)'
            INSTALL_LIB='$(INSTALL_LIBRARY) $(LIB_FILE) $(LIB_INSTALL_DIR)/$(LIB_FILE)'
        else
        else
            MAKE_LIB='${STLIB_LD} [$]@ ${OBJS} ; ${RANLIB} [$]@'
            MAKE_LIB='${STLIB_LD} [$]@ ${OBJS} ; ${RANLIB} [$]@'
            INSTALL_LIB='$(INSTALL_LIBRARY) $(LIB_FILE) $(LIB_INSTALL_DIR)/$(LIB_FILE) ; (cd $(LIB_INSTALL_DIR) ; $(RANLIB) $(LIB_FILE))'
            INSTALL_LIB='$(INSTALL_LIBRARY) $(LIB_FILE) $(LIB_INSTALL_DIR)/$(LIB_FILE) ; (cd $(LIB_INSTALL_DIR) ; $(RANLIB) $(LIB_FILE))'
        fi
        fi
 
 
dnl        Not at all clear what this was doing in Tcl's configure.in
dnl        Not at all clear what this was doing in Tcl's configure.in
dnl        or why it was needed was needed. In any event, this sort of
dnl        or why it was needed was needed. In any event, this sort of
dnl        things needs to be done in the big loop above.
dnl        things needs to be done in the big loop above.
dnl        REMOVE THIS BLOCK LATER! (mdejong)
dnl        REMOVE THIS BLOCK LATER! (mdejong)
dnl        case $system in
dnl        case $system in
dnl            BSD/OS*)
dnl            BSD/OS*)
dnl                ;;
dnl                ;;
dnl            AIX-[[1-4]].*)
dnl            AIX-[[1-4]].*)
dnl                ;;
dnl                ;;
dnl            *)
dnl            *)
dnl                SHLIB_LD_LIBS=""
dnl                SHLIB_LD_LIBS=""
dnl                ;;
dnl                ;;
dnl        esac
dnl        esac
    fi
    fi
 
 
 
 
    # Stub lib does not depend on shared/static configuration
    # Stub lib does not depend on shared/static configuration
    if test "$RANLIB" = "" ; then
    if test "$RANLIB" = "" ; then
        MAKE_STUB_LIB='${STLIB_LD} [$]@ ${STUB_LIB_OBJS}'
        MAKE_STUB_LIB='${STLIB_LD} [$]@ ${STUB_LIB_OBJS}'
        INSTALL_STUB_LIB='$(INSTALL_LIBRARY) $(STUB_LIB_FILE) $(LIB_INSTALL_DIR)/$(STUB_LIB_FILE)'
        INSTALL_STUB_LIB='$(INSTALL_LIBRARY) $(STUB_LIB_FILE) $(LIB_INSTALL_DIR)/$(STUB_LIB_FILE)'
    else
    else
        MAKE_STUB_LIB='${STLIB_LD} [$]@ ${STUB_LIB_OBJS} ; ${RANLIB} [$]@'
        MAKE_STUB_LIB='${STLIB_LD} [$]@ ${STUB_LIB_OBJS} ; ${RANLIB} [$]@'
        INSTALL_STUB_LIB='$(INSTALL_LIBRARY) $(STUB_LIB_FILE) $(LIB_INSTALL_DIR)/$(STUB_LIB_FILE) ; (cd $(LIB_INSTALL_DIR) ; $(RANLIB) $(STUB_LIB_FILE))'
        INSTALL_STUB_LIB='$(INSTALL_LIBRARY) $(STUB_LIB_FILE) $(LIB_INSTALL_DIR)/$(STUB_LIB_FILE) ; (cd $(LIB_INSTALL_DIR) ; $(RANLIB) $(STUB_LIB_FILE))'
    fi
    fi
 
 
 
 
    AC_SUBST(DL_LIBS)
    AC_SUBST(DL_LIBS)
 
 
    AC_SUBST(DL_OBJS)
    AC_SUBST(DL_OBJS)
    AC_SUBST(PLAT_OBJS)
    AC_SUBST(PLAT_OBJS)
    AC_SUBST(PLAT_SRCS)
    AC_SUBST(PLAT_SRCS)
    AC_SUBST(CFLAGS)
    AC_SUBST(CFLAGS)
    AC_SUBST(CFLAGS_DEBUG)
    AC_SUBST(CFLAGS_DEBUG)
    AC_SUBST(CFLAGS_OPTIMIZE)
    AC_SUBST(CFLAGS_OPTIMIZE)
    AC_SUBST(CFLAGS_WARNING)
    AC_SUBST(CFLAGS_WARNING)
 
 
    AC_SUBST(LDFLAGS)
    AC_SUBST(LDFLAGS)
    AC_SUBST(LDFLAGS_DEBUG)
    AC_SUBST(LDFLAGS_DEBUG)
    AC_SUBST(LDFLAGS_OPTIMIZE)
    AC_SUBST(LDFLAGS_OPTIMIZE)
    AC_SUBST(CC_SEARCH_FLAGS)
    AC_SUBST(CC_SEARCH_FLAGS)
    AC_SUBST(LD_SEARCH_FLAGS)
    AC_SUBST(LD_SEARCH_FLAGS)
 
 
    AC_SUBST(STLIB_LD)
    AC_SUBST(STLIB_LD)
    AC_SUBST(SHLIB_LD)
    AC_SUBST(SHLIB_LD)
    AC_SUBST(TCL_SHLIB_LD_EXTRAS)
    AC_SUBST(TCL_SHLIB_LD_EXTRAS)
    AC_SUBST(TK_SHLIB_LD_EXTRAS)
    AC_SUBST(TK_SHLIB_LD_EXTRAS)
    AC_SUBST(SHLIB_LD_LIBS)
    AC_SUBST(SHLIB_LD_LIBS)
    AC_SUBST(SHLIB_CFLAGS)
    AC_SUBST(SHLIB_CFLAGS)
    AC_SUBST(SHLIB_SUFFIX)
    AC_SUBST(SHLIB_SUFFIX)
 
 
    AC_SUBST(MAKE_LIB)
    AC_SUBST(MAKE_LIB)
    AC_SUBST(MAKE_STUB_LIB)
    AC_SUBST(MAKE_STUB_LIB)
    AC_SUBST(INSTALL_LIB)
    AC_SUBST(INSTALL_LIB)
    AC_SUBST(INSTALL_STUB_LIB)
    AC_SUBST(INSTALL_STUB_LIB)
    AC_SUBST(RANLIB)
    AC_SUBST(RANLIB)
])
])
 
 
#--------------------------------------------------------------------
#--------------------------------------------------------------------
# SC_SERIAL_PORT
# SC_SERIAL_PORT
#
#
#       Determine which interface to use to talk to the serial port.
#       Determine which interface to use to talk to the serial port.
#       Note that #include lines must begin in leftmost column for
#       Note that #include lines must begin in leftmost column for
#       some compilers to recognize them as preprocessor directives,
#       some compilers to recognize them as preprocessor directives,
#       and some build environments have stdin not pointing at a
#       and some build environments have stdin not pointing at a
#       pseudo-terminal (usually /dev/null instead.)
#       pseudo-terminal (usually /dev/null instead.)
#
#
# Arguments:
# Arguments:
#       none
#       none
#
#
# Results:
# Results:
#
#
#       Defines only one of the following vars:
#       Defines only one of the following vars:
#               HAVE_SYS_MODEM_H
#               HAVE_SYS_MODEM_H
#               USE_TERMIOS
#               USE_TERMIOS
#               USE_TERMIO
#               USE_TERMIO
#               USE_SGTTY
#               USE_SGTTY
#
#
#--------------------------------------------------------------------
#--------------------------------------------------------------------
 
 
AC_DEFUN([SC_SERIAL_PORT], [
AC_DEFUN([SC_SERIAL_PORT], [
    AC_CHECK_HEADERS(sys/modem.h)
    AC_CHECK_HEADERS(sys/modem.h)
    AC_CACHE_CHECK([termios vs. termio vs. sgtty], tcl_cv_api_serial, [
    AC_CACHE_CHECK([termios vs. termio vs. sgtty], tcl_cv_api_serial, [
    AC_TRY_RUN([
    AC_TRY_RUN([
#include <termios.h>
#include <termios.h>
 
 
int main() {
int main() {
    struct termios t;
    struct termios t;
    if (tcgetattr(0, &t) == 0) {
    if (tcgetattr(0, &t) == 0) {
        cfsetospeed(&t, 0);
        cfsetospeed(&t, 0);
        t.c_cflag |= PARENB | PARODD | CSIZE | CSTOPB;
        t.c_cflag |= PARENB | PARODD | CSIZE | CSTOPB;
        return 0;
        return 0;
    }
    }
    return 1;
    return 1;
}], tcl_cv_api_serial=termios, tcl_cv_api_serial=no, tcl_cv_api_serial=no)
}], tcl_cv_api_serial=termios, tcl_cv_api_serial=no, tcl_cv_api_serial=no)
    if test $tcl_cv_api_serial = no ; then
    if test $tcl_cv_api_serial = no ; then
        AC_TRY_RUN([
        AC_TRY_RUN([
#include <termio.h>
#include <termio.h>
 
 
int main() {
int main() {
    struct termio t;
    struct termio t;
    if (ioctl(0, TCGETA, &t) == 0) {
    if (ioctl(0, TCGETA, &t) == 0) {
        t.c_cflag |= CBAUD | PARENB | PARODD | CSIZE | CSTOPB;
        t.c_cflag |= CBAUD | PARENB | PARODD | CSIZE | CSTOPB;
        return 0;
        return 0;
    }
    }
    return 1;
    return 1;
}], tcl_cv_api_serial=termio, tcl_cv_api_serial=no, tcl_cv_api_serial=no)
}], tcl_cv_api_serial=termio, tcl_cv_api_serial=no, tcl_cv_api_serial=no)
    fi
    fi
    if test $tcl_cv_api_serial = no ; then
    if test $tcl_cv_api_serial = no ; then
        AC_TRY_RUN([
        AC_TRY_RUN([
#include <sgtty.h>
#include <sgtty.h>
 
 
int main() {
int main() {
    struct sgttyb t;
    struct sgttyb t;
    if (ioctl(0, TIOCGETP, &t) == 0) {
    if (ioctl(0, TIOCGETP, &t) == 0) {
        t.sg_ospeed = 0;
        t.sg_ospeed = 0;
        t.sg_flags |= ODDP | EVENP | RAW;
        t.sg_flags |= ODDP | EVENP | RAW;
        return 0;
        return 0;
    }
    }
    return 1;
    return 1;
}], tcl_cv_api_serial=sgtty, tcl_cv_api_serial=no, tcl_cv_api_serial=no)
}], tcl_cv_api_serial=sgtty, tcl_cv_api_serial=no, tcl_cv_api_serial=no)
    fi
    fi
    if test $tcl_cv_api_serial = no ; then
    if test $tcl_cv_api_serial = no ; then
        AC_TRY_RUN([
        AC_TRY_RUN([
#include <termios.h>
#include <termios.h>
#include <errno.h>
#include <errno.h>
 
 
int main() {
int main() {
    struct termios t;
    struct termios t;
    if (tcgetattr(0, &t) == 0
    if (tcgetattr(0, &t) == 0
        || errno == ENOTTY || errno == ENXIO || errno == EINVAL) {
        || errno == ENOTTY || errno == ENXIO || errno == EINVAL) {
        cfsetospeed(&t, 0);
        cfsetospeed(&t, 0);
        t.c_cflag |= PARENB | PARODD | CSIZE | CSTOPB;
        t.c_cflag |= PARENB | PARODD | CSIZE | CSTOPB;
        return 0;
        return 0;
    }
    }
    return 1;
    return 1;
}], tcl_cv_api_serial=termios, tcl_cv_api_serial=no, tcl_cv_api_serial=no)
}], tcl_cv_api_serial=termios, tcl_cv_api_serial=no, tcl_cv_api_serial=no)
    fi
    fi
    if test $tcl_cv_api_serial = no; then
    if test $tcl_cv_api_serial = no; then
        AC_TRY_RUN([
        AC_TRY_RUN([
#include <termio.h>
#include <termio.h>
#include <errno.h>
#include <errno.h>
 
 
int main() {
int main() {
    struct termio t;
    struct termio t;
    if (ioctl(0, TCGETA, &t) == 0
    if (ioctl(0, TCGETA, &t) == 0
        || errno == ENOTTY || errno == ENXIO || errno == EINVAL) {
        || errno == ENOTTY || errno == ENXIO || errno == EINVAL) {
        t.c_cflag |= CBAUD | PARENB | PARODD | CSIZE | CSTOPB;
        t.c_cflag |= CBAUD | PARENB | PARODD | CSIZE | CSTOPB;
        return 0;
        return 0;
    }
    }
    return 1;
    return 1;
    }], tcl_cv_api_serial=termio, tcl_cv_api_serial=no, tcl_cv_api_serial=no)
    }], tcl_cv_api_serial=termio, tcl_cv_api_serial=no, tcl_cv_api_serial=no)
    fi
    fi
    if test $tcl_cv_api_serial = no; then
    if test $tcl_cv_api_serial = no; then
        AC_TRY_RUN([
        AC_TRY_RUN([
#include <sgtty.h>
#include <sgtty.h>
#include <errno.h>
#include <errno.h>
 
 
int main() {
int main() {
    struct sgttyb t;
    struct sgttyb t;
    if (ioctl(0, TIOCGETP, &t) == 0
    if (ioctl(0, TIOCGETP, &t) == 0
        || errno == ENOTTY || errno == ENXIO || errno == EINVAL) {
        || errno == ENOTTY || errno == ENXIO || errno == EINVAL) {
        t.sg_ospeed = 0;
        t.sg_ospeed = 0;
        t.sg_flags |= ODDP | EVENP | RAW;
        t.sg_flags |= ODDP | EVENP | RAW;
        return 0;
        return 0;
    }
    }
    return 1;
    return 1;
}], tcl_cv_api_serial=sgtty, tcl_cv_api_serial=none, tcl_cv_api_serial=none)
}], tcl_cv_api_serial=sgtty, tcl_cv_api_serial=none, tcl_cv_api_serial=none)
    fi])
    fi])
    case $tcl_cv_api_serial in
    case $tcl_cv_api_serial in
        termios) AC_DEFINE(USE_TERMIOS);;
        termios) AC_DEFINE(USE_TERMIOS);;
        termio)  AC_DEFINE(USE_TERMIO);;
        termio)  AC_DEFINE(USE_TERMIO);;
        sgtty)   AC_DEFINE(USE_SGTTY);;
        sgtty)   AC_DEFINE(USE_SGTTY);;
    esac
    esac
])
])
 
 
#--------------------------------------------------------------------
#--------------------------------------------------------------------
# SC_MISSING_POSIX_HEADERS
# SC_MISSING_POSIX_HEADERS
#
#
#       Supply substitutes for missing POSIX header files.  Special
#       Supply substitutes for missing POSIX header files.  Special
#       notes:
#       notes:
#           - stdlib.h doesn't define strtol, strtoul, or
#           - stdlib.h doesn't define strtol, strtoul, or
#             strtod insome versions of SunOS
#             strtod insome versions of SunOS
#           - some versions of string.h don't declare procedures such
#           - some versions of string.h don't declare procedures such
#             as strstr
#             as strstr
#
#
# Arguments:
# Arguments:
#       none
#       none
#
#
# Results:
# Results:
#
#
#       Defines some of the following vars:
#       Defines some of the following vars:
#               NO_DIRENT_H
#               NO_DIRENT_H
#               NO_ERRNO_H
#               NO_ERRNO_H
#               NO_VALUES_H
#               NO_VALUES_H
#               HAVE_LIMITS_H or NO_LIMITS_H
#               HAVE_LIMITS_H or NO_LIMITS_H
#               NO_STDLIB_H
#               NO_STDLIB_H
#               NO_STRING_H
#               NO_STRING_H
#               NO_SYS_WAIT_H
#               NO_SYS_WAIT_H
#               NO_DLFCN_H
#               NO_DLFCN_H
#               HAVE_UNISTD_H
#               HAVE_UNISTD_H
#               HAVE_SYS_PARAM_H
#               HAVE_SYS_PARAM_H
#
#
#               HAVE_STRING_H ?
#               HAVE_STRING_H ?
#
#
#--------------------------------------------------------------------
#--------------------------------------------------------------------
 
 
AC_DEFUN([SC_MISSING_POSIX_HEADERS], [
AC_DEFUN([SC_MISSING_POSIX_HEADERS], [
    AC_CACHE_CHECK([dirent.h], tcl_cv_dirent_h, [
    AC_CACHE_CHECK([dirent.h], tcl_cv_dirent_h, [
    AC_TRY_LINK([#include <sys/types.h>
    AC_TRY_LINK([#include <sys/types.h>
#include <dirent.h>], [
#include <dirent.h>], [
#ifndef _POSIX_SOURCE
#ifndef _POSIX_SOURCE
#   ifdef __Lynx__
#   ifdef __Lynx__
        /*
        /*
         * Generate compilation error to make the test fail:  Lynx headers
         * Generate compilation error to make the test fail:  Lynx headers
         * are only valid if really in the POSIX environment.
         * are only valid if really in the POSIX environment.
         */
         */
 
 
        missing_procedure();
        missing_procedure();
#   endif
#   endif
#endif
#endif
DIR *d;
DIR *d;
struct dirent *entryPtr;
struct dirent *entryPtr;
char *p;
char *p;
d = opendir("foobar");
d = opendir("foobar");
entryPtr = readdir(d);
entryPtr = readdir(d);
p = entryPtr->d_name;
p = entryPtr->d_name;
closedir(d);
closedir(d);
], tcl_cv_dirent_h=yes, tcl_cv_dirent_h=no)])
], tcl_cv_dirent_h=yes, tcl_cv_dirent_h=no)])
 
 
    if test $tcl_cv_dirent_h = no; then
    if test $tcl_cv_dirent_h = no; then
        AC_DEFINE(NO_DIRENT_H)
        AC_DEFINE(NO_DIRENT_H)
    fi
    fi
 
 
    AC_CHECK_HEADER(errno.h, , [AC_DEFINE(NO_ERRNO_H)])
    AC_CHECK_HEADER(errno.h, , [AC_DEFINE(NO_ERRNO_H)])
    AC_CHECK_HEADER(float.h, , [AC_DEFINE(NO_FLOAT_H)])
    AC_CHECK_HEADER(float.h, , [AC_DEFINE(NO_FLOAT_H)])
    AC_CHECK_HEADER(values.h, , [AC_DEFINE(NO_VALUES_H)])
    AC_CHECK_HEADER(values.h, , [AC_DEFINE(NO_VALUES_H)])
    AC_CHECK_HEADER(limits.h,
    AC_CHECK_HEADER(limits.h,
        [AC_DEFINE(HAVE_LIMITS_H)], [AC_DEFINE(NO_LIMITS_H)])
        [AC_DEFINE(HAVE_LIMITS_H)], [AC_DEFINE(NO_LIMITS_H)])
    AC_CHECK_HEADER(stdlib.h, tcl_ok=1, tcl_ok=0)
    AC_CHECK_HEADER(stdlib.h, tcl_ok=1, tcl_ok=0)
    AC_EGREP_HEADER(strtol, stdlib.h, , tcl_ok=0)
    AC_EGREP_HEADER(strtol, stdlib.h, , tcl_ok=0)
    AC_EGREP_HEADER(strtoul, stdlib.h, , tcl_ok=0)
    AC_EGREP_HEADER(strtoul, stdlib.h, , tcl_ok=0)
    AC_EGREP_HEADER(strtod, stdlib.h, , tcl_ok=0)
    AC_EGREP_HEADER(strtod, stdlib.h, , tcl_ok=0)
    if test $tcl_ok = 0; then
    if test $tcl_ok = 0; then
        AC_DEFINE(NO_STDLIB_H)
        AC_DEFINE(NO_STDLIB_H)
    fi
    fi
    AC_CHECK_HEADER(string.h, tcl_ok=1, tcl_ok=0)
    AC_CHECK_HEADER(string.h, tcl_ok=1, tcl_ok=0)
    AC_EGREP_HEADER(strstr, string.h, , tcl_ok=0)
    AC_EGREP_HEADER(strstr, string.h, , tcl_ok=0)
    AC_EGREP_HEADER(strerror, string.h, , tcl_ok=0)
    AC_EGREP_HEADER(strerror, string.h, , tcl_ok=0)
 
 
    # See also memmove check below for a place where NO_STRING_H can be
    # See also memmove check below for a place where NO_STRING_H can be
    # set and why.
    # set and why.
 
 
    if test $tcl_ok = 0; then
    if test $tcl_ok = 0; then
        AC_DEFINE(NO_STRING_H)
        AC_DEFINE(NO_STRING_H)
    fi
    fi
 
 
    AC_CHECK_HEADER(sys/wait.h, , [AC_DEFINE(NO_SYS_WAIT_H)])
    AC_CHECK_HEADER(sys/wait.h, , [AC_DEFINE(NO_SYS_WAIT_H)])
    AC_CHECK_HEADER(dlfcn.h, , [AC_DEFINE(NO_DLFCN_H)])
    AC_CHECK_HEADER(dlfcn.h, , [AC_DEFINE(NO_DLFCN_H)])
 
 
    # OS/390 lacks sys/param.h (and doesn't need it, by chance).
    # OS/390 lacks sys/param.h (and doesn't need it, by chance).
    AC_HAVE_HEADERS(unistd.h sys/param.h)
    AC_HAVE_HEADERS(unistd.h sys/param.h)
])
])
 
 
#--------------------------------------------------------------------
#--------------------------------------------------------------------
# SC_PATH_X
# SC_PATH_X
#
#
#       Locate the X11 header files and the X11 library archive.  Try
#       Locate the X11 header files and the X11 library archive.  Try
#       the ac_path_x macro first, but if it doesn't find the X stuff
#       the ac_path_x macro first, but if it doesn't find the X stuff
#       (e.g. because there's no xmkmf program) then check through
#       (e.g. because there's no xmkmf program) then check through
#       a list of possible directories.  Under some conditions the
#       a list of possible directories.  Under some conditions the
#       autoconf macro will return an include directory that contains
#       autoconf macro will return an include directory that contains
#       no include files, so double-check its result just to be safe.
#       no include files, so double-check its result just to be safe.
#
#
# Arguments:
# Arguments:
#       none
#       none
#
#
# Results:
# Results:
#
#
#       Sets the the following vars:
#       Sets the the following vars:
#               XINCLUDES
#               XINCLUDES
#               XLIBSW
#               XLIBSW
#
#
#--------------------------------------------------------------------
#--------------------------------------------------------------------
 
 
AC_DEFUN([SC_PATH_X], [
AC_DEFUN([SC_PATH_X], [
    AC_PATH_X
    AC_PATH_X
    not_really_there=""
    not_really_there=""
    if test "$no_x" = ""; then
    if test "$no_x" = ""; then
        if test "$x_includes" = ""; then
        if test "$x_includes" = ""; then
            AC_TRY_CPP([#include <X11/XIntrinsic.h>], , not_really_there="yes")
            AC_TRY_CPP([#include <X11/XIntrinsic.h>], , not_really_there="yes")
        else
        else
            if test ! -r $x_includes/X11/Intrinsic.h; then
            if test ! -r $x_includes/X11/Intrinsic.h; then
                not_really_there="yes"
                not_really_there="yes"
            fi
            fi
        fi
        fi
    fi
    fi
    if test "$no_x" = "yes" -o "$not_really_there" = "yes"; then
    if test "$no_x" = "yes" -o "$not_really_there" = "yes"; then
        AC_MSG_CHECKING([for X11 header files])
        AC_MSG_CHECKING([for X11 header files])
        found_xincludes="no"
        found_xincludes="no"
        AC_TRY_CPP([#include <X11/Intrinsic.h>], found_xincludes="yes", found_xincludes="no")
        AC_TRY_CPP([#include <X11/Intrinsic.h>], found_xincludes="yes", found_xincludes="no")
        if test "$found_xincludes" = "no"; then
        if test "$found_xincludes" = "no"; then
            dirs="/usr/unsupported/include /usr/local/include /usr/X386/include /usr/X11R6/include /usr/X11R5/include /usr/include/X11R5 /usr/include/X11R4 /usr/openwin/include /usr/X11/include /usr/sww/include"
            dirs="/usr/unsupported/include /usr/local/include /usr/X386/include /usr/X11R6/include /usr/X11R5/include /usr/include/X11R5 /usr/include/X11R4 /usr/openwin/include /usr/X11/include /usr/sww/include"
            for i in $dirs ; do
            for i in $dirs ; do
                if test -r $i/X11/Intrinsic.h; then
                if test -r $i/X11/Intrinsic.h; then
                    AC_MSG_RESULT([$i])
                    AC_MSG_RESULT([$i])
                    XINCLUDES=" -I$i"
                    XINCLUDES=" -I$i"
                    found_xincludes="yes"
                    found_xincludes="yes"
                    break
                    break
                fi
                fi
            done
            done
        fi
        fi
    else
    else
        if test "$x_includes" != ""; then
        if test "$x_includes" != ""; then
            XINCLUDES="-I$x_includes"
            XINCLUDES="-I$x_includes"
            found_xincludes="yes"
            found_xincludes="yes"
        fi
        fi
    fi
    fi
    if test found_xincludes = "no"; then
    if test found_xincludes = "no"; then
        AC_MSG_RESULT([couldn't find any!])
        AC_MSG_RESULT([couldn't find any!])
    fi
    fi
 
 
    if test "$no_x" = yes; then
    if test "$no_x" = yes; then
        AC_MSG_CHECKING([for X11 libraries])
        AC_MSG_CHECKING([for X11 libraries])
        XLIBSW=nope
        XLIBSW=nope
        dirs="/usr/unsupported/lib /usr/local/lib /usr/X386/lib /usr/X11R6/lib /usr/X11R5/lib /usr/lib/X11R5 /usr/lib/X11R4 /usr/openwin/lib /usr/X11/lib /usr/sww/X11/lib"
        dirs="/usr/unsupported/lib /usr/local/lib /usr/X386/lib /usr/X11R6/lib /usr/X11R5/lib /usr/lib/X11R5 /usr/lib/X11R4 /usr/openwin/lib /usr/X11/lib /usr/sww/X11/lib"
        for i in $dirs ; do
        for i in $dirs ; do
            if test -r $i/libX11.a -o -r $i/libX11.so -o -r $i/libX11.sl; then
            if test -r $i/libX11.a -o -r $i/libX11.so -o -r $i/libX11.sl; then
                AC_MSG_RESULT([$i])
                AC_MSG_RESULT([$i])
                XLIBSW="-L$i -lX11"
                XLIBSW="-L$i -lX11"
                x_libraries="$i"
                x_libraries="$i"
                break
                break
            fi
            fi
        done
        done
    else
    else
        if test "$x_libraries" = ""; then
        if test "$x_libraries" = ""; then
            XLIBSW=-lX11
            XLIBSW=-lX11
        else
        else
            XLIBSW="-L$x_libraries -lX11"
            XLIBSW="-L$x_libraries -lX11"
        fi
        fi
    fi
    fi
    if test "$XLIBSW" = nope ; then
    if test "$XLIBSW" = nope ; then
        AC_CHECK_LIB(Xwindow, XCreateWindow, XLIBSW=-lXwindow)
        AC_CHECK_LIB(Xwindow, XCreateWindow, XLIBSW=-lXwindow)
    fi
    fi
    if test "$XLIBSW" = nope ; then
    if test "$XLIBSW" = nope ; then
        AC_MSG_RESULT([could not find any!  Using -lX11.])
        AC_MSG_RESULT([could not find any!  Using -lX11.])
        XLIBSW=-lX11
        XLIBSW=-lX11
    fi
    fi
])
])
 
 
#--------------------------------------------------------------------
#--------------------------------------------------------------------
# SC_BLOCKING_STYLE
# SC_BLOCKING_STYLE
#
#
#       The statements below check for systems where POSIX-style
#       The statements below check for systems where POSIX-style
#       non-blocking I/O (O_NONBLOCK) doesn't work or is unimplemented.
#       non-blocking I/O (O_NONBLOCK) doesn't work or is unimplemented.
#       On these systems (mostly older ones), use the old BSD-style
#       On these systems (mostly older ones), use the old BSD-style
#       FIONBIO approach instead.
#       FIONBIO approach instead.
#
#
# Arguments:
# Arguments:
#       none
#       none
#
#
# Results:
# Results:
#
#
#       Defines some of the following vars:
#       Defines some of the following vars:
#               HAVE_SYS_IOCTL_H
#               HAVE_SYS_IOCTL_H
#               HAVE_SYS_FILIO_H
#               HAVE_SYS_FILIO_H
#               USE_FIONBIO
#               USE_FIONBIO
#               O_NONBLOCK
#               O_NONBLOCK
#
#
#--------------------------------------------------------------------
#--------------------------------------------------------------------
 
 
AC_DEFUN([SC_BLOCKING_STYLE], [
AC_DEFUN([SC_BLOCKING_STYLE], [
    AC_CHECK_HEADERS(sys/ioctl.h)
    AC_CHECK_HEADERS(sys/ioctl.h)
    AC_CHECK_HEADERS(sys/filio.h)
    AC_CHECK_HEADERS(sys/filio.h)
    SC_CONFIG_SYSTEM
    SC_CONFIG_SYSTEM
    AC_MSG_CHECKING([FIONBIO vs. O_NONBLOCK for nonblocking I/O])
    AC_MSG_CHECKING([FIONBIO vs. O_NONBLOCK for nonblocking I/O])
    case $system in
    case $system in
        # There used to be code here to use FIONBIO under AIX.  However, it
        # There used to be code here to use FIONBIO under AIX.  However, it
        # was reported that FIONBIO doesn't work under AIX 3.2.5.  Since
        # was reported that FIONBIO doesn't work under AIX 3.2.5.  Since
        # using O_NONBLOCK seems fine under AIX 4.*, I removed the FIONBIO
        # using O_NONBLOCK seems fine under AIX 4.*, I removed the FIONBIO
        # code (JO, 5/31/97).
        # code (JO, 5/31/97).
 
 
        OSF*)
        OSF*)
            AC_DEFINE(USE_FIONBIO)
            AC_DEFINE(USE_FIONBIO)
            AC_MSG_RESULT([FIONBIO])
            AC_MSG_RESULT([FIONBIO])
            ;;
            ;;
        SunOS-4*)
        SunOS-4*)
            AC_DEFINE(USE_FIONBIO)
            AC_DEFINE(USE_FIONBIO)
            AC_MSG_RESULT([FIONBIO])
            AC_MSG_RESULT([FIONBIO])
            ;;
            ;;
        ULTRIX-4.*)
        ULTRIX-4.*)
            AC_DEFINE(USE_FIONBIO)
            AC_DEFINE(USE_FIONBIO)
            AC_MSG_RESULT([FIONBIO])
            AC_MSG_RESULT([FIONBIO])
            ;;
            ;;
        *)
        *)
            AC_MSG_RESULT([O_NONBLOCK])
            AC_MSG_RESULT([O_NONBLOCK])
            ;;
            ;;
    esac
    esac
])
])
 
 
#--------------------------------------------------------------------
#--------------------------------------------------------------------
# SC_TIME_HANLDER
# SC_TIME_HANLDER
#
#
#       Checks how the system deals with time.h, what time structures
#       Checks how the system deals with time.h, what time structures
#       are used on the system, and what fields the structures have.
#       are used on the system, and what fields the structures have.
#
#
# Arguments:
# Arguments:
#       none
#       none
#
#
# Results:
# Results:
#
#
#       Defines some of the following vars:
#       Defines some of the following vars:
#               USE_DELTA_FOR_TZ
#               USE_DELTA_FOR_TZ
#               HAVE_TM_GMTOFF
#               HAVE_TM_GMTOFF
#               HAVE_TM_TZADJ
#               HAVE_TM_TZADJ
#               HAVE_TIMEZONE_VAR
#               HAVE_TIMEZONE_VAR
#
#
#--------------------------------------------------------------------
#--------------------------------------------------------------------
 
 
AC_DEFUN([SC_TIME_HANDLER], [
AC_DEFUN([SC_TIME_HANDLER], [
    AC_CHECK_HEADERS(sys/time.h)
    AC_CHECK_HEADERS(sys/time.h)
    AC_HEADER_TIME
    AC_HEADER_TIME
    AC_STRUCT_TIMEZONE
    AC_STRUCT_TIMEZONE
 
 
    AC_CHECK_FUNCS(gmtime_r localtime_r)
    AC_CHECK_FUNCS(gmtime_r localtime_r)
 
 
    AC_CACHE_CHECK([tm_tzadj in struct tm], tcl_cv_member_tm_tzadj, [
    AC_CACHE_CHECK([tm_tzadj in struct tm], tcl_cv_member_tm_tzadj, [
        AC_TRY_COMPILE([#include <time.h>], [struct tm tm; tm.tm_tzadj;],
        AC_TRY_COMPILE([#include <time.h>], [struct tm tm; tm.tm_tzadj;],
            tcl_cv_member_tm_tzadj=yes, tcl_cv_member_tm_tzadj=no)])
            tcl_cv_member_tm_tzadj=yes, tcl_cv_member_tm_tzadj=no)])
    if test $tcl_cv_member_tm_tzadj = yes ; then
    if test $tcl_cv_member_tm_tzadj = yes ; then
        AC_DEFINE(HAVE_TM_TZADJ)
        AC_DEFINE(HAVE_TM_TZADJ)
    fi
    fi
 
 
    AC_CACHE_CHECK([tm_gmtoff in struct tm], tcl_cv_member_tm_gmtoff, [
    AC_CACHE_CHECK([tm_gmtoff in struct tm], tcl_cv_member_tm_gmtoff, [
        AC_TRY_COMPILE([#include <time.h>], [struct tm tm; tm.tm_gmtoff;],
        AC_TRY_COMPILE([#include <time.h>], [struct tm tm; tm.tm_gmtoff;],
            tcl_cv_member_tm_gmtoff=yes, tcl_cv_member_tm_gmtoff=no)])
            tcl_cv_member_tm_gmtoff=yes, tcl_cv_member_tm_gmtoff=no)])
    if test $tcl_cv_member_tm_gmtoff = yes ; then
    if test $tcl_cv_member_tm_gmtoff = yes ; then
        AC_DEFINE(HAVE_TM_GMTOFF)
        AC_DEFINE(HAVE_TM_GMTOFF)
    fi
    fi
 
 
    #
    #
    # Its important to include time.h in this check, as some systems
    # Its important to include time.h in this check, as some systems
    # (like convex) have timezone functions, etc.
    # (like convex) have timezone functions, etc.
    #
    #
    AC_CACHE_CHECK([long timezone variable], tcl_cv_timezone_long, [
    AC_CACHE_CHECK([long timezone variable], tcl_cv_timezone_long, [
        AC_TRY_COMPILE([#include <time.h>],
        AC_TRY_COMPILE([#include <time.h>],
            [extern long timezone;
            [extern long timezone;
            timezone += 1;
            timezone += 1;
            exit (0);],
            exit (0);],
            tcl_cv_timezone_long=yes, tcl_cv_timezone_long=no)])
            tcl_cv_timezone_long=yes, tcl_cv_timezone_long=no)])
    if test $tcl_cv_timezone_long = yes ; then
    if test $tcl_cv_timezone_long = yes ; then
        AC_DEFINE(HAVE_TIMEZONE_VAR)
        AC_DEFINE(HAVE_TIMEZONE_VAR)
    else
    else
        #
        #
        # On some systems (eg IRIX 6.2), timezone is a time_t and not a long.
        # On some systems (eg IRIX 6.2), timezone is a time_t and not a long.
        #
        #
        AC_CACHE_CHECK([time_t timezone variable], tcl_cv_timezone_time, [
        AC_CACHE_CHECK([time_t timezone variable], tcl_cv_timezone_time, [
            AC_TRY_COMPILE([#include <time.h>],
            AC_TRY_COMPILE([#include <time.h>],
                [extern time_t timezone;
                [extern time_t timezone;
                timezone += 1;
                timezone += 1;
                exit (0);],
                exit (0);],
                tcl_cv_timezone_time=yes, tcl_cv_timezone_time=no)])
                tcl_cv_timezone_time=yes, tcl_cv_timezone_time=no)])
        if test $tcl_cv_timezone_time = yes ; then
        if test $tcl_cv_timezone_time = yes ; then
            AC_DEFINE(HAVE_TIMEZONE_VAR)
            AC_DEFINE(HAVE_TIMEZONE_VAR)
        fi
        fi
    fi
    fi
])
])
 
 
#--------------------------------------------------------------------
#--------------------------------------------------------------------
# SC_BUGGY_STRTOD
# SC_BUGGY_STRTOD
#
#
#       Under Solaris 2.4, strtod returns the wrong value for the
#       Under Solaris 2.4, strtod returns the wrong value for the
#       terminating character under some conditions.  Check for this
#       terminating character under some conditions.  Check for this
#       and if the problem exists use a substitute procedure
#       and if the problem exists use a substitute procedure
#       "fixstrtod" (provided by Tcl) that corrects the error.
#       "fixstrtod" (provided by Tcl) that corrects the error.
#       Also, on Compaq's Tru64 Unix 5.0,
#       Also, on Compaq's Tru64 Unix 5.0,
#       strtod(" ") returns 0.0 instead of a failure to convert.
#       strtod(" ") returns 0.0 instead of a failure to convert.
#
#
# Arguments:
# Arguments:
#       none
#       none
#
#
# Results:
# Results:
#
#
#       Might defines some of the following vars:
#       Might defines some of the following vars:
#               strtod (=fixstrtod)
#               strtod (=fixstrtod)
#
#
#--------------------------------------------------------------------
#--------------------------------------------------------------------
 
 
AC_DEFUN([SC_BUGGY_STRTOD], [
AC_DEFUN([SC_BUGGY_STRTOD], [
    AC_CHECK_FUNC(strtod, tcl_strtod=1, tcl_strtod=0)
    AC_CHECK_FUNC(strtod, tcl_strtod=1, tcl_strtod=0)
    if test "$tcl_strtod" = 1; then
    if test "$tcl_strtod" = 1; then
        AC_CACHE_CHECK([for Solaris2.4/Tru64 strtod bugs], tcl_cv_strtod_buggy,[
        AC_CACHE_CHECK([for Solaris2.4/Tru64 strtod bugs], tcl_cv_strtod_buggy,[
            AC_TRY_RUN([
            AC_TRY_RUN([
                extern double strtod();
                extern double strtod();
                int main() {
                int main() {
                    char *infString="Inf", *nanString="NaN", *spaceString=" ";
                    char *infString="Inf", *nanString="NaN", *spaceString=" ";
                    char *term;
                    char *term;
                    double value;
                    double value;
                    value = strtod(infString, &term);
                    value = strtod(infString, &term);
                    if ((term != infString) && (term[-1] == 0)) {
                    if ((term != infString) && (term[-1] == 0)) {
                        exit(1);
                        exit(1);
                    }
                    }
                    value = strtod(nanString, &term);
                    value = strtod(nanString, &term);
                    if ((term != nanString) && (term[-1] == 0)) {
                    if ((term != nanString) && (term[-1] == 0)) {
                        exit(1);
                        exit(1);
                    }
                    }
                    value = strtod(spaceString, &term);
                    value = strtod(spaceString, &term);
                    if (term == (spaceString+1)) {
                    if (term == (spaceString+1)) {
                        exit(1);
                        exit(1);
                    }
                    }
                    exit(0);
                    exit(0);
                }], tcl_cv_strtod_buggy=ok, tcl_cv_strtod_buggy=buggy,
                }], tcl_cv_strtod_buggy=ok, tcl_cv_strtod_buggy=buggy,
                    tcl_cv_strtod_buggy=buggy)])
                    tcl_cv_strtod_buggy=buggy)])
        if test "$tcl_cv_strtod_buggy" = buggy; then
        if test "$tcl_cv_strtod_buggy" = buggy; then
            LIBOBJS="$LIBOBJS fixstrtod.o"
            LIBOBJS="$LIBOBJS fixstrtod.o"
            AC_DEFINE(strtod, fixstrtod)
            AC_DEFINE(strtod, fixstrtod)
        fi
        fi
    fi
    fi
])
])
 
 
#--------------------------------------------------------------------
#--------------------------------------------------------------------
# SC_TCL_LINK_LIBS
# SC_TCL_LINK_LIBS
#
#
#       Search for the libraries needed to link the Tcl shell.
#       Search for the libraries needed to link the Tcl shell.
#       Things like the math library (-lm) and socket stuff (-lsocket vs.
#       Things like the math library (-lm) and socket stuff (-lsocket vs.
#       -lnsl) are dealt with here.
#       -lnsl) are dealt with here.
#
#
# Arguments:
# Arguments:
#       Requires the following vars to be set in the Makefile:
#       Requires the following vars to be set in the Makefile:
#               DL_LIBS
#               DL_LIBS
#               LIBS
#               LIBS
#               MATH_LIBS
#               MATH_LIBS
#
#
# Results:
# Results:
#
#
#       Subst's the following var:
#       Subst's the following var:
#               TCL_LIBS
#               TCL_LIBS
#               MATH_LIBS
#               MATH_LIBS
#
#
#       Might append to the following vars:
#       Might append to the following vars:
#               LIBS
#               LIBS
#
#
#       Might define the following vars:
#       Might define the following vars:
#               HAVE_NET_ERRNO_H
#               HAVE_NET_ERRNO_H
#
#
#--------------------------------------------------------------------
#--------------------------------------------------------------------
 
 
AC_DEFUN([SC_TCL_LINK_LIBS], [
AC_DEFUN([SC_TCL_LINK_LIBS], [
    #--------------------------------------------------------------------
    #--------------------------------------------------------------------
    # On a few very rare systems, all of the libm.a stuff is
    # On a few very rare systems, all of the libm.a stuff is
    # already in libc.a.  Set compiler flags accordingly.
    # already in libc.a.  Set compiler flags accordingly.
    # Also, Linux requires the "ieee" library for math to work
    # Also, Linux requires the "ieee" library for math to work
    # right (and it must appear before "-lm").
    # right (and it must appear before "-lm").
    #--------------------------------------------------------------------
    #--------------------------------------------------------------------
 
 
    AC_CHECK_FUNC(sin, MATH_LIBS="", MATH_LIBS="-lm")
    AC_CHECK_FUNC(sin, MATH_LIBS="", MATH_LIBS="-lm")
    AC_CHECK_LIB(ieee, main, [MATH_LIBS="-lieee $MATH_LIBS"])
    AC_CHECK_LIB(ieee, main, [MATH_LIBS="-lieee $MATH_LIBS"])
 
 
    #--------------------------------------------------------------------
    #--------------------------------------------------------------------
    # Interactive UNIX requires -linet instead of -lsocket, plus it
    # Interactive UNIX requires -linet instead of -lsocket, plus it
    # needs net/errno.h to define the socket-related error codes.
    # needs net/errno.h to define the socket-related error codes.
    #--------------------------------------------------------------------
    #--------------------------------------------------------------------
 
 
    AC_CHECK_LIB(inet, main, [LIBS="$LIBS -linet"])
    AC_CHECK_LIB(inet, main, [LIBS="$LIBS -linet"])
    AC_CHECK_HEADER(net/errno.h, [AC_DEFINE(HAVE_NET_ERRNO_H)])
    AC_CHECK_HEADER(net/errno.h, [AC_DEFINE(HAVE_NET_ERRNO_H)])
 
 
    #--------------------------------------------------------------------
    #--------------------------------------------------------------------
    #   Check for the existence of the -lsocket and -lnsl libraries.
    #   Check for the existence of the -lsocket and -lnsl libraries.
    #   The order here is important, so that they end up in the right
    #   The order here is important, so that they end up in the right
    #   order in the command line generated by make.  Here are some
    #   order in the command line generated by make.  Here are some
    #   special considerations:
    #   special considerations:
    #   1. Use "connect" and "accept" to check for -lsocket, and
    #   1. Use "connect" and "accept" to check for -lsocket, and
    #      "gethostbyname" to check for -lnsl.
    #      "gethostbyname" to check for -lnsl.
    #   2. Use each function name only once:  can't redo a check because
    #   2. Use each function name only once:  can't redo a check because
    #      autoconf caches the results of the last check and won't redo it.
    #      autoconf caches the results of the last check and won't redo it.
    #   3. Use -lnsl and -lsocket only if they supply procedures that
    #   3. Use -lnsl and -lsocket only if they supply procedures that
    #      aren't already present in the normal libraries.  This is because
    #      aren't already present in the normal libraries.  This is because
    #      IRIX 5.2 has libraries, but they aren't needed and they're
    #      IRIX 5.2 has libraries, but they aren't needed and they're
    #      bogus:  they goof up name resolution if used.
    #      bogus:  they goof up name resolution if used.
    #   4. On some SVR4 systems, can't use -lsocket without -lnsl too.
    #   4. On some SVR4 systems, can't use -lsocket without -lnsl too.
    #      To get around this problem, check for both libraries together
    #      To get around this problem, check for both libraries together
    #      if -lsocket doesn't work by itself.
    #      if -lsocket doesn't work by itself.
    #--------------------------------------------------------------------
    #--------------------------------------------------------------------
 
 
    tcl_checkBoth=0
    tcl_checkBoth=0
    AC_CHECK_FUNC(connect, tcl_checkSocket=0, tcl_checkSocket=1)
    AC_CHECK_FUNC(connect, tcl_checkSocket=0, tcl_checkSocket=1)
    if test "$tcl_checkSocket" = 1; then
    if test "$tcl_checkSocket" = 1; then
        AC_CHECK_FUNC(setsockopt, , [AC_CHECK_LIB(socket, setsockopt,
        AC_CHECK_FUNC(setsockopt, , [AC_CHECK_LIB(socket, setsockopt,
            LIBS="$LIBS -lsocket", tcl_checkBoth=1)])
            LIBS="$LIBS -lsocket", tcl_checkBoth=1)])
    fi
    fi
    if test "$tcl_checkBoth" = 1; then
    if test "$tcl_checkBoth" = 1; then
        tk_oldLibs=$LIBS
        tk_oldLibs=$LIBS
        LIBS="$LIBS -lsocket -lnsl"
        LIBS="$LIBS -lsocket -lnsl"
        AC_CHECK_FUNC(accept, tcl_checkNsl=0, [LIBS=$tk_oldLibs])
        AC_CHECK_FUNC(accept, tcl_checkNsl=0, [LIBS=$tk_oldLibs])
    fi
    fi
    AC_CHECK_FUNC(gethostbyname, , [AC_CHECK_LIB(nsl, gethostbyname,
    AC_CHECK_FUNC(gethostbyname, , [AC_CHECK_LIB(nsl, gethostbyname,
            [LIBS="$LIBS -lnsl"])])
            [LIBS="$LIBS -lnsl"])])
 
 
    # Don't perform the eval of the libraries here because DL_LIBS
    # Don't perform the eval of the libraries here because DL_LIBS
    # won't be set until we call SC_CONFIG_CFLAGS
    # won't be set until we call SC_CONFIG_CFLAGS
 
 
    TCL_LIBS='${DL_LIBS} ${LIBS} ${MATH_LIBS}'
    TCL_LIBS='${DL_LIBS} ${LIBS} ${MATH_LIBS}'
    AC_SUBST(TCL_LIBS)
    AC_SUBST(TCL_LIBS)
    AC_SUBST(MATH_LIBS)
    AC_SUBST(MATH_LIBS)
])
])
 
 
#--------------------------------------------------------------------
#--------------------------------------------------------------------
# SC_TCL_EARLY_FLAGS
# SC_TCL_EARLY_FLAGS
#
#
#       Check for what flags are needed to be passed so the correct OS
#       Check for what flags are needed to be passed so the correct OS
#       features are available.
#       features are available.
#
#
# Arguments:
# Arguments:
#       None
#       None
#
#
# Results:
# Results:
#
#
#       Might define the following vars:
#       Might define the following vars:
#               _ISOC99_SOURCE
#               _ISOC99_SOURCE
#               _LARGEFILE64_SOURCE
#               _LARGEFILE64_SOURCE
#               _LARGEFILE_SOURCE64
#               _LARGEFILE_SOURCE64
#
#
#--------------------------------------------------------------------
#--------------------------------------------------------------------
 
 
AC_DEFUN([SC_TCL_EARLY_FLAG],[
AC_DEFUN([SC_TCL_EARLY_FLAG],[
    AC_CACHE_VAL([tcl_cv_flag_]translit($1,[A-Z],[a-z]),
    AC_CACHE_VAL([tcl_cv_flag_]translit($1,[A-Z],[a-z]),
        AC_TRY_COMPILE([$2], $3, [tcl_cv_flag_]translit($1,[A-Z],[a-z])=no,
        AC_TRY_COMPILE([$2], $3, [tcl_cv_flag_]translit($1,[A-Z],[a-z])=no,
            AC_TRY_COMPILE([[#define ]$1[ 1
            AC_TRY_COMPILE([[#define ]$1[ 1
]$2], $3,
]$2], $3,
                [tcl_cv_flag_]translit($1,[A-Z],[a-z])=yes,
                [tcl_cv_flag_]translit($1,[A-Z],[a-z])=yes,
                [tcl_cv_flag_]translit($1,[A-Z],[a-z])=no)))
                [tcl_cv_flag_]translit($1,[A-Z],[a-z])=no)))
    if test ["x${tcl_cv_flag_]translit($1,[A-Z],[a-z])[}" = "xyes"] ; then
    if test ["x${tcl_cv_flag_]translit($1,[A-Z],[a-z])[}" = "xyes"] ; then
        AC_DEFINE($1)
        AC_DEFINE($1)
        tcl_flags="$tcl_flags $1"
        tcl_flags="$tcl_flags $1"
    fi
    fi
])
])
 
 
AC_DEFUN([SC_TCL_EARLY_FLAGS],[
AC_DEFUN([SC_TCL_EARLY_FLAGS],[
    AC_MSG_CHECKING([for required early compiler flags])
    AC_MSG_CHECKING([for required early compiler flags])
    tcl_flags=""
    tcl_flags=""
    SC_TCL_EARLY_FLAG(_ISOC99_SOURCE,[#include <stdlib.h>],
    SC_TCL_EARLY_FLAG(_ISOC99_SOURCE,[#include <stdlib.h>],
        [char *p = (char *)strtoll; char *q = (char *)strtoull;])
        [char *p = (char *)strtoll; char *q = (char *)strtoull;])
    SC_TCL_EARLY_FLAG(_LARGEFILE64_SOURCE,[#include <sys/stat.h>],
    SC_TCL_EARLY_FLAG(_LARGEFILE64_SOURCE,[#include <sys/stat.h>],
        [struct stat64 buf; int i = stat64("/", &buf);])
        [struct stat64 buf; int i = stat64("/", &buf);])
    SC_TCL_EARLY_FLAG(_LARGEFILE_SOURCE64,[#include <sys/stat.h>],
    SC_TCL_EARLY_FLAG(_LARGEFILE_SOURCE64,[#include <sys/stat.h>],
        [char *p = (char *)open64;])
        [char *p = (char *)open64;])
    if test "x${tcl_flags}" = "x" ; then
    if test "x${tcl_flags}" = "x" ; then
        AC_MSG_RESULT([none])
        AC_MSG_RESULT([none])
    else
    else
        AC_MSG_RESULT([${tcl_flags}])
        AC_MSG_RESULT([${tcl_flags}])
    fi
    fi
])
])
 
 
#--------------------------------------------------------------------
#--------------------------------------------------------------------
# SC_TCL_64BIT_FLAGS
# SC_TCL_64BIT_FLAGS
#
#
#       Check for what is defined in the way of 64-bit features.
#       Check for what is defined in the way of 64-bit features.
#
#
# Arguments:
# Arguments:
#       None
#       None
#
#
# Results:
# Results:
#
#
#       Might define the following vars:
#       Might define the following vars:
#               TCL_WIDE_INT_IS_LONG
#               TCL_WIDE_INT_IS_LONG
#               TCL_WIDE_INT_TYPE
#               TCL_WIDE_INT_TYPE
#               HAVE_STRUCT_DIRENT64
#               HAVE_STRUCT_DIRENT64
#               HAVE_STRUCT_STAT64
#               HAVE_STRUCT_STAT64
#               HAVE_TYPE_OFF64_T
#               HAVE_TYPE_OFF64_T
#
#
#--------------------------------------------------------------------
#--------------------------------------------------------------------
 
 
AC_DEFUN([SC_TCL_64BIT_FLAGS], [
AC_DEFUN([SC_TCL_64BIT_FLAGS], [
    AC_MSG_CHECKING([for 64-bit integer type])
    AC_MSG_CHECKING([for 64-bit integer type])
    AC_CACHE_VAL(tcl_cv_type_64bit,[
    AC_CACHE_VAL(tcl_cv_type_64bit,[
        tcl_cv_type_64bit=none
        tcl_cv_type_64bit=none
        # See if the compiler knows natively about __int64
        # See if the compiler knows natively about __int64
        AC_TRY_COMPILE(,[__int64 value = (__int64) 0;],
        AC_TRY_COMPILE(,[__int64 value = (__int64) 0;],
            tcl_type_64bit=__int64, tcl_type_64bit="long long")
            tcl_type_64bit=__int64, tcl_type_64bit="long long")
        # See if we should use long anyway  Note that we substitute in the
        # See if we should use long anyway  Note that we substitute in the
        # type that is our current guess for a 64-bit type inside this check
        # type that is our current guess for a 64-bit type inside this check
        # program, so it should be modified only carefully...
        # program, so it should be modified only carefully...
        AC_TRY_COMPILE(,[switch (0) {
        AC_TRY_COMPILE(,[switch (0) {
            case 1: case (sizeof(]${tcl_type_64bit}[)==sizeof(long)): ;
            case 1: case (sizeof(]${tcl_type_64bit}[)==sizeof(long)): ;
        }],tcl_cv_type_64bit=${tcl_type_64bit})])
        }],tcl_cv_type_64bit=${tcl_type_64bit})])
    if test "${tcl_cv_type_64bit}" = none ; then
    if test "${tcl_cv_type_64bit}" = none ; then
        AC_DEFINE(TCL_WIDE_INT_IS_LONG)
        AC_DEFINE(TCL_WIDE_INT_IS_LONG)
        AC_MSG_RESULT([using long])
        AC_MSG_RESULT([using long])
    else
    else
        AC_DEFINE_UNQUOTED(TCL_WIDE_INT_TYPE,${tcl_cv_type_64bit})
        AC_DEFINE_UNQUOTED(TCL_WIDE_INT_TYPE,${tcl_cv_type_64bit})
        AC_MSG_RESULT([${tcl_cv_type_64bit}])
        AC_MSG_RESULT([${tcl_cv_type_64bit}])
 
 
        # Now check for auxiliary declarations
        # Now check for auxiliary declarations
        AC_CACHE_CHECK([for struct dirent64], tcl_cv_struct_dirent64,[
        AC_CACHE_CHECK([for struct dirent64], tcl_cv_struct_dirent64,[
            AC_TRY_COMPILE([#include <sys/types.h>
            AC_TRY_COMPILE([#include <sys/types.h>
#include <sys/dirent.h>],[struct dirent64 p;],
#include <sys/dirent.h>],[struct dirent64 p;],
                tcl_cv_struct_dirent64=yes,tcl_cv_struct_dirent64=no)])
                tcl_cv_struct_dirent64=yes,tcl_cv_struct_dirent64=no)])
        if test "x${tcl_cv_struct_dirent64}" = "xyes" ; then
        if test "x${tcl_cv_struct_dirent64}" = "xyes" ; then
            AC_DEFINE(HAVE_STRUCT_DIRENT64)
            AC_DEFINE(HAVE_STRUCT_DIRENT64)
        fi
        fi
 
 
        AC_CACHE_CHECK([for struct stat64], tcl_cv_struct_stat64,[
        AC_CACHE_CHECK([for struct stat64], tcl_cv_struct_stat64,[
            AC_TRY_COMPILE([#include <sys/stat.h>],[struct stat64 p;
            AC_TRY_COMPILE([#include <sys/stat.h>],[struct stat64 p;
],
],
                tcl_cv_struct_stat64=yes,tcl_cv_struct_stat64=no)])
                tcl_cv_struct_stat64=yes,tcl_cv_struct_stat64=no)])
        if test "x${tcl_cv_struct_stat64}" = "xyes" ; then
        if test "x${tcl_cv_struct_stat64}" = "xyes" ; then
            AC_DEFINE(HAVE_STRUCT_STAT64)
            AC_DEFINE(HAVE_STRUCT_STAT64)
        fi
        fi
 
 
        AC_CHECK_FUNCS(open64 lseek64)
        AC_CHECK_FUNCS(open64 lseek64)
        AC_MSG_CHECKING([for off64_t])
        AC_MSG_CHECKING([for off64_t])
        AC_CACHE_VAL(tcl_cv_type_off64_t,[
        AC_CACHE_VAL(tcl_cv_type_off64_t,[
            AC_TRY_COMPILE([#include <sys/types.h>],[off64_t offset;
            AC_TRY_COMPILE([#include <sys/types.h>],[off64_t offset;
],
],
                tcl_cv_type_off64_t=yes,tcl_cv_type_off64_t=no)])
                tcl_cv_type_off64_t=yes,tcl_cv_type_off64_t=no)])
        dnl Define HAVE_TYPE_OFF64_T only when the off64_t type and the
        dnl Define HAVE_TYPE_OFF64_T only when the off64_t type and the
        dnl functions lseek64 and open64 are defined.
        dnl functions lseek64 and open64 are defined.
        if test "x${tcl_cv_type_off64_t}" = "xyes" && \
        if test "x${tcl_cv_type_off64_t}" = "xyes" && \
                test "x${ac_cv_func_lseek64}" = "xyes" && \
                test "x${ac_cv_func_lseek64}" = "xyes" && \
                test "x${ac_cv_func_open64}" = "xyes" ; then
                test "x${ac_cv_func_open64}" = "xyes" ; then
            AC_DEFINE(HAVE_TYPE_OFF64_T)
            AC_DEFINE(HAVE_TYPE_OFF64_T)
            AC_MSG_RESULT([yes])
            AC_MSG_RESULT([yes])
        else
        else
            AC_MSG_RESULT([no])
            AC_MSG_RESULT([no])
        fi
        fi
    fi
    fi
])
])
 
 
#--------------------------------------------------------------------
#--------------------------------------------------------------------
# SC_TCL_GETHOSTBYADDR_R
# SC_TCL_GETHOSTBYADDR_R
#
#
#       Check if we have MT-safe variant of gethostbyaddr().
#       Check if we have MT-safe variant of gethostbyaddr().
#
#
# Arguments:
# Arguments:
#       None
#       None
#
#
# Results:
# Results:
#
#
#       Might define the following vars:
#       Might define the following vars:
#               HAVE_GETHOSTBYADDR_R
#               HAVE_GETHOSTBYADDR_R
#               HAVE_GETHOSTBYADDR_R_7
#               HAVE_GETHOSTBYADDR_R_7
#               HAVE_GETHOSTBYADDR_R_8
#               HAVE_GETHOSTBYADDR_R_8
#
#
#--------------------------------------------------------------------
#--------------------------------------------------------------------
 
 
AC_DEFUN([SC_TCL_GETHOSTBYADDR_R], [AC_CHECK_FUNC(gethostbyaddr_r, [
AC_DEFUN([SC_TCL_GETHOSTBYADDR_R], [AC_CHECK_FUNC(gethostbyaddr_r, [
    AC_CACHE_CHECK([for gethostbyaddr_r with 7 args], tcl_cv_api_gethostbyaddr_r_7, [
    AC_CACHE_CHECK([for gethostbyaddr_r with 7 args], tcl_cv_api_gethostbyaddr_r_7, [
    AC_TRY_COMPILE([
    AC_TRY_COMPILE([
        #include <netdb.h>
        #include <netdb.h>
    ], [
    ], [
        char *addr;
        char *addr;
        int length;
        int length;
        int type;
        int type;
        struct hostent *result;
        struct hostent *result;
        char buffer[2048];
        char buffer[2048];
        int buflen = 2048;
        int buflen = 2048;
        int h_errnop;
        int h_errnop;
 
 
        (void) gethostbyaddr_r(addr, length, type, result, buffer, buflen,
        (void) gethostbyaddr_r(addr, length, type, result, buffer, buflen,
                               &h_errnop);
                               &h_errnop);
    ], tcl_cv_api_gethostbyaddr_r_7=yes, tcl_cv_api_gethostbyaddr_r_7=no)])
    ], tcl_cv_api_gethostbyaddr_r_7=yes, tcl_cv_api_gethostbyaddr_r_7=no)])
    tcl_ok=$tcl_cv_api_gethostbyaddr_r_7
    tcl_ok=$tcl_cv_api_gethostbyaddr_r_7
    if test "$tcl_ok" = yes; then
    if test "$tcl_ok" = yes; then
        AC_DEFINE(HAVE_GETHOSTBYADDR_R_7)
        AC_DEFINE(HAVE_GETHOSTBYADDR_R_7)
    else
    else
        AC_CACHE_CHECK([for gethostbyaddr_r with 8 args], tcl_cv_api_gethostbyaddr_r_8, [
        AC_CACHE_CHECK([for gethostbyaddr_r with 8 args], tcl_cv_api_gethostbyaddr_r_8, [
        AC_TRY_COMPILE([
        AC_TRY_COMPILE([
            #include <netdb.h>
            #include <netdb.h>
        ], [
        ], [
            char *addr;
            char *addr;
            int length;
            int length;
            int type;
            int type;
            struct hostent *result, *resultp;
            struct hostent *result, *resultp;
            char buffer[2048];
            char buffer[2048];
            int buflen = 2048;
            int buflen = 2048;
            int h_errnop;
            int h_errnop;
 
 
            (void) gethostbyaddr_r(addr, length, type, result, buffer, buflen,
            (void) gethostbyaddr_r(addr, length, type, result, buffer, buflen,
                                   &resultp, &h_errnop);
                                   &resultp, &h_errnop);
        ], tcl_cv_api_gethostbyaddr_r_8=yes, tcl_cv_api_gethostbyaddr_r_8=no)])
        ], tcl_cv_api_gethostbyaddr_r_8=yes, tcl_cv_api_gethostbyaddr_r_8=no)])
        tcl_ok=$tcl_cv_api_gethostbyaddr_r_8
        tcl_ok=$tcl_cv_api_gethostbyaddr_r_8
        if test "$tcl_ok" = yes; then
        if test "$tcl_ok" = yes; then
            AC_DEFINE(HAVE_GETHOSTBYADDR_R_8)
            AC_DEFINE(HAVE_GETHOSTBYADDR_R_8)
        fi
        fi
    fi
    fi
    if test "$tcl_ok" = yes; then
    if test "$tcl_ok" = yes; then
        AC_DEFINE(HAVE_GETHOSTBYADDR_R)
        AC_DEFINE(HAVE_GETHOSTBYADDR_R)
    fi
    fi
])])
])])
 
 
#--------------------------------------------------------------------
#--------------------------------------------------------------------
# SC_TCL_GETHOSTBYNAME_R
# SC_TCL_GETHOSTBYNAME_R
#
#
#       Check to see what variant of gethostbyname_r() we have.
#       Check to see what variant of gethostbyname_r() we have.
#       Based on David Arnold's example from the comp.programming.threads
#       Based on David Arnold's example from the comp.programming.threads
#       FAQ Q213
#       FAQ Q213
#
#
# Arguments:
# Arguments:
#       None
#       None
#
#
# Results:
# Results:
#
#
#       Might define the following vars:
#       Might define the following vars:
#               HAVE_GETHOSTBYADDR_R
#               HAVE_GETHOSTBYADDR_R
#               HAVE_GETHOSTBYADDR_R_3
#               HAVE_GETHOSTBYADDR_R_3
#               HAVE_GETHOSTBYADDR_R_5
#               HAVE_GETHOSTBYADDR_R_5
#               HAVE_GETHOSTBYADDR_R_6
#               HAVE_GETHOSTBYADDR_R_6
#
#
#--------------------------------------------------------------------
#--------------------------------------------------------------------
 
 
AC_DEFUN([SC_TCL_GETHOSTBYNAME_R], [AC_CHECK_FUNC(gethostbyname_r, [
AC_DEFUN([SC_TCL_GETHOSTBYNAME_R], [AC_CHECK_FUNC(gethostbyname_r, [
    AC_CACHE_CHECK([for gethostbyname_r with 6 args], tcl_cv_api_gethostbyname_r_6, [
    AC_CACHE_CHECK([for gethostbyname_r with 6 args], tcl_cv_api_gethostbyname_r_6, [
    AC_TRY_COMPILE([
    AC_TRY_COMPILE([
        #include <netdb.h>
        #include <netdb.h>
    ], [
    ], [
        char *name;
        char *name;
        struct hostent *he, *res;
        struct hostent *he, *res;
        char buffer[2048];
        char buffer[2048];
        int buflen = 2048;
        int buflen = 2048;
        int h_errnop;
        int h_errnop;
 
 
        (void) gethostbyname_r(name, he, buffer, buflen, &res, &h_errnop);
        (void) gethostbyname_r(name, he, buffer, buflen, &res, &h_errnop);
    ], tcl_cv_api_gethostbyname_r_6=yes, tcl_cv_api_gethostbyname_r_6=no)])
    ], tcl_cv_api_gethostbyname_r_6=yes, tcl_cv_api_gethostbyname_r_6=no)])
    tcl_ok=$tcl_cv_api_gethostbyname_r_6
    tcl_ok=$tcl_cv_api_gethostbyname_r_6
    if test "$tcl_ok" = yes; then
    if test "$tcl_ok" = yes; then
        AC_DEFINE(HAVE_GETHOSTBYNAME_R_6)
        AC_DEFINE(HAVE_GETHOSTBYNAME_R_6)
    else
    else
        AC_CACHE_CHECK([for gethostbyname_r with 5 args], tcl_cv_api_gethostbyname_r_5, [
        AC_CACHE_CHECK([for gethostbyname_r with 5 args], tcl_cv_api_gethostbyname_r_5, [
        AC_TRY_COMPILE([
        AC_TRY_COMPILE([
            #include <netdb.h>
            #include <netdb.h>
        ], [
        ], [
            char *name;
            char *name;
            struct hostent *he;
            struct hostent *he;
            char buffer[2048];
            char buffer[2048];
            int buflen = 2048;
            int buflen = 2048;
            int h_errnop;
            int h_errnop;
 
 
            (void) gethostbyname_r(name, he, buffer, buflen, &h_errnop);
            (void) gethostbyname_r(name, he, buffer, buflen, &h_errnop);
        ], tcl_cv_api_gethostbyname_r_5=yes, tcl_cv_api_gethostbyname_r_5=no)])
        ], tcl_cv_api_gethostbyname_r_5=yes, tcl_cv_api_gethostbyname_r_5=no)])
        tcl_ok=$tcl_cv_api_gethostbyname_r_5
        tcl_ok=$tcl_cv_api_gethostbyname_r_5
        if test "$tcl_ok" = yes; then
        if test "$tcl_ok" = yes; then
            AC_DEFINE(HAVE_GETHOSTBYNAME_R_5)
            AC_DEFINE(HAVE_GETHOSTBYNAME_R_5)
        else
        else
            AC_CACHE_CHECK([for gethostbyname_r with 3 args], tcl_cv_api_gethostbyname_r_3, [
            AC_CACHE_CHECK([for gethostbyname_r with 3 args], tcl_cv_api_gethostbyname_r_3, [
            AC_TRY_COMPILE([
            AC_TRY_COMPILE([
                #include <netdb.h>
                #include <netdb.h>
            ], [
            ], [
                char *name;
                char *name;
                struct hostent *he;
                struct hostent *he;
                struct hostent_data data;
                struct hostent_data data;
 
 
                (void) gethostbyname_r(name, he, &data);
                (void) gethostbyname_r(name, he, &data);
            ], tcl_cv_api_gethostbyname_r_3=yes, tcl_cv_api_gethostbyname_r_3=no)])
            ], tcl_cv_api_gethostbyname_r_3=yes, tcl_cv_api_gethostbyname_r_3=no)])
            tcl_ok=$tcl_cv_api_gethostbyname_r_3
            tcl_ok=$tcl_cv_api_gethostbyname_r_3
            if test "$tcl_ok" = yes; then
            if test "$tcl_ok" = yes; then
                AC_DEFINE(HAVE_GETHOSTBYNAME_R_3)
                AC_DEFINE(HAVE_GETHOSTBYNAME_R_3)
            fi
            fi
        fi
        fi
    fi
    fi
    if test "$tcl_ok" = yes; then
    if test "$tcl_ok" = yes; then
        AC_DEFINE(HAVE_GETHOSTBYNAME_R)
        AC_DEFINE(HAVE_GETHOSTBYNAME_R)
    fi
    fi
])])
])])
 
 
#--------------------------------------------------------------------
#--------------------------------------------------------------------
# SC_TCL_GETPWUID_R
# SC_TCL_GETPWUID_R
#
#
#       Check if we have MT-safe variant of getpwuid() and if yes,
#       Check if we have MT-safe variant of getpwuid() and if yes,
#       which one exactly.
#       which one exactly.
#
#
# Arguments:
# Arguments:
#       None
#       None
#
#
# Results:
# Results:
#
#
#       Might define the following vars:
#       Might define the following vars:
#               HAVE_GETPWUID_R
#               HAVE_GETPWUID_R
#               HAVE_GETPWUID_R_4
#               HAVE_GETPWUID_R_4
#               HAVE_GETPWUID_R_5
#               HAVE_GETPWUID_R_5
#
#
#--------------------------------------------------------------------
#--------------------------------------------------------------------
 
 
AC_DEFUN([SC_TCL_GETPWUID_R], [AC_CHECK_FUNC(getpwuid_r, [
AC_DEFUN([SC_TCL_GETPWUID_R], [AC_CHECK_FUNC(getpwuid_r, [
    AC_CACHE_CHECK([for getpwuid_r with 5 args], tcl_cv_api_getpwuid_r_5, [
    AC_CACHE_CHECK([for getpwuid_r with 5 args], tcl_cv_api_getpwuid_r_5, [
    AC_TRY_COMPILE([
    AC_TRY_COMPILE([
        #include <sys/types.h>
        #include <sys/types.h>
        #include <pwd.h>
        #include <pwd.h>
    ], [
    ], [
        uid_t uid;
        uid_t uid;
        struct passwd pw, *pwp;
        struct passwd pw, *pwp;
        char buf[512];
        char buf[512];
        int buflen = 512;
        int buflen = 512;
 
 
        (void) getpwuid_r(uid, &pw, buf, buflen, &pwp);
        (void) getpwuid_r(uid, &pw, buf, buflen, &pwp);
    ], tcl_cv_api_getpwuid_r_5=yes, tcl_cv_api_getpwuid_r_5=no)])
    ], tcl_cv_api_getpwuid_r_5=yes, tcl_cv_api_getpwuid_r_5=no)])
    tcl_ok=$tcl_cv_api_getpwuid_r_5
    tcl_ok=$tcl_cv_api_getpwuid_r_5
    if test "$tcl_ok" = yes; then
    if test "$tcl_ok" = yes; then
        AC_DEFINE(HAVE_GETPWUID_R_5)
        AC_DEFINE(HAVE_GETPWUID_R_5)
    else
    else
        AC_CACHE_CHECK([for getpwuid_r with 4 args], tcl_cv_api_getpwuid_r_4, [
        AC_CACHE_CHECK([for getpwuid_r with 4 args], tcl_cv_api_getpwuid_r_4, [
        AC_TRY_COMPILE([
        AC_TRY_COMPILE([
            #include <sys/types.h>
            #include <sys/types.h>
            #include <pwd.h>
            #include <pwd.h>
        ], [
        ], [
            uid_t uid;
            uid_t uid;
            struct passwd pw;
            struct passwd pw;
            char buf[512];
            char buf[512];
            int buflen = 512;
            int buflen = 512;
 
 
            (void)getpwnam_r(uid, &pw, buf, buflen);
            (void)getpwnam_r(uid, &pw, buf, buflen);
        ], tcl_cv_api_getpwuid_r_4=yes, tcl_cv_api_getpwuid_r_4=no)])
        ], tcl_cv_api_getpwuid_r_4=yes, tcl_cv_api_getpwuid_r_4=no)])
        tcl_ok=$tcl_cv_api_getpwuid_r_4
        tcl_ok=$tcl_cv_api_getpwuid_r_4
        if test "$tcl_ok" = yes; then
        if test "$tcl_ok" = yes; then
            AC_DEFINE(HAVE_GETPWUID_R_4)
            AC_DEFINE(HAVE_GETPWUID_R_4)
        fi
        fi
    fi
    fi
    if test "$tcl_ok" = yes; then
    if test "$tcl_ok" = yes; then
        AC_DEFINE(HAVE_GETPWUID_R)
        AC_DEFINE(HAVE_GETPWUID_R)
    fi
    fi
])])
])])
 
 
#--------------------------------------------------------------------
#--------------------------------------------------------------------
# SC_TCL_GETPWNAM_R
# SC_TCL_GETPWNAM_R
#
#
#       Check if we have MT-safe variant of getpwnam() and if yes,
#       Check if we have MT-safe variant of getpwnam() and if yes,
#       which one exactly.
#       which one exactly.
#
#
# Arguments:
# Arguments:
#       None
#       None
#
#
# Results:
# Results:
#
#
#       Might define the following vars:
#       Might define the following vars:
#               HAVE_GETPWNAM_R
#               HAVE_GETPWNAM_R
#               HAVE_GETPWNAM_R_4
#               HAVE_GETPWNAM_R_4
#               HAVE_GETPWNAM_R_5
#               HAVE_GETPWNAM_R_5
#
#
#--------------------------------------------------------------------
#--------------------------------------------------------------------
 
 
AC_DEFUN([SC_TCL_GETPWNAM_R], [AC_CHECK_FUNC(getpwnam_r, [
AC_DEFUN([SC_TCL_GETPWNAM_R], [AC_CHECK_FUNC(getpwnam_r, [
    AC_CACHE_CHECK([for getpwnam_r with 5 args], tcl_cv_api_getpwnam_r_5, [
    AC_CACHE_CHECK([for getpwnam_r with 5 args], tcl_cv_api_getpwnam_r_5, [
    AC_TRY_COMPILE([
    AC_TRY_COMPILE([
        #include <sys/types.h>
        #include <sys/types.h>
        #include <pwd.h>
        #include <pwd.h>
    ], [
    ], [
        char *name;
        char *name;
        struct passwd pw, *pwp;
        struct passwd pw, *pwp;
        char buf[512];
        char buf[512];
        int buflen = 512;
        int buflen = 512;
 
 
        (void) getpwnam_r(name, &pw, buf, buflen, &pwp);
        (void) getpwnam_r(name, &pw, buf, buflen, &pwp);
    ], tcl_cv_api_getpwnam_r_5=yes, tcl_cv_api_getpwnam_r_5=no)])
    ], tcl_cv_api_getpwnam_r_5=yes, tcl_cv_api_getpwnam_r_5=no)])
    tcl_ok=$tcl_cv_api_getpwnam_r_5
    tcl_ok=$tcl_cv_api_getpwnam_r_5
    if test "$tcl_ok" = yes; then
    if test "$tcl_ok" = yes; then
        AC_DEFINE(HAVE_GETPWNAM_R_5)
        AC_DEFINE(HAVE_GETPWNAM_R_5)
    else
    else
        AC_CACHE_CHECK([for getpwnam_r with 4 args], tcl_cv_api_getpwnam_r_4, [
        AC_CACHE_CHECK([for getpwnam_r with 4 args], tcl_cv_api_getpwnam_r_4, [
        AC_TRY_COMPILE([
        AC_TRY_COMPILE([
            #include <sys/types.h>
            #include <sys/types.h>
            #include <pwd.h>
            #include <pwd.h>
        ], [
        ], [
            char *name;
            char *name;
            struct passwd pw;
            struct passwd pw;
            char buf[512];
            char buf[512];
            int buflen = 512;
            int buflen = 512;
 
 
            (void)getpwnam_r(name, &pw, buf, buflen);
            (void)getpwnam_r(name, &pw, buf, buflen);
        ], tcl_cv_api_getpwnam_r_4=yes, tcl_cv_api_getpwnam_r_4=no)])
        ], tcl_cv_api_getpwnam_r_4=yes, tcl_cv_api_getpwnam_r_4=no)])
        tcl_ok=$tcl_cv_api_getpwnam_r_4
        tcl_ok=$tcl_cv_api_getpwnam_r_4
        if test "$tcl_ok" = yes; then
        if test "$tcl_ok" = yes; then
            AC_DEFINE(HAVE_GETPWNAM_R_4)
            AC_DEFINE(HAVE_GETPWNAM_R_4)
        fi
        fi
    fi
    fi
    if test "$tcl_ok" = yes; then
    if test "$tcl_ok" = yes; then
        AC_DEFINE(HAVE_GETPWNAM_R)
        AC_DEFINE(HAVE_GETPWNAM_R)
    fi
    fi
])])
])])
 
 
#--------------------------------------------------------------------
#--------------------------------------------------------------------
# SC_TCL_GETGRGID_R
# SC_TCL_GETGRGID_R
#
#
#       Check if we have MT-safe variant of getgrgid() and if yes,
#       Check if we have MT-safe variant of getgrgid() and if yes,
#       which one exactly.
#       which one exactly.
#
#
# Arguments:
# Arguments:
#       None
#       None
#
#
# Results:
# Results:
#
#
#       Might define the following vars:
#       Might define the following vars:
#               HAVE_GETGRGID_R
#               HAVE_GETGRGID_R
#               HAVE_GETGRGID_R_4
#               HAVE_GETGRGID_R_4
#               HAVE_GETGRGID_R_5
#               HAVE_GETGRGID_R_5
#
#
#--------------------------------------------------------------------
#--------------------------------------------------------------------
 
 
AC_DEFUN([SC_TCL_GETGRGID_R], [AC_CHECK_FUNC(getgrgid_r, [
AC_DEFUN([SC_TCL_GETGRGID_R], [AC_CHECK_FUNC(getgrgid_r, [
    AC_CACHE_CHECK([for getgrgid_r with 5 args], tcl_cv_api_getgrgid_r_5, [
    AC_CACHE_CHECK([for getgrgid_r with 5 args], tcl_cv_api_getgrgid_r_5, [
    AC_TRY_COMPILE([
    AC_TRY_COMPILE([
        #include <sys/types.h>
        #include <sys/types.h>
        #include <grp.h>
        #include <grp.h>
    ], [
    ], [
        gid_t gid;
        gid_t gid;
        struct group gr, *grp;
        struct group gr, *grp;
        char buf[512];
        char buf[512];
        int buflen = 512;
        int buflen = 512;
 
 
        (void) getgrgid_r(gid, &gr, buf, buflen, &grp);
        (void) getgrgid_r(gid, &gr, buf, buflen, &grp);
    ], tcl_cv_api_getgrgid_r_5=yes, tcl_cv_api_getgrgid_r_5=no)])
    ], tcl_cv_api_getgrgid_r_5=yes, tcl_cv_api_getgrgid_r_5=no)])
    tcl_ok=$tcl_cv_api_getgrgid_r_5
    tcl_ok=$tcl_cv_api_getgrgid_r_5
    if test "$tcl_ok" = yes; then
    if test "$tcl_ok" = yes; then
        AC_DEFINE(HAVE_GETGRGID_R_5)
        AC_DEFINE(HAVE_GETGRGID_R_5)
    else
    else
        AC_CACHE_CHECK([for getgrgid_r with 4 args], tcl_cv_api_getgrgid_r_4, [
        AC_CACHE_CHECK([for getgrgid_r with 4 args], tcl_cv_api_getgrgid_r_4, [
        AC_TRY_COMPILE([
        AC_TRY_COMPILE([
            #include <sys/types.h>
            #include <sys/types.h>
            #include <grp.h>
            #include <grp.h>
        ], [
        ], [
            gid_t gid;
            gid_t gid;
            struct group gr;
            struct group gr;
            char buf[512];
            char buf[512];
            int buflen = 512;
            int buflen = 512;
 
 
            (void)getgrgid_r(gid, &gr, buf, buflen);
            (void)getgrgid_r(gid, &gr, buf, buflen);
        ], tcl_cv_api_getgrgid_r_4=yes, tcl_cv_api_getgrgid_r_4=no)])
        ], tcl_cv_api_getgrgid_r_4=yes, tcl_cv_api_getgrgid_r_4=no)])
        tcl_ok=$tcl_cv_api_getgrgid_r_4
        tcl_ok=$tcl_cv_api_getgrgid_r_4
        if test "$tcl_ok" = yes; then
        if test "$tcl_ok" = yes; then
            AC_DEFINE(HAVE_GETGRGID_R_4)
            AC_DEFINE(HAVE_GETGRGID_R_4)
        fi
        fi
    fi
    fi
    if test "$tcl_ok" = yes; then
    if test "$tcl_ok" = yes; then
        AC_DEFINE(HAVE_GETGRGID_R)
        AC_DEFINE(HAVE_GETGRGID_R)
    fi
    fi
])])
])])
 
 
#--------------------------------------------------------------------
#--------------------------------------------------------------------
# SC_TCL_GETGRNAM_R
# SC_TCL_GETGRNAM_R
#
#
#       Check if we have MT-safe variant of getgrnam() and if yes,
#       Check if we have MT-safe variant of getgrnam() and if yes,
#       which one exactly.
#       which one exactly.
#
#
# Arguments:
# Arguments:
#       None
#       None
#
#
# Results:
# Results:
#
#
#       Might define the following vars:
#       Might define the following vars:
#               HAVE_GETGRNAM_R
#               HAVE_GETGRNAM_R
#               HAVE_GETGRNAM_R_4
#               HAVE_GETGRNAM_R_4
#               HAVE_GETGRNAM_R_5
#               HAVE_GETGRNAM_R_5
#
#
#--------------------------------------------------------------------
#--------------------------------------------------------------------
 
 
AC_DEFUN([SC_TCL_GETGRNAM_R], [AC_CHECK_FUNC(getgrnam_r, [
AC_DEFUN([SC_TCL_GETGRNAM_R], [AC_CHECK_FUNC(getgrnam_r, [
    AC_CACHE_CHECK([for getgrnam_r with 5 args], tcl_cv_api_getgrnam_r_5, [
    AC_CACHE_CHECK([for getgrnam_r with 5 args], tcl_cv_api_getgrnam_r_5, [
    AC_TRY_COMPILE([
    AC_TRY_COMPILE([
        #include <sys/types.h>
        #include <sys/types.h>
        #include <grp.h>
        #include <grp.h>
    ], [
    ], [
        char *name;
        char *name;
        struct group gr, *grp;
        struct group gr, *grp;
        char buf[512];
        char buf[512];
        int buflen = 512;
        int buflen = 512;
 
 
        (void) getgrnam_r(name, &gr, buf, buflen, &grp);
        (void) getgrnam_r(name, &gr, buf, buflen, &grp);
    ], tcl_cv_api_getgrnam_r_5=yes, tcl_cv_api_getgrnam_r_5=no)])
    ], tcl_cv_api_getgrnam_r_5=yes, tcl_cv_api_getgrnam_r_5=no)])
    tcl_ok=$tcl_cv_api_getgrnam_r_5
    tcl_ok=$tcl_cv_api_getgrnam_r_5
    if test "$tcl_ok" = yes; then
    if test "$tcl_ok" = yes; then
        AC_DEFINE(HAVE_GETGRNAM_R_5)
        AC_DEFINE(HAVE_GETGRNAM_R_5)
    else
    else
        AC_CACHE_CHECK([for getgrnam_r with 4 args], tcl_cv_api_getgrnam_r_4, [
        AC_CACHE_CHECK([for getgrnam_r with 4 args], tcl_cv_api_getgrnam_r_4, [
        AC_TRY_COMPILE([
        AC_TRY_COMPILE([
            #include <sys/types.h>
            #include <sys/types.h>
            #include <grp.h>
            #include <grp.h>
        ], [
        ], [
            char *name;
            char *name;
            struct group gr;
            struct group gr;
            char buf[512];
            char buf[512];
            int buflen = 512;
            int buflen = 512;
 
 
            (void)getgrnam_r(name, &gr, buf, buflen);
            (void)getgrnam_r(name, &gr, buf, buflen);
        ], tcl_cv_api_getgrnam_r_4=yes, tcl_cv_api_getgrnam_r_4=no)])
        ], tcl_cv_api_getgrnam_r_4=yes, tcl_cv_api_getgrnam_r_4=no)])
        tcl_ok=$tcl_cv_api_getgrnam_r_4
        tcl_ok=$tcl_cv_api_getgrnam_r_4
        if test "$tcl_ok" = yes; then
        if test "$tcl_ok" = yes; then
            AC_DEFINE(HAVE_GETGRNAM_R_4)
            AC_DEFINE(HAVE_GETGRNAM_R_4)
        fi
        fi
    fi
    fi
    if test "$tcl_ok" = yes; then
    if test "$tcl_ok" = yes; then
        AC_DEFINE(HAVE_GETGRNAM_R)
        AC_DEFINE(HAVE_GETGRNAM_R)
    fi
    fi
])])
])])
 
 
#--------------------------------------------------------------------
#--------------------------------------------------------------------
# SC_CONFIG_COMMANDS_PRE(CMDS)
# SC_CONFIG_COMMANDS_PRE(CMDS)
#
#
#       Replacement for autoconf 2.5x AC_COMMANDS_PRE:
#       Replacement for autoconf 2.5x AC_COMMANDS_PRE:
#               Commands to run right before config.status is
#               Commands to run right before config.status is
#               created. Accumulates.
#               created. Accumulates.
#
#
#       Requires presence of SC_OUTPUT_COMMANDS_PRE at the end
#       Requires presence of SC_OUTPUT_COMMANDS_PRE at the end
#       of configure.in (right before AC_OUTPUT).
#       of configure.in (right before AC_OUTPUT).
#
#
#--------------------------------------------------------------------
#--------------------------------------------------------------------
 
 
AC_DEFUN([SC_CONFIG_COMMANDS_PRE], [
AC_DEFUN([SC_CONFIG_COMMANDS_PRE], [
    define([SC_OUTPUT_COMMANDS_PRE], defn([SC_OUTPUT_COMMANDS_PRE])[$1
    define([SC_OUTPUT_COMMANDS_PRE], defn([SC_OUTPUT_COMMANDS_PRE])[$1
])])
])])
AC_DEFUN([SC_OUTPUT_COMMANDS_PRE])
AC_DEFUN([SC_OUTPUT_COMMANDS_PRE])
 
 
 
 

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.