Changeset 1018 for trunk/lang/tcl/tclconfig/tcl.m4

Timestamp:

Jun 8, 2008 6:24:34 PM (16 years ago)

Author:

gah

Message:

Massive changes: New directory/file layout

Location:

trunk/lang

Files:

• . (added)
• tcl (moved) (moved from trunk/src/tcl)
• tcl/tclconfig/tcl.m4 (modified) (97 diffs)

trunk/lang/tcl/tclconfig/tcl.m4

@@ -1 @@
-# tcl.m4 --
-#
-#       This file provides a set of autoconf macros to help TEA-enable
-#       a Tcl extension.
-#
-# Copyright (c) 1999-2000 Ajuba Solutions.
-# Copyright (c) 2002-2005 ActiveState Corporation.
-#
-# See the file "license.terms" for information on usage and redistribution
-# of this file, and for a DISCLAIMER OF ALL WARRANTIES.
-#
-# RCS: @(#) $Id: tcl.m4,v 1.92 2006/05/26 19:15:38 das Exp $
-
-AC_PREREQ(2.50)
-
-dnl TEA extensions pass this us the version of TEA they think they
-dnl are compatible with (must be set in TEA_INIT below)
-dnl TEA_VERSION="3.5"
-
-# Possible values for key variables defined:
-#
-# TEA_WINDOWINGSYSTEM - win32 aqua x11 (mirrors 'tk windowingsystem')
-# TEA_PLATFORM        - windows unix
-#
-
 #------------------------------------------------------------------------
-# TEA_PATH_TCLCONFIG --
+# SC_PATH_TCLCONFIG --
 #
 #       Locate the tclConfig.sh file and perform a sanity check on
@@ -43 +18 @@
 #------------------------------------------------------------------------
 
-AC_DEFUN([TEA_PATH_TCLCONFIG], [
-    dnl Make sure we are initialized
-    AC_REQUIRE([TEA_INIT])
+AC_DEFUN([SC_PATH_TCLCONFIG], [
     #
     # Ok, lets find the tcl configuration
@@ -55 +28 @@
         # we reset no_tcl in case something fails here
         no_tcl=true
-        AC_ARG_WITH(tcl,
-            AC_HELP_STRING([--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_CACHE_VAL(ac_cv_c_tclconfig,[
@@ -64 +34 @@
             # First check to see if --with-tcl was specified.
             if test x"${with_tclconfig}" != x ; then
-                case ${with_tclconfig} in
-                    */tclConfig.sh )
-                        if test -f ${with_tclconfig}; then
-                            AC_MSG_WARN([--with-tcl argument should refer to directory containing tclConfig.sh, not to tclConfig.sh itself])
-                            with_tclconfig=`echo ${with_tclconfig} | sed 's!/tclConfig\.sh$!!'`
-                        fi ;;
-                esac
                 if test -f "${with_tclconfig}/tclConfig.sh" ; then
                     ac_cv_c_tclconfig=`(cd ${with_tclconfig}; pwd)`
@@ -114 +77 @@
             fi
 
-            # on Windows, check in common installation locations
-            if test "${TEA_PLATFORM}" = "windows" \
-                -a x"${ac_cv_c_tclconfig}" = x ; then
-                for i in `ls -d C:/Tcl/lib 2>/dev/null` \
-                        `ls -d C:/Progra~1/Tcl/lib 2>/dev/null` \
-                        ; do
-                    if test -f "$i/tclConfig.sh" ; then
-                        ac_cv_c_tclconfig=`(cd $i; pwd)`
-                        break
-                    fi
-                done
-            fi
-
             # check in a few common install locations
             if test x"${ac_cv_c_tclconfig}" = x ; then
@@ -171 +121 @@
 
 #------------------------------------------------------------------------
-# TEA_PATH_TKCONFIG --
+# SC_PATH_TKCONFIG --
 #
 #       Locate the tkConfig.sh file
@@ -188 +138 @@
 #------------------------------------------------------------------------
 
-AC_DEFUN([TEA_PATH_TKCONFIG], [
+AC_DEFUN([SC_PATH_TKCONFIG], [
     #
     # Ok, lets find the tk configuration
@@ -198 +148 @@
         # we reset no_tk in case something fails here
         no_tk=true
-        AC_ARG_WITH(tk,
-            AC_HELP_STRING([--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_CACHE_VAL(ac_cv_c_tkconfig,[
@@ -207 +154 @@
             # First check to see if --with-tkconfig was specified.
             if test x"${with_tkconfig}" != x ; then
-                case ${with_tkconfig} in
-                    */tkConfig.sh )
-                        if test -f ${with_tkconfig}; then
-                            AC_MSG_WARN([--with-tk argument should refer to directory containing tkConfig.sh, not to tkConfig.sh itself])
-                            with_tkconfig=`echo ${with_tkconfig} | sed 's!/tkConfig\.sh$!!'`
-                        fi ;;
-                esac
                 if test -f "${with_tkconfig}/tkConfig.sh" ; then
                     ac_cv_c_tkconfig=`(cd ${with_tkconfig}; pwd)`
@@ -272 +212 @@
                 done
             fi
-
-            # on Windows, check in common installation locations
-            if test "${TEA_PLATFORM}" = "windows" \
-                -a x"${ac_cv_c_tkconfig}" = x ; then
-                for i in `ls -d C:/Tcl/lib 2>/dev/null` \
-                        `ls -d C:/Progra~1/Tcl/lib 2>/dev/null` \
-                        ; do
-                    if test -f "$i/tkConfig.sh" ; then
-                        ac_cv_c_tkconfig=`(cd $i; pwd)`
-                        break
-                    fi
-                done
-            fi
-
             # check in a few other private locations
             if test x"${ac_cv_c_tkconfig}" = x ; then
@@ -314 +240 @@
 
 #------------------------------------------------------------------------
-# TEA_LOAD_TCLCONFIG --
+# SC_LOAD_TCLCONFIG --
 #
 #       Load the tclConfig.sh file
@@ -332 +258 @@
 #------------------------------------------------------------------------
 
-AC_DEFUN([TEA_LOAD_TCLCONFIG], [
+AC_DEFUN([SC_LOAD_TCLCONFIG], [
     AC_MSG_CHECKING([for existence of ${TCL_BIN_DIR}/tclConfig.sh])
 
@@ -386 +312 @@
 
     AC_SUBST(TCL_VERSION)
+    AC_SUBST(TCL_PATCH_LEVEL)
     AC_SUBST(TCL_BIN_DIR)
     AC_SUBST(TCL_SRC_DIR)
@@ -396 +323 @@
     AC_SUBST(TCL_STUB_LIB_FLAG)
     AC_SUBST(TCL_STUB_LIB_SPEC)
-
-    AC_SUBST(TCL_LIBS)
-    AC_SUBST(TCL_DEFS)
-    AC_SUBST(TCL_EXTRA_CFLAGS)
-    AC_SUBST(TCL_LD_FLAGS)
-    AC_SUBST(TCL_SHLIB_LD_LIBS)
 ])
 
 #------------------------------------------------------------------------
-# TEA_LOAD_TKCONFIG --
+# SC_LOAD_TKCONFIG --
 #
 #       Load the tkConfig.sh file
@@ -420 +341 @@
 #------------------------------------------------------------------------
 
-AC_DEFUN([TEA_LOAD_TKCONFIG], [
+AC_DEFUN([SC_LOAD_TKCONFIG], [
     AC_MSG_CHECKING([for existence of ${TK_BIN_DIR}/tkConfig.sh])
 
@@ -473 +394 @@
     eval "TK_STUB_LIB_SPEC=\"${TK_STUB_LIB_SPEC}\""
 
-    # Ensure windowingsystem is defined
-    if test "${TEA_PLATFORM}" = "unix" ; then
-        case ${TK_DEFS} in
-            *MAC_OSX_TK*)
-                AC_DEFINE(MAC_OSX_TK, 1, [Are we building against Mac OS X TkAqua?])
-                TEA_WINDOWINGSYSTEM="aqua"
-                ;;
-            *)
-                TEA_WINDOWINGSYSTEM="x11"
-                ;;
-        esac
-    elif test "${TEA_PLATFORM}" = "windows" ; then
-        TEA_WINDOWINGSYSTEM="win32"
-    fi
-
     AC_SUBST(TK_VERSION)
     AC_SUBST(TK_BIN_DIR)
@@ -499 +405 @@
     AC_SUBST(TK_STUB_LIB_FLAG)
     AC_SUBST(TK_STUB_LIB_SPEC)
-
-    AC_SUBST(TK_LIBS)
-    AC_SUBST(TK_XINCLUDES)
 ])
 
 #------------------------------------------------------------------------
-# TEA_ENABLE_SHARED --
+# SC_PROG_TCLSH
+#       Locate a tclsh shell installed on the system path. This macro
+#       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
+#       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
+#       be set to "". Extensions should take care not to create Makefile
+#       rules that are run by default and depend on TCLSH_PROG. An
+#       extension can't assume that an executable Tcl shell exists at
+#       build time.
+#
+# Arguments
+#       none
+#
+# Results
+#       Subst's the following values:
+#               TCLSH_PROG
+#------------------------------------------------------------------------
+
+AC_DEFUN([SC_PROG_TCLSH], [
+    AC_MSG_CHECKING([for tclsh])
+    AC_CACHE_VAL(ac_cv_path_tclsh, [
+        search_path=`echo ${PATH} | sed -e 's/:/ /g'`
+        for dir in $search_path ; do
+            for j in `ls -r $dir/tclsh[[8-9]]* 2> /dev/null` \
+                    `ls -r $dir/tclsh* 2> /dev/null` ; do
+                if test x"$ac_cv_path_tclsh" = x ; then
+                    if test -f "$j" ; then
+                        ac_cv_path_tclsh=$j
+                        break
+                    fi
+                fi
+            done
+        done
+    ])
+
+    if test -f "$ac_cv_path_tclsh" ; then
+        TCLSH_PROG="$ac_cv_path_tclsh"
+        AC_MSG_RESULT([$TCLSH_PROG])
+    else
+        # It is not an error if an installed version of Tcl can't be located.
+        TCLSH_PROG=""
+        AC_MSG_RESULT([No tclsh found on PATH])
+    fi
+    AC_SUBST(TCLSH_PROG)
+])
+
+#------------------------------------------------------------------------
+# SC_BUILD_TCLSH
+#       Determine the fully qualified path name of the tclsh executable
+#       in the Tcl build directory. This macro will correctly determine
+#       the name of the tclsh executable even if tclsh has not yet
+#       been built in the build directory. The build tclsh must be used
+#       when running tests from an extension build directory. It is not
+#       correct to use the TCLSH_PROG in cases like this.
+#
+# Arguments
+#       none
+#
+# Results
+#       Subst's the following values:
+#               BUILD_TCLSH
+#------------------------------------------------------------------------
+
+AC_DEFUN([SC_BUILD_TCLSH], [
+    AC_MSG_CHECKING([for tclsh in Tcl build directory])
+    BUILD_TCLSH=${TCL_BIN_DIR}/tclsh
+    AC_MSG_RESULT([$BUILD_TCLSH])
+    AC_SUBST(BUILD_TCLSH)
+])
+
+#------------------------------------------------------------------------
+# SC_ENABLE_SHARED --
 #
 #       Allows the building of shared libraries
@@ -525 +500 @@
 #------------------------------------------------------------------------
 
-AC_DEFUN([TEA_ENABLE_SHARED], [
+AC_DEFUN([SC_ENABLE_SHARED], [
     AC_MSG_CHECKING([how to build libraries])
     AC_ARG_ENABLE(shared,
-        AC_HELP_STRING([--enable-shared],
-            [build and link with shared libraries (default: on)]),
+        [  --enable-shared         build and link with shared libraries [--enable-shared]],
         [tcl_ok=$enableval], [tcl_ok=yes])
 
@@ -545 +519 @@
         AC_MSG_RESULT([static])
         SHARED_BUILD=0
-        AC_DEFINE(STATIC_BUILD, 1, [Is this a static build?])
-    fi
-    AC_SUBST(SHARED_BUILD)
+        AC_DEFINE(STATIC_BUILD)
+    fi
 ])
 
 #------------------------------------------------------------------------
-# TEA_ENABLE_THREADS --
-#
-#       Specify if thread support should be enabled.  If "yes" is specified
-#       as an arg (optional), threads are enabled by default, "no" means
-#       threads are disabled.  "yes" is the default.
-#
-#       TCL_THREADS is checked so that if you are compiling an extension
-#       against a threaded core, your extension must be compiled threaded
-#       as well.
-#
-#       Note that it is legal to have a thread enabled extension run in a
-#       threaded or non-threaded Tcl core, but a non-threaded extension may
-#       only run in a non-threaded Tcl core.
+# SC_ENABLE_FRAMEWORK --
+#
+#       Allows the building of shared libraries into frameworks
 #
 # Arguments:
@@ -571 +534 @@
 #
 #       Adds the following arguments to configure:
+#               --enable-framework=yes|no
+#
+#       Sets the following vars:
+#               FRAMEWORK_BUILD Value of 1 or 0
+#------------------------------------------------------------------------
+
+AC_DEFUN([SC_ENABLE_FRAMEWORK], [
+    if test "`uname -s`" = "Darwin" ; then
+        AC_MSG_CHECKING([how to package libraries])
+        AC_ARG_ENABLE(framework,
+            [  --enable-framework      package shared libraries in MacOSX frameworks [--disable-framework]],
+            [enable_framework=$enableval], [enable_framework=no])
+        if test $enable_framework = yes; then
+            if test $SHARED_BUILD = 0; then
+                AC_MSG_WARN([Frameworks can only be built if --enable-shared is yes])
+                enable_framework=no
+            fi
+            if test $tcl_corefoundation = no; then
+                AC_MSG_WARN([Frameworks can only be used when CoreFoundation is available])
+                enable_framework=no
+            fi
+        fi
+        if test $enable_framework = yes; then
+            AC_MSG_RESULT([framework])
+            FRAMEWORK_BUILD=1
+        else
+            if test $SHARED_BUILD = 1; then
+                AC_MSG_RESULT([shared library])
+            else
+                AC_MSG_RESULT([static library])
+            fi
+            FRAMEWORK_BUILD=0
+        fi
+    fi
+])
+
+#------------------------------------------------------------------------
+# SC_ENABLE_THREADS --
+#
+#       Specify if thread support should be enabled.  TCL_THREADS is
+#       checked so that if you are compiling an extension against a
+#       threaded core, your extension must be compiled threaded as well.
+#
+# Arguments:
+#       none
+#       
+# Results:
+#
+#       Adds the following arguments to configure:
 #               --enable-threads
 #
@@ -583 +595 @@
 #------------------------------------------------------------------------
 
-AC_DEFUN([TEA_ENABLE_THREADS], [
-    AC_ARG_ENABLE(threads,
-        AC_HELP_STRING([--enable-threads],
-            [build with threads]),
-        [tcl_ok=$enableval], [tcl_ok=yes])
-
-    if test "${enable_threads+set}" = set; then
-        enableval="$enable_threads"
-        tcl_ok=$enableval
-    else
-        tcl_ok=yes
+AC_DEFUN([SC_ENABLE_THREADS], [
+    AC_ARG_ENABLE(threads, [  --enable-threads        build with threads],
+        [tcl_ok=$enableval], [tcl_ok=no])
+
+    if test "${TCL_THREADS}" = 1; then
+        tcl_threaded_core=1;
     fi
 
     if test "$tcl_ok" = "yes" -o "${TCL_THREADS}" = 1; then
         TCL_THREADS=1
-
-        if test "${TEA_PLATFORM}" != "windows" ; then
-            # We are always OK on Windows, so check what this platform wants:
-    
-            # USE_THREAD_ALLOC tells us to try the special thread-based
-            # allocator that significantly reduces lock contention
-            AC_DEFINE(USE_THREAD_ALLOC, 1,
-                [Do we want to use the threaded memory allocator?])
-            AC_DEFINE(_REENTRANT, 1, [Do we want the reentrant OS API?])
-            if test "`uname -s`" = "SunOS" ; then
-                AC_DEFINE(_POSIX_PTHREAD_SEMANTICS, 1,
-                        [Do we really want to follow the standard? Yes we do!])
-            fi
-            AC_DEFINE(_THREAD_SAFE, 1, [Do we want the thread-safe OS API?])
-            AC_CHECK_LIB(pthread,pthread_mutex_init,tcl_ok=yes,tcl_ok=no)
-            if test "$tcl_ok" = "no"; then
-                # Check a little harder for __pthread_mutex_init in the same
-                # library, as some systems hide it there until pthread.h is
-                # defined.  We could alternatively do an AC_TRY_COMPILE with
-                # pthread.h, but that will work with libpthread really doesn't
-                # exist, like AIX 4.2.  [Bug: 4359]
-                AC_CHECK_LIB(pthread, __pthread_mutex_init,
-                    tcl_ok=yes, tcl_ok=no)
-            fi
-
+        # USE_THREAD_ALLOC tells us to try the special thread-based
+        # allocator that significantly reduces lock contention
+        AC_DEFINE(USE_THREAD_ALLOC)
+        AC_DEFINE(_REENTRANT)
+        if test "`uname -s`" = "SunOS" ; then
+            AC_DEFINE(_POSIX_PTHREAD_SEMANTICS)
+        fi
+        AC_DEFINE(_THREAD_SAFE)
+        AC_CHECK_LIB(pthread,pthread_mutex_init,tcl_ok=yes,tcl_ok=no)
+        if test "$tcl_ok" = "no"; then
+            # Check a little harder for __pthread_mutex_init in the same
+            # library, as some systems hide it there until pthread.h is
+            # defined.  We could alternatively do an AC_TRY_COMPILE with
+            # pthread.h, but that will work with libpthread really doesn't
+            # exist, like AIX 4.2.  [Bug: 4359]
+            AC_CHECK_LIB(pthread, __pthread_mutex_init,
+                tcl_ok=yes, tcl_ok=no)
+        fi
+
+        if test "$tcl_ok" = "yes"; then
+            # The space is needed
+            THREADS_LIBS=" -lpthread"
+        else
+            AC_CHECK_LIB(pthreads, pthread_mutex_init,
+                tcl_ok=yes, tcl_ok=no)
             if test "$tcl_ok" = "yes"; then
                 # The space is needed
-                THREADS_LIBS=" -lpthread"
+                THREADS_LIBS=" -lpthreads"
             else
-                AC_CHECK_LIB(pthreads, pthread_mutex_init,
+                AC_CHECK_LIB(c, pthread_mutex_init,
                     tcl_ok=yes, tcl_ok=no)
-                if test "$tcl_ok" = "yes"; then
-                    # The space is needed
-                    THREADS_LIBS=" -lpthreads"
-                else
-                    AC_CHECK_LIB(c, pthread_mutex_init,
+                if test "$tcl_ok" = "no"; then
+                    AC_CHECK_LIB(c_r, pthread_mutex_init,
                         tcl_ok=yes, tcl_ok=no)
-                    if test "$tcl_ok" = "no"; then
-                        AC_CHECK_LIB(c_r, pthread_mutex_init,
-                            tcl_ok=yes, tcl_ok=no)
-                        if test "$tcl_ok" = "yes"; then
-                            # The space is needed
-                            THREADS_LIBS=" -pthread"
-                        else
-                            TCL_THREADS=0
-                            AC_MSG_WARN([Do not know how to find pthread lib on your system - thread support disabled])
-                        fi
+                    if test "$tcl_ok" = "yes"; then
+                        # The space is needed
+                        THREADS_LIBS=" -pthread"
+                    else
+                        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...])
                     fi
                 fi
             fi
         fi
+
+        # Does the pthread-implementation provide
+        # 'pthread_attr_setstacksize' ?
+
+        ac_saved_libs=$LIBS
+        LIBS="$LIBS $THREADS_LIBS"
+        AC_CHECK_FUNCS(pthread_attr_setstacksize)
+        AC_CHECK_FUNCS(pthread_atfork)
+        LIBS=$ac_saved_libs
     else
         TCL_THREADS=0
@@ -656 +665 @@
     if test "${TCL_THREADS}" = 1; then
         AC_DEFINE(TCL_THREADS, 1, [Are we building with threads enabled?])
-        AC_MSG_RESULT([yes (default)])
+        if test "${tcl_threaded_core}" = 1; then
+            AC_MSG_RESULT([yes (threaded core)])
+        else
+            AC_MSG_RESULT([yes])
+        fi
     else
-        AC_MSG_RESULT([no])
-    fi
-    # TCL_THREADS sanity checking.  See if our request for building with
-    # threads is the same as the way Tcl was built.  If not, warn the user.
-    case ${TCL_DEFS} in
-        *THREADS=1*)
-            if test "${TCL_THREADS}" = "0"; then
-                AC_MSG_WARN([
-    Building ${PACKAGE_NAME} without threads enabled, but building against Tcl
-    that IS thread-enabled.  It is recommended to use --enable-threads.])
-            fi
-            ;;
-        *)
-            if test "${TCL_THREADS}" = "1"; then
-                AC_MSG_WARN([
-    --enable-threads requested, but building against a Tcl that is NOT
-    thread-enabled.  This is an OK configuration that will also run in
-    a thread-enabled core.])
-            fi
-            ;;
-    esac
+        AC_MSG_RESULT([no (default)])
+    fi
+
     AC_SUBST(TCL_THREADS)
 ])
 
 #------------------------------------------------------------------------
-# TEA_ENABLE_SYMBOLS --
+# SC_ENABLE_SYMBOLS --
 #
 #       Specify if debugging symbols should be used.
-#       Memory (TCL_MEM_DEBUG) debugging can also be enabled.
+#       Memory (TCL_MEM_DEBUG) and compile (TCL_COMPILE_DEBUG) debugging
+#       can also be enabled.
 #
 # Arguments:
 #       none
 #       
-#       TEA varies from core Tcl in that C|LDFLAGS_DEFAULT receives
-#       the value of C|LDFLAGS_OPTIMIZE|DEBUG already substituted.
 #       Requires the following vars to be set in the Makefile:
-#               CFLAGS_DEFAULT
-#               LDFLAGS_DEFAULT
+#               CFLAGS_DEBUG
+#               CFLAGS_OPTIMIZE
+#               LDFLAGS_DEBUG
+#               LDFLAGS_OPTIMIZE
 #       
 # Results:
@@ -707 +703 @@
 #               LDFLAGS_DEFAULT Sets to $(LDFLAGS_DEBUG) if true
 #                               Sets to $(LDFLAGS_OPTIMIZE) if false
-#               DBGX            Formerly used as debug library extension;
-#                               always blank now.
+#               DBGX            Debug library extension
 #
 #------------------------------------------------------------------------
 
-AC_DEFUN([TEA_ENABLE_SYMBOLS], [
-    dnl Make sure we are initialized
-    AC_REQUIRE([TEA_CONFIG_CFLAGS])
+AC_DEFUN([SC_ENABLE_SYMBOLS], [
     AC_MSG_CHECKING([for build with symbols])
-    AC_ARG_ENABLE(symbols,
-        AC_HELP_STRING([--enable-symbols],
-            [build with debugging symbols (default: off)]),
-        [tcl_ok=$enableval], [tcl_ok=no])
-    DBGX=""
+    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.
     if test "$tcl_ok" = "no"; then
-        CFLAGS_DEFAULT="${CFLAGS_OPTIMIZE}"
-        LDFLAGS_DEFAULT="${LDFLAGS_OPTIMIZE}"
+        CFLAGS_DEFAULT='$(CFLAGS_OPTIMIZE)'
+        LDFLAGS_DEFAULT='$(LDFLAGS_OPTIMIZE)'
+        DBGX=""
         AC_MSG_RESULT([no])
     else
-        CFLAGS_DEFAULT="${CFLAGS_DEBUG}"
-        LDFLAGS_DEFAULT="${LDFLAGS_DEBUG}"
+        CFLAGS_DEFAULT='$(CFLAGS_DEBUG)'
+        LDFLAGS_DEFAULT='$(LDFLAGS_DEBUG)'
+        DBGX=g
         if test "$tcl_ok" = "yes"; then
             AC_MSG_RESULT([yes (standard debugging)])
         fi
     fi
-    if test "${TEA_PLATFORM}" != "windows" ; then
-        LDFLAGS_DEFAULT="${LDFLAGS}"
-    fi
-
-    AC_SUBST(TCL_DBGX)
     AC_SUBST(CFLAGS_DEFAULT)
     AC_SUBST(LDFLAGS_DEFAULT)
 
     if test "$tcl_ok" = "mem" -o "$tcl_ok" = "all"; then
-        AC_DEFINE(TCL_MEM_DEBUG, 1, [Is memory debugging enabled?])
+        AC_DEFINE(TCL_MEM_DEBUG)
+    fi
+
+    if test "$tcl_ok" = "compile" -o "$tcl_ok" = "all"; then
+        AC_DEFINE(TCL_COMPILE_DEBUG)
+        AC_DEFINE(TCL_COMPILE_STATS)
     fi
 
     if test "$tcl_ok" != "yes" -a "$tcl_ok" != "no"; then
         if test "$tcl_ok" = "all"; then
-            AC_MSG_RESULT([enabled symbols mem debugging])
+            AC_MSG_RESULT([enabled symbols mem compile debugging])
         else
             AC_MSG_RESULT([enabled $tcl_ok debugging])
@@ -754 +746 @@
 
 #------------------------------------------------------------------------
-# TEA_ENABLE_LANGINFO --
+# SC_ENABLE_LANGINFO --
 #
 #       Allows use of modern nl_langinfo check for better l10n.
@@ -772 +764 @@
 #------------------------------------------------------------------------
 
-AC_DEFUN([TEA_ENABLE_LANGINFO], [
+AC_DEFUN([SC_ENABLE_LANGINFO], [
     AC_ARG_ENABLE(langinfo,
-        AC_HELP_STRING([--enable-langinfo],
-            [use nl_langinfo if possible to determine encoding at startup, otherwise use old heuristic (default: on)]),
+        [  --enable-langinfo      use nl_langinfo if possible to determine
+                          encoding at startup, otherwise use old heuristic],
         [langinfo_ok=$enableval], [langinfo_ok=yes])
 
@@ -784 +776 @@
     AC_MSG_CHECKING([whether to use nl_langinfo])
     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);],
-                    [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])
         if test $tcl_cv_langinfo_h = yes; then
-            AC_DEFINE(HAVE_LANGINFO, 1, [Do we have nl_langinfo()?])
+            AC_DEFINE(HAVE_LANGINFO)
         fi
     else 
@@ -797 +789 @@
 
 #--------------------------------------------------------------------
-# TEA_CONFIG_SYSTEM
+# SC_CONFIG_MANPAGES
+#       
+#       Decide whether to use symlinks for linking the manpages,
+#       whether to compress the manpages after installation, and
+#       whether to add a package name suffix to the installed
+#       manpages to avoidfile name clashes.
+#       If compression is enabled also find out what file name suffix
+#       the given compression program is using.
+#
+# Arguments:
+#       none
+#
+# Results:
+#
+#       Adds the following arguments to configure:
+#               --enable-man-symlinks
+#               --enable-man-compression=PROG
+#               --enable-man-suffix[=STRING]
+#
+#       Defines the following variable:
+#
+#       MAN_FLAGS -     The apropriate flags for installManPage
+#                       according to the user's selection.
+#
+#--------------------------------------------------------------------
+
+AC_DEFUN([SC_CONFIG_MANPAGES], [
+    AC_MSG_CHECKING([whether to use symlinks for manpages])
+    AC_ARG_ENABLE(man-symlinks,
+            [  --enable-man-symlinks   use symlinks for the manpages],
+        test "$enableval" != "no" && MAN_FLAGS="$MAN_FLAGS --symlinks",
+        enableval="no")
+    AC_MSG_RESULT([$enableval])
+
+    AC_MSG_CHECKING([whether to compress the manpages])
+    AC_ARG_ENABLE(man-compression,
+            [  --enable-man-compression=PROG
+                      compress the manpages with PROG],
+        [case $enableval in
+            yes) AC_MSG_ERROR([missing argument to --enable-man-compression]);;
+            no)  ;;
+            *)   MAN_FLAGS="$MAN_FLAGS --compress $enableval";;
+        esac],
+        enableval="no")
+    AC_MSG_RESULT([$enableval])
+    if test "$enableval" != "no"; then
+        AC_MSG_CHECKING([for compressed file suffix])
+        touch TeST
+        $enableval TeST
+        Z=`ls TeST* | sed 's/^....//'`
+        rm -f TeST*
+        MAN_FLAGS="$MAN_FLAGS --extension $Z"
+        AC_MSG_RESULT([$Z])
+    fi
+
+    AC_MSG_CHECKING([whether to add a package name suffix for the manpages])
+    AC_ARG_ENABLE(man-suffix,
+            [  --enable-man-suffix=STRING
+                      use STRING as a suffix to manpage file names
+                      (default: $1)],
+        [case $enableval in
+            yes) enableval="$1" MAN_FLAGS="$MAN_FLAGS --suffix $enableval";;
+            no)  ;;
+            *)   MAN_FLAGS="$MAN_FLAGS --suffix $enableval";;
+        esac],
+        enableval="no")
+    AC_MSG_RESULT([$enableval])
+
+    AC_SUBST(MAN_FLAGS)
+])
+
+#--------------------------------------------------------------------
+# SC_CONFIG_SYSTEM
 #
 #       Determine what the system is (some things cannot be easily checked
@@ -814 +878 @@
 #--------------------------------------------------------------------
 
-AC_DEFUN([TEA_CONFIG_SYSTEM], [
+AC_DEFUN([SC_CONFIG_SYSTEM], [
     AC_CACHE_CHECK([system version], tcl_cv_sys_version, [
-        if test "${TEA_PLATFORM}" = "windows" ; then
-            tcl_cv_sys_version=windows
-        elif 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`
         else
@@ -830 +892 @@
 
                 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
                 if test "`uname -s`" = "AIX" ; then
@@ -842 +904 @@
 
 #--------------------------------------------------------------------
-# TEA_CONFIG_CFLAGS
+# SC_CONFIG_CFLAGS
 #
 #       Try to determine the proper flags to pass to the compiler
@@ -870 +932 @@
 #                       for shared libraries such as libtcl.so.  Depends on
 #                       the variable LIB_RUNTIME_DIR in the Makefile.
+#       MAKE_LIB -      Command to execute to build the a library;
+#                       differs when building shared or static.
+#       MAKE_STUB_LIB -
+#                       Command to execute to build a stub library.
+#       INSTALL_LIB -   Command to execute to install a library;
+#                       differs when building shared or static.
+#       INSTALL_STUB_LIB -
+#                       Command to execute to install a stub library.
+#       STLIB_LD -      Base command to use for combining object files
+#                       into a static library.
 #       SHLIB_CFLAGS -  Flags to pass to cc when compiling the components
 #                       of a shared library (may request position-independent
@@ -889 +961 @@
 #                       extensions.  An empty string means we don't know how
 #                       to use shared libraries on this platform.
+# 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
+#                       tclConfig.sh, since they are only used for the build
+#                       of Tcl and Tk. 
+#                       Examples: MacOS X records the library version and
+#                       compatibility version in the shared library.  But
+#                       of course the Tcl version of this is only used for Tcl.
 #       LIB_SUFFIX -    Specifies everything that comes after the "libfoo"
 #                       in a static or shared library name, using the $VERSION variable
@@ -917 +996 @@
 #--------------------------------------------------------------------
 
-AC_DEFUN([TEA_CONFIG_CFLAGS], [
-    dnl Make sure we are initialized
-    AC_REQUIRE([TEA_INIT])
+AC_DEFUN([SC_CONFIG_CFLAGS], [
 
     # Step 0.a: Enable 64 bit support?
 
     AC_MSG_CHECKING([if 64bit support is requested])
-    AC_ARG_ENABLE(64bit,
-        AC_HELP_STRING([--enable-64bit],
-            [enable 64bit support (default: off)]),
+    AC_ARG_ENABLE(64bit,[  --enable-64bit          enable 64bit support (where applicable)],
         [do64bit=$enableval], [do64bit=no])
     AC_MSG_RESULT([$do64bit])
@@ -933 +1008 @@
 
     AC_MSG_CHECKING([if 64bit Sparc VIS support is requested])
-    AC_ARG_ENABLE(64bit-vis,
-        AC_HELP_STRING([--enable-64bit-vis],
-            [enable 64bit Sparc VIS support (default: off)]),
+    AC_ARG_ENABLE(64bit-vis,[  --enable-64bit-vis      enable 64bit Sparc VIS support],
         [do64bitVIS=$enableval], [do64bitVIS=no])
     AC_MSG_RESULT([$do64bitVIS])
@@ -944 +1017 @@
     fi
 
-    # Step 0.c: Cross-compiling options for Windows/CE builds?
-
-    if test "${TEA_PLATFORM}" = "windows" ; then
-        AC_MSG_CHECKING([if Windows/CE build is requested])
-        AC_ARG_ENABLE(wince,[  --enable-wince          enable Win/CE support (where applicable)], [doWince=$enableval], [doWince=no])
-        AC_MSG_RESULT([$doWince])
-    fi
-
     # Step 1: set the variable "system" to hold the name and version number
     # for the system.
 
-    TEA_CONFIG_SYSTEM
+    SC_CONFIG_SYSTEM
 
     # Step 2: check for existence of -ldl library.  This is needed because
@@ -967 +1032 @@
 
     # Step 3: set configuration options based on system name and version.
-    # This is similar to Tcl's unix/tcl.m4 except that we've added a
-    # "windows" case.
 
     do64bit_ok=no
     LDFLAGS_ORIG="$LDFLAGS"
-    # When ld needs options to work in 64-bit mode, put them in
-    # LDFLAGS_ARCH so they eventually end up in LDFLAGS even if [load]
-    # is disabled by the user. [Bug 1016796]
-    LDFLAGS_ARCH=""
     TCL_EXPORT_FILE_SUFFIX=""
     UNSHARED_LIB_SUFFIX=""
-    TCL_TRIM_DOTS='`echo ${PACKAGE_VERSION} | tr -d .`'
-    ECHO_VERSION='`echo ${PACKAGE_VERSION}`'
+    TCL_TRIM_DOTS='`echo ${VERSION} | tr -d .`'
+    ECHO_VERSION='`echo ${VERSION}`'
     TCL_LIB_VERSIONS_OK=ok
     CFLAGS_DEBUG=-g
     CFLAGS_OPTIMIZE=-O
     if test "$GCC" = "yes" ; then
-        CFLAGS_OPTIMIZE=-O2
-        CFLAGS_WARNING="-Wall -Wno-implicit-int"
+        CFLAGS_WARNING="-Wall -Wno-implicit-int -fno-strict-aliasing"
     else
         CFLAGS_WARNING=""
@@ -995 +1053 @@
 dnl AC_CHECK_TOOL(AR, ar)
     AC_CHECK_PROG(AR, ar, ar)
+    if test "${AR}" = "" ; then
+        AC_MSG_ERROR([Required archive tool 'ar' not found on PATH.])
+    fi
     STLIB_LD='${AR} cr'
     LD_LIBRARY_PATH_VAR="LD_LIBRARY_PATH"
+    PLAT_OBJS=""
+    PLAT_SRCS=""
     case $system in
-        windows)
-            # This is a 2-stage check to make sure we have the 64-bit SDK
-            # We have to know where the SDK is installed.
-            # This magic is based on MS Platform SDK for Win2003 SP1 - hobbs
-            # MACHINE is IX86 for LINK, but this is used by the manifest,
-            # which requires x86|amd64|ia64.
-            MACHINE="X86"
-            if test "$do64bit" != "no" ; then
-                if test "x${MSSDK}x" = "xx" ; then
-                    MSSDK="C:/Progra~1/Microsoft Platform SDK"
-                fi
-                MSSDK=`echo "$MSSDK" | sed -e  's!\\\!/!g'`
-                PATH64=""
-                case "$do64bit" in
-                    amd64|x64|yes)
-                        MACHINE="AMD64" ; # default to AMD64 64-bit build
-                        PATH64="${MSSDK}/Bin/Win64/x86/AMD64"
-                        ;;
-                    ia64)
-                        MACHINE="IA64"
-                        PATH64="${MSSDK}/Bin/Win64"
-                        ;;
-                esac
-                if test ! -d "${PATH64}" ; then
-                    AC_MSG_WARN([Could not find 64-bit $MACHINE SDK to enable 64bit mode])
-                    AC_MSG_WARN([Ensure latest Platform SDK is installed])
-                    do64bit="no"
-                else
-                    AC_MSG_RESULT([   Using 64-bit $MACHINE mode])
-                    do64bit_ok="yes"
-                fi
-            fi
-
-            if test "$doWince" != "no" ; then
-                if test "$do64bit" != "no" ; then
-                    AC_MSG_ERROR([Windows/CE and 64-bit builds incompatible])
-                fi
-                if test "$GCC" = "yes" ; then
-                    AC_MSG_ERROR([Windows/CE and GCC builds incompatible])
-                fi
-                TEA_PATH_CELIB
-                # Set defaults for common evc4/PPC2003 setup
-                # Currently Tcl requires 300+, possibly 420+ for sockets
-                CEVERSION=420;          # could be 211 300 301 400 420 ...
-                TARGETCPU=ARMV4;        # could be ARMV4 ARM MIPS SH3 X86 ...
-                ARCH=ARM;               # could be ARM MIPS X86EM ...
-                PLATFORM="Pocket PC 2003"; # or "Pocket PC 2002"
-                if test "$doWince" != "yes"; then
-                    # If !yes then the user specified something
-                    # Reset ARCH to allow user to skip specifying it
-                    ARCH=
-                    eval `echo $doWince | awk -F, '{ \
-            if (length([$]1)) { printf "CEVERSION=\"%s\"\n", [$]1; \
-            if ([$]1 < 400)   { printf "PLATFORM=\"Pocket PC 2002\"\n" } }; \
-            if (length([$]2)) { printf "TARGETCPU=\"%s\"\n", toupper([$]2) }; \
-            if (length([$]3)) { printf "ARCH=\"%s\"\n", toupper([$]3) }; \
-            if (length([$]4)) { printf "PLATFORM=\"%s\"\n", [$]4 }; \
-                    }'`
-                    if test "x${ARCH}" = "x" ; then
-                        ARCH=$TARGETCPU;
-                    fi
-                fi
-                OSVERSION=WCE$CEVERSION;
-                if test "x${WCEROOT}" = "x" ; then
-                        WCEROOT="C:/Program Files/Microsoft eMbedded C++ 4.0"
-                    if test ! -d "${WCEROOT}" ; then
-                        WCEROOT="C:/Program Files/Microsoft eMbedded Tools"
-                    fi
-                fi
-                if test "x${SDKROOT}" = "x" ; then
-                    SDKROOT="C:/Program Files/Windows CE Tools"
-                    if test ! -d "${SDKROOT}" ; then
-                        SDKROOT="C:/Windows CE Tools"
-                    fi
-                fi
-                WCEROOT=`echo "$WCEROOT" | sed -e 's!\\\!/!g'`
-                SDKROOT=`echo "$SDKROOT" | sed -e 's!\\\!/!g'`
-                if test ! -d "${SDKROOT}/${OSVERSION}/${PLATFORM}/Lib/${TARGETCPU}" \
-                    -o ! -d "${WCEROOT}/EVC/${OSVERSION}/bin"; then
-                    AC_MSG_ERROR([could not find PocketPC SDK or target compiler to enable WinCE mode [$CEVERSION,$TARGETCPU,$ARCH,$PLATFORM]])
-                    doWince="no"
-                else
-                    # We could PATH_NOSPACE these, but that's not important,
-                    # as long as we quote them when used.
-                    CEINCLUDE="${SDKROOT}/${OSVERSION}/${PLATFORM}/include"
-                    if test -d "${CEINCLUDE}/${TARGETCPU}" ; then
-                        CEINCLUDE="${CEINCLUDE}/${TARGETCPU}"
-                    fi
-                    CELIBPATH="${SDKROOT}/${OSVERSION}/${PLATFORM}/Lib/${TARGETCPU}"
-                fi
-            fi
-
-            if test "$GCC" != "yes" ; then
-                if test "${SHARED_BUILD}" = "0" ; then
-                    runtime=-MT
-                else
-                    runtime=-MD
-                fi
-
-                if test "$do64bit" != "no" ; then
-                    # All this magic is necessary for the Win64 SDK RC1 - hobbs
-                    CC="\"${PATH64}/cl.exe\""
-                    CFLAGS="${CFLAGS} -I\"${MSSDK}/Include\" -I\"${MSSDK}/Include/crt\" -I\"${MSSDK}/Include/crt/sys\""
-                    RC="\"${MSSDK}/bin/rc.exe\""
-                    lflags="-nologo -MACHINE:${MACHINE} -LIBPATH:\"${MSSDK}/Lib/${MACHINE}\""
-                    LINKBIN="\"${PATH64}/link.exe\""
-                    CFLAGS_DEBUG="-nologo -Zi -Od -W3 ${runtime}d"
-                    CFLAGS_OPTIMIZE="-nologo -O2 -W2 ${runtime}"
-                    # Avoid 'unresolved external symbol __security_cookie'
-                    # errors, c.f. http://support.microsoft.com/?id=894573
-                    TEA_ADD_LIBS([bufferoverflowU.lib])
-                elif test "$doWince" != "no" ; then
-                    CEBINROOT="${WCEROOT}/EVC/${OSVERSION}/bin"
-                    if test "${TARGETCPU}" = "X86"; then
-                        CC="\"${CEBINROOT}/cl.exe\""
-                    else
-                        CC="\"${CEBINROOT}/cl${ARCH}.exe\""
-                    fi
-                    CFLAGS="$CFLAGS -I\"${CELIB_DIR}/inc\" -I\"${CEINCLUDE}\""
-                    RC="\"${WCEROOT}/Common/EVC/bin/rc.exe\""
-                    arch=`echo ${ARCH} | awk '{print tolower([$]0)}'`
-                    defs="${ARCH} _${ARCH}_ ${arch} PALM_SIZE _MT _WINDOWS"
-                    if test "${SHARED_BUILD}" = "1" ; then
-                        # Static CE builds require static celib as well
-                        defs="${defs} _DLL"
-                    fi
-                    for i in $defs ; do
-                        AC_DEFINE_UNQUOTED($i, 1, [WinCE def ]$i)
-                    done
-                    AC_DEFINE_UNQUOTED(_WIN32_WCE, $CEVERSION, [_WIN32_WCE version])
-                    AC_DEFINE_UNQUOTED(UNDER_CE, $CEVERSION, [UNDER_CE version])
-                    CFLAGS_DEBUG="-nologo -Zi -Od"
-                    CFLAGS_OPTIMIZE="-nologo -Ox"
-                    lversion=`echo ${CEVERSION} | sed -e 's/\(.\)\(..\)/\1\.\2/'`
-                    lflags="-MACHINE:${ARCH} -LIBPATH:\"${CELIBPATH}\" -subsystem:windowsce,${lversion} -nologo"
-                    LINKBIN="\"${CEBINROOT}/link.exe\""
-                    AC_SUBST(CELIB_DIR)
-                else
-                    RC="rc"
-                    lflags="-nologo"
-                    LINKBIN="link"
-                    CFLAGS_DEBUG="-nologo -Z7 -Od -W3 -WX ${runtime}d"
-                    CFLAGS_OPTIMIZE="-nologo -O2 -W2 ${runtime}"
-                fi
-            fi
-
-            if test "$GCC" = "yes"; then
-                # mingw gcc mode
-                RC="windres"
-                CFLAGS_DEBUG="-g"
-                CFLAGS_OPTIMIZE="-O2 -fomit-frame-pointer"
-                SHLIB_LD="$CC -shared"
-                UNSHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}.a'
-                LDFLAGS_CONSOLE="-wl,--subsystem,console ${lflags}"
-                LDFLAGS_WINDOW="-wl,--subsystem,windows ${lflags}"
-            else
-                SHLIB_LD="${LINKBIN} -dll ${lflags}"
-                # link -lib only works when -lib is the first arg
-                STLIB_LD="${LINKBIN} -lib ${lflags}"
-                UNSHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}.lib'
-                PATHTYPE=-w
-                # For information on what debugtype is most useful, see:
-                # http://msdn.microsoft.com/library/en-us/dnvc60/html/gendepdebug.asp
-                # This essentially turns it all on.
-                LDFLAGS_DEBUG="-debug:full -debugtype:both -warn:2"
-                LDFLAGS_OPTIMIZE="-release"
-                if test "$doWince" != "no" ; then
-                    LDFLAGS_CONSOLE="-link ${lflags}"
-                    LDFLAGS_WINDOW=${LDFLAGS_CONSOLE}
-                else
-                    LDFLAGS_CONSOLE="-link -subsystem:console ${lflags}"
-                    LDFLAGS_WINDOW="-link -subsystem:windows ${lflags}"
-                fi
-            fi
-
-            SHLIB_LD_LIBS='${LIBS}'
-            SHLIB_SUFFIX=".dll"
-            SHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}.dll'
-
-            TCL_LIB_VERSIONS_OK=nodots
-            # Bogus to avoid getting this turned off
-            DL_OBJS="tclLoadNone.obj"
-            ;;
         AIX-*)
             if test "${TCL_THREADS}" = "1" -a "$GCC" != "yes" ; then
@@ -1196 +1076 @@
             LIBS="$LIBS -lc"
             SHLIB_CFLAGS=""
+            # Note: need the LIBS below, otherwise Tk won't find Tcl's
+            # symbols when dynamically loaded into tclsh.
             SHLIB_LD_LIBS='${LIBS}'
             SHLIB_SUFFIX=".so"
@@ -1209 +1091 @@
                     do64bit_ok=yes
                     CFLAGS="$CFLAGS -q64"
-                    LDFLAGS_ARCH="-q64"
+                    LDFLAGS="$LDFLAGS -q64"
                     RANLIB="${RANLIB} -X64"
                     AR="${AR} -X64"
@@ -1238 +1120 @@
                 LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS}
                 TCL_NEEDS_EXP_FILE=1
-                TCL_EXPORT_FILE_SUFFIX='${PACKAGE_VERSION}.exp'
+                TCL_EXPORT_FILE_SUFFIX='${VERSION}\$\{DBGX\}.exp'
             fi
 
             # AIX v<=4.1 has some different flags than 4.2+
             if test "$system" = "AIX-4.1" -o "`uname -v`" -lt "4" ; then
-                AC_LIBOBJ([tclLoadAix])
+                LIBOBJS="$LIBOBJS tclLoadAix.o"
                 DL_LIBS="-lld"
             fi
@@ -1262 +1144 @@
             if test $libbsd = yes; then
                 MATH_LIBS="$MATH_LIBS -lbsd"
-                AC_DEFINE(USE_DELTA_FOR_TZ, 1, [Do we need a special AIX hack for timezones?])
+                AC_DEFINE(USE_DELTA_FOR_TZ)
             fi
             ;;
@@ -1313 +1195 @@
         HP-UX-*.11.*)
             # Use updated header definitions where possible
-            AC_DEFINE(_XOPEN_SOURCE_EXTENDED, 1, [Do we want to use the XOPEN network library?])
-            # Needed by Tcl, but not most extensions
-            #AC_DEFINE(_XOPEN_SOURCE, 1, [Do we want to use the XOPEN network library?])
-            #LIBS="$LIBS -lxnet"               # Use the XOPEN network library
-
-            SHLIB_SUFFIX=".sl"
+            AC_DEFINE(_XOPEN_SOURCE)          # Use the XOPEN network library
+            AC_DEFINE(_XOPEN_SOURCE_EXTENDED) # Use the XOPEN network library
+            LIBS="$LIBS -lxnet"               # Use the XOPEN network library
+
+            if test "`uname -m`" = "ia64" ; then
+                SHLIB_SUFFIX=".so"
+            else
+                SHLIB_SUFFIX=".sl"
+            fi
             AC_CHECK_LIB(dld, shl_load, tcl_ok=yes, tcl_ok=no)
             if test "$tcl_ok" = yes; then
@@ -1360 +1245 @@
                     do64bit_ok=yes
                     CFLAGS="$CFLAGS +DD64"
-                    LDFLAGS_ARCH="+DD64"
+                    LDFLAGS="$LDFLAGS +DD64"
                 fi
             fi
@@ -1378 +1263 @@
                 LD_LIBRARY_PATH_VAR="SHLIB_PATH"
             fi
+            ;;
+        IRIX-4.*)
+            SHLIB_CFLAGS="-G 0"
+            SHLIB_SUFFIX=".a"
+            SHLIB_LD="echo tclLdAout $CC \{$SHLIB_CFLAGS\} | `pwd`/tclsh -r -G 0"
+            SHLIB_LD_LIBS='${LIBS}'
+            DL_OBJS="tclLoadAout.o"
+            DL_LIBS=""
+            LDFLAGS="$LDFLAGS -Wl,-D,08000000"
+            CC_SEARCH_FLAGS='-L${LIB_RUNTIME_DIR}'
+            LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS}
+            SHARED_LIB_SUFFIX='${VERSION}\$\{DBGX\}.a'
             ;;
         IRIX-5.*)
@@ -1433 +1330 @@
                     SHLIB_LD="ld -64 -shared -rdata_shared"
                     CFLAGS="$CFLAGS -64"
-                    LDFLAGS_ARCH="-64"
+                    LDFLAGS="$LDFLAGS -64"
                 fi
             fi
@@ -1442 +1339 @@
             SHLIB_SUFFIX=".so"
 
-            CFLAGS_OPTIMIZE="-O2 -fomit-frame-pointer"
+            CFLAGS_OPTIMIZE=-O2
             # 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
@@ -1448 +1345 @@
             #CFLAGS_OPTIMIZE="${CFLAGS_OPTIMIZE} -D__NO_STRING_INLINES -D__NO_MATH_INLINES"
 
-            SHLIB_LD="${CC} -shared"
-            DL_OBJS="tclLoadDl.o"
-            DL_LIBS="-ldl"
-            LDFLAGS="$LDFLAGS -Wl,--export-dynamic"
-            CC_SEARCH_FLAGS='-Wl,-rpath,${LIB_RUNTIME_DIR}'
-            LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS}
+            if test "$have_dl" = yes; then
+                SHLIB_LD='${CC} -shared ${CFLAGS} ${LDFLAGS}'
+                DL_OBJS="tclLoadDl.o"
+                DL_LIBS="-ldl"
+                LDFLAGS="$LDFLAGS -Wl,--export-dynamic"
+                CC_SEARCH_FLAGS='-Wl,-rpath,${LIB_RUNTIME_DIR}'
+                LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS}
+            else
+                AC_CHECK_HEADER(dld.h, [
+                    SHLIB_LD="ld -shared"
+                    DL_OBJS="tclLoadDld.o"
+                    DL_LIBS="-ldld"
+                    CC_SEARCH_FLAGS=""
+                    LD_SEARCH_FLAGS=""])
+            fi
             if test "`uname -m`" = "alpha" ; then
                 CFLAGS="$CFLAGS -mieee"
+            fi
+            if test $do64bit = yes; then
+                AC_CACHE_CHECK([if compiler accepts -m64 flag], tcl_cv_cc_m64, [
+                    hold_cflags=$CFLAGS
+                    CFLAGS="$CFLAGS -m64"
+                    AC_TRY_LINK(,, tcl_cv_cc_m64=yes, tcl_cv_cc_m64=no)
+                    CFLAGS=$hold_cflags])
+                if test $tcl_cv_cc_m64 = yes; then
+                    CFLAGS="$CFLAGS -m64"
+                    do64bit_ok=yes
+                fi
             fi
 
@@ -1465 +1382 @@
             # Disable inlining only when one of the
             # files in compat/*.c is being linked in.
-            if test x"${USE_COMPAT}" != x ; then
+            if test x"${LIBOBJS}" != x ; then
                 CFLAGS="$CFLAGS -fno-inline"
             fi
+
+            # XIM peeking works under XFree86.
+            AC_DEFINE(PEEK_XCLOSEIM)
 
             ;;
@@ -1475 +1395 @@
             SHLIB_SUFFIX=".so"
 
-            SHLIB_LD="${CC} -shared"
-            DL_OBJS=""
-            DL_LIBS="-ldl"
-            LDFLAGS="$LDFLAGS -Wl,--export-dynamic"
-            CC_SEARCH_FLAGS=""
-            LD_SEARCH_FLAGS=""
+            if test "$have_dl" = yes; then
+                SHLIB_LD="${CC} -shared"
+                DL_OBJS=""
+                DL_LIBS="-ldl"
+                LDFLAGS="$LDFLAGS -Wl,--export-dynamic"
+                CC_SEARCH_FLAGS=""
+                LD_SEARCH_FLAGS=""
+            else
+                AC_CHECK_HEADER(dld.h, [
+                    SHLIB_LD="ld -shared"
+                    DL_OBJS=""
+                    DL_LIBS="-ldld"
+                    CC_SEARCH_FLAGS=""
+                    LD_SEARCH_FLAGS=""])
+            fi
             if test "`uname -m`" = "alpha" ; then
                 CFLAGS="$CFLAGS -mieee"
@@ -1519 +1448 @@
             ;;
         NetBSD-*|FreeBSD-[[1-2]].*)
-            # NetBSD/SPARC needs -fPIC, -fpic will not do.
-            SHLIB_CFLAGS="-fPIC"
-            SHLIB_LD="ld -Bshareable -x"
-            SHLIB_LD_LIBS='${LIBS}'
-            SHLIB_SUFFIX=".so"
-            DL_OBJS="tclLoadDl.o"
-            DL_LIBS=""
-            CC_SEARCH_FLAGS='-Wl,-rpath,${LIB_RUNTIME_DIR}'
-            LD_SEARCH_FLAGS='-rpath ${LIB_RUNTIME_DIR}'
-            AC_CACHE_CHECK([for ELF], tcl_cv_ld_elf, [
-                AC_EGREP_CPP(yes, [
+            # Not available on all versions:  check for include file.
+            AC_CHECK_HEADER(dlfcn.h, [
+                # NetBSD/SPARC needs -fPIC, -fpic will not do.
+                SHLIB_CFLAGS="-fPIC"
+                SHLIB_LD="ld -Bshareable -x"
+                SHLIB_LD_LIBS='${LIBS}'
+                SHLIB_SUFFIX=".so"
+                DL_OBJS="tclLoadDl.o"
+                DL_LIBS=""
+                CC_SEARCH_FLAGS='-Wl,-rpath,${LIB_RUNTIME_DIR}'
+                LD_SEARCH_FLAGS='-rpath ${LIB_RUNTIME_DIR}'
+                AC_CACHE_CHECK([for ELF], tcl_cv_ld_elf, [
+                    AC_EGREP_CPP(yes, [
 #ifdef __ELF__
         yes
 #endif
-                ], tcl_cv_ld_elf=yes, tcl_cv_ld_elf=no)])
-            if test $tcl_cv_ld_elf = yes; then
-                SHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}.so'
-            else
-                SHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}.so.1.0'
-            fi
-
-            # Ancient FreeBSD doesn't handle version numbers with dots.
-
-            UNSHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}.a'
+                    ], tcl_cv_ld_elf=yes, tcl_cv_ld_elf=no)])
+                if test $tcl_cv_ld_elf = yes; then
+                    SHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}\$\{DBGX\}.so'
+                else
+                    SHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}\$\{DBGX\}.so.1.0'
+                fi
+            ], [
+                SHLIB_CFLAGS=""
+                SHLIB_LD="echo tclLdAout $CC \{$SHLIB_CFLAGS\} | `pwd`/tclsh -r"
+                SHLIB_LD_LIBS='${LIBS}'
+                SHLIB_SUFFIX=".a"
+                DL_OBJS="tclLoadAout.o"
+                DL_LIBS=""
+                CC_SEARCH_FLAGS='-L${LIB_RUNTIME_DIR}'
+                LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS}
+                SHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}\$\{DBGX\}.a'
+            ])
+
+            # FreeBSD doesn't handle version numbers with dots.
+
+            UNSHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}\$\{DBGX\}.a'
             TCL_LIB_VERSIONS_OK=nodots
             ;;
         OpenBSD-*)
-            # OpenBSD/SPARC[64] needs -fPIC, -fpic will not do.
-            case `machine` in
-            sparc|sparc64)
-                SHLIB_CFLAGS="-fPIC";;
+            case `arch -s` in
+            m88k|vax)
+                SHLIB_CFLAGS=""
+                SHLIB_LD="echo tclLdAout $CC \{$SHLIB_CFLAGS\} | `pwd`/tclsh -r"
+                SHLIB_LD_LIBS='${LIBS}'
+                SHLIB_SUFFIX=".a"
+                DL_OBJS="tclLoadAout.o"
+                DL_LIBS=""
+                LDFLAGS=""
+                CC_SEARCH_FLAGS='-L${LIB_RUNTIME_DIR}'
+                LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS}
+                SHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}\$\{DBGX\}.a'
+                ;;
             *)
-                SHLIB_CFLAGS="-fpic";;
-            esac
-            SHLIB_LD="${CC} -shared ${SHLIB_CFLAGS}"
-            SHLIB_LD_LIBS='${LIBS}'
-            SHLIB_SUFFIX=".so"
-            DL_OBJS="tclLoadDl.o"
-            DL_LIBS=""
-            CC_SEARCH_FLAGS='-Wl,-rpath,${LIB_RUNTIME_DIR}'
-            LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS}
-            SHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}.so.1.0'
-            AC_CACHE_CHECK([for ELF], tcl_cv_ld_elf, [
-                AC_EGREP_CPP(yes, [
+                # OpenBSD/SPARC[64] needs -fPIC, -fpic will not do.
+                case `machine` in
+                sparc|sparc64)
+                    SHLIB_CFLAGS="-fPIC";;
+                *)
+                    SHLIB_CFLAGS="-fpic";;
+                esac
+                SHLIB_LD="${CC} -shared ${SHLIB_CFLAGS}"
+                SHLIB_LD_LIBS='${LIBS}'
+                SHLIB_SUFFIX=".so"
+                DL_OBJS="tclLoadDl.o"
+                DL_LIBS=""
+                CC_SEARCH_FLAGS='-Wl,-rpath,${LIB_RUNTIME_DIR}'
+                LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS}
+                SHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}\$\{DBGX\}.so.1.0'
+                AC_CACHE_CHECK([for ELF], tcl_cv_ld_elf, [
+                    AC_EGREP_CPP(yes, [
 #ifdef __ELF__
         yes
 #endif
-                ], tcl_cv_ld_elf=yes, tcl_cv_ld_elf=no)])
-            if test $tcl_cv_ld_elf = yes; then
-                LDFLAGS=-Wl,-export-dynamic
-            else
-                LDFLAGS=""
-            fi
+                    ], tcl_cv_ld_elf=yes, tcl_cv_ld_elf=no)])
+                if test $tcl_cv_ld_elf = yes; then
+                    LDFLAGS=-Wl,-export-dynamic
+                else
+                    LDFLAGS=""
+                fi
+                ;;
+            esac
 
             # OpenBSD doesn't do version numbers with dots.
-            UNSHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}.a'
+            UNSHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}\$\{DBGX\}.a'
             TCL_LIB_VERSIONS_OK=nodots
             ;;
@@ -1597 +1555 @@
             FreeBSD-3.*)
                 # FreeBSD-3 doesn't handle version numbers with dots.
-                UNSHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}.a'
-                SHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}.so'
+                UNSHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}\$\{DBGX\}.a'
+                SHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}\$\{DBGX\}.so'
                 TCL_LIB_VERSIONS_OK=nodots
                 ;;
@@ -1606 +1564 @@
             CFLAGS_OPTIMIZE="-Os"
             SHLIB_CFLAGS="-fno-common"
+            # To avoid discrepancies between what headers configure sees during
+            # preprocessing tests and compiling tests, move any -isysroot and
+            # -mmacosx-version-min flags from CFLAGS to CPPFLAGS:
+            CPPFLAGS="${CPPFLAGS} `echo " ${CFLAGS}" | \
+                awk 'BEGIN {FS=" +-";ORS=" "}; {for (i=2;i<=NF;i++) \
+                if ([$]i~/^(isysroot|mmacosx-version-min)/) print "-"[$]i}'`"
+            CFLAGS="`echo " ${CFLAGS}" | \
+                awk 'BEGIN {FS=" +-";ORS=" "}; {for (i=2;i<=NF;i++) \
+                if (!([$]i~/^(isysroot|mmacosx-version-min)/)) print "-"[$]i}'`"
             if test $do64bit = yes; then
-                do64bit_ok=yes
-                CFLAGS="$CFLAGS -arch ppc64 -mpowerpc64 -mcpu=G5"
-            fi
-            # TEA specific: use LDFLAGS_DEFAULT instead of LDFLAGS here:
-            SHLIB_LD='${CC} -dynamiclib ${CFLAGS} ${LDFLAGS_DEFAULT}'
+                case `arch` in
+                    ppc)
+                        AC_CACHE_CHECK([if compiler accepts -arch ppc64 flag],
+                                tcl_cv_cc_arch_ppc64, [
+                            hold_cflags=$CFLAGS
+                            CFLAGS="$CFLAGS -arch ppc64 -mpowerpc64 -mcpu=G5"
+                            AC_TRY_LINK(,, tcl_cv_cc_arch_ppc64=yes,
+                                    tcl_cv_cc_arch_ppc64=no)
+                            CFLAGS=$hold_cflags])
+                        if test $tcl_cv_cc_arch_ppc64 = yes; then
+                            CFLAGS="$CFLAGS -arch ppc64 -mpowerpc64 -mcpu=G5"
+                            do64bit_ok=yes
+                        fi;;
+                    i386)
+                        AC_CACHE_CHECK([if compiler accepts -arch x86_64 flag],
+                                tcl_cv_cc_arch_x86_64, [
+                            hold_cflags=$CFLAGS
+                            CFLAGS="$CFLAGS -arch x86_64"
+                            AC_TRY_LINK(,, tcl_cv_cc_arch_x86_64=yes,
+                                    tcl_cv_cc_arch_x86_64=no)
+                            CFLAGS=$hold_cflags])
+                        if test $tcl_cv_cc_arch_x86_64 = yes; then
+                            CFLAGS="$CFLAGS -arch x86_64"
+                            do64bit_ok=yes
+                        fi;;
+                    *)
+                        AC_MSG_WARN([Don't know how enable 64-bit on architecture `arch`]);;
+                esac
+            else
+                # 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 (ppc|i386) ' && \
+                    fat_32_64=yes
+            fi
+            SHLIB_LD='${CC} -dynamiclib ${CFLAGS} ${LDFLAGS}'
             AC_CACHE_CHECK([if ld accepts -single_module flag], tcl_cv_ld_single_module, [
-                hold_ldflags=$LDFLAGS
-                LDFLAGS="$LDFLAGS -dynamiclib -Wl,-single_module"
-                AC_TRY_LINK(, [int i;], tcl_cv_ld_single_module=yes, tcl_cv_ld_single_module=no)
-                LDFLAGS=$hold_ldflags])
+                hold_ldflags=$LDFLAGS
+                LDFLAGS="$LDFLAGS -dynamiclib -Wl,-single_module"
+                AC_TRY_LINK(, [int i;], tcl_cv_ld_single_module=yes, tcl_cv_ld_single_module=no)
+                LDFLAGS=$hold_ldflags])
             if test $tcl_cv_ld_single_module = yes; then
-                SHLIB_LD="${SHLIB_LD} -Wl,-single_module"
+                SHLIB_LD="${SHLIB_LD} -Wl,-single_module"
             fi
             SHLIB_LD_LIBS='${LIBS}'
@@ -1625 +1622 @@
             DL_LIBS=""
             # Don't use -prebind when building for Mac OS X 10.4 or later only:
-            test -z "${MACOSX_DEPLOYMENT_TARGET}" || \
-                test "`echo "${MACOSX_DEPLOYMENT_TARGET}" | awk -F. '{print [$]2}'`" -lt 4 && \
+            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 && \
                 LDFLAGS="$LDFLAGS -prebind"
             LDFLAGS="$LDFLAGS -headerpad_max_install_names"
             AC_CACHE_CHECK([if ld accepts -search_paths_first flag], tcl_cv_ld_search_paths_first, [
-                hold_ldflags=$LDFLAGS
-                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)
-                LDFLAGS=$hold_ldflags])
+                hold_ldflags=$LDFLAGS
+                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)
+                LDFLAGS=$hold_ldflags])
             if test $tcl_cv_ld_search_paths_first = yes; then
-                LDFLAGS="$LDFLAGS -Wl,-search_paths_first"
+                LDFLAGS="$LDFLAGS -Wl,-search_paths_first"
             fi
             CC_SEARCH_FLAGS=""
             LD_SEARCH_FLAGS=""
             LD_LIBRARY_PATH_VAR="DYLD_LIBRARY_PATH"
-
-            # TEA specific: for Tk extensions, remove -arch ppc64 from CFLAGS
-            # for fat builds, as neither TkAqua nor TkX11 can be built for 64bit
-            # at present (no 64bit GUI libraries).
-            test $do64bit_ok = no && test -n "${TK_BIN_DIR}" && \
-                CFLAGS="`echo "$CFLAGS" | sed -e 's/-arch ppc64/-arch ppc/g'`"
+            PLAT_OBJS=\$\(MAC\_OSX_OBJS\)
+            PLAT_SRCS=\$\(MAC\_OSX_SRCS\)
+            AC_MSG_CHECKING([whether to use CoreFoundation])
+            AC_ARG_ENABLE(corefoundation, [  --enable-corefoundation use CoreFoundation API [--enable-corefoundation]],
+                [tcl_corefoundation=$enableval], [tcl_corefoundation=yes])
+            AC_MSG_RESULT([$tcl_corefoundation])
+            if test $tcl_corefoundation = yes; then
+                AC_CACHE_CHECK([for CoreFoundation.framework], tcl_cv_lib_corefoundation, [
+                    hold_libs=$LIBS
+                    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
+                        # from CFLAGS et al. while testing for presence of CF.
+                        # 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"`"'
+                    done; fi
+                    LIBS="$LIBS -framework CoreFoundation"
+                    AC_TRY_LINK([#include <CoreFoundation/CoreFoundation.h>], 
+                        [CFBundleRef b = CFBundleGetMainBundle();], 
+                        tcl_cv_lib_corefoundation=yes, tcl_cv_lib_corefoundation=no)
+                    if test "$fat_32_64" = yes; then for v in CFLAGS CPPFLAGS LDFLAGS; do
+                        eval $v'="$hold_'$v'"'
+                    done; fi; LIBS=$hold_libs])
+                if test $tcl_cv_lib_corefoundation = yes; then
+                    LIBS="$LIBS -framework CoreFoundation"
+                    AC_DEFINE(HAVE_COREFOUNDATION)
+                else
+                    tcl_corefoundation=no
+                fi
+                if test "$fat_32_64" = yes -a $tcl_corefoundation = yes; then
+                    AC_CACHE_CHECK([for 64-bit CoreFoundation], tcl_cv_lib_corefoundation_64, [
+                        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"`"'
+                        done
+                        AC_TRY_LINK([#include <CoreFoundation/CoreFoundation.h>], 
+                            [CFBundleRef b = CFBundleGetMainBundle();], 
+                            tcl_cv_lib_corefoundation_64=yes, tcl_cv_lib_corefoundation_64=no)
+                        for v in CFLAGS CPPFLAGS LDFLAGS; do
+                            eval $v'="$hold_'$v'"'
+                        done])
+                    if test $tcl_cv_lib_corefoundation_64 = no; then
+                        AC_DEFINE(NO_COREFOUNDATION_64)
+                    fi
+                fi
+            fi
+            AC_DEFINE(MAC_OSX_TCL)
             ;;
         NEXTSTEP-*)
@@ -1659 +1695 @@
         OS/390-*)
             CFLAGS_OPTIMIZE=""          # Optimizer is buggy
-            AC_DEFINE(_OE_SOCKETS, 1,   # needed in sys/socket.h
-                [Should OS/390 do the right thing with sockets?])
+            AC_DEFINE(_OE_SOCKETS)      # needed in sys/socket.h
             ;;      
         OSF1-1.0|OSF1-1.1|OSF1-1.2)
@@ -1735 +1770 @@
             LD_SEARCH_FLAGS=""
             ;;
+        RISCos-*)
+            SHLIB_CFLAGS="-G 0"
+            SHLIB_LD="echo tclLdAout $CC \{$SHLIB_CFLAGS\} | `pwd`/tclsh -r -G 0"
+            SHLIB_LD_LIBS='${LIBS}'
+            SHLIB_SUFFIX=".a"
+            DL_OBJS="tclLoadAout.o"
+            DL_LIBS=""
+            LDFLAGS="$LDFLAGS -Wl,-D,08000000"
+            CC_SEARCH_FLAGS='-L${LIB_RUNTIME_DIR}'
+            LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS}
+            ;;
         SCO_SV-3.2*)
             # Note, dlopen is available only on SCO 3.2.5 and greater. However,
@@ -1779 +1825 @@
             # So, the library has to have a name like libtcl75.so.1.0
 
-            SHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}.so.1.0'
-            UNSHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}.a'
+            SHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}\$\{DBGX\}.so.1.0'
+            UNSHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}\$\{DBGX\}.a'
             TCL_LIB_VERSIONS_OK=nodots
             ;;
@@ -1789 +1835 @@
             # won't define thread-safe library routines.
 
-            AC_DEFINE(_REENTRANT, 1, [Do we want the reentrant OS API?])
-            AC_DEFINE(_POSIX_PTHREAD_SEMANTICS, 1,
-                [Do we really want to follow the standard? Yes we do!])
+            AC_DEFINE(_REENTRANT)
+            AC_DEFINE(_POSIX_PTHREAD_SEMANTICS)
 
             SHLIB_CFLAGS="-KPIC"
@@ -1816 +1861 @@
             # won't define thread-safe library routines.
 
-            AC_DEFINE(_REENTRANT, 1, [Do we want the reentrant OS API?])
-            AC_DEFINE(_POSIX_PTHREAD_SEMANTICS, 1,
-                [Do we really want to follow the standard? Yes we do!])
+            AC_DEFINE(_REENTRANT)
+            AC_DEFINE(_POSIX_PTHREAD_SEMANTICS)
 
             SHLIB_CFLAGS="-KPIC"
@@ -1839 +1883 @@
                             if test "$do64bitVIS" = "yes" ; then
                                 CFLAGS="$CFLAGS -xarch=v9a"
-                                LDFLAGS_ARCH="-xarch=v9a"
+                                LDFLAGS="$LDFLAGS -xarch=v9a"
                             else
                                 CFLAGS="$CFLAGS -xarch=v9"
-                                LDFLAGS_ARCH="-xarch=v9"
+                                LDFLAGS="$LDFLAGS -xarch=v9"
                             fi
                             # Solaris 64 uses this as well
@@ -1874 +1918 @@
                     # We need to specify -static-libgcc or we need to
                     # add the path to the sparv9 libgcc.
-                    # JH: static-libgcc is necessary for core Tcl, but may
-                    # not be necessary for extensions.
                     SHLIB_LD="$SHLIB_LD -m64 -mcpu=v9 -static-libgcc"
                     # for finding sparcv9 libgcc, get the regular libgcc
@@ -1883 +1925 @@
                 fi
             else
-                SHLIB_LD="/usr/ccs/bin/ld -G -z text"
+                case $system in
+                    SunOS-5.[[1-9]][[0-9]]*)
+                        SHLIB_LD='${CC} -G -z text ${LDFLAGS}';;
+                    *)
+                        SHLIB_LD="/usr/ccs/bin/ld -G -z text";;
+                esac
                 CC_SEARCH_FLAGS='-Wl,-R,${LIB_RUNTIME_DIR}'
                 LD_SEARCH_FLAGS='-R ${LIB_RUNTIME_DIR}'
+            fi
+            ;;
+        ULTRIX-4.*)
+            SHLIB_CFLAGS="-G 0"
+            SHLIB_SUFFIX=".a"
+            SHLIB_LD="echo tclLdAout $CC \{$SHLIB_CFLAGS\} | `pwd`/tclsh -r -G 0"
+            SHLIB_LD_LIBS='${LIBS}'
+            DL_OBJS="tclLoadAout.o"
+            DL_LIBS=""
+            LDFLAGS="$LDFLAGS -Wl,-D,08000000"
+            CC_SEARCH_FLAGS='-L${LIB_RUNTIME_DIR}'
+            LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS}
+            if test "$GCC" != "yes" ; then
+                CFLAGS="$CFLAGS -DHAVE_TZSET -std1"
             fi
             ;;
@@ -1914 +1975 @@
     fi
 
-    # Step 4: disable dynamic loading if requested via a command-line switch.
-
-    AC_ARG_ENABLE(load,
-        AC_HELP_STRING([--disable-load],
-            [disallow dynamic loading and "load" command (default: enabled)]),
+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 # both CPPFLAGS and CFLAGS (unlike our compile and link) but configure's
+dnl # preprocessing tests use only CPPFLAGS.
+    SC_CONFIG_COMMANDS_PRE([CFLAGS="${CFLAGS} ${CPPFLAGS}"; CPPFLAGS=""])
+
+    # 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,
+    # New Orleans, LA, Computerized Processes Unlimited, 1994), then we need
+    # 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
+    # support only a file format that is more or less version-7-compatible. 
+    # In particular,
+    #   - a.out files must begin with `struct exec'.
+    #   - the N_TXTOFF on the `struct exec' must compute the seek address
+    #     of the text segment
+    #   - The `struct exec' must contain a_magic, a_text, a_data, a_bss
+    #     and a_entry fields.
+    # The following compilation should succeed if and only if either sys/exec.h
+    # or a.out.h is usable for the purpose.
+    #
+    # 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
+    # duplicates the v7 fields that are needed.
+
+    if test "x$DL_OBJS" = "xtclLoadAout.o" ; then
+        AC_CACHE_CHECK([sys/exec.h], tcl_cv_sysexec_h, [
+        AC_TRY_COMPILE([#include <sys/exec.h>],[
+            struct exec foo;
+            unsigned long seek;
+            int flag;
+#if defined(__mips) || defined(mips)
+            seek = N_TXTOFF (foo.ex_f, foo.ex_o);
+#else
+            seek = N_TXTOFF (foo);
+#endif
+            flag = (foo.a_magic == OMAGIC);
+            return foo.a_text + foo.a_data + foo.a_bss + foo.a_entry;
+    ], tcl_cv_sysexec_h=usable, tcl_cv_sysexec_h=unusable)])
+        if test $tcl_cv_sysexec_h = usable; then
+            AC_DEFINE(USE_SYS_EXEC_H)
+        else
+            AC_CACHE_CHECK([a.out.h], tcl_cv_aout_h, [
+            AC_TRY_COMPILE([#include <a.out.h>],[
+                struct exec foo;
+                unsigned long seek;
+                int flag;
+#if defined(__mips) || defined(mips)
+                seek = N_TXTOFF (foo.ex_f, foo.ex_o);
+#else
+                seek = N_TXTOFF (foo);
+#endif
+                flag = (foo.a_magic == OMAGIC);
+                return foo.a_text + foo.a_data + foo.a_bss + foo.a_entry;
+            ], tcl_cv_aout_h=usable, tcl_cv_aout_h=unusable)])
+            if test $tcl_cv_aout_h = usable; then
+                AC_DEFINE(USE_A_OUT_H)
+            else
+                AC_CACHE_CHECK([sys/exec_aout.h], tcl_cv_sysexecaout_h, [
+                AC_TRY_COMPILE([#include <sys/exec_aout.h>],[
+                    struct exec foo;
+                    unsigned long seek;
+                    int flag;
+#if defined(__mips) || defined(mips)
+                    seek = N_TXTOFF (foo.ex_f, foo.ex_o);
+#else
+                    seek = N_TXTOFF (foo);
+#endif
+                    flag = (foo.a_midmag == OMAGIC);
+                    return foo.a_text + foo.a_data + foo.a_bss + foo.a_entry;
+                ], tcl_cv_sysexecaout_h=usable, tcl_cv_sysexecaout_h=unusable)])
+                if test $tcl_cv_sysexecaout_h = usable; then
+                    AC_DEFINE(USE_SYS_EXEC_AOUT_H)
+                else
+                    DL_OBJS=""
+                fi
+            fi
+        fi
+    fi
+
+    # Step 5: disable dynamic loading if requested via a command-line switch.
+
+    AC_ARG_ENABLE(load, [  --disable-load          disallow dynamic loading and "load" command],
         [tcl_ok=$enableval], [tcl_ok=yes])
     if test "$tcl_ok" = "no"; then
@@ -1939 +2078 @@
         BUILD_DLTEST=""
     fi
-    LDFLAGS="$LDFLAGS $LDFLAGS_ARCH"
 
     # If we're running gcc, then change the C flags for compiling shared
@@ -1954 +2092 @@
                 IRIX*)
                     ;;
-                NetBSD-*|FreeBSD-*)
+                NetBSD-*|FreeBSD-*|OpenBSD-*)
                     ;;
                 Darwin-*)
                     ;;
+                RISCos-*)
+                    ;;
                 SCO_SV-3.2*)
                     ;;
-                windows)
+                ULTRIX-4.*)
                     ;;
                 *)
@@ -1970 +2110 @@
 
     if test "$SHARED_LIB_SUFFIX" = "" ; then
-        SHARED_LIB_SUFFIX='${PACKAGE_VERSION}${SHLIB_SUFFIX}'
+        SHARED_LIB_SUFFIX='${VERSION}\$\{DBGX\}${SHLIB_SUFFIX}'
     fi
     if test "$UNSHARED_LIB_SUFFIX" = "" ; then
-        UNSHARED_LIB_SUFFIX='${PACKAGE_VERSION}.a'
-    fi
+        UNSHARED_LIB_SUFFIX='${VERSION}\$\{DBGX\}.a'
+    fi
+
+    if test "${SHARED_BUILD}" = "1" && test "${SHLIB_SUFFIX}" != "" ; then
+        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}'
+        INSTALL_LIB='$(INSTALL_LIBRARY) $(LIB_FILE) $(LIB_INSTALL_DIR)/$(LIB_FILE)'
+    else
+        LIB_SUFFIX=${UNSHARED_LIB_SUFFIX}
+
+        if test "$RANLIB" = "" ; then
+            MAKE_LIB='$(STLIB_LD) [$]@ ${OBJS}'
+            INSTALL_LIB='$(INSTALL_LIBRARY) $(LIB_FILE) $(LIB_INSTALL_DIR)/$(LIB_FILE)'
+        else
+            MAKE_LIB='${STLIB_LD} [$]@ ${OBJS} ; ${RANLIB} [$]@'
+            INSTALL_LIB='$(INSTALL_LIBRARY) $(LIB_FILE) $(LIB_INSTALL_DIR)/$(LIB_FILE) ; (cd $(LIB_INSTALL_DIR) ; $(RANLIB) $(LIB_FILE))'
+        fi
+
+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        things needs to be done in the big loop above.
+dnl        REMOVE THIS BLOCK LATER! (mdejong)
+dnl        case $system in
+dnl            BSD/OS*)
+dnl                ;;
+dnl            AIX-[[1-4]].*)
+dnl                ;;
+dnl            *)
+dnl                SHLIB_LD_LIBS=""
+dnl                ;;
+dnl        esac
+    fi
+
+
+    # Stub lib does not depend on shared/static configuration
+    if test "$RANLIB" = "" ; then
+        MAKE_STUB_LIB='${STLIB_LD} [$]@ ${STUB_LIB_OBJS}'
+        INSTALL_STUB_LIB='$(INSTALL_LIBRARY) $(STUB_LIB_FILE) $(LIB_INSTALL_DIR)/$(STUB_LIB_FILE)'
+    else
+        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))'
+    fi
+
 
     AC_SUBST(DL_LIBS)
 
+    AC_SUBST(DL_OBJS)
+    AC_SUBST(PLAT_OBJS)
+    AC_SUBST(PLAT_SRCS)
+    AC_SUBST(CFLAGS)
     AC_SUBST(CFLAGS_DEBUG)
     AC_SUBST(CFLAGS_OPTIMIZE)
     AC_SUBST(CFLAGS_WARNING)
 
+    AC_SUBST(LDFLAGS)
+    AC_SUBST(LDFLAGS_DEBUG)
+    AC_SUBST(LDFLAGS_OPTIMIZE)
+    AC_SUBST(CC_SEARCH_FLAGS)
+    AC_SUBST(LD_SEARCH_FLAGS)
+
     AC_SUBST(STLIB_LD)
     AC_SUBST(SHLIB_LD)
-
+    AC_SUBST(TCL_SHLIB_LD_EXTRAS)
+    AC_SUBST(TK_SHLIB_LD_EXTRAS)
     AC_SUBST(SHLIB_LD_LIBS)
     AC_SUBST(SHLIB_CFLAGS)
-
-    AC_SUBST(LD_LIBRARY_PATH_VAR)
-
-    # These must be called after we do the basic CFLAGS checks and
-    # verify any possible 64-bit or similar switches are necessary
-    TEA_TCL_EARLY_FLAGS
-    TEA_TCL_64BIT_FLAGS
+    AC_SUBST(SHLIB_SUFFIX)
+
+    AC_SUBST(MAKE_LIB)
+    AC_SUBST(MAKE_STUB_LIB)
+    AC_SUBST(INSTALL_LIB)
+    AC_SUBST(INSTALL_STUB_LIB)
+    AC_SUBST(RANLIB)
 ])
 
 #--------------------------------------------------------------------
-# TEA_SERIAL_PORT
+# SC_SERIAL_PORT
 #
 #       Determine which interface to use to talk to the serial port.
@@ -2018 +2210 @@
 #--------------------------------------------------------------------
 
-AC_DEFUN([TEA_SERIAL_PORT], [
+AC_DEFUN([SC_SERIAL_PORT], [
     AC_CHECK_HEADERS(sys/modem.h)
     AC_CACHE_CHECK([termios vs. termio vs. sgtty], tcl_cv_api_serial, [
@@ -2108 +2300 @@
     fi])
     case $tcl_cv_api_serial in
-        termios) AC_DEFINE(USE_TERMIOS, 1, [Use the termios API for serial lines]);;
-        termio)  AC_DEFINE(USE_TERMIO, 1, [Use the termio API for serial lines]);;
-        sgtty)   AC_DEFINE(USE_SGTTY, 1, [Use the sgtty API for serial lines]);;
+        termios) AC_DEFINE(USE_TERMIOS);;
+        termio)  AC_DEFINE(USE_TERMIO);;
+        sgtty)   AC_DEFINE(USE_SGTTY);;
     esac
 ])
 
 #--------------------------------------------------------------------
-# TEA_MISSING_POSIX_HEADERS
+# SC_MISSING_POSIX_HEADERS
 #
 #       Supply substitutes for missing POSIX header files.  Special
@@ -2138 +2330 @@
 #               NO_SYS_WAIT_H
 #               NO_DLFCN_H
+#               HAVE_UNISTD_H
 #               HAVE_SYS_PARAM_H
 #
 #               HAVE_STRING_H ?
 #
-# tkUnixPort.h checks for HAVE_LIMITS_H, so do both HAVE and
-# CHECK on limits.h
-#--------------------------------------------------------------------
-
-AC_DEFUN([TEA_MISSING_POSIX_HEADERS], [
-    AC_CACHE_CHECK([dirent.h], tcl_cv_dirent_h,
+#--------------------------------------------------------------------
+
+AC_DEFUN([SC_MISSING_POSIX_HEADERS], [
+    AC_CACHE_CHECK([dirent.h], tcl_cv_dirent_h, [
     AC_TRY_LINK([#include <sys/types.h>
 #include <dirent.h>], [
@@ -2167 +2358 @@
 p = entryPtr->d_name;
 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
-        AC_DEFINE(NO_DIRENT_H, 1, [Do we have <dirent.h>?])
-    fi
-
-    AC_CHECK_HEADER(errno.h, , [AC_DEFINE(NO_ERRNO_H, 1, [Do we have <errno.h>?])])
-    AC_CHECK_HEADER(float.h, , [AC_DEFINE(NO_FLOAT_H, 1, [Do we have <float.h>?])])
-    AC_CHECK_HEADER(values.h, , [AC_DEFINE(NO_VALUES_H, 1, [Do we have <values.h>?])])
+        AC_DEFINE(NO_DIRENT_H)
+    fi
+
+    AC_CHECK_HEADER(errno.h, , [AC_DEFINE(NO_ERRNO_H)])
+    AC_CHECK_HEADER(float.h, , [AC_DEFINE(NO_FLOAT_H)])
+    AC_CHECK_HEADER(values.h, , [AC_DEFINE(NO_VALUES_H)])
     AC_CHECK_HEADER(limits.h,
-        [AC_DEFINE(HAVE_LIMITS_H, 1, [Do we have <limits.h>?])],
-        [AC_DEFINE(NO_LIMITS_H, 1, [Do we have <limits.h>?])])
+        [AC_DEFINE(HAVE_LIMITS_H)], [AC_DEFINE(NO_LIMITS_H)])
     AC_CHECK_HEADER(stdlib.h, tcl_ok=1, tcl_ok=0)
     AC_EGREP_HEADER(strtol, stdlib.h, , tcl_ok=0)
@@ -2184 +2374 @@
     AC_EGREP_HEADER(strtod, stdlib.h, , tcl_ok=0)
     if test $tcl_ok = 0; then
-        AC_DEFINE(NO_STDLIB_H, 1, [Do we have <stdlib.h>?])
+        AC_DEFINE(NO_STDLIB_H)
     fi
     AC_CHECK_HEADER(string.h, tcl_ok=1, tcl_ok=0)
@@ -2194 +2384 @@
 
     if test $tcl_ok = 0; then
-        AC_DEFINE(NO_STRING_H, 1, [Do we have <string.h>?])
-    fi
-
-    AC_CHECK_HEADER(sys/wait.h, , [AC_DEFINE(NO_SYS_WAIT_H, 1, [Do we have <sys/wait.h>?])])
-    AC_CHECK_HEADER(dlfcn.h, , [AC_DEFINE(NO_DLFCN_H, 1, [Do we have <dlfcn.h>?])])
+        AC_DEFINE(NO_STRING_H)
+    fi
+
+    AC_CHECK_HEADER(sys/wait.h, , [AC_DEFINE(NO_SYS_WAIT_H)])
+    AC_CHECK_HEADER(dlfcn.h, , [AC_DEFINE(NO_DLFCN_H)])
 
     # OS/390 lacks sys/param.h (and doesn't need it, by chance).
-    AC_HAVE_HEADERS(sys/param.h)
+    AC_HAVE_HEADERS(unistd.h sys/param.h)
 ])
 
 #--------------------------------------------------------------------
-# TEA_PATH_X
+# SC_PATH_X
 #
 #       Locate the X11 header files and the X11 library archive.  Try
@@ -2214 +2404 @@
 #       no include files, so double-check its result just to be safe.
 #
-#       This should be called after TEA_CONFIG_CFLAGS as setting the
-#       LIBS line can confuse some configure macro magic.
-#
 # Arguments:
 #       none
@@ -2222 +2409 @@
 # Results:
 #
-#       Sets the following vars:
+#       Sets the the following vars:
 #               XINCLUDES
 #               XLIBSW
-#               PKG_LIBS (appends to)
-#
-#--------------------------------------------------------------------
-
-AC_DEFUN([TEA_PATH_X], [
-    if test "${TEA_WINDOWINGSYSTEM}" = "x11" ; then
-        TEA_PATH_UNIX_X
-    fi
-])
-
-AC_DEFUN([TEA_PATH_UNIX_X], [
+#
+#--------------------------------------------------------------------
+
+AC_DEFUN([SC_PATH_X], [
     AC_PATH_X
     not_really_there=""
@@ -2298 +2478 @@
         XLIBSW=-lX11
     fi
-    if test x"${XLIBSW}" != x ; then
-        PKG_LIBS="${PKG_LIBS} ${XLIBSW}"
-    fi
 ])
 
 #--------------------------------------------------------------------
-# TEA_BLOCKING_STYLE
+# SC_BLOCKING_STYLE
 #
 #       The statements below check for systems where POSIX-style
@@ -2324 +2501 @@
 #--------------------------------------------------------------------
 
-AC_DEFUN([TEA_BLOCKING_STYLE], [
+AC_DEFUN([SC_BLOCKING_STYLE], [
     AC_CHECK_HEADERS(sys/ioctl.h)
     AC_CHECK_HEADERS(sys/filio.h)
-    TEA_CONFIG_SYSTEM
+    SC_CONFIG_SYSTEM
     AC_MSG_CHECKING([FIONBIO vs. O_NONBLOCK for nonblocking I/O])
     case $system in
@@ -2336 +2513 @@
 
         OSF*)
-            AC_DEFINE(USE_FIONBIO, 1, [Should we use FIONBIO?])
+            AC_DEFINE(USE_FIONBIO)
             AC_MSG_RESULT([FIONBIO])
             ;;
         SunOS-4*)
-            AC_DEFINE(USE_FIONBIO, 1, [Should we use FIONBIO?])
+            AC_DEFINE(USE_FIONBIO)
+            AC_MSG_RESULT([FIONBIO])
+            ;;
+        ULTRIX-4.*)
+            AC_DEFINE(USE_FIONBIO)
             AC_MSG_RESULT([FIONBIO])
             ;;
@@ -2350 +2531 @@
 
 #--------------------------------------------------------------------
-# TEA_TIME_HANLDER
+# SC_TIME_HANLDER
 #
 #       Checks how the system deals with time.h, what time structures
@@ -2368 +2549 @@
 #--------------------------------------------------------------------
 
-AC_DEFUN([TEA_TIME_HANDLER], [
+AC_DEFUN([SC_TIME_HANDLER], [
     AC_CHECK_HEADERS(sys/time.h)
     AC_HEADER_TIME
@@ -2375 +2556 @@
     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;],
-            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
-        AC_DEFINE(HAVE_TM_TZADJ, 1, [Should we use the tm_tzadj field of struct tm?])
-    fi
-
-    AC_CACHE_CHECK([tm_gmtoff in struct tm], tcl_cv_member_tm_gmtoff,
+        AC_DEFINE(HAVE_TM_TZADJ)
+    fi
+
+    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;],
-            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
-        AC_DEFINE(HAVE_TM_GMTOFF, 1, [Should we use the tm_gmtoff field of struct tm?])
+        AC_DEFINE(HAVE_TM_GMTOFF)
     fi
 
@@ -2393 +2574 @@
     # (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>],
             [extern long timezone;
             timezone += 1;
             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
-        AC_DEFINE(HAVE_TIMEZONE_VAR, 1, [Should we use the global timezone variable?])
+        AC_DEFINE(HAVE_TIMEZONE_VAR)
     else
         #
         # 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>],
                 [extern time_t timezone;
                 timezone += 1;
                 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
-            AC_DEFINE(HAVE_TIMEZONE_VAR, 1, [Should we use the global timezone variable?])
+            AC_DEFINE(HAVE_TIMEZONE_VAR)
         fi
     fi
@@ -2418 +2599 @@
 
 #--------------------------------------------------------------------
-# TEA_BUGGY_STRTOD
+# SC_BUGGY_STRTOD
 #
 #       Under Solaris 2.4, strtod returns the wrong value for the
@@ -2437 +2618 @@
 #--------------------------------------------------------------------
 
-AC_DEFUN([TEA_BUGGY_STRTOD], [
+AC_DEFUN([SC_BUGGY_STRTOD], [
     AC_CHECK_FUNC(strtod, tcl_strtod=1, tcl_strtod=0)
     if test "$tcl_strtod" = 1; then
@@ -2463 +2644 @@
                     tcl_cv_strtod_buggy=buggy)])
         if test "$tcl_cv_strtod_buggy" = buggy; then
-            AC_LIBOBJ([fixstrtod])
-            USE_COMPAT=1
-            AC_DEFINE(strtod, fixstrtod, [Do we want to use the strtod() in compat?])
+            LIBOBJS="$LIBOBJS fixstrtod.o"
+            AC_DEFINE(strtod, fixstrtod)
         fi
     fi
@@ -2471 +2651 @@
 
 #--------------------------------------------------------------------
-# TEA_TCL_LINK_LIBS
+# SC_TCL_LINK_LIBS
 #
 #       Search for the libraries needed to link the Tcl shell.
@@ -2497 +2677 @@
 #--------------------------------------------------------------------
 
-AC_DEFUN([TEA_TCL_LINK_LIBS], [
+AC_DEFUN([SC_TCL_LINK_LIBS], [
     #--------------------------------------------------------------------
     # On a few very rare systems, all of the libm.a stuff is
@@ -2514 +2694 @@
 
     AC_CHECK_LIB(inet, main, [LIBS="$LIBS -linet"])
-    AC_CHECK_HEADER(net/errno.h, [
-        AC_DEFINE(HAVE_NET_ERRNO_H, 1, [Do we have <net/errno.h>?])])
+    AC_CHECK_HEADER(net/errno.h, [AC_DEFINE(HAVE_NET_ERRNO_H)])
 
     #--------------------------------------------------------------------
@@ -2550 +2729 @@
     
     # Don't perform the eval of the libraries here because DL_LIBS
-    # won't be set until we call TEA_CONFIG_CFLAGS
+    # won't be set until we call SC_CONFIG_CFLAGS
 
     TCL_LIBS='${DL_LIBS} ${LIBS} ${MATH_LIBS}'
@@ -2558 +2737 @@
 
 #--------------------------------------------------------------------
-# TEA_TCL_EARLY_FLAGS
+# SC_TCL_EARLY_FLAGS
 #
 #       Check for what flags are needed to be passed so the correct OS
@@ -2575 +2754 @@
 #--------------------------------------------------------------------
 
-AC_DEFUN([TEA_TCL_EARLY_FLAG],[
+AC_DEFUN([SC_TCL_EARLY_FLAG],[
     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,
@@ -2583 +2762 @@
                 [tcl_cv_flag_]translit($1,[A-Z],[a-z])=no)))
     if test ["x${tcl_cv_flag_]translit($1,[A-Z],[a-z])[}" = "xyes"] ; then
-        AC_DEFINE($1, 1, [Add the ]$1[ flag when building])
+        AC_DEFINE($1)
         tcl_flags="$tcl_flags $1"
     fi
 ])
 
-AC_DEFUN([TEA_TCL_EARLY_FLAGS],[
+AC_DEFUN([SC_TCL_EARLY_FLAGS],[
     AC_MSG_CHECKING([for required early compiler flags])
     tcl_flags=""
-    TEA_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;])
-    TEA_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);])
-    TEA_TCL_EARLY_FLAG(_LARGEFILE_SOURCE64,[#include <sys/stat.h>],
+    SC_TCL_EARLY_FLAG(_LARGEFILE_SOURCE64,[#include <sys/stat.h>],
         [char *p = (char *)open64;])
     if test "x${tcl_flags}" = "x" ; then
@@ -2605 +2784 @@
 
 #--------------------------------------------------------------------
-# TEA_TCL_64BIT_FLAGS
+# SC_TCL_64BIT_FLAGS
 #
 #       Check for what is defined in the way of 64-bit features.
@@ -2623 +2802 @@
 #--------------------------------------------------------------------
 
-AC_DEFUN([TEA_TCL_64BIT_FLAGS], [
+AC_DEFUN([SC_TCL_64BIT_FLAGS], [
     AC_MSG_CHECKING([for 64-bit integer type])
     AC_CACHE_VAL(tcl_cv_type_64bit,[
@@ -2637 +2816 @@
         }],tcl_cv_type_64bit=${tcl_type_64bit})])
     if test "${tcl_cv_type_64bit}" = none ; then
-        AC_DEFINE(TCL_WIDE_INT_IS_LONG, 1, [Are wide integers to be implemented with C 'long's?])
+        AC_DEFINE(TCL_WIDE_INT_IS_LONG)
         AC_MSG_RESULT([using long])
-    elif test "${tcl_cv_type_64bit}" = "__int64" \
-                -a "${TEA_PLATFORM}" = "windows" ; then
-        # We actually want to use the default tcl.h checks in this
-        # case to handle both TCL_WIDE_INT_TYPE and TCL_LL_MODIFIER*
-        AC_MSG_RESULT([using Tcl header defaults])
     else
-        AC_DEFINE_UNQUOTED(TCL_WIDE_INT_TYPE,${tcl_cv_type_64bit},
-            [What type should be used to define wide integers?])
+        AC_DEFINE_UNQUOTED(TCL_WIDE_INT_TYPE,${tcl_cv_type_64bit})
         AC_MSG_RESULT([${tcl_cv_type_64bit}])
 
@@ -2655 +2828 @@
                 tcl_cv_struct_dirent64=yes,tcl_cv_struct_dirent64=no)])
         if test "x${tcl_cv_struct_dirent64}" = "xyes" ; then
-            AC_DEFINE(HAVE_STRUCT_DIRENT64, 1, [Is 'struct dirent64' in <sys/types.h>?])
+            AC_DEFINE(HAVE_STRUCT_DIRENT64)
         fi
 
@@ -2663 +2836 @@
                 tcl_cv_struct_stat64=yes,tcl_cv_struct_stat64=no)])
         if test "x${tcl_cv_struct_stat64}" = "xyes" ; then
-            AC_DEFINE(HAVE_STRUCT_STAT64, 1, [Is 'struct stat64' in <sys/stat.h>?])
+            AC_DEFINE(HAVE_STRUCT_STAT64)
         fi
 
@@ -2677 +2850 @@
                 test "x${ac_cv_func_lseek64}" = "xyes" && \
                 test "x${ac_cv_func_open64}" = "xyes" ; then
-            AC_DEFINE(HAVE_TYPE_OFF64_T, 1, [Is off64_t in <sys/types.h>?])
+            AC_DEFINE(HAVE_TYPE_OFF64_T)
             AC_MSG_RESULT([yes])
         else
@@ -2685 +2858 @@
 ])
 
-##
-## Here ends the standard Tcl configuration bits and starts the
-## TEA specific functions
-##
-
-#------------------------------------------------------------------------
-# TEA_INIT --
-#
-#       Init various Tcl Extension Architecture (TEA) variables.
-#       This should be the first called TEA_* macro.
+#--------------------------------------------------------------------
+# SC_TCL_GETHOSTBYADDR_R
+#
+#       Check if we have MT-safe variant of gethostbyaddr().
 #
 # Arguments:
-#       none
-#
+#       None
+#       
 # Results:
 #
-#       Defines and substs the following vars:
-#               CYGPATH
-#               EXEEXT
-#       Defines only:
-#               TEA_VERSION
-#               TEA_INITED
-#               TEA_PLATFORM (windows or unix)
-#
-# "cygpath" is used on windows to generate native path names for include
-# files. These variables should only be used with the compiler and linker
-# since they generate native path names.
-#
-# EXEEXT
-#       Select the executable extension based on the host type.  This
-#       is a lightweight replacement for AC_EXEEXT that doesn't require
-#       a compiler.
-#------------------------------------------------------------------------
-
-AC_DEFUN([TEA_INIT], [
-    # TEA extensions pass this us the version of TEA they think they
-    # are compatible with.
-    TEA_VERSION="3.5"
-
-    AC_MSG_CHECKING([for correct TEA configuration])
-    if test x"${PACKAGE_NAME}" = x ; then
-        AC_MSG_ERROR([
-The PACKAGE_NAME variable must be defined by your TEA configure.in])
-    fi
-    if test x"$1" = x ; then
-        AC_MSG_ERROR([
-TEA version not specified.])
-    elif test "$1" != "${TEA_VERSION}" ; then
-        AC_MSG_RESULT([warning: requested TEA version "$1", have "${TEA_VERSION}"])
+#       Might define the following vars:
+#               HAVE_GETHOSTBYADDR_R
+#               HAVE_GETHOSTBYADDR_R_7
+#               HAVE_GETHOSTBYADDR_R_8
+#
+#--------------------------------------------------------------------
+
+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_TRY_COMPILE([
+        #include <netdb.h>
+    ], [
+        char *addr;
+        int length;
+        int type;
+        struct hostent *result;
+        char buffer[2048];
+        int buflen = 2048;
+        int h_errnop;
+
+        (void) gethostbyaddr_r(addr, length, type, result, buffer, buflen,
+                               &h_errnop);
+    ], tcl_cv_api_gethostbyaddr_r_7=yes, tcl_cv_api_gethostbyaddr_r_7=no)])
+    tcl_ok=$tcl_cv_api_gethostbyaddr_r_7
+    if test "$tcl_ok" = yes; then
+        AC_DEFINE(HAVE_GETHOSTBYADDR_R_7)
     else
-        AC_MSG_RESULT([ok (TEA ${TEA_VERSION})])
-    fi
-    case "`uname -s`" in
-        *win32*|*WIN32*|*CYGWIN_NT*|*CYGWIN_9*|*CYGWIN_ME*|*MINGW32_*|*MSYS_NT*)
-            AC_CHECK_PROG(CYGPATH, cygpath, cygpath -w, echo)
-            EXEEXT=".exe"
-            TEA_PLATFORM="windows"
-            ;;
-        *)
-            CYGPATH=echo
-            EXEEXT=""
-            TEA_PLATFORM="unix"
-            ;;
-    esac
-
-    # Check if exec_prefix is set. If not use fall back to prefix.
-    # Note when adjusted, so that TEA_PREFIX can correct for this.
-    # This is needed for recursive configures, since autoconf propagates
-    # $prefix, but not $exec_prefix (doh!).
-    if test x$exec_prefix = xNONE ; then
-        exec_prefix_default=yes
-        exec_prefix=$prefix
-    fi
-
-    AC_SUBST(EXEEXT)
-    AC_SUBST(CYGPATH)
-
-    # This package name must be replaced statically for AC_SUBST to work
-    AC_SUBST(PKG_LIB_FILE)
-    # Substitute STUB_LIB_FILE in case package creates a stub library too.
-    AC_SUBST(PKG_STUB_LIB_FILE)
-
-    # We AC_SUBST these here to ensure they are subst'ed,
-    # in case the user doesn't call TEA_ADD_...
-    AC_SUBST(PKG_STUB_SOURCES)
-    AC_SUBST(PKG_STUB_OBJECTS)
-    AC_SUBST(PKG_TCL_SOURCES)
-    AC_SUBST(PKG_HEADERS)
-    AC_SUBST(PKG_INCLUDES)
-    AC_SUBST(PKG_LIBS)
-    AC_SUBST(PKG_CFLAGS)
-])
-
-#------------------------------------------------------------------------
-# TEA_ADD_SOURCES --
-#
-#       Specify one or more source files.  Users should check for
-#       the right platform before adding to their list.
-#       It is not important to specify the directory, as long as it is
-#       in the generic, win or unix subdirectory of $(srcdir).
+        AC_CACHE_CHECK([for gethostbyaddr_r with 8 args], tcl_cv_api_gethostbyaddr_r_8, [
+        AC_TRY_COMPILE([
+            #include <netdb.h>
+        ], [
+            char *addr;
+            int length;
+            int type;
+            struct hostent *result, *resultp;
+            char buffer[2048];
+            int buflen = 2048;
+            int h_errnop;
+
+            (void) gethostbyaddr_r(addr, length, type, result, buffer, buflen,
+                                   &resultp, &h_errnop);
+        ], tcl_cv_api_gethostbyaddr_r_8=yes, tcl_cv_api_gethostbyaddr_r_8=no)])
+        tcl_ok=$tcl_cv_api_gethostbyaddr_r_8
+        if test "$tcl_ok" = yes; then
+            AC_DEFINE(HAVE_GETHOSTBYADDR_R_8)
+        fi
+    fi
+    if test "$tcl_ok" = yes; then
+        AC_DEFINE(HAVE_GETHOSTBYADDR_R)
+    fi
+])])
+
+#--------------------------------------------------------------------
+# SC_TCL_GETHOSTBYNAME_R
+#
+#       Check to see what variant of gethostbyname_r() we have.
+#       Based on David Arnold's example from the comp.programming.threads
+#       FAQ Q213
 #
 # Arguments:
-#       one or more file names
-#
+#       None
+#       
 # Results:
 #
-#       Defines and substs the following vars:
-#               PKG_SOURCES
-#               PKG_OBJECTS
-#------------------------------------------------------------------------
-AC_DEFUN([TEA_ADD_SOURCES], [
-    vars="$@"
-    for i in $vars; do
-        case $i in
-            [\$]*)
-                # allow $-var names
-                PKG_SOURCES="$PKG_SOURCES $i"
-                PKG_OBJECTS="$PKG_OBJECTS $i"
-                ;;
-            *)
-                # check for existence - allows for generic/win/unix VPATH
-                if test ! -f "${srcdir}/$i" -a ! -f "${srcdir}/src/$i" \
-                    -a ! -f "${srcdir}/win/$i" -a ! -f "${srcdir}/unix/$i" \
-                    ; then
-                    AC_MSG_ERROR([could not find source file '$i'])
-                fi
-                PKG_SOURCES="$PKG_SOURCES $i"
-                # this assumes it is in a VPATH dir
-                i=`basename $i`
-                # handle user calling this before or after TEA_SETUP_COMPILER
-                if test x"${OBJEXT}" != x ; then
-                    j="`echo $i | sed -e 's/\.[[^.]]*$//'`.${OBJEXT}"
-                else
-                    j="`echo $i | sed -e 's/\.[[^.]]*$//'`.\${OBJEXT}"
-                fi
-                PKG_OBJECTS="$PKG_OBJECTS $j"
-                ;;
-        esac
-    done
-    AC_SUBST(PKG_SOURCES)
-    AC_SUBST(PKG_OBJECTS)
-])
-
-#------------------------------------------------------------------------
-# TEA_ADD_STUB_SOURCES --
-#
-#       Specify one or more source files.  Users should check for
-#       the right platform before adding to their list.
-#       It is not important to specify the directory, as long as it is
-#       in the generic, win or unix subdirectory of $(srcdir).
+#       Might define the following vars:
+#               HAVE_GETHOSTBYADDR_R
+#               HAVE_GETHOSTBYADDR_R_3
+#               HAVE_GETHOSTBYADDR_R_5
+#               HAVE_GETHOSTBYADDR_R_6
+#
+#--------------------------------------------------------------------
+
+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_TRY_COMPILE([
+        #include <netdb.h>
+    ], [
+        char *name;
+        struct hostent *he, *res;
+        char buffer[2048];
+        int buflen = 2048;
+        int 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_ok=$tcl_cv_api_gethostbyname_r_6
+    if test "$tcl_ok" = yes; then
+        AC_DEFINE(HAVE_GETHOSTBYNAME_R_6)
+    else
+        AC_CACHE_CHECK([for gethostbyname_r with 5 args], tcl_cv_api_gethostbyname_r_5, [
+        AC_TRY_COMPILE([
+            #include <netdb.h>
+        ], [
+            char *name;
+            struct hostent *he;
+            char buffer[2048];
+            int buflen = 2048;
+            int 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_ok=$tcl_cv_api_gethostbyname_r_5
+        if test "$tcl_ok" = yes; then
+            AC_DEFINE(HAVE_GETHOSTBYNAME_R_5)
+        else
+            AC_CACHE_CHECK([for gethostbyname_r with 3 args], tcl_cv_api_gethostbyname_r_3, [
+            AC_TRY_COMPILE([
+                #include <netdb.h>
+            ], [
+                char *name;
+                struct hostent *he;
+                struct hostent_data data;
+
+                (void) gethostbyname_r(name, he, &data);
+            ], tcl_cv_api_gethostbyname_r_3=yes, tcl_cv_api_gethostbyname_r_3=no)])
+            tcl_ok=$tcl_cv_api_gethostbyname_r_3
+            if test "$tcl_ok" = yes; then
+                AC_DEFINE(HAVE_GETHOSTBYNAME_R_3)
+            fi
+        fi
+    fi
+    if test "$tcl_ok" = yes; then
+        AC_DEFINE(HAVE_GETHOSTBYNAME_R)
+    fi
+])])
+
+#--------------------------------------------------------------------
+# SC_TCL_GETPWUID_R
+#
+#       Check if we have MT-safe variant of getpwuid() and if yes,
+#       which one exactly.
 #
 # Arguments:
-#       one or more file names
-#
+#       None
+#       
 # Results:
 #
-#       Defines and substs the following vars:
-#               PKG_STUB_SOURCES
-#               PKG_STUB_OBJECTS
-#------------------------------------------------------------------------
-AC_DEFUN([TEA_ADD_STUB_SOURCES], [
-    vars="$@"
-    for i in $vars; do
-        # check for existence - allows for generic/win/unix VPATH
-        if test ! -f "${srcdir}/$i" -a ! -f "${srcdir}/generic/$i" \
-            -a ! -f "${srcdir}/win/$i" -a ! -f "${srcdir}/unix/$i" \
-            ; then
-            AC_MSG_ERROR([could not find stub source file '$i'])
+#       Might define the following vars:
+#               HAVE_GETPWUID_R
+#               HAVE_GETPWUID_R_4
+#               HAVE_GETPWUID_R_5
+#
+#--------------------------------------------------------------------
+
+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_TRY_COMPILE([
+        #include <sys/types.h>
+        #include <pwd.h>
+    ], [
+        uid_t uid;
+        struct passwd pw, *pwp;
+        char buf[512];
+        int buflen = 512;
+
+        (void) getpwuid_r(uid, &pw, buf, buflen, &pwp);
+    ], tcl_cv_api_getpwuid_r_5=yes, tcl_cv_api_getpwuid_r_5=no)])
+    tcl_ok=$tcl_cv_api_getpwuid_r_5
+    if test "$tcl_ok" = yes; then
+        AC_DEFINE(HAVE_GETPWUID_R_5)
+    else
+        AC_CACHE_CHECK([for getpwuid_r with 4 args], tcl_cv_api_getpwuid_r_4, [
+        AC_TRY_COMPILE([
+            #include <sys/types.h>
+            #include <pwd.h>
+        ], [
+            uid_t uid;
+            struct passwd pw;
+            char buf[512];
+            int buflen = 512;
+
+            (void)getpwnam_r(uid, &pw, buf, buflen);
+        ], tcl_cv_api_getpwuid_r_4=yes, tcl_cv_api_getpwuid_r_4=no)])
+        tcl_ok=$tcl_cv_api_getpwuid_r_4
+        if test "$tcl_ok" = yes; then
+            AC_DEFINE(HAVE_GETPWUID_R_4)
         fi
-        PKG_STUB_SOURCES="$PKG_STUB_SOURCES $i"
-        # this assumes it is in a VPATH dir
-        i=`basename $i`
-        # handle user calling this before or after TEA_SETUP_COMPILER
-        if test x"${OBJEXT}" != x ; then
-            j="`echo $i | sed -e 's/\.[[^.]]*$//'`.${OBJEXT}"
-        else
-            j="`echo $i | sed -e 's/\.[[^.]]*$//'`.\${OBJEXT}"
+    fi
+    if test "$tcl_ok" = yes; then
+        AC_DEFINE(HAVE_GETPWUID_R)
+    fi
+])])
+
+#--------------------------------------------------------------------
+# SC_TCL_GETPWNAM_R
+#
+#       Check if we have MT-safe variant of getpwnam() and if yes,
+#       which one exactly.
+#
+# Arguments:
+#       None
+#       
+# Results:
+#
+#       Might define the following vars:
+#               HAVE_GETPWNAM_R
+#               HAVE_GETPWNAM_R_4
+#               HAVE_GETPWNAM_R_5
+#
+#--------------------------------------------------------------------
+
+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_TRY_COMPILE([
+        #include <sys/types.h>
+        #include <pwd.h>
+    ], [
+        char *name;
+        struct passwd pw, *pwp;
+        char buf[512];
+        int buflen = 512;
+
+        (void) getpwnam_r(name, &pw, buf, buflen, &pwp);
+    ], tcl_cv_api_getpwnam_r_5=yes, tcl_cv_api_getpwnam_r_5=no)])
+    tcl_ok=$tcl_cv_api_getpwnam_r_5
+    if test "$tcl_ok" = yes; then
+        AC_DEFINE(HAVE_GETPWNAM_R_5)
+    else
+        AC_CACHE_CHECK([for getpwnam_r with 4 args], tcl_cv_api_getpwnam_r_4, [
+        AC_TRY_COMPILE([
+            #include <sys/types.h>
+            #include <pwd.h>
+        ], [
+            char *name;
+            struct passwd pw;
+            char buf[512];
+            int buflen = 512;
+
+            (void)getpwnam_r(name, &pw, buf, buflen);
+        ], tcl_cv_api_getpwnam_r_4=yes, tcl_cv_api_getpwnam_r_4=no)])
+        tcl_ok=$tcl_cv_api_getpwnam_r_4
+        if test "$tcl_ok" = yes; then
+            AC_DEFINE(HAVE_GETPWNAM_R_4)
         fi
-        PKG_STUB_OBJECTS="$PKG_STUB_OBJECTS $j"
-    done
-    AC_SUBST(PKG_STUB_SOURCES)
-    AC_SUBST(PKG_STUB_OBJECTS)
-])
-
-#------------------------------------------------------------------------
-# TEA_ADD_TCL_SOURCES --
-#
-#       Specify one or more Tcl source files.  These should be platform
-#       independent runtime files.
+    fi
+    if test "$tcl_ok" = yes; then
+        AC_DEFINE(HAVE_GETPWNAM_R)
+    fi
+])])
+
+#--------------------------------------------------------------------
+# SC_TCL_GETGRGID_R
+#
+#       Check if we have MT-safe variant of getgrgid() and if yes,
+#       which one exactly.
 #
 # Arguments:
-#       one or more file names
-#
+#       None
+#       
 # Results:
 #
-#       Defines and substs the following vars:
-#               PKG_TCL_SOURCES
-#------------------------------------------------------------------------
-AC_DEFUN([TEA_ADD_TCL_SOURCES], [
-    vars="$@"
-    for i in $vars; do
-        # check for existence, be strict because it is installed
-        if test ! -f "${srcdir}/$i" ; then
-            AC_MSG_ERROR([could not find tcl source file '${srcdir}/$i'])
+#       Might define the following vars:
+#               HAVE_GETGRGID_R
+#               HAVE_GETGRGID_R_4
+#               HAVE_GETGRGID_R_5
+#
+#--------------------------------------------------------------------
+
+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_TRY_COMPILE([
+        #include <sys/types.h>
+        #include <grp.h>
+    ], [
+        gid_t gid;
+        struct group gr, *grp;
+        char buf[512];
+        int buflen = 512;
+
+        (void) getgrgid_r(gid, &gr, buf, buflen, &grp);
+    ], tcl_cv_api_getgrgid_r_5=yes, tcl_cv_api_getgrgid_r_5=no)])
+    tcl_ok=$tcl_cv_api_getgrgid_r_5
+    if test "$tcl_ok" = yes; then
+        AC_DEFINE(HAVE_GETGRGID_R_5)
+    else
+        AC_CACHE_CHECK([for getgrgid_r with 4 args], tcl_cv_api_getgrgid_r_4, [
+        AC_TRY_COMPILE([
+            #include <sys/types.h>
+            #include <grp.h>
+        ], [
+            gid_t gid;
+            struct group gr;
+            char buf[512];
+            int buflen = 512;
+
+            (void)getgrgid_r(gid, &gr, buf, buflen);
+        ], tcl_cv_api_getgrgid_r_4=yes, tcl_cv_api_getgrgid_r_4=no)])
+        tcl_ok=$tcl_cv_api_getgrgid_r_4
+        if test "$tcl_ok" = yes; then
+            AC_DEFINE(HAVE_GETGRGID_R_4)
         fi
-        PKG_TCL_SOURCES="$PKG_TCL_SOURCES $i"
-    done
-    AC_SUBST(PKG_TCL_SOURCES)
-])
-
-#------------------------------------------------------------------------
-# TEA_ADD_HEADERS --
-#
-#       Specify one or more source headers.  Users should check for
-#       the right platform before adding to their list.
+    fi
+    if test "$tcl_ok" = yes; then
+        AC_DEFINE(HAVE_GETGRGID_R)
+    fi
+])])
+
+#--------------------------------------------------------------------
+# SC_TCL_GETGRNAM_R
+#
+#       Check if we have MT-safe variant of getgrnam() and if yes,
+#       which one exactly.
 #
 # Arguments:
-#       one or more file names
-#
+#       None
+#       
 # Results:
 #
-#       Defines and substs the following vars:
-#               PKG_HEADERS
-#------------------------------------------------------------------------
-AC_DEFUN([TEA_ADD_HEADERS], [
-    vars="$@"
-    for i in $vars; do
-        # check for existence, be strict because it is installed
-        if test ! -f "${srcdir}/$i" ; then
-            AC_MSG_ERROR([could not find header file '${srcdir}/$i'])
+#       Might define the following vars:
+#               HAVE_GETGRNAM_R
+#               HAVE_GETGRNAM_R_4
+#               HAVE_GETGRNAM_R_5
+#
+#--------------------------------------------------------------------
+
+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_TRY_COMPILE([
+        #include <sys/types.h>
+        #include <grp.h>
+    ], [
+        char *name;
+        struct group gr, *grp;
+        char buf[512];
+        int buflen = 512;
+
+        (void) getgrnam_r(name, &gr, buf, buflen, &grp);
+    ], tcl_cv_api_getgrnam_r_5=yes, tcl_cv_api_getgrnam_r_5=no)])
+    tcl_ok=$tcl_cv_api_getgrnam_r_5
+    if test "$tcl_ok" = yes; then
+        AC_DEFINE(HAVE_GETGRNAM_R_5)
+    else
+        AC_CACHE_CHECK([for getgrnam_r with 4 args], tcl_cv_api_getgrnam_r_4, [
+        AC_TRY_COMPILE([
+            #include <sys/types.h>
+            #include <grp.h>
+        ], [
+            char *name;
+            struct group gr;
+            char buf[512];
+            int buflen = 512;
+
+            (void)getgrnam_r(name, &gr, buf, buflen);
+        ], tcl_cv_api_getgrnam_r_4=yes, tcl_cv_api_getgrnam_r_4=no)])
+        tcl_ok=$tcl_cv_api_getgrnam_r_4
+        if test "$tcl_ok" = yes; then
+            AC_DEFINE(HAVE_GETGRNAM_R_4)
         fi
-        PKG_HEADERS="$PKG_HEADERS $i"
-    done
-    AC_SUBST(PKG_HEADERS)
-])
-
-#------------------------------------------------------------------------
-# TEA_ADD_INCLUDES --
-#
-#       Specify one or more include dirs.  Users should check for
-#       the right platform before adding to their list.
-#
-# Arguments:
-#       one or more file names
-#
-# Results:
-#
-#       Defines and substs the following vars:
-#               PKG_INCLUDES
-#------------------------------------------------------------------------
-AC_DEFUN([TEA_ADD_INCLUDES], [
-    vars="$@"
-    for i in $vars; do
-        PKG_INCLUDES="$PKG_INCLUDES $i"
-    done
-    AC_SUBST(PKG_INCLUDES)
-])
-
-#------------------------------------------------------------------------
-# TEA_ADD_LIBS --
-#
-#       Specify one or more libraries.  Users should check for
-#       the right platform before adding to their list.  For Windows,
-#       libraries provided in "foo.lib" format will be converted to
-#       "-lfoo" when using GCC (mingw).
-#
-# Arguments:
-#       one or more file names
-#
-# Results:
-#
-#       Defines and substs the following vars:
-#               PKG_LIBS
-#------------------------------------------------------------------------
-AC_DEFUN([TEA_ADD_LIBS], [
-    vars="$@"
-    for i in $vars; do
-        if test "${TEA_PLATFORM}" = "windows" -a "$GCC" = "yes" ; then
-            # Convert foo.lib to -lfoo for GCC.  No-op if not *.lib
-            i=`echo "$i" | sed -e 's/^\([[^-]].*\)\.lib[$]/-l\1/i'`
-        fi
-        PKG_LIBS="$PKG_LIBS $i"
-    done
-    AC_SUBST(PKG_LIBS)
-])
-
-#------------------------------------------------------------------------
-# TEA_ADD_CFLAGS --
-#
-#       Specify one or more CFLAGS.  Users should check for
-#       the right platform before adding to their list.
-#
-# Arguments:
-#       one or more file names
-#
-# Results:
-#
-#       Defines and substs the following vars:
-#               PKG_CFLAGS
-#------------------------------------------------------------------------
-AC_DEFUN([TEA_ADD_CFLAGS], [
-    PKG_CFLAGS="$PKG_CFLAGS $@"
-    AC_SUBST(PKG_CFLAGS)
-])
-
-#------------------------------------------------------------------------
-# TEA_PREFIX --
-#
-#       Handle the --prefix=... option by defaulting to what Tcl gave
-#
-# Arguments:
-#       none
-#
-# Results:
-#
-#       If --prefix or --exec-prefix was not specified, $prefix and
-#       $exec_prefix will be set to the values given to Tcl when it was
-#       configured.
-#------------------------------------------------------------------------
-AC_DEFUN([TEA_PREFIX], [
-    if test "${prefix}" = "NONE"; then
-        prefix_default=yes
-        if test x"${TCL_PREFIX}" != x; then
-            AC_MSG_NOTICE([--prefix defaulting to TCL_PREFIX ${TCL_PREFIX}])
-            prefix=${TCL_PREFIX}
-        else
-            AC_MSG_NOTICE([--prefix defaulting to /usr/local])
-            prefix=/usr/local
-        fi
-    fi
-    if test "${exec_prefix}" = "NONE" -a x"${prefix_default}" = x"yes" \
-        -o x"${exec_prefix_default}" = x"yes" ; then
-        if test x"${TCL_EXEC_PREFIX}" != x; then
-            AC_MSG_NOTICE([--exec-prefix defaulting to TCL_EXEC_PREFIX ${TCL_EXEC_PREFIX}])
-            exec_prefix=${TCL_EXEC_PREFIX}
-        else
-            AC_MSG_NOTICE([--exec-prefix defaulting to ${prefix}])
-            exec_prefix=$prefix
-        fi
-    fi
-])
-
-#------------------------------------------------------------------------
-# TEA_SETUP_COMPILER_CC --
-#
-#       Do compiler checks the way we want.  This is just a replacement
-#       for AC_PROG_CC in TEA configure.in files to make them cleaner.
-#
-# Arguments:
-#       none
-#
-# Results:
-#
-#       Sets up CC var and other standard bits we need to make executables.
-#------------------------------------------------------------------------
-AC_DEFUN([TEA_SETUP_COMPILER_CC], [
-    # Don't put any macros that use the compiler (e.g. AC_TRY_COMPILE)
-    # in this macro, they need to go into TEA_SETUP_COMPILER instead.
-
-    # If the user did not set CFLAGS, set it now to keep
-    # the AC_PROG_CC macro from adding "-g -O2".
-    if test "${CFLAGS+set}" != "set" ; then
-        CFLAGS=""
-    fi
-
-    AC_PROG_CC
-    AC_PROG_CXX
-    AC_PROG_CPP
-
-    AC_PROG_INSTALL
-
-    #--------------------------------------------------------------------
-    # Checks to see if the make program sets the $MAKE variable.
-    #--------------------------------------------------------------------
-
-    AC_PROG_MAKE_SET
-
-    #--------------------------------------------------------------------
-    # Find ranlib
-    #--------------------------------------------------------------------
-
-    AC_PROG_RANLIB
-
-    #--------------------------------------------------------------------
-    # Determines the correct binary file extension (.o, .obj, .exe etc.)
-    #--------------------------------------------------------------------
-
-    AC_OBJEXT
-    AC_EXEEXT
-])
-
-#------------------------------------------------------------------------
-# TEA_SETUP_COMPILER --
-#
-#       Do compiler checks that use the compiler.  This must go after
-#       TEA_SETUP_COMPILER_CC, which does the actual compiler check.
-#
-# Arguments:
-#       none
-#
-# Results:
-#
-#       Sets up CC var and other standard bits we need to make executables.
-#------------------------------------------------------------------------
-AC_DEFUN([TEA_SETUP_COMPILER], [
-    # Any macros that use the compiler (e.g. AC_TRY_COMPILE) have to go here.
-    AC_REQUIRE([TEA_SETUP_COMPILER_CC])
-
-    #------------------------------------------------------------------------
-    # If we're using GCC, see if the compiler understands -pipe. If so, use it.
-    # It makes compiling go faster.  (This is only a performance feature.)
-    #------------------------------------------------------------------------
-
-    if test -z "$no_pipe" -a -n "$GCC"; then
-        AC_MSG_CHECKING([if the compiler understands -pipe])
-        OLDCC="$CC"
-        CC="$CC -pipe"
-        AC_TRY_COMPILE(,, AC_MSG_RESULT([yes]), CC="$OLDCC"
-            AC_MSG_RESULT([no]))
-    fi
-
-    #--------------------------------------------------------------------
-    # Common compiler flag setup
-    #--------------------------------------------------------------------
-
-    AC_C_BIGENDIAN
-    if test "${TEA_PLATFORM}" = "unix" ; then
-        TEA_TCL_LINK_LIBS
-        TEA_MISSING_POSIX_HEADERS
-        # Let the user call this, because if it triggers, they will
-        # need a compat/strtod.c that is correct.  Users can also
-        # use Tcl_GetDouble(FromObj) instead.
-        #TEA_BUGGY_STRTOD
-    fi
-])
-
-#------------------------------------------------------------------------
-# TEA_MAKE_LIB --
-#
-#       Generate a line that can be used to build a shared/unshared library
-#       in a platform independent manner.
-#
-# Arguments:
-#       none
-#
-#       Requires:
-#
-# Results:
-#
-#       Defines the following vars:
-#       CFLAGS -        Done late here to note disturb other AC macros
-#       MAKE_LIB -      Command to execute to build the Tcl library;
-#                       differs depending on whether or not Tcl is being
-#                       compiled as a shared library.
-#       MAKE_SHARED_LIB Makefile rule for building a shared library
-#       MAKE_STATIC_LIB Makefile rule for building a static library
-#       MAKE_STUB_LIB   Makefile rule for building a stub library
-#------------------------------------------------------------------------
-
-AC_DEFUN([TEA_MAKE_LIB], [
-    if test "${TEA_PLATFORM}" = "windows" -a "$GCC" != "yes"; then
-        MAKE_STATIC_LIB="\${STLIB_LD} -out:\[$]@ \$(PKG_OBJECTS)"
-        MAKE_SHARED_LIB="\${SHLIB_LD} \${SHLIB_LD_LIBS} \${LDFLAGS_DEFAULT} -out:\[$]@ \$(PKG_OBJECTS)"
-        MAKE_STUB_LIB="\${STLIB_LD} -out:\[$]@ \$(PKG_STUB_OBJECTS)"
-    else
-        MAKE_STATIC_LIB="\${STLIB_LD} \[$]@ \$(PKG_OBJECTS)"
-        MAKE_SHARED_LIB="\${SHLIB_LD} -o \[$]@ \$(PKG_OBJECTS) \${SHLIB_LD_LIBS}"
-        MAKE_STUB_LIB="\${STLIB_LD} \[$]@ \$(PKG_STUB_OBJECTS)"
-    fi
-
-    if test "${SHARED_BUILD}" = "1" ; then
-        MAKE_LIB="${MAKE_SHARED_LIB} "
-    else
-        MAKE_LIB="${MAKE_STATIC_LIB} "
-    fi
-
-    #--------------------------------------------------------------------
-    # Shared libraries and static libraries have different names.
-    # Use the double eval to make sure any variables in the suffix is
-    # substituted. (@@@ Might not be necessary anymore)
-    #--------------------------------------------------------------------
-
-    if test "${TEA_PLATFORM}" = "windows" ; then
-        if test "${SHARED_BUILD}" = "1" ; then
-            # We force the unresolved linking of symbols that are really in
-            # the private libraries of Tcl and Tk.
-            SHLIB_LD_LIBS="${SHLIB_LD_LIBS} \"`${CYGPATH} ${TCL_BIN_DIR}/${TCL_STUB_LIB_FILE}`\""
-            if test x"${TK_BIN_DIR}" != x ; then
-                SHLIB_LD_LIBS="${SHLIB_LD_LIBS} \"`${CYGPATH} ${TK_BIN_DIR}/${TK_STUB_LIB_FILE}`\""
-            fi
-            eval eval "PKG_LIB_FILE=${PACKAGE_NAME}${SHARED_LIB_SUFFIX}"
-        else
-            eval eval "PKG_LIB_FILE=${PACKAGE_NAME}${UNSHARED_LIB_SUFFIX}"
-        fi
-        # Some packages build their own stubs libraries
-        eval eval "PKG_STUB_LIB_FILE=${PACKAGE_NAME}stub${UNSHARED_LIB_SUFFIX}"
-        if test "$GCC" = "yes"; then
-            PKG_STUB_LIB_FILE=lib${PKG_STUB_LIB_FILE}
-        fi
-        # These aren't needed on Windows (either MSVC or gcc)
-        RANLIB="mt -manifest ${PKG_LIB_FILE}.manifest -outputresource:${PKG_LIB_FILE}\;2 ; test -f"
-        RANLIB_STUB=:
-    else
-        RANLIB_STUB="${RANLIB}"
-        if test "${SHARED_BUILD}" = "1" ; then
-            SHLIB_LD_LIBS="${SHLIB_LD_LIBS} ${TCL_STUB_LIB_SPEC}"
-            if test x"${TK_BIN_DIR}" != x ; then
-                SHLIB_LD_LIBS="${SHLIB_LD_LIBS} ${TK_STUB_LIB_SPEC}"
-            fi
-            eval eval "PKG_LIB_FILE=lib${PACKAGE_NAME}${SHARED_LIB_SUFFIX}"
-            RANLIB=:
-        else
-            eval eval "PKG_LIB_FILE=lib${PACKAGE_NAME}${UNSHARED_LIB_SUFFIX}"
-        fi
-        # Some packages build their own stubs libraries
-        eval eval "PKG_STUB_LIB_FILE=lib${PACKAGE_NAME}stub${UNSHARED_LIB_SUFFIX}"
-    fi
-
-    # These are escaped so that only CFLAGS is picked up at configure time.
-    # The other values will be substituted at make time.
-    CFLAGS="${CFLAGS} \${CFLAGS_DEFAULT} \${CFLAGS_WARNING}"
-    if test "${SHARED_BUILD}" = "1" ; then
-        CFLAGS="${CFLAGS} \${SHLIB_CFLAGS}"
-    fi
-
-    AC_SUBST(MAKE_LIB)
-    AC_SUBST(MAKE_SHARED_LIB)
-    AC_SUBST(MAKE_STATIC_LIB)
-    AC_SUBST(MAKE_STUB_LIB)
-    AC_SUBST(RANLIB_STUB)
-    AC_SUBST(RANLIB)
-])
-
-#------------------------------------------------------------------------
-# TEA_LIB_SPEC --
-#
-#       Compute the name of an existing object library located in libdir
-#       from the given base name and produce the appropriate linker flags.
-#
-# Arguments:
-#       basename        The base name of the library without version
-#                       numbers, extensions, or "lib" prefixes.
-#       extra_dir       Extra directory in which to search for the
-#                       library.  This location is used first, then
-#                       $prefix/$exec-prefix, then some defaults.
-#
-# Requires:
-#       TEA_INIT and TEA_PREFIX must be called first.
-#
-# Results:
-#
-#       Defines the following vars:
-#               ${basename}_LIB_NAME    The computed library name.
-#               ${basename}_LIB_SPEC    The computed linker flags.
-#------------------------------------------------------------------------
-
-AC_DEFUN([TEA_LIB_SPEC], [
-    AC_MSG_CHECKING([for $1 library])
-
-    # Look in exec-prefix for the library (defined by TEA_PREFIX).
-
-    tea_lib_name_dir="${exec_prefix}/lib"
-
-    # Or in a user-specified location.
-
-    if test x"$2" != x ; then
-        tea_extra_lib_dir=$2
-    else
-        tea_extra_lib_dir=NONE
-    fi
-
-    for i in \
-            `ls -dr ${tea_extra_lib_dir}/$1[[0-9]]*.lib 2>/dev/null ` \
-            `ls -dr ${tea_extra_lib_dir}/lib$1[[0-9]]* 2>/dev/null ` \
-            `ls -dr ${tea_lib_name_dir}/$1[[0-9]]*.lib 2>/dev/null ` \
-            `ls -dr ${tea_lib_name_dir}/lib$1[[0-9]]* 2>/dev/null ` \
-            `ls -dr /usr/lib/$1[[0-9]]*.lib 2>/dev/null ` \
-            `ls -dr /usr/lib/lib$1[[0-9]]* 2>/dev/null ` \
-            `ls -dr /usr/local/lib/$1[[0-9]]*.lib 2>/dev/null ` \
-            `ls -dr /usr/local/lib/lib$1[[0-9]]* 2>/dev/null ` ; do
-        if test -f "$i" ; then
-            tea_lib_name_dir=`dirname $i`
-            $1_LIB_NAME=`basename $i`
-            $1_LIB_PATH_NAME=$i
-            break
-        fi
-    done
-
-    if test "${TEA_PLATFORM}" = "windows"; then
-        $1_LIB_SPEC=\"`${CYGPATH} ${$1_LIB_PATH_NAME} 2>/dev/null`\"
-    else
-        # Strip off the leading "lib" and trailing ".a" or ".so"
-
-        tea_lib_name_lib=`echo ${$1_LIB_NAME}|sed -e 's/^lib//' -e 's/\.[[^.]]*$//' -e 's/\.so.*//'`
-        $1_LIB_SPEC="-L${tea_lib_name_dir} -l${tea_lib_name_lib}"
-    fi
-
-    if test "x${$1_LIB_NAME}" = x ; then
-        AC_MSG_ERROR([not found])
-    else
-        AC_MSG_RESULT([${$1_LIB_SPEC}])
-    fi
-])
-
-#------------------------------------------------------------------------
-# TEA_PRIVATE_TCL_HEADERS --
-#
-#       Locate the private Tcl include files
-#
-# Arguments:
-#
-#       Requires:
-#               TCL_SRC_DIR     Assumes that TEA_LOAD_TCLCONFIG has
-#                                already been called.
-#
-# Results:
-#
-#       Substs the following vars:
-#               TCL_TOP_DIR_NATIVE
-#               TCL_GENERIC_DIR_NATIVE
-#               TCL_UNIX_DIR_NATIVE
-#               TCL_WIN_DIR_NATIVE
-#               TCL_BMAP_DIR_NATIVE
-#               TCL_TOOL_DIR_NATIVE
-#               TCL_PLATFORM_DIR_NATIVE
-#               TCL_BIN_DIR_NATIVE
-#               TCL_INCLUDES
-#------------------------------------------------------------------------
-
-AC_DEFUN([TEA_PRIVATE_TCL_HEADERS], [
-    AC_MSG_CHECKING([for Tcl private include files])
-
-    TCL_SRC_DIR_NATIVE=`${CYGPATH} ${TCL_SRC_DIR}`
-    TCL_TOP_DIR_NATIVE=\"${TCL_SRC_DIR_NATIVE}\"
-    TCL_GENERIC_DIR_NATIVE=\"${TCL_SRC_DIR_NATIVE}/generic\"
-    TCL_UNIX_DIR_NATIVE=\"${TCL_SRC_DIR_NATIVE}/unix\"
-    TCL_WIN_DIR_NATIVE=\"${TCL_SRC_DIR_NATIVE}/win\"
-    TCL_BMAP_DIR_NATIVE=\"${TCL_SRC_DIR_NATIVE}/bitmaps\"
-    TCL_TOOL_DIR_NATIVE=\"${TCL_SRC_DIR_NATIVE}/tools\"
-    TCL_COMPAT_DIR_NATIVE=\"${TCL_SRC_DIR_NATIVE}/compat\"
-
-    if test "${TEA_PLATFORM}" = "windows"; then
-        TCL_PLATFORM_DIR_NATIVE=${TCL_WIN_DIR_NATIVE}
-    else
-        TCL_PLATFORM_DIR_NATIVE=${TCL_UNIX_DIR_NATIVE}
-    fi
-    # We want to ensure these are substituted so as not to require
-    # any *_NATIVE vars be defined in the Makefile
-    TCL_INCLUDES="-I${TCL_GENERIC_DIR_NATIVE} -I${TCL_PLATFORM_DIR_NATIVE}"
-    if test "`uname -s`" = "Darwin"; then
-        # If Tcl was built as a framework, attempt to use
-        # the framework's Headers and PrivateHeaders directories
-        case ${TCL_DEFS} in
-            *TCL_FRAMEWORK*)
-                if test -d "${TCL_BIN_DIR}/Headers" -a -d "${TCL_BIN_DIR}/PrivateHeaders"; then
-                TCL_INCLUDES="-I\"${TCL_BIN_DIR}/Headers\" -I\"${TCL_BIN_DIR}/PrivateHeaders\" ${TCL_INCLUDES}"; else
-                TCL_INCLUDES="${TCL_INCLUDES} ${TCL_INCLUDE_SPEC} `echo "${TCL_INCLUDE_SPEC}" | sed -e 's/Headers/PrivateHeaders/'`"; fi
-                ;;
-        esac
-    fi
-
-    AC_SUBST(TCL_TOP_DIR_NATIVE)
-    AC_SUBST(TCL_GENERIC_DIR_NATIVE)
-    AC_SUBST(TCL_UNIX_DIR_NATIVE)
-    AC_SUBST(TCL_WIN_DIR_NATIVE)
-    AC_SUBST(TCL_BMAP_DIR_NATIVE)
-    AC_SUBST(TCL_TOOL_DIR_NATIVE)
-    AC_SUBST(TCL_PLATFORM_DIR_NATIVE)
-
-    AC_SUBST(TCL_INCLUDES)
-    AC_MSG_RESULT([Using srcdir found in tclConfig.sh: ${TCL_SRC_DIR}])
-])
-
-#------------------------------------------------------------------------
-# TEA_PUBLIC_TCL_HEADERS --
-#
-#       Locate the installed public Tcl header files
-#
-# Arguments:
-#       None.
-#
-# Requires:
-#       CYGPATH must be set
-#
-# Results:
-#
-#       Adds a --with-tclinclude switch to configure.
-#       Result is cached.
-#
-#       Substs the following vars:
-#               TCL_INCLUDES
-#------------------------------------------------------------------------
-
-AC_DEFUN([TEA_PUBLIC_TCL_HEADERS], [
-    AC_MSG_CHECKING([for Tcl public headers])
-
-    AC_ARG_WITH(tclinclude, [  --with-tclinclude       directory containing the public Tcl header files], with_tclinclude=${withval})
-
-    AC_CACHE_VAL(ac_cv_c_tclh, [
-        # Use the value from --with-tclinclude, if it was given
-
-        if test x"${with_tclinclude}" != x ; then
-            if test -f "${with_tclinclude}/tcl.h" ; then
-                ac_cv_c_tclh=${with_tclinclude}
-            else
-                AC_MSG_ERROR([${with_tclinclude} directory does not contain tcl.h])
-            fi
-        else
-            if test "`uname -s`" = "Darwin"; then
-                # If Tcl was built as a framework, attempt to use
-                # the framework's Headers directory
-                case ${TCL_DEFS} in
-                    *TCL_FRAMEWORK*)
-                        list="`ls -d ${TCL_BIN_DIR}/Headers 2>/dev/null`"
-                        ;;
-                esac
-            fi
-
-            # Look in the source dir only if Tcl is not installed,
-            # and in that situation, look there before installed locations.
-            if test -f "${TCL_BIN_DIR}/Makefile" ; then
-                list="$list `ls -d ${TCL_SRC_DIR}/generic 2>/dev/null`"
-            fi
-
-            # Check order: pkg --prefix location, Tcl's --prefix location,
-            # relative to directory of tclConfig.sh.
-
-            eval "temp_includedir=${includedir}"
-            list="$list \
-                `ls -d ${temp_includedir}        2>/dev/null` \
-                `ls -d ${TCL_PREFIX}/include     2>/dev/null` \
-                `ls -d ${TCL_BIN_DIR}/../include 2>/dev/null`"
-            if test "${TEA_PLATFORM}" != "windows" -o "$GCC" = "yes"; then
-                list="$list /usr/local/include /usr/include"
-                if test x"${TCL_INCLUDE_SPEC}" != x ; then
-                    d=`echo "${TCL_INCLUDE_SPEC}" | sed -e 's/^-I//'`
-                    list="$list `ls -d ${d} 2>/dev/null`"
-                fi
-            fi
-            for i in $list ; do
-                if test -f "$i/tcl.h" ; then
-                    ac_cv_c_tclh=$i
-                    break
-                fi
-            done
-        fi
-    ])
-
-    # Print a message based on how we determined the include path
-
-    if test x"${ac_cv_c_tclh}" = x ; then
-        AC_MSG_ERROR([tcl.h not found.  Please specify its location with --with-tclinclude])
-    else
-        AC_MSG_RESULT([${ac_cv_c_tclh}])
-    fi
-
-    # Convert to a native path and substitute into the output files.
-
-    INCLUDE_DIR_NATIVE=`${CYGPATH} ${ac_cv_c_tclh}`
-
-    TCL_INCLUDES=-I\"${INCLUDE_DIR_NATIVE}\"
-
-    AC_SUBST(TCL_INCLUDES)
-])
-
-#------------------------------------------------------------------------
-# TEA_PRIVATE_TK_HEADERS --
-#
-#       Locate the private Tk include files
-#
-# Arguments:
-#
-#       Requires:
-#               TK_SRC_DIR      Assumes that TEA_LOAD_TKCONFIG has
-#                                already been called.
-#
-# Results:
-#
-#       Substs the following vars:
-#               TK_INCLUDES
-#------------------------------------------------------------------------
-
-AC_DEFUN([TEA_PRIVATE_TK_HEADERS], [
-    AC_MSG_CHECKING([for Tk private include files])
-
-    TK_SRC_DIR_NATIVE=`${CYGPATH} ${TK_SRC_DIR}`
-    TK_TOP_DIR_NATIVE=\"${TK_SRC_DIR_NATIVE}\"
-    TK_UNIX_DIR_NATIVE=\"${TK_SRC_DIR_NATIVE}/unix\"
-    TK_WIN_DIR_NATIVE=\"${TK_SRC_DIR_NATIVE}/win\"
-    TK_GENERIC_DIR_NATIVE=\"${TK_SRC_DIR_NATIVE}/generic\"
-    TK_XLIB_DIR_NATIVE=\"${TK_SRC_DIR_NATIVE}/xlib\"
-    if test "${TEA_PLATFORM}" = "windows"; then
-        TK_PLATFORM_DIR_NATIVE=${TK_WIN_DIR_NATIVE}
-    else
-        TK_PLATFORM_DIR_NATIVE=${TK_UNIX_DIR_NATIVE}
-    fi
-    # We want to ensure these are substituted so as not to require
-    # any *_NATIVE vars be defined in the Makefile
-    TK_INCLUDES="-I${TK_GENERIC_DIR_NATIVE} -I${TK_PLATFORM_DIR_NATIVE}"
-    if test "${TEA_WINDOWINGSYSTEM}" = "win32" \
-        -o "${TEA_WINDOWINGSYSTEM}" = "aqua"; then
-        TK_INCLUDES="${TK_INCLUDES} -I${TK_XLIB_DIR_NATIVE}"
-    fi
-    if test "${TEA_WINDOWINGSYSTEM}" = "aqua"; then
-        TK_INCLUDES="${TK_INCLUDES} -I${TK_SRC_DIR_NATIVE}/macosx"
-    fi
-    if test "`uname -s`" = "Darwin"; then
-        # If Tk was built as a framework, attempt to use
-        # the framework's Headers and PrivateHeaders directories
-        case ${TK_DEFS} in
-            *TK_FRAMEWORK*)
-                if test -d "${TK_BIN_DIR}/Headers" -a -d "${TK_BIN_DIR}/PrivateHeaders"; then
-                TK_INCLUDES="-I\"${TK_BIN_DIR}/Headers\" -I\"${TK_BIN_DIR}/PrivateHeaders\" ${TK_INCLUDES}"; fi
-                ;;
-        esac
-    fi
-
-    AC_SUBST(TK_TOP_DIR_NATIVE)
-    AC_SUBST(TK_UNIX_DIR_NATIVE)
-    AC_SUBST(TK_WIN_DIR_NATIVE)
-    AC_SUBST(TK_GENERIC_DIR_NATIVE)
-    AC_SUBST(TK_XLIB_DIR_NATIVE)
-    AC_SUBST(TK_PLATFORM_DIR_NATIVE)
-
-    AC_SUBST(TK_INCLUDES)
-    AC_MSG_RESULT([Using srcdir found in tkConfig.sh: ${TK_SRC_DIR}])
-])
-
-#------------------------------------------------------------------------
-# TEA_PUBLIC_TK_HEADERS --
-#
-#       Locate the installed public Tk header files
-#
-# Arguments:
-#       None.
-#
-# Requires:
-#       CYGPATH must be set
-#
-# Results:
-#
-#       Adds a --with-tkinclude switch to configure.
-#       Result is cached.
-#
-#       Substs the following vars:
-#               TK_INCLUDES
-#------------------------------------------------------------------------
-
-AC_DEFUN([TEA_PUBLIC_TK_HEADERS], [
-    AC_MSG_CHECKING([for Tk public headers])
-
-    AC_ARG_WITH(tkinclude, [  --with-tkinclude      directory containing the public Tk header files.], with_tkinclude=${withval})
-
-    AC_CACHE_VAL(ac_cv_c_tkh, [
-        # Use the value from --with-tkinclude, if it was given
-
-        if test x"${with_tkinclude}" != x ; then
-            if test -f "${with_tkinclude}/tk.h" ; then
-                ac_cv_c_tkh=${with_tkinclude}
-            else
-                AC_MSG_ERROR([${with_tkinclude} directory does not contain tk.h])
-            fi
-        else
-            if test "`uname -s`" = "Darwin"; then
-                # If Tk was built as a framework, attempt to use
-                # the framework's Headers directory.
-                case ${TK_DEFS} in
-                    *TK_FRAMEWORK*)
-                        list="`ls -d ${TK_BIN_DIR}/Headers 2>/dev/null`"
-                        ;;
-                esac
-            fi
-
-            # Look in the source dir only if Tk is not installed,
-            # and in that situation, look there before installed locations.
-            if test -f "${TK_BIN_DIR}/Makefile" ; then
-                list="$list `ls -d ${TK_SRC_DIR}/generic 2>/dev/null`"
-            fi
-
-            # Check order: pkg --prefix location, Tk's --prefix location,
-            # relative to directory of tkConfig.sh, Tcl's --prefix location, 
-            # relative to directory of tclConfig.sh.
-
-            eval "temp_includedir=${includedir}"
-            list="$list \
-                `ls -d ${temp_includedir}        2>/dev/null` \
-                `ls -d ${TK_PREFIX}/include      2>/dev/null` \
-                `ls -d ${TK_BIN_DIR}/../include  2>/dev/null` \
-                `ls -d ${TCL_PREFIX}/include     2>/dev/null` \
-                `ls -d ${TCL_BIN_DIR}/../include 2>/dev/null`"
-            if test "${TEA_PLATFORM}" != "windows" -o "$GCC" = "yes"; then
-                list="$list /usr/local/include /usr/include"
-            fi
-            for i in $list ; do
-                if test -f "$i/tk.h" ; then
-                    ac_cv_c_tkh=$i
-                    break
-                fi
-            done
-        fi
-    ])
-
-    # Print a message based on how we determined the include path
-
-    if test x"${ac_cv_c_tkh}" = x ; then
-        AC_MSG_ERROR([tk.h not found.  Please specify its location with --with-tkinclude])
-    else
-        AC_MSG_RESULT([${ac_cv_c_tkh}])
-    fi
-
-    # Convert to a native path and substitute into the output files.
-
-    INCLUDE_DIR_NATIVE=`${CYGPATH} ${ac_cv_c_tkh}`
-
-    TK_INCLUDES=-I\"${INCLUDE_DIR_NATIVE}\"
-
-    AC_SUBST(TK_INCLUDES)
-
-    if test "${TEA_WINDOWINGSYSTEM}" = "win32" \
-        -o "${TEA_WINDOWINGSYSTEM}" = "aqua"; then
-        # On Windows and Aqua, we need the X compat headers
-        AC_MSG_CHECKING([for X11 header files])
-        if test ! -r "${INCLUDE_DIR_NATIVE}/X11/Xlib.h"; then
-            INCLUDE_DIR_NATIVE="`${CYGPATH} ${TK_SRC_DIR}/xlib`"
-            TK_XINCLUDES=-I\"${INCLUDE_DIR_NATIVE}\"
-            AC_SUBST(TK_XINCLUDES)
-        fi
-        AC_MSG_RESULT([${INCLUDE_DIR_NATIVE}])
-    fi
-])
-
-#------------------------------------------------------------------------
-# TEA_PROG_TCLSH
-#       Determine the fully qualified path name of the tclsh executable
-#       in the Tcl build directory or the tclsh installed in a bin
-#       directory. This macro will correctly determine the name
-#       of the tclsh executable even if tclsh has not yet been
-#       built in the build directory. The tclsh found is always
-#       associated with a tclConfig.sh file. This tclsh should be used
-#       only for running extension test cases. It should never be
-#       or generation of files (like pkgIndex.tcl) at build time.
-#
-# Arguments
-#       none
-#
-# Results
-#       Subst's the following values:
-#               TCLSH_PROG
-#------------------------------------------------------------------------
-
-AC_DEFUN([TEA_PROG_TCLSH], [
-    AC_MSG_CHECKING([for tclsh])
-    if test -f "${TCL_BIN_DIR}/Makefile" ; then
-        # tclConfig.sh is in Tcl build directory
-        if test "${TEA_PLATFORM}" = "windows"; then
-            TCLSH_PROG="${TCL_BIN_DIR}/tclsh${TCL_MAJOR_VERSION}${TCL_MINOR_VERSION}${TCL_DBGX}${EXEEXT}"
-        else
-            TCLSH_PROG="${TCL_BIN_DIR}/tclsh"
-        fi
-    else
-        # tclConfig.sh is in install location
-        if test "${TEA_PLATFORM}" = "windows"; then
-            TCLSH_PROG="tclsh${TCL_MAJOR_VERSION}${TCL_MINOR_VERSION}${TCL_DBGX}${EXEEXT}"
-        else
-            TCLSH_PROG="tclsh${TCL_MAJOR_VERSION}.${TCL_MINOR_VERSION}${TCL_DBGX}"
-        fi
-        list="`ls -d ${TCL_BIN_DIR}/../bin 2>/dev/null` \
-              `ls -d ${TCL_BIN_DIR}/..     2>/dev/null` \
-              `ls -d ${TCL_PREFIX}/bin     2>/dev/null`"
-        for i in $list ; do
-            if test -f "$i/${TCLSH_PROG}" ; then
-                REAL_TCL_BIN_DIR="`cd "$i"; pwd`"
-                break
-            fi
-        done
-        TCLSH_PROG="${REAL_TCL_BIN_DIR}/${TCLSH_PROG}"
-    fi
-    AC_MSG_RESULT([${TCLSH_PROG}])
-    AC_SUBST(TCLSH_PROG)
-])
-
-#------------------------------------------------------------------------
-# TEA_PROG_WISH
-#       Determine the fully qualified path name of the wish executable
-#       in the Tk build directory or the wish installed in a bin
-#       directory. This macro will correctly determine the name
-#       of the wish executable even if wish has not yet been
-#       built in the build directory. The wish found is always
-#       associated with a tkConfig.sh file. This wish should be used
-#       only for running extension test cases. It should never be
-#       or generation of files (like pkgIndex.tcl) at build time.
-#
-# Arguments
-#       none
-#
-# Results
-#       Subst's the following values:
-#               WISH_PROG
-#------------------------------------------------------------------------
-
-AC_DEFUN([TEA_PROG_WISH], [
-    AC_MSG_CHECKING([for wish])
-    if test -f "${TK_BIN_DIR}/Makefile" ; then
-        # tkConfig.sh is in Tk build directory
-        if test "${TEA_PLATFORM}" = "windows"; then
-            WISH_PROG="${TK_BIN_DIR}/wish${TK_MAJOR_VERSION}${TK_MINOR_VERSION}${TK_DBGX}${EXEEXT}"
-        else
-            WISH_PROG="${TK_BIN_DIR}/wish"
-        fi
-    else
-        # tkConfig.sh is in install location
-        if test "${TEA_PLATFORM}" = "windows"; then
-            WISH_PROG="wish${TK_MAJOR_VERSION}${TK_MINOR_VERSION}${TK_DBGX}${EXEEXT}"
-        else
-            WISH_PROG="wish${TK_MAJOR_VERSION}.${TK_MINOR_VERSION}${TK_DBGX}"
-        fi
-        list="`ls -d ${TK_BIN_DIR}/../bin 2>/dev/null` \
-              `ls -d ${TK_BIN_DIR}/..     2>/dev/null` \
-              `ls -d ${TK_PREFIX}/bin     2>/dev/null`"
-        for i in $list ; do
-            if test -f "$i/${WISH_PROG}" ; then
-                REAL_TK_BIN_DIR="`cd "$i"; pwd`"
-                break
-            fi
-        done
-        WISH_PROG="${REAL_TK_BIN_DIR}/${WISH_PROG}"
-    fi
-    AC_MSG_RESULT([${WISH_PROG}])
-    AC_SUBST(WISH_PROG)
-])
-
-#------------------------------------------------------------------------
-# TEA_PATH_CONFIG --
-#
-#       Locate the ${1}Config.sh file and perform a sanity check on
-#       the ${1} compile flags.  These are used by packages like
-#       [incr Tk] that load *Config.sh files from more than Tcl and Tk.
-#
-# Arguments:
-#       none
-#
-# Results:
-#
-#       Adds the following arguments to configure:
-#               --with-$1=...
-#
-#       Defines the following vars:
-#               $1_BIN_DIR      Full path to the directory containing
-#                               the $1Config.sh file
-#------------------------------------------------------------------------
-
-AC_DEFUN([TEA_PATH_CONFIG], [
-    #
-    # Ok, lets find the $1 configuration
-    # First, look for one uninstalled.
-    # the alternative search directory is invoked by --with-$1
-    #
-
-    if test x"${no_$1}" = x ; then
-        # we reset no_$1 in case something fails here
-        no_$1=true
-        AC_ARG_WITH($1, [  --with-$1              directory containing $1 configuration ($1Config.sh)], with_$1config=${withval})
-        AC_MSG_CHECKING([for $1 configuration])
-        AC_CACHE_VAL(ac_cv_c_$1config,[
-
-            # First check to see if --with-$1 was specified.
-            if test x"${with_$1config}" != x ; then
-                case ${with_$1config} in
-                    */$1Config.sh )
-                        if test -f ${with_$1config}; then
-                            AC_MSG_WARN([--with-$1 argument should refer to directory containing $1Config.sh, not to $1Config.sh itself])
-                            with_$1config=`echo ${with_$1config} | sed 's!/$1Config\.sh$!!'`
-                        fi;;
-                esac
-                if test -f "${with_$1config}/$1Config.sh" ; then
-                    ac_cv_c_$1config=`(cd ${with_$1config}; pwd)`
-                else
-                    AC_MSG_ERROR([${with_$1config} directory doesn't contain $1Config.sh])
-                fi
-            fi
-
-            # then check for a private $1 installation
-            if test x"${ac_cv_c_$1config}" = x ; then
-                for i in \
-                        ../$1 \
-                        `ls -dr ../$1*[[0-9]].[[0-9]]*.[[0-9]]* 2>/dev/null` \
-                        `ls -dr ../$1*[[0-9]].[[0-9]][[0-9]] 2>/dev/null` \
-                        `ls -dr ../$1*[[0-9]].[[0-9]] 2>/dev/null` \
-                        `ls -dr ../$1*[[0-9]].[[0-9]]* 2>/dev/null` \
-                        ../../$1 \
-                        `ls -dr ../../$1*[[0-9]].[[0-9]]*.[[0-9]]* 2>/dev/null` \
-                        `ls -dr ../../$1*[[0-9]].[[0-9]][[0-9]] 2>/dev/null` \
-                        `ls -dr ../../$1*[[0-9]].[[0-9]] 2>/dev/null` \
-                        `ls -dr ../../$1*[[0-9]].[[0-9]]* 2>/dev/null` \
-                        ../../../$1 \
-                        `ls -dr ../../../$1*[[0-9]].[[0-9]]*.[[0-9]]* 2>/dev/null` \
-                        `ls -dr ../../../$1*[[0-9]].[[0-9]][[0-9]] 2>/dev/null` \
-                        `ls -dr ../../../$1*[[0-9]].[[0-9]] 2>/dev/null` \
-                        `ls -dr ../../../$1*[[0-9]].[[0-9]]* 2>/dev/null` \
-                        ${srcdir}/../$1 \
-                        `ls -dr ${srcdir}/../$1*[[0-9]].[[0-9]]*.[[0-9]]* 2>/dev/null` \
-                        `ls -dr ${srcdir}/../$1*[[0-9]].[[0-9]][[0-9]] 2>/dev/null` \
-                        `ls -dr ${srcdir}/../$1*[[0-9]].[[0-9]] 2>/dev/null` \
-                        `ls -dr ${srcdir}/../$1*[[0-9]].[[0-9]]* 2>/dev/null` \
-                        ; do
-                    if test -f "$i/$1Config.sh" ; then
-                        ac_cv_c_$1config=`(cd $i; pwd)`
-                        break
-                    fi
-                    if test -f "$i/unix/$1Config.sh" ; then
-                        ac_cv_c_$1config=`(cd $i/unix; pwd)`
-                        break
-                    fi
-                done
-            fi
-
-            # check in a few common install locations
-            if test x"${ac_cv_c_$1config}" = x ; then
-                for i in `ls -d ${libdir} 2>/dev/null` \
-                        `ls -d ${exec_prefix}/lib 2>/dev/null` \
-                        `ls -d ${prefix}/lib 2>/dev/null` \
-                        `ls -d /usr/local/lib 2>/dev/null` \
-                        `ls -d /usr/contrib/lib 2>/dev/null` \
-                        `ls -d /usr/lib 2>/dev/null` \
-                        ; do
-                    if test -f "$i/$1Config.sh" ; then
-                        ac_cv_c_$1config=`(cd $i; pwd)`
-                        break
-                    fi
-                done
-            fi
-        ])
-
-        if test x"${ac_cv_c_$1config}" = x ; then
-            $1_BIN_DIR="# no $1 configs found"
-            AC_MSG_WARN([Cannot find $1 configuration definitions])
-            exit 0
-        else
-            no_$1=
-            $1_BIN_DIR=${ac_cv_c_$1config}
-            AC_MSG_RESULT([found $$1_BIN_DIR/$1Config.sh])
-        fi
-    fi
-])
-
-#------------------------------------------------------------------------
-# TEA_LOAD_CONFIG --
-#
-#       Load the $1Config.sh file
-#
-# Arguments:
-#       
-#       Requires the following vars to be set:
-#               $1_BIN_DIR
-#
-# Results:
-#
-#       Subst the following vars:
-#               $1_SRC_DIR
-#               $1_LIB_FILE
-#               $1_LIB_SPEC
-#
-#------------------------------------------------------------------------
-
-AC_DEFUN([TEA_LOAD_CONFIG], [
-    AC_MSG_CHECKING([for existence of ${$1_BIN_DIR}/$1Config.sh])
-
-    if test -f "${$1_BIN_DIR}/$1Config.sh" ; then
-        AC_MSG_RESULT([loading])
-        . ${$1_BIN_DIR}/$1Config.sh
-    else
-        AC_MSG_RESULT([file not found])
-    fi
-
-    #
-    # If the $1_BIN_DIR is the build directory (not the install directory),
-    # then set the common variable name to the value of the build variables.
-    # For example, the variable $1_LIB_SPEC will be set to the value
-    # of $1_BUILD_LIB_SPEC. An extension should make use of $1_LIB_SPEC
-    # instead of $1_BUILD_LIB_SPEC since it will work with both an
-    # installed and uninstalled version of Tcl.
-    #
-
-    if test -f ${$1_BIN_DIR}/Makefile ; then
-        AC_MSG_WARN([Found Makefile - using build library specs for $1])
-        $1_LIB_SPEC=${$1_BUILD_LIB_SPEC}
-        $1_STUB_LIB_SPEC=${$1_BUILD_STUB_LIB_SPEC}
-        $1_STUB_LIB_PATH=${$1_BUILD_STUB_LIB_PATH}
-    fi
-
-    AC_SUBST($1_VERSION)
-    AC_SUBST($1_BIN_DIR)
-    AC_SUBST($1_SRC_DIR)
-
-    AC_SUBST($1_LIB_FILE)
-    AC_SUBST($1_LIB_SPEC)
-
-    AC_SUBST($1_STUB_LIB_FILE)
-    AC_SUBST($1_STUB_LIB_SPEC)
-    AC_SUBST($1_STUB_LIB_PATH)
-])
-
-#------------------------------------------------------------------------
-# TEA_PATH_CELIB --
-#
-#       Locate Keuchel's celib emulation layer for targeting Win/CE
-#
-# Arguments:
-#       none
-#
-# Results:
-#
-#       Adds the following arguments to configure:
-#               --with-celib=...
-#
-#       Defines the following vars:
-#               CELIB_DIR       Full path to the directory containing
-#                               the include and platform lib files
-#------------------------------------------------------------------------
-
-AC_DEFUN([TEA_PATH_CELIB], [
-    # First, look for one uninstalled.
-    # the alternative search directory is invoked by --with-celib
-
-    if test x"${no_celib}" = x ; then
-        # we reset no_celib in case something fails here
-        no_celib=true
-        AC_ARG_WITH(celib,[  --with-celib=DIR        use Windows/CE support library from DIR], with_celibconfig=${withval})
-        AC_MSG_CHECKING([for Windows/CE celib directory])
-        AC_CACHE_VAL(ac_cv_c_celibconfig,[
-            # First check to see if --with-celibconfig was specified.
-            if test x"${with_celibconfig}" != x ; then
-                if test -d "${with_celibconfig}/inc" ; then
-                    ac_cv_c_celibconfig=`(cd ${with_celibconfig}; pwd)`
-                else
-                    AC_MSG_ERROR([${with_celibconfig} directory doesn't contain inc directory])
-                fi
-            fi
-
-            # then check for a celib library
-            if test x"${ac_cv_c_celibconfig}" = x ; then
-                for i in \
-                        ../celib-palm-3.0 \
-                        ../celib \
-                        ../../celib-palm-3.0 \
-                        ../../celib \
-                        `ls -dr ../celib-*3.[[0-9]]* 2>/dev/null` \
-                        ${srcdir}/../celib-palm-3.0 \
-                        ${srcdir}/../celib \
-                        `ls -dr ${srcdir}/../celib-*3.[[0-9]]* 2>/dev/null` \
-                        ; do
-                    if test -d "$i/inc" ; then
-                        ac_cv_c_celibconfig=`(cd $i; pwd)`
-                        break
-                    fi
-                done
-            fi
-        ])
-        if test x"${ac_cv_c_celibconfig}" = x ; then
-            AC_MSG_ERROR([Cannot find celib support library directory])
-        else
-            no_celib=
-            CELIB_DIR=${ac_cv_c_celibconfig}
-            CELIB_DIR=`echo "$CELIB_DIR" | sed -e 's!\\\!/!g'`
-            AC_MSG_RESULT([found $CELIB_DIR])
-        fi
-    fi
-])
-
-
-# Local Variables:
-# mode: autoconf
-# End:
+    fi
+    if test "$tcl_ok" = yes; then
+        AC_DEFINE(HAVE_GETGRNAM_R)
+    fi
+])])
+
+#--------------------------------------------------------------------
+# SC_CONFIG_COMMANDS_PRE(CMDS)
+#
+#       Replacement for autoconf 2.5x AC_COMMANDS_PRE:
+#               Commands to run right before config.status is
+#               created. Accumulates.
+#
+#       Requires presence of SC_OUTPUT_COMMANDS_PRE at the end
+#       of configure.in (right before AC_OUTPUT).
+#
+#--------------------------------------------------------------------
+
+AC_DEFUN([SC_CONFIG_COMMANDS_PRE], [
+    define([SC_OUTPUT_COMMANDS_PRE], defn([SC_OUTPUT_COMMANDS_PRE])[$1
+])])
+AC_DEFUN([SC_OUTPUT_COMMANDS_PRE])
+