/*
 * tclUnixInit.c --
 *
 *	Contains the Unix-specific interpreter initialization functions.
 *
 * Copyright (c) 1995-1997 Sun Microsystems, Inc.
 * Copyright (c) 1999 by Scriptics Corporation.
 * All rights reserved.
 *
 * RCS: @(#) $Id: tclUnixInit.c,v 1.72 2007/11/09 21:35:19 msofer Exp $
 */

#include "tclInt.h"
#include <stddef.h>
#include <locale.h>
#ifdef HAVE_LANGINFO
#   include <langinfo.h>

 * Need to check Darwin release at runtime in tclUnixFCmd.c and tclLoadDyld.c:
 * initialize release global at startup from uname().
 */
#define GET_DARWIN_RELEASE 1
MODULE_SCOPE long tclMacOSXDarwinRelease;
long tclMacOSXDarwinRelease = 0;
#endif

/*
 * Auxiliary function to compute the direction of stack growth, and a static
 * variable to cache the result.
 */

static stackGrowsDown = -1;
static int StackGrowsDown(int *parent);


/*
 *---------------------------------------------------------------------------
 *
 * TclpInitPlatform --
 *
 *	Initialize all the platform-dependant things like signals and

 *
 * Results:
 *	1 if there is enough stack space to continue; 0 if not.
 *
 * Side effects:
 *	None.
 *
 * Remark: Unused in the core, to be removed.
 *----------------------------------------------------------------------
 */

int
TclpCheckStackSpace(void)
{
#ifdef TCL_NO_STACK_CHECK

    /*
     * This function was normally unimplemented on Unix platforms and this
     * implements old behavior, i.e. no stack checking performed.
     */

    return 1;

#else

    int localInt, *stackBound;

    TclpGetCStackParams(&stackBound);

    if (stackGrowsDown) {
	return (&localInt > stackBound) ;
    } else {
	return (&localInt > stackBound) ;
    }
#endif
}

/*
 *----------------------------------------------------------------------
 *
 * TclpGetStackParams --
 *
 *        Determine tha stack params for the current thread: in which
 *        direction does the stack grow, and what is the stack lower (resp
 *        upper) bound for safe invocation of a new command. This is used to
 *        cache the values needed for an efficient computation of
 *        TclpCheckStackSpace() when the interp is known.
 *
 *    Results:
 *        Returns 1 if the stack grows down, in which case a stack lower bound
 *        is stored at stackBoundPtr. If the stack grows up, 0 is returned and
 *        an upper bound is stored at stackBoundPtr. If a bound cannot be
 *        determined NULL is stored at stackBoundPtr.
 */

int
TclpGetCStackParams(
    int **stackBoundPtr)
{
#ifdef TCL_NO_STACK_CHECK
    *stackBoundPtr = NULL;
    return 0;
#else
    int localVar;
    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
				/* Most variables are actually in a
				 * thread-specific data block to minimise the
				 * impact on the stack. */




	
    if (stackGrowsDown == -1) {
	/*


	 * Not initialised!
	 */

	stackGrowsDown = StackGrowsDown(&localVar);
    }

        /*
     * The first time through, we record the "outermost" stack frame.
     */

    if (tsdPtr->outerVarPtr == NULL) {
	tsdPtr->outerVarPtr = &localVar;
    }

    if (tsdPtr->initialised == 0) {
	/*
	 * We appear to have not computed the stack size before. Attempt to
	 * retrieve it from either the current thread or, failing that, the
	 * process accounting limit. Note that we assume that stack sizes do
	 * not change throughout the lifespan of the thread/process; this is
	 * almost always true.
	 */

	tsdPtr->stackDetermineResult = GetStackSize(&tsdPtr->stackSize);
	tsdPtr->initialised = 1;
    }

    if (tsdPtr->stackDetermineResult != TCL_OK) {
	switch (tsdPtr->stackDetermineResult) {
	    case TCL_BREAK:
		STACK_DEBUG(("skipping stack checks with failure\n"));

	    case TCL_CONTINUE:
		STACK_DEBUG(("skipping stack checks with success\n"));

	}
	*stackBoundPtr = NULL;
	return 1; /* so that check always succeeds */
    }





    if (stackGrowsDown) {
	*stackBoundPtr = tsdPtr->outerVarPtr - tsdPtr->stackSize;
    } else {
	*stackBoundPtr = tsdPtr->outerVarPtr + tsdPtr->stackSize;
    }
    return stackGrowsDown;
#endif
}

int
StackGrowsDown(
    int *parent)
{



    int here;



    return (&here < parent);
}



/*
 *----------------------------------------------------------------------
 *
 * GetStackSize --
 *
 *	Discover what the stack size for the current thread/process actually