_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h.  */

#include <sys/types.h>
#include <sys/times.h>
#include <unistd.h>
main() {
    struct tms cpu;
    times(&cpu);
    sleep(2);
    exit ((times(&cpu) > 0) ? 0 : 1);
}

    # time.
    #-------------------------------------------------------------------------
    
    AC_MSG_CHECKING(checking to see what 'times' returns)
    AC_TRY_RUN([
#include <sys/types.h>
#include <sys/times.h>
#include <unistd.h>
main() {
    struct tms cpu;
    times(&cpu);
    sleep(2);
    exit ((times(&cpu) > 0) ? 0 : 1);
}
], [AC_MSG_RESULT(elapsed real time)],

/*
 * Assert macro for use in TclX.  Some GCCs libraries are missing a function
 * used by their macro, so we define our own.
 */
#ifdef TCLX_DEBUG
#   define TclX_Assert(expr) ((expr) ? (void)0 : \
                              Tcl_Panic("TclX assertion failure: %s:%d \"%s\"\n",\
                                    __FILE__, __LINE__, "expr"))
#else
#   define TclX_Assert(expr)
#endif

/*
 * Get ranges of integers and longs.

     * standard files generates an error on some systems.  Skip options
     * that can't be set.
     */
    if (Tcl_SplitList(interp, strValues.string, &optArgc, &optArgv) != TCL_OK) {
        goto errorExit;
    }
    if ((optArgc % 2) != 0) {
        Tcl_Panic("channel didn't return keyword/value pairs");
    }

    for (idx = 0; idx < optArgc; idx += 2) {
        option = optArgv[idx];
        value = optArgv[idx+1];
        if (STREQU (option, "-blocking") && (value [0] != '0')) {
            continue;

        break;
      case ATTR_KEEPALIVE:
        if (TclXOSgetsockopt (interp, channel, SO_KEEPALIVE, &sval) != TCL_OK)
            return TCL_ERROR;
        value = sval;
        break;
      default:
        Tcl_Panic ("bug in fcntl get attrib");
    }

    Tcl_SetIntObj (Tcl_GetObjResult (interp), value != 0);
    return TCL_OK;
}

/*-----------------------------------------------------------------------------

      case ATTR_LINEBUF:
        return TclX_SetChannelOption (interp, channel, TCLX_COPT_BUFFERING,
                                      value ? TCLX_BUFFERING_LINE :
                                              TCLX_BUFFERING_FULL);
      case ATTR_KEEPALIVE:
        return TclXOSsetsockopt (interp, channel, SO_KEEPALIVE, value);
      default:
        Tcl_Panic ("buf in fcntl set attrib");
    }
    return TCL_ERROR;  /* Should never be reached */
}

/*-----------------------------------------------------------------------------
 * TclX_FcntlObjCmd --
 *     Implements the fcntl TCL command:

TclX_HandleFree (void_pt headerPtr, void_pt entryPtr)
{
    tblHeader_pt   tblHdrPtr = (tblHeader_pt)headerPtr;
    entryHeader_pt entryHdrPtr;

    entryHdrPtr = HEADER_AREA (entryPtr);
    if (entryHdrPtr->freeLink != ALLOCATED_IDX)
        Tcl_Panic ("Tcl_HandleFree: entry not allocated %p\n",
            (char *) entryHdrPtr);

    entryHdrPtr->freeLink = tblHdrPtr->freeHeadIdx;
    tblHdrPtr->freeHeadIdx =
        (((ubyte_pt) entryHdrPtr) - tblHdrPtr->bodyPtr) / tblHdrPtr->entrySize;

}

           ((isProc && (scanPtr->scopeLevel >= scopeLevel)) ||
            ((!isProc) && (scanPtr->scopeLevel > scopeLevel)))) {
        scanPtr = scanPtr->prevScopePtr;
        /*
         * Only global level can be NULL.
         */
        if (scanPtr == NULL)
            Tcl_Panic (PROF_PANIC, 1);
    }
    entryPtr->prevScopePtr = scanPtr;
    infoPtr->scopeChainPtr = entryPtr;
}

/*-----------------------------------------------------------------------------
 * RecordData --

            return TCL_OK;  /* Ignore unknown ops */

        Tcl_ListObjGetElements (NULL, objv[1], &cmdObjc, &cmdObjv);
        if (cmdObjc > 0) {
            cmdName = Tcl_GetStringFromObj (cmdObjv[0], NULL);
            cmd = Tcl_FindCommand (interp, cmdName, NULL, 0);
            if (cmd == NULL)
                Tcl_Panic (PROF_PANIC, 1000);

            fullCmdNameObj = Tcl_NewObj ();
            Tcl_GetCommandFullName (interp, cmd, fullCmdNameObj);
            fullCmdName = Tcl_GetStringFromObj (fullCmdNameObj, NULL);

            /*
             * Determine current proc and var levels.

             * initial entries that where pushed on the stack before
             * we started.  Pop those entries.
             */
            if (infoPtr->stackPtr->procLevel > procLevel) {
                UpdateTOSTimes (infoPtr);
                do {
                    if (infoPtr->stackPtr->evalLevel != UNKNOWN_LEVEL)
                        Tcl_Panic (PROF_PANIC, 2);  /* Not an initial entry */
                    if (infoPtr->stackPtr->prevEntryPtr == NULL)
                        break;  /* Keep first entry */
                    PopEntry (infoPtr);
                } while (infoPtr->stackPtr->procLevel > procLevel);
            }

            /*

            return TCL_OK;  /* Ignore unknown ops */

        Tcl_ListObjGetElements (NULL, objv[1], &cmdObjc, &cmdObjv);
        if (cmdObjc > 0) {
            cmdName = Tcl_GetStringFromObj (cmdObjv[0], NULL);
            cmd = Tcl_FindCommand (interp, cmdName, NULL, 0);
            if (cmd == NULL)
                Tcl_Panic (PROF_PANIC, 1001);

            fullCmdNameObj = Tcl_NewObj ();
            Tcl_GetCommandFullName (interp, cmd, fullCmdNameObj);
            fullCmdName = Tcl_GetStringFromObj (fullCmdNameObj, NULL);

            /*
             * Pop the entry, recording the information.

    while ((scanPtr != NULL) && (scanPtr->scopeLevel >= scopeLevel) &&
           (scanPtr->procLevel > 0)) {
        scanPtr = scanPtr->prevScopePtr;
        /*
         * Only global level can be NULL.
         */
        if (scanPtr == NULL)
            Tcl_Panic (PROF_PANIC, 6);
    }
    infoPtr->scopeChainPtr = scanPtr;

    /*
     * Get the time we started.
     */
    TclXOSElapsedTime (&infoPtr->realTime, &infoPtr->cpuTime);

     * Not done for SIGCHLD, as we would continue to the signal until the
     * wait is done.  This is fixed by Posix signals and is not necessary under
     * BSD, but it done this way for consistency.
     */
#ifdef SIGCHLD
    if (signalNum != SIGCHLD) {
        if (SetSignalState (signalNum, SignalTrap, FALSE) == TCL_ERROR)
            Tcl_Panic ("SignalTrap bug");
    }
#else
    if (SetSignalState (signalNum, SignalTrap, FALSE) == TCL_ERROR)
        Tcl_Panic ("SignalTrap bug");
#endif /* SIGCHLD */
#endif /* NO_SIGACTION */
}

/*-----------------------------------------------------------------------------
 * FormatTrapCode --
 *     Format the signal name into the signal trap command.  Replacing %S with

    int idx;

    for (idx = 0; idx < tsdPtr->numInterps; idx++) {
        if (tsdPtr->interpTable [idx] == interp)
            break;
    }
    if (idx == tsdPtr->numInterps)
        Tcl_Panic ("signal interp lost");

    tsdPtr->interpTable [idx] = tsdPtr->interpTable [--tsdPtr->numInterps];

    /*
     * If there are no more interpreters, clean everything up.
     */
    if (tsdPtr->numInterps == 0) {

    } else if (STREQU (strValue, "cr")) {
        return TCLX_TRANSLATE_CR;
    } else if (STREQU (strValue, "crlf")) {
        return TCLX_TRANSLATE_CRLF;
    } else if (STREQU (strValue, "platform")) {
        return TCLX_TRANSLATE_PLATFORM;
    }
    Tcl_Panic ("ParseTranslationOption bug");
    return TCL_ERROR;  /* Not reached */
}

/*-----------------------------------------------------------------------------
 * FormatTranslationOption --
 *
 *   Format the string that represents the translation value for one channel

      case TCLX_TRANSLATE_CR:
        return "cr";
      case TCLX_TRANSLATE_CRLF:
        return "crlf";
      case TCLX_TRANSLATE_PLATFORM:
        return "platform";
      default:
        Tcl_Panic ("FormatTranslationOption bug");
    }
    return NULL;  /* Not reached */
}


/*-----------------------------------------------------------------------------
 * TclX_GetChannelOption --

      }
    }
    Tcl_DStringFree (&strValue);
    *valuePtr = value;
    return TCL_OK;

  fatalError:
    Tcl_Panic ("TclX_GetChannelOption bug");  /* FIX: return error. */
    return 0;  /* Not reached */
}

/*-----------------------------------------------------------------------------
 * TclX_SetChannelOption --
 *
 *   C-friendly front end to Tcl_SetChannelOption.

      default:
        goto fatalError;
    }

    return Tcl_SetChannelOption (interp, channel, strOption, strValue);

  fatalError:
    Tcl_Panic ("TclX_SetChannelOption bug");
    return TCL_ERROR;  /* Not reached */
}

/*-----------------------------------------------------------------------------
 * TclX_JoinPath --
 *
 *   Interface to Tcl_Join path to join only two files.

    if ((Tcl_ListObjGetElements (NULL, saveObjPtr, &saveObjc,
                                 &saveObjv) != TCL_OK) ||
        (saveObjc != 4) ||
        (Tcl_GetLongFromObj (NULL, saveObjv[3], &flags) != TCL_OK)) {
        /*
         * This should never happen
         */
        Tcl_Panic ("invalid TclX result save object");
    }

    Tcl_SetVar2Ex(interp, ERRORCODE, NULL, saveObjv[2], TCL_GLOBAL_ONLY);
    Tcl_SetVar2Ex(interp, ERRORINFO, NULL, saveObjv[1], TCL_GLOBAL_ONLY);

    Tcl_ResetResult(interp);
    Tcl_AppendObjToErrorInfo(interp, saveObjv[1]);

#--------------------------------------------------------------------

AC_DEFUN([TEA_BUGGY_STRTOD], [
    AC_CHECK_FUNC(strtod, tcl_strtod=1, tcl_strtod=0)
    if test "$tcl_strtod" = 1; then
	AC_CACHE_CHECK([for Solaris2.4/Tru64 strtod bugs], tcl_cv_strtod_buggy,[
	    AC_TRY_RUN([
		#include <stdlib.h>
		extern double strtod();
		int main() {
		    char *infString="Inf", *nanString="NaN", *spaceString=" ";
		    char *term;
		    double value;
		    value = strtod(infString, &term);
		    if ((term != infString) && (term[-1] == 0)) {

#include <grp.h>
#include <assert.h>

#ifndef __xlC__ /* AIX xlc */
extern int h_errno;
#endif






/*
 * Included the tcl file tclUnixPort.h after other system files, as it checks
 * if certain things are defined.
 */
#include "tclUnixPort.h"

/*

      case TCLX_WIN_SOCKET:
        TclX_AppendObjResult (interp, "can't lock a socket under windows",
                              (char *) NULL);
        return INVALID_HANDLE_VALUE;
      case TCLX_WIN_CONSOLE:
        break;  /* FIX: Is this legal?? */
      default:
        Tcl_Panic ("unknown win channel type %d\n", type);
    }

    /*
     * Calculate actual offset of the start.
     */
    switch (lockInfoPtr->whence) {
      case 0:  /* start */