/* 

 * tclUnixInit.c --

 *

 * Portions Copyright (c) 2007-2008 Nokia Corporation and/or its subsidiaries. All rights reserved.

 *

 *	Contains the Unix-specific interpreter initialization functions.

 *

 * Copyright (c) 1995-1997 Sun Microsystems, Inc.

 * Copyright (c) 1999 by Scriptics Corporation.

 * Portions Copyright (c) 2007-2008 Nokia Corporation and/or its subsidiaries. All rights reserved.  

 * All rights reserved.

 *

 * RCS: @(#) $Id: tclUnixInit.c,v 1.34.2.15 2007/04/29 02:19:51 das Exp $

 */

#if defined(HAVE_COREFOUNDATION)

#include <CoreFoundation/CoreFoundation.h>

#endif

#include "tclInt.h"

#include "tclPort.h"

#include <locale.h>

#ifdef HAVE_LANGINFO

#   include <langinfo.h>

#   ifdef __APPLE__

#       if defined(HAVE_WEAK_IMPORT) && MAC_OS_X_VERSION_MIN_REQUIRED < 1030

	    /* Support for weakly importing nl_langinfo on Darwin. */

#           define WEAK_IMPORT_NL_LANGINFO

	    extern char *nl_langinfo(nl_item) WEAK_IMPORT_ATTRIBUTE;

#       endif

#    endif

#endif

#if defined(__FreeBSD__) && defined(__GNUC__)

#   include <floatingpoint.h>

#endif

#if defined(__bsdi__)

#   include <sys/param.h>

#   if _BSDI_VERSION > 199501

#	include <dlfcn.h>

#   endif

#endif

#if defined(__SYMBIAN32__) 

#include "tclSymbianGlobals.h"

#include "convertPathSlashes.h"

#endif 

/*

 * The Init script (common to Windows and Unix platforms) is

 * defined in tkInitScript.h

 */

#include "tclInitScript.h"

/* Used to store the encoding used for binary files */

static Tcl_Encoding binaryEncoding = NULL;

/* Has the basic library path encoding issue been fixed */

static int libraryPathEncodingFixed = 0;

/*

 * Tcl tries to use standard and homebrew methods to guess the right

 * encoding on the platform.  However, there is always a final fallback,

 * and this value is it.  Make sure it is a real Tcl encoding.

 */

#ifndef TCL_DEFAULT_ENCODING

#define TCL_DEFAULT_ENCODING "iso8859-1"

#endif

/*

 * Default directory in which to look for Tcl library scripts.  The

 * symbol is defined by Makefile.

 */

#ifdef __SYMBIAN32__  

// building one *.exe, giving substitute values to tclUnixInt.c (l#65) to bypass compiler errors for 'normal' install. 

//  IMPORTANT NOTE: tcl uses unix-style slashes _inside_ tcl.

#ifndef TCL_LIBRARY

#define TCL_LIBRARY "C:/private/00000000/library/" 

#endif

#endif

static char defaultLibraryDir[sizeof(TCL_LIBRARY)+200] = TCL_LIBRARY;

/*

 * Directory in which to look for packages (each package is typically

 * installed as a subdirectory of this directory).  The symbol is

 * defined by Makefile.

 */

#ifdef __SYMBIAN32__   

// building one *.exe, giving substitute values to tclUnixInt.c (l#65) to bypass compiler errors for 'normal' install. 

//  IMPORTANT NOTE: tcl uses unix-style slashes _insode_ tcl.

#ifndef TCL_PACKAGE_PATH

#define TCL_PACKAGE_PATH "C:/private/00000000/" 

#endif

#endif

static char pkgPath[sizeof(TCL_PACKAGE_PATH)+200] = TCL_PACKAGE_PATH;

/*

 * The following table is used to map from Unix locale strings to

 * encoding files.  If HAVE_LANGINFO is defined, then this is a fallback

 * table when the result from nl_langinfo isn't a recognized encoding.

 * Otherwise this is the first list checked for a mapping from env

 * encoding to Tcl encoding name.

 */

typedef struct LocaleTable {

    CONST char *lang;

    CONST char *encoding;

} LocaleTable;

static CONST LocaleTable localeTable[] = {

#ifdef HAVE_LANGINFO

    {"gb2312-1980",	"gb2312"},

    {"ansi-1251",	"cp1251"},		/* Solaris gets this wrong. */

#ifdef __hpux

    {"SJIS",		"shiftjis"},

    {"eucjp",		"euc-jp"},

    {"euckr",		"euc-kr"},

    {"euctw",		"euc-cn"},

    {"greek8",		"cp869"},

    {"iso88591",	"iso8859-1"},

    {"iso88592",	"iso8859-2"},

    {"iso88595",	"iso8859-5"},

    {"iso88596",	"iso8859-6"},

    {"iso88597",	"iso8859-7"},

    {"iso88598",	"iso8859-8"},

    {"iso88599",	"iso8859-9"},

    {"iso885915",	"iso8859-15"},

    {"roman8",		"iso8859-1"},

    {"tis620",		"tis-620"},

    {"turkish8",	"cp857"},

    {"utf8",		"utf-8"},

#endif /* __hpux */

#endif /* HAVE_LANGINFO */

    {"ja_JP.SJIS",	"shiftjis"},

    {"ja_JP.EUC",	"euc-jp"},

    {"ja_JP.eucJP",     "euc-jp"},

    {"ja_JP.JIS",	"iso2022-jp"},

    {"ja_JP.mscode",	"shiftjis"},

    {"ja_JP.ujis",	"euc-jp"},

    {"ja_JP",		"euc-jp"},

    {"Ja_JP",		"shiftjis"},

    {"Jp_JP",		"shiftjis"},

    {"japan",		"euc-jp"},

#ifdef hpux

    {"japanese",	"shiftjis"},	

    {"ja",		"shiftjis"},	

#else

    {"japanese",	"euc-jp"},

    {"ja",		"euc-jp"},

#endif

    {"japanese.sjis",	"shiftjis"},

    {"japanese.euc",	"euc-jp"},

    {"japanese-sjis",	"shiftjis"},

    {"japanese-ujis",	"euc-jp"},

    {"ko",              "euc-kr"},

    {"ko_KR",           "euc-kr"},

    {"ko_KR.EUC",       "euc-kr"},

    {"ko_KR.euc",       "euc-kr"},

    {"ko_KR.eucKR",     "euc-kr"},

    {"korean",          "euc-kr"},

    {"ru",		"iso8859-5"},		

    {"ru_RU",		"iso8859-5"},		

    {"ru_SU",		"iso8859-5"},		

    {"zh",		"cp936"},

    {"zh_CN.gb2312",	"euc-cn"},

    {"zh_CN.GB2312",	"euc-cn"},

    {"zh_CN.GBK",	"euc-cn"},

    {"zh_TW.Big5",	"big5"},

    {"zh_TW",		"euc-tw"},

    {NULL, NULL}

};

#ifdef HAVE_COREFOUNDATION

static int		MacOSXGetLibraryPath _ANSI_ARGS_((

			    Tcl_Interp *interp, int maxPathLen,

			    char *tclLibPath));

#endif /* HAVE_COREFOUNDATION */

#if defined(__APPLE__) && (defined(TCL_LOAD_FROM_MEMORY) || ( \

	defined(TCL_THREADS) && defined(MAC_OS_X_VERSION_MIN_REQUIRED) && \

	MAC_OS_X_VERSION_MIN_REQUIRED < 1030) || ( \

	defined(__LP64__) && defined(MAC_OS_X_VERSION_MIN_REQUIRED) && \

	MAC_OS_X_VERSION_MIN_REQUIRED < 1050))

/*

 * 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

long tclMacOSXDarwinRelease = 0;

#endif

/*

 *---------------------------------------------------------------------------

 *

 * TclpInitPlatform --

 *

 *	Initialize all the platform-dependant things like signals and

 *	floating-point error handling.

 *

 *	Called at process initialization time.

 *

 * Results:

 *	None.

 *

 * Side effects:

 *	None.

 *

 *---------------------------------------------------------------------------

 */

void

TclpInitPlatform()

{

#if defined(__SYMBIAN32__) 

	// we need to use Windows file and path name convention with unix code.

	tclPlatform = TCL_PLATFORM_WINDOWS;

#else

    tclPlatform = TCL_PLATFORM_UNIX;	

#endif

    /*

     * Make sure, that the standard FDs exist. [Bug 772288]

     */

    if (TclOSseek(0, (Tcl_SeekOffset) 0, SEEK_CUR) == -1 && errno == EBADF) {

	open("/dev/null", O_RDONLY);

    }

    if (TclOSseek(1, (Tcl_SeekOffset) 0, SEEK_CUR) == -1 && errno == EBADF) {

	open("/dev/null", O_WRONLY);

    }

    if (TclOSseek(2, (Tcl_SeekOffset) 0, SEEK_CUR) == -1 && errno == EBADF) {

	open("/dev/null", O_WRONLY);

    }

    /*

     * The code below causes SIGPIPE (broken pipe) errors to

     * be ignored.  This is needed so that Tcl processes don't

     * die if they create child processes (e.g. using "exec" or

     * "open") that terminate prematurely.  The signal handler

     * is only set up when the first interpreter is created;

     * after this the application can override the handler with

     * a different one of its own, if it wants.

     */

#ifdef SIGPIPE

    (void) signal(SIGPIPE, SIG_IGN);

#endif /* SIGPIPE */

#if defined(__FreeBSD__) && defined(__GNUC__)

    /*

     * Adjust the rounding mode to be more conventional. Note that FreeBSD

     * only provides the __fpsetreg() used by the following two for the GNU

     * Compiler. When using, say, Intel's icc they break. (Partially based on

     * patch in BSD ports system from root@celsius.bychok.com)

     */

    fpsetround(FP_RN);

    fpsetmask(0L);

#endif

#if defined(__bsdi__) && (_BSDI_VERSION > 199501)

    /*

     * Find local symbols. Don't report an error if we fail.

     */

    (void) dlopen (NULL, RTLD_NOW);			/* INTL: Native. */

#endif

#ifdef GET_DARWIN_RELEASE

    {

	struct utsname name;

	if (!uname(&name)) {

	    tclMacOSXDarwinRelease = strtol(name.release, NULL, 10);

	}

    }

#endif

}

/*

 *---------------------------------------------------------------------------

 *

 * TclpInitLibraryPath --

 *

 *	Initialize the library path at startup.  We have a minor

 *	metacircular problem that we don't know the encoding of the

 *	operating system but we may need to talk to operating system

 *	to find the library directories so that we know how to talk to

 *	the operating system.

 *

 *	We do not know the encoding of the operating system.

 *	We do know that the encoding is some multibyte encoding.

 *	In that multibyte encoding, the characters 0..127 are equivalent

 *	    to ascii.

 *

 *	So although we don't know the encoding, it's safe:

 *	    to look for the last slash character in a path in the encoding.

 *	    to append an ascii string to a path.

 *	    to pass those strings back to the operating system.

 *

 *	But any strings that we remembered before we knew the encoding of

 *	the operating system must be translated to UTF-8 once we know the

 *	encoding so that the rest of Tcl can use those strings.

 *

 *	This call sets the library path to strings in the unknown native

 *	encoding.  TclpSetInitialEncodings() will translate the library

 *	path from the native encoding to UTF-8 as soon as it determines

 *	what the native encoding actually is.

 *

 *	Called at process initialization time.

 *

 * Results:

 *	Return 1, indicating that the UTF may be dirty and require "cleanup"

 *	after encodings are initialized.

 *

 * Side effects:

 *	None.

 *

 *---------------------------------------------------------------------------

 */

int

TclpInitLibraryPath(path)

CONST char *path;		/* Path to the executable in native 

				 * multi-byte encoding. */

{

#define LIBRARY_SIZE	    32

    Tcl_Obj *pathPtr, *objPtr;

    CONST char *str;

    Tcl_DString buffer, ds;

    int pathc;

    CONST char **pathv;

    char installLib[LIBRARY_SIZE], developLib[LIBRARY_SIZE];

#ifdef __SYMBIAN32__  

    int retEnv;  

    char homeEnvVariableBuf[LIBRARY_SIZE];  

    char *homeEnvVariableStr;  

#endif

    Tcl_DStringInit(&ds);

    pathPtr = Tcl_NewObj();

    /*

     * Initialize the substrings used when locating an executable.  The

     * installLib variable computes the path as though the executable

     * is installed.  The developLib computes the path as though the

     * executable is run from a develpment directory.

     */

    sprintf(installLib, "lib/tcl%s", TCL_VERSION);

    sprintf(developLib, "tcl%s/library", TCL_PATCH_LEVEL);

    /*

     * Look for the library relative to default encoding dir.

     */

    str = Tcl_GetDefaultEncodingDir();

    if ((str != NULL) && (str[0] != '\0')) {

	objPtr = Tcl_NewStringObj(str, -1);

	Tcl_ListObjAppendElement(NULL, pathPtr, objPtr);

    }

    /*

     * Look for the library relative to the TCL_LIBRARY env variable.

     * If the last dirname in the TCL_LIBRARY path does not match the

     * last dirname in the installLib variable, use the last dir name

     * of installLib in addition to the orginal TCL_LIBRARY path.

     */

#ifdef __SYMBIAN32__  

	// add setenv so that tcl has access to the TCL_LIBRARY "system" environment var.  (It can also be accessed from *.tcl scripts.)   	

	if (!getenv("HOME")) {		

	    homeEnvVariableStr = getcwd(homeEnvVariableBuf, LIBRARY_SIZE);

		if (!homeEnvVariableStr) {

			fprintf(stderr, "Error getting cwd, defaulting to SYMB_TCL_DEFAULT_HOME_DIR.\r\n");   				

		}

		/* TODO - the line bellow is a temporary patch. The defect number is: DEF116621. */

		homeEnvVariableBuf[0] = 'c';

	    tclCopySymbianPathSlashConversion(TO_TCL, homeEnvVariableStr, homeEnvVariableStr);  

    	retEnv = setenv("HOME", homeEnvVariableStr, 1);	

    	if (retEnv == -1)

    	{

			fprintf(stderr, "Error setting env(HOME)\r\n");   

    	}

	}

	// add setenv so that tcl has access to the TCL_LIBRARY "system" environment var.  (It can also be accessed from *.tcl scripts.)   

    retEnv = setenv("TCL_LIBRARY", TCL_LIBRARY, 1);		

    if (retEnv == -1)

    {

		fprintf(stderr, "Error setting env(TCL_LIBRARY)\r\n");   

    }

	// add setenv so that tcl has access to the TCL_LIBRARY "system" environment var 'tcllibpath' in init.tcl.  (It can also be accessed from *.tcl scripts.)   

    retEnv = setenv("TCLLIBPATH", TCL_LIBRARY, 1);		

    if (retEnv == -1)

    {

		fprintf(stderr, "Error setting env(TCLLIBPATH)\r\n");   

    }

#endif    

    str = getenv("TCL_LIBRARY");			/* INTL: Native. */

    Tcl_ExternalToUtfDString(NULL, str, -1, &buffer);

    str = Tcl_DStringValue(&buffer);

    if ((str != NULL) && (str[0] != '\0')) {

	/*

	 * If TCL_LIBRARY is set, search there.

	 */

	objPtr = Tcl_NewStringObj(str, -1);

	Tcl_ListObjAppendElement(NULL, pathPtr, objPtr);

	Tcl_SplitPath(str, &pathc, &pathv);

	if ((pathc > 0) && (strcasecmp(installLib + 4, pathv[pathc-1]) != 0)) {

	    /*

	     * If TCL_LIBRARY is set but refers to a different tcl

	     * installation than the current version, try fiddling with the

	     * specified directory to make it refer to this installation by

	     * removing the old "tclX.Y" and substituting the current

	     * version string.

	     */

	    pathv[pathc - 1] = installLib + 4;

	    str = Tcl_JoinPath(pathc, pathv, &ds);

	    objPtr = Tcl_NewStringObj(str, Tcl_DStringLength(&ds));

	    Tcl_ListObjAppendElement(NULL, pathPtr, objPtr);

	    Tcl_DStringFree(&ds);

	}

	ckfree((char *) pathv);

    }

    /*

     * Look for the library relative to the executable.  This algorithm

     * should be the same as the one in the tcl_findLibrary procedure.

     *

     * This code looks in the following directories:

     *

     *	<bindir>/../<installLib>

     *	  (e.g. /usr/local/bin/../lib/tcl8.4)

     *	<bindir>/../../<installLib>

     *	  (e.g. /usr/local/TclPro/solaris-sparc/bin/../../lib/tcl8.4)

     *	<bindir>/../library

     *	  (e.g. /usr/src/tcl8.4.0/unix/../library)

     *	<bindir>/../../library

     *	  (e.g. /usr/src/tcl8.4.0/unix/solaris-sparc/../../library)

     *	<bindir>/../../<developLib>

     *	  (e.g. /usr/src/tcl8.4.0/unix/../../tcl8.4.0/library)

     *	<bindir>/../../../<developLib>

     *	  (e.g. /usr/src/tcl8.4.0/unix/solaris-sparc/../../../tcl8.4.0/library)

     */

     /*

      * The variable path holds an absolute path.  Take care not to

      * overwrite pathv[0] since that might produce a relative path.

      */

#ifndef __SYMBIAN32__

    if (path != NULL) {

	int i, origc;

	CONST char **origv;

	Tcl_SplitPath(path, &origc, &origv);

	pathc = 0;

	pathv = (CONST char **) ckalloc((unsigned int)(origc * sizeof(char *)));

	for (i=0; i< origc; i++) {

	    if (origv[i][0] == '.') {

		if (strcmp(origv[i], ".") == 0) {

		    // do nothing //

		} else if (strcmp(origv[i], "..") == 0) {

		    pathc--;

		} else {

		    pathv[pathc++] = origv[i];

		}

	    } else {

		pathv[pathc++] = origv[i];

	    }

	}

	if (pathc > 2) {

	    str = pathv[pathc - 2];

	    pathv[pathc - 2] = installLib;

	    path = Tcl_JoinPath(pathc - 1, pathv, &ds);

	    pathv[pathc - 2] = str;

	    objPtr = Tcl_NewStringObj(path, Tcl_DStringLength(&ds));

	    Tcl_ListObjAppendElement(NULL, pathPtr, objPtr);

	    Tcl_DStringFree(&ds);

	}

	if (pathc > 3) {

	    str = pathv[pathc - 3];

	    pathv[pathc - 3] = installLib;

	    path = Tcl_JoinPath(pathc - 2, pathv, &ds);

	    pathv[pathc - 3] = str;

	    objPtr = Tcl_NewStringObj(path, Tcl_DStringLength(&ds));

	    Tcl_ListObjAppendElement(NULL, pathPtr, objPtr);

	    Tcl_DStringFree(&ds);

	}

	if (pathc > 2) {

	    str = pathv[pathc - 2];

	    pathv[pathc - 2] = "library";

	    path = Tcl_JoinPath(pathc - 1, pathv, &ds);

	    pathv[pathc - 2] = str;

	    objPtr = Tcl_NewStringObj(path, Tcl_DStringLength(&ds));

	    Tcl_ListObjAppendElement(NULL, pathPtr, objPtr);

	    Tcl_DStringFree(&ds);

	}

	if (pathc > 3) {

	    str = pathv[pathc - 3];

	    pathv[pathc - 3] = "library";

	    path = Tcl_JoinPath(pathc - 2, pathv, &ds);

	    pathv[pathc - 3] = str;

	    objPtr = Tcl_NewStringObj(path, Tcl_DStringLength(&ds));

	    Tcl_ListObjAppendElement(NULL, pathPtr, objPtr);

	    Tcl_DStringFree(&ds);

	}

	if (pathc > 3) {

	    str = pathv[pathc - 3];

	    pathv[pathc - 3] = developLib;

	    path = Tcl_JoinPath(pathc - 2, pathv, &ds);

	    pathv[pathc - 3] = str;

	    objPtr = Tcl_NewStringObj(path, Tcl_DStringLength(&ds));

	    Tcl_ListObjAppendElement(NULL, pathPtr, objPtr);

	    Tcl_DStringFree(&ds);

	}

	if (pathc > 4) {

	    str = pathv[pathc - 4];

	    pathv[pathc - 4] = developLib;

	    path = Tcl_JoinPath(pathc - 3, pathv, &ds);

	    pathv[pathc - 4] = str;

	    objPtr = Tcl_NewStringObj(path, Tcl_DStringLength(&ds));

	    Tcl_ListObjAppendElement(NULL, pathPtr, objPtr);

	    Tcl_DStringFree(&ds);

	}

	ckfree((char *) origv);

	ckfree((char *) pathv);

    }

#endif    

    /*

     * Finally, look for the library relative to the compiled-in path.

     * This is needed when users install Tcl with an exec-prefix that

     * is different from the prtefix.

     */

    {

#ifdef HAVE_COREFOUNDATION

    char tclLibPath[MAXPATHLEN + 1];

    if (MacOSXGetLibraryPath(NULL, MAXPATHLEN, tclLibPath) == TCL_OK) {

        str = tclLibPath;

    } else

#endif /* HAVE_COREFOUNDATION */

    {

        str = defaultLibraryDir;

    }

    if (str[0] != '\0') {

        objPtr = Tcl_NewStringObj(str, -1);

        Tcl_ListObjAppendElement(NULL, pathPtr, objPtr);

    }

    }

    TclSetLibraryPath(pathPtr);    

    Tcl_DStringFree(&buffer);

    return 1; /* 1 indicates that pathPtr may be dirty utf (needs cleaning) */

}

/*

 *---------------------------------------------------------------------------

 *

 * TclpSetInitialEncodings --

 *

 *	Based on the locale, determine the encoding of the operating

 *	system and the default encoding for newly opened files.

 *

 *	Called at process initialization time, and part way through

 *	startup, we verify that the initial encodings were correctly

 *	setup.  Depending on Tcl's environment, there may not have been

 *	enough information first time through (above).

 *

 * Results:

 *	None.

 *

 * Side effects:

 *	The Tcl library path is converted from native encoding to UTF-8,

 *	on the first call, and the encodings may be changed on first or

 *	second call.

 *

 *---------------------------------------------------------------------------

 */

void

TclpSetInitialEncodings()

{

	CONST char *encoding = NULL;

	int i, setSysEncCode = TCL_ERROR;

	Tcl_Obj *pathPtr;

	/*

	 * Determine the current encoding from the LC_* or LANG environment

	 * variables.  We previously used setlocale() to determine the locale,

	 * but this does not work on some systems (e.g. Linux/i386 RH 5.0).

	 */

#ifdef HAVE_LANGINFO

	if (

#ifdef WEAK_IMPORT_NL_LANGINFO

		nl_langinfo != NULL &&

#endif

		setlocale(LC_CTYPE, "") != NULL) {

	    Tcl_DString ds;

	    /*

	     * Use a DString so we can overwrite it in name compatability

	     * checks below.

	     */

	    Tcl_DStringInit(&ds);

	    encoding = Tcl_DStringAppend(&ds, nl_langinfo(CODESET), -1);

	    Tcl_UtfToLower(Tcl_DStringValue(&ds));

#ifdef HAVE_LANGINFO_DEBUG

	    fprintf(stderr, "encoding '%s'\r\n", encoding);

#endif

	    if (encoding[0] == 'i' && encoding[1] == 's' && encoding[2] == 'o'

		    && encoding[3] == '-') {

		char *p, *q;

		/* need to strip '-' from iso-* encoding */

		for(p = Tcl_DStringValue(&ds)+3, q = Tcl_DStringValue(&ds)+4;

		    *p; *p++ = *q++);

	    } else if (encoding[0] == 'i' && encoding[1] == 'b'

		    && encoding[2] == 'm' && encoding[3] >= '0'

		    && encoding[3] <= '9') {

		char *p, *q;

		/* if langinfo reports "ibm*" we should use "cp*" */

		p = Tcl_DStringValue(&ds);

		*p++ = 'c'; *p++ = 'p';

		for(q = p+1; *p ; *p++ = *q++);

	    } else if ((*encoding == '\0')

		    || !strcmp(encoding, "ansi_x3.4-1968")) {

		/* Use iso8859-1 for empty or 'ansi_x3.4-1968' encoding */

		encoding = "iso8859-1";

	    }

#ifdef HAVE_LANGINFO_DEBUG

	    fprintf(stderr, " ?%s?\r\n", encoding);

#endif

	    setSysEncCode = Tcl_SetSystemEncoding(NULL, encoding);

	    if (setSysEncCode != TCL_OK) {

		/*

		 * If this doesn't return TCL_OK, the encoding returned by

		 * nl_langinfo or as we translated it wasn't accepted.  Do

		 * this fallback check.  If this fails, we will enter the

		 * old fallback below.

		 */

		for (i = 0; localeTable[i].lang != NULL; i++) {

		    if (strcmp(localeTable[i].lang, encoding) == 0) {

			setSysEncCode = Tcl_SetSystemEncoding(NULL,

				localeTable[i].encoding);

			break;

		    }

		}

	    }

#ifdef HAVE_LANGINFO_DEBUG

	    fprintf(stderr, " => '%s'\n", encoding);

#endif

	    Tcl_DStringFree(&ds);

	}

#ifdef HAVE_LANGINFO_DEBUG

	else {

	    fprintf(stderr, "setlocale returned NULL\n");

	}

#endif

#endif /* HAVE_LANGINFO */

	if (setSysEncCode != TCL_OK) {

	    /*

	     * Classic fallback check.  This tries a homebrew algorithm to

	     * determine what encoding should be used based on env vars.

	     */

	    char *langEnv = getenv("LC_ALL");

	    encoding = NULL;

	    if (langEnv == NULL || langEnv[0] == '\0') {

		langEnv = getenv("LC_CTYPE");

	    }

	    if (langEnv == NULL || langEnv[0] == '\0') {

		langEnv = getenv("LANG");

	    }

	    if (langEnv == NULL || langEnv[0] == '\0') {

		langEnv = NULL;

	    }

	    if (langEnv != NULL) {

		for (i = 0; localeTable[i].lang != NULL; i++) {

		    if (strcmp(localeTable[i].lang, langEnv) == 0) {

			encoding = localeTable[i].encoding;

			break;

		    }

		}

		/*

		 * There was no mapping in the locale table.  If there is an

		 * encoding subfield, we can try to guess from that.

		 */

		if (encoding == NULL) {

		    char *p;

		    for (p = langEnv; *p != '\0'; p++) {

			if (*p == '.') {

			    p++;

			    break;

			}

		    }

		    if (*p != '\0') {

			Tcl_DString ds;

			Tcl_DStringInit(&ds);

			encoding = Tcl_DStringAppend(&ds, p, -1);

			Tcl_UtfToLower(Tcl_DStringValue(&ds));

			setSysEncCode = Tcl_SetSystemEncoding(NULL, encoding);

			if (setSysEncCode != TCL_OK) {

			    encoding = NULL;

			}

			Tcl_DStringFree(&ds);

		    }

		}

#ifdef HAVE_LANGINFO_DEBUG

		fprintf(stderr, "encoding fallback check '%s' => '%s'\n",

			langEnv, encoding);

#endif

	    }

	    if (setSysEncCode != TCL_OK) {

		if (encoding == NULL) {

		    encoding = TCL_DEFAULT_ENCODING;

		}

		Tcl_SetSystemEncoding(NULL, encoding);

	    }

	    /*

	     * Initialize the C library's locale subsystem.  This is required

	     * for input methods to work properly on X11.  We only do this for

	     * LC_CTYPE because that's the necessary one, and we don't want to

	     * affect LC_TIME here.  The side effect of setting the default

	     * locale should be to load any locale specific modules that are

	     * needed by X.  [BUG: 5422 3345 4236 2522 2521].

	     * In HAVE_LANGINFO, this call is already done above.

	     */

#ifndef HAVE_LANGINFO

	    setlocale(LC_CTYPE, "");

#endif

	}

	/*

	 * In case the initial locale is not "C", ensure that the numeric

	 * processing is done in "C" locale regardless.  This is needed because

	 * Tcl relies on routines like strtod, but should not have locale

	 * dependent behavior.

	 */

	setlocale(LC_NUMERIC, "C");

    if ((libraryPathEncodingFixed == 0) && strcmp("identity",

	    Tcl_GetEncodingName(Tcl_GetEncoding(NULL, NULL))) ) {

	/*

	 * Until the system encoding was actually set, the library path was

	 * actually in the native multi-byte encoding, and not really UTF-8

	 * as advertised.  We cheated as follows:

	 *

	 * 1. It was safe to allow the Tcl_SetSystemEncoding() call to 

	 * append the ASCII chars that make up the encoding's filename to 

	 * the names (in the native encoding) of directories in the library 

	 * path, since all Unix multi-byte encodings have ASCII in the

	 * beginning.

	 *

	 * 2. To open the encoding file, the native bytes in the file name

	 * were passed to the OS, without translating from UTF-8 to native,

	 * because the name was already in the native encoding.

	 *

	 * Now that the system encoding was actually successfully set,

	 * translate all the names in the library path to UTF-8.  That way,

	 * next time we search the library path, we'll translate the names 

	 * from UTF-8 to the system encoding which will be the native 

	 * encoding.

	 */

	pathPtr = TclGetLibraryPath();

	if (pathPtr != NULL) {

	    int objc;

	    Tcl_Obj **objv;

	    objc = 0;

	    Tcl_ListObjGetElements(NULL, pathPtr, &objc, &objv);

	    for (i = 0; i < objc; i++) {

		int length;

		char *string;

		Tcl_DString ds;

		string = Tcl_GetStringFromObj(objv[i], &length);

		Tcl_ExternalToUtfDString(NULL, string, length, &ds);

		Tcl_SetStringObj(objv[i], Tcl_DStringValue(&ds), 

			Tcl_DStringLength(&ds));

		Tcl_DStringFree(&ds);

	    }

	}

	libraryPathEncodingFixed = 1;

    }

    /* This is only ever called from the startup thread */

    if (binaryEncoding == NULL) {

	/*

	 * Keep the iso8859-1 encoding preloaded.  The IO package uses

	 * it for gets on a binary channel.

	 */

	binaryEncoding = Tcl_GetEncoding(NULL, "iso8859-1");

    }

}

/*

 *---------------------------------------------------------------------------

 *

 * TclpSetVariables --

 *

 *	Performs platform-specific interpreter initialization related to

 *	the tcl_library and tcl_platform variables, and other platform-

 *	specific things.

 *

 * Results:

 *	None.

 *

 * Side effects:

 *	Sets "tclDefaultLibrary", "tcl_pkgPath", and "tcl_platform" Tcl

 *	variables.

 *

 *----------------------------------------------------------------------

 */

void

TclpSetVariables(interp)

    Tcl_Interp *interp;

{

#ifndef NO_UNAME

    struct utsname name;

#endif

    int unameOK;

    CONST char *user;

    Tcl_DString ds;

#ifdef HAVE_COREFOUNDATION

    char tclLibPath[MAXPATHLEN + 1];

#if MAC_OS_X_VERSION_MAX_ALLOWED > 1020

    /*

     * Set msgcat fallback locale to current CFLocale identifier.

     */

    CFLocaleRef localeRef;

    if (CFLocaleCopyCurrent != NULL && CFLocaleGetIdentifier != NULL &&

	    (localeRef = CFLocaleCopyCurrent())) {

	CFStringRef locale = CFLocaleGetIdentifier(localeRef);

	if (locale) {

	    char loc[256];

	    if (CFStringGetCString(locale, loc, 256, kCFStringEncodingUTF8)) {

		if (!Tcl_CreateNamespace(interp, "::tcl::mac", NULL, NULL)) {

		    Tcl_ResetResult(interp);

		}

		Tcl_SetVar(interp, "::tcl::mac::locale", loc, TCL_GLOBAL_ONLY);

	    }

	}

	CFRelease(localeRef);

    }

#endif

    if (MacOSXGetLibraryPath(interp, MAXPATHLEN, tclLibPath) == TCL_OK) {

        CONST char *str;

        Tcl_DString ds;

        CFBundleRef bundleRef;

        Tcl_SetVar(interp, "tclDefaultLibrary", tclLibPath, 

                TCL_GLOBAL_ONLY);

        Tcl_SetVar(interp, "tcl_pkgPath", tclLibPath,

                TCL_GLOBAL_ONLY);

        Tcl_SetVar(interp, "tcl_pkgPath", " ",

                TCL_GLOBAL_ONLY | TCL_APPEND_VALUE);

        str = TclGetEnv("DYLD_FRAMEWORK_PATH", &ds);

        if ((str != NULL) && (str[0] != '\0')) {

            char *p = Tcl_DStringValue(&ds);

            /* convert DYLD_FRAMEWORK_PATH from colon to space separated */

            do {

                if(*p == ':') *p = ' ';

            } while (*p++);

            Tcl_SetVar(interp, "tcl_pkgPath", Tcl_DStringValue(&ds),

                    TCL_GLOBAL_ONLY | TCL_APPEND_VALUE);

            Tcl_SetVar(interp, "tcl_pkgPath", " ",

                    TCL_GLOBAL_ONLY | TCL_APPEND_VALUE);

            Tcl_DStringFree(&ds);

        }

        if ((bundleRef = CFBundleGetMainBundle())) {

            CFURLRef frameworksURL;

            Tcl_StatBuf statBuf;

            if((frameworksURL = CFBundleCopyPrivateFrameworksURL(bundleRef))) {

                if(CFURLGetFileSystemRepresentation(frameworksURL, TRUE,

                            (unsigned char*) tclLibPath, MAXPATHLEN) &&

                        ! TclOSstat(tclLibPath, &statBuf) &&

                        S_ISDIR(statBuf.st_mode)) {

                    Tcl_SetVar(interp, "tcl_pkgPath", tclLibPath,

                            TCL_GLOBAL_ONLY | TCL_APPEND_VALUE);

                    Tcl_SetVar(interp, "tcl_pkgPath", " ",

                            TCL_GLOBAL_ONLY | TCL_APPEND_VALUE);

                }

                CFRelease(frameworksURL);

            }

            if((frameworksURL = CFBundleCopySharedFrameworksURL(bundleRef))) {

                if(CFURLGetFileSystemRepresentation(frameworksURL, TRUE,

                            (unsigned char*) tclLibPath, MAXPATHLEN) &&

                        ! TclOSstat(tclLibPath, &statBuf) &&

                        S_ISDIR(statBuf.st_mode)) {

                    Tcl_SetVar(interp, "tcl_pkgPath", tclLibPath,

                            TCL_GLOBAL_ONLY | TCL_APPEND_VALUE);

                    Tcl_SetVar(interp, "tcl_pkgPath", " ",

                            TCL_GLOBAL_ONLY | TCL_APPEND_VALUE);

                }

                CFRelease(frameworksURL);

            }

        }

        Tcl_SetVar(interp, "tcl_pkgPath", pkgPath,

                TCL_GLOBAL_ONLY | TCL_APPEND_VALUE);

    } else

#endif /* HAVE_COREFOUNDATION */

    {

        Tcl_SetVar(interp, "tclDefaultLibrary", defaultLibraryDir, 

                TCL_GLOBAL_ONLY);

        Tcl_SetVar(interp, "tcl_pkgPath", pkgPath, TCL_GLOBAL_ONLY);

    }

#ifdef DJGPP

    Tcl_SetVar2(interp, "tcl_platform", "platform", "dos", TCL_GLOBAL_ONLY);

#else

    Tcl_SetVar2(interp, "tcl_platform", "platform", "symbian", TCL_GLOBAL_ONLY);

#endif

    unameOK = 0;

#ifndef NO_UNAME

    if (uname(&name) >= 0) {

	CONST char *native;

	unameOK = 1;

	native = Tcl_ExternalToUtfDString(NULL, name.sysname, -1, &ds);

	Tcl_SetVar2(interp, "tcl_platform", "os", native, TCL_GLOBAL_ONLY);

	Tcl_DStringFree(&ds);

	/*

	 * The following code is a special hack to handle differences in

	 * the way version information is returned by uname.  On most

	 * systems the full version number is available in name.release.

	 * However, under AIX the major version number is in

	 * name.version and the minor version number is in name.release.

	 */

	if ((strchr(name.release, '.') != NULL)

		|| !isdigit(UCHAR(name.version[0]))) {	/* INTL: digit */

	    Tcl_SetVar2(interp, "tcl_platform", "osVersion", name.release,

		    TCL_GLOBAL_ONLY);

	} else {

	    Tcl_SetVar2(interp, "tcl_platform", "osVersion", name.version,

		    TCL_GLOBAL_ONLY);

	    Tcl_SetVar2(interp, "tcl_platform", "osVersion", ".",

		    TCL_GLOBAL_ONLY|TCL_APPEND_VALUE);

	    Tcl_SetVar2(interp, "tcl_platform", "osVersion", name.release,

		    TCL_GLOBAL_ONLY|TCL_APPEND_VALUE);

	}

	Tcl_SetVar2(interp, "tcl_platform", "machine", name.machine,

		TCL_GLOBAL_ONLY);

    }

#ifdef __SYMBIAN32__

	// Symbian P.I.P.S. is a "flavour of" unix in that it's an emulation layer. 

    Tcl_SetVar2(interp, "tcl_platform", "osSystemName", name.sysname, TCL_GLOBAL_ONLY);

#endif    

#endif

    if (!unameOK) {

	  Tcl_SetVar2(interp, "tcl_platform", "os", "", TCL_GLOBAL_ONLY);

	  Tcl_SetVar2(interp, "tcl_platform", "osVersion", "", TCL_GLOBAL_ONLY);

	  Tcl_SetVar2(interp, "tcl_platform", "machine", "", TCL_GLOBAL_ONLY);

    }

    /*

     * Copy USER or LOGNAME environment variable into tcl_platform(user)

     */

    Tcl_DStringInit(&ds);

    user = TclGetEnv("USER", &ds);

    if (user == NULL) {

	user = TclGetEnv("LOGNAME", &ds);

	if (user == NULL) {