/[dtapublic]/projs/trunk/shared_source/c_tcl_base_7_5_w_mods/tclwininit.c

Diff of /projs/trunk/shared_source/c_tcl_base_7_5_w_mods/tclwininit.c

Parent Directory | Revision Log | View Patch Patch

-revision 67 by dashley,
Mon Oct 31 00:57:34 2016 UTC
+revision 71 by dashley,
Sat Nov  5 11:07:06 2016 UTC
 Line 1
  /* $Header$ */
  /*
   * tclWinInit.c --
   *
   *      Contains the Windows-specific interpreter initialization functions.
   *
   * Copyright (c) 1994-1997 Sun Microsystems, Inc.
   * Copyright (c) 1998-1999 by Scriptics Corporation.
   * All rights reserved.
   *
   * RCS: @(#) $Id: tclwininit.c,v 1.1.1.1 2001/06/13 04:49:17 dtashley Exp $
   */
  #include "tclWinInt.h"
  #include <winreg.h>
  #include <winnt.h>
  #include <winbase.h>
  /*
   * The following macro can be defined at compile time to specify
   * the root of the Tcl registry keys.
   */
  #ifndef TCL_REGISTRY_KEY
  #define TCL_REGISTRY_KEY "Software\\Scriptics\\Tcl\\" TCL_VERSION
  #endif
  /*
   * The following declaration is a workaround for some Microsoft brain damage.
   * The SYSTEM_INFO structure is different in various releases, even though the
   * layout is the same.  So we overlay our own structure on top of it so we
   * can access the interesting slots in a uniform way.
   */
  typedef struct {
      WORD wProcessorArchitecture;
      WORD wReserved;
  } OemId;
  /*
   * The following macros are missing from some versions of winnt.h.
   */
  #ifndef PROCESSOR_ARCHITECTURE_INTEL
  #define PROCESSOR_ARCHITECTURE_INTEL 0
  #endif
  #ifndef PROCESSOR_ARCHITECTURE_MIPS
  #define PROCESSOR_ARCHITECTURE_MIPS  1
  #endif
  #ifndef PROCESSOR_ARCHITECTURE_ALPHA
  #define PROCESSOR_ARCHITECTURE_ALPHA 2
  #endif
  #ifndef PROCESSOR_ARCHITECTURE_PPC
  #define PROCESSOR_ARCHITECTURE_PPC   3
  #endif
  #ifndef PROCESSOR_ARCHITECTURE_UNKNOWN
  #define PROCESSOR_ARCHITECTURE_UNKNOWN 0xFFFF
  #endif
  /*
   * The following arrays contain the human readable strings for the Windows
   * platform and processor values.
   */
  #define NUMPLATFORMS 3
  static char* platforms[NUMPLATFORMS] = {
      "Win32s", "Windows 95", "Windows NT"
  };
  #define NUMPROCESSORS 4
  static char* processors[NUMPROCESSORS] = {
      "intel", "mips", "alpha", "ppc"
  };
  /*
   * Thread id used for asynchronous notification from signal handlers.
   */
  static DWORD mainThreadId;
  /*
   * The Init script (common to Windows and Unix platforms) is
   * defined in tkInitScript.h
   */
  #include "tclInitScript.h"
  static void             AppendEnvironment(Tcl_Obj *listPtr, CONST char *lib);
  static void             AppendDllPath(Tcl_Obj *listPtr, HMODULE hModule,
                              CONST char *lib);
  static void             AppendRegistry(Tcl_Obj *listPtr, CONST char *lib);
  static int              ToUtf(CONST WCHAR *wSrc, char *dst);
  /*
   *---------------------------------------------------------------------------
   *
   * 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()
  {
      tclPlatform = TCL_PLATFORM_WINDOWS;
      /*
       * The following code stops Windows 3.X and Windows NT 3.51 from
       * automatically putting up Sharing Violation dialogs, e.g, when
       * someone tries to access a file that is locked or a drive with no
       * disk in it.  Tcl already returns the appropriate error to the
       * caller, and they can decide to put up their own dialog in response
       * to that failure.
       *
       * Under 95 and NT 4.0, this is a NOOP because the system doesn't
       * automatically put up dialogs when the above operations fail.
       */
      SetErrorMode(SetErrorMode(0) | SEM_FAILCRITICALERRORS);
      /*
       * Save the id of the first thread to intialize the Tcl library.  This
       * thread will be used to handle notifications from async event
       * procedures.  This is not strictly correct.  A better solution involves
       * using a designated "main" notifier that is kept up to date as threads
       * come and go.
       */
      mainThreadId = GetCurrentThreadId();
  #ifdef STATIC_BUILD
      /*
       * If we are in a statically linked executable, then we need to
       * explicitly initialize the Windows function tables here since
       * DllMain() will not be invoked.
       */
      TclWinInit(GetModuleHandle(NULL));
  #endif
  }
  /*
   *---------------------------------------------------------------------------
   *
   * TclpInitLibraryPath --
   *
   *      Initialize the library path at startup.
   *
   *      This call sets the library path to strings in UTF-8. Any
   *      pre-existing library path information is assumed to have been
   *      in the native multibyte encoding.
   *
   *      Called at process initialization time.
   *
   * Results:
   *      None.
   *
   * Side effects:
   *      None.
   *
   *---------------------------------------------------------------------------
   */
  void
  TclpInitLibraryPath(path)
      CONST char *path;           /* Potentially dirty UTF string that is */
                                  /* the path to the executable name.     */
  {
  #define LIBRARY_SIZE        32
      Tcl_Obj *pathPtr, *objPtr;
      char *str;
      Tcl_DString ds;
      int pathc;
      char **pathv;
      char installLib[LIBRARY_SIZE], developLib[LIBRARY_SIZE];
      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_RELEASE_LEVEL < 2) ? TCL_PATCH_LEVEL : TCL_VERSION));
      /*
       * 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.
       */
      AppendEnvironment(pathPtr, installLib);
      /*
       * Look for the library relative to the DLL.  Only use the installLib
       * because in practice, the DLL is always installed.
       */
      AppendDllPath(pathPtr, TclWinGetTclInstance(), installLib);
      /*
       * 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.2)
       *  <bindir>/../../<installLib>
       *          (e.g. /usr/local/TclPro/solaris-sparc/bin/../../lib/tcl8.2)
       *  <bindir>/../library
       *          (e.g. /usr/src/tcl8.2/unix/../library)
       *  <bindir>/../../library
       *          (e.g. /usr/src/tcl8.2/unix/solaris-sparc/../../library)
       *  <bindir>/../../<developLib>
       *          (e.g. /usr/src/tcl8.2/unix/../../tcl8.2/library)
       *  <bindir>/../../../<devlopLib>
       *          (e.g. /usr/src/tcl8.2/unix/solaris-sparc/../../../tcl8.2/library)
       */
      if (path != NULL) {
          Tcl_SplitPath(path, &pathc, &pathv);
          if (pathc > 1) {
              pathv[pathc - 2] = installLib;
              path = Tcl_JoinPath(pathc - 1, pathv, &ds);
              objPtr = Tcl_NewStringObj(path, Tcl_DStringLength(&ds));
              Tcl_ListObjAppendElement(NULL, pathPtr, objPtr);
              Tcl_DStringFree(&ds);
          }
          if (pathc > 2) {
              pathv[pathc - 3] = installLib;
              path = Tcl_JoinPath(pathc - 2, pathv, &ds);
              objPtr = Tcl_NewStringObj(path, Tcl_DStringLength(&ds));
              Tcl_ListObjAppendElement(NULL, pathPtr, objPtr);
              Tcl_DStringFree(&ds);
          }
          if (pathc > 1) {
              pathv[pathc - 2] = "library";
              path = Tcl_JoinPath(pathc - 1, pathv, &ds);
              objPtr = Tcl_NewStringObj(path, Tcl_DStringLength(&ds));
              Tcl_ListObjAppendElement(NULL, pathPtr, objPtr);
              Tcl_DStringFree(&ds);
          }
          if (pathc > 2) {
              pathv[pathc - 3] = "library";
              path = Tcl_JoinPath(pathc - 2, pathv, &ds);
              objPtr = Tcl_NewStringObj(path, Tcl_DStringLength(&ds));
              Tcl_ListObjAppendElement(NULL, pathPtr, objPtr);
              Tcl_DStringFree(&ds);
          }
          if (pathc > 1) {
              pathv[pathc - 3] = developLib;
              path = Tcl_JoinPath(pathc - 2, pathv, &ds);
              objPtr = Tcl_NewStringObj(path, Tcl_DStringLength(&ds));
              Tcl_ListObjAppendElement(NULL, pathPtr, objPtr);
              Tcl_DStringFree(&ds);
          }
          if (pathc > 3) {
              pathv[pathc - 4] = developLib;
              path = Tcl_JoinPath(pathc - 3, pathv, &ds);
              objPtr = Tcl_NewStringObj(path, Tcl_DStringLength(&ds));
              Tcl_ListObjAppendElement(NULL, pathPtr, objPtr);
              Tcl_DStringFree(&ds);
          }
          ckfree((char *) pathv);
      }
      TclSetLibraryPath(pathPtr);
  }
  /*
   *---------------------------------------------------------------------------
   *
   * AppendEnvironment --
   *
   *      Append the value of the TCL_LIBRARY environment variable onto the
   *      path pointer.  If the env variable points to another version of
   *      tcl (e.g. "tcl7.6") also append the path to this version (e.g.,
   *      "tcl7.6/../tcl8.2")
   *
   * Results:
   *      None.
   *
   * Side effects:
   *      None.
   *
   *---------------------------------------------------------------------------
   */
  static void
  AppendEnvironment(
      Tcl_Obj *pathPtr,
      CONST char *lib)
  {
      int pathc;
      WCHAR wBuf[MAX_PATH];
      char buf[MAX_PATH * TCL_UTF_MAX];
      Tcl_Obj *objPtr;
      char *str;
      Tcl_DString ds;
      char **pathv;
      /*
       * The "L" preceeding the TCL_LIBRARY string is used to tell VC++
       * that this is a unicode string.
       */
      if (GetEnvironmentVariableW(L"TCL_LIBRARY", wBuf, MAX_PATH) == 0) {
          buf[0] = '\0';
          GetEnvironmentVariableA("TCL_LIBRARY", buf, MAX_PATH);
      } else {
          ToUtf(wBuf, buf);
      }
      if (buf[0] != '\0') {
          objPtr = Tcl_NewStringObj(buf, -1);
          Tcl_ListObjAppendElement(NULL, pathPtr, objPtr);
          TclWinNoBackslash(buf);
          Tcl_SplitPath(buf, &pathc, &pathv);
          /*
           * The lstrcmpi() will work even if pathv[pathc - 1] is random
           * UTF-8 chars because I know lib is ascii.
           */
          if ((pathc > 0) && (lstrcmpiA(lib + 4, pathv[pathc - 1]) != 0)) {
              /*
               * 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] = (char *) (lib + 4);
              Tcl_DStringInit(&ds);
              str = Tcl_JoinPath(pathc, pathv, &ds);
              objPtr = Tcl_NewStringObj(str, Tcl_DStringLength(&ds));
              Tcl_DStringFree(&ds);
          } else {
              objPtr = Tcl_NewStringObj(buf, -1);
          }
          Tcl_ListObjAppendElement(NULL, pathPtr, objPtr);
          ckfree((char *) pathv);
      }
  }
  /*
   *---------------------------------------------------------------------------
   *
   * AppendDllPath --
   *
   *      Append a path onto the path pointer that tries to locate the Tcl
   *      library relative to the location of the Tcl DLL.
   *
   * Results:
   *      None.
   *
   * Side effects:
   *      None.
   *
   *---------------------------------------------------------------------------
   */
  static void
  AppendDllPath(
      Tcl_Obj *pathPtr,
      HMODULE hModule,
      CONST char *lib)
  {
      WCHAR wName[MAX_PATH + LIBRARY_SIZE];
      char name[(MAX_PATH + LIBRARY_SIZE) * TCL_UTF_MAX];
      if (GetModuleFileNameW(hModule, wName, MAX_PATH) == 0) {
          GetModuleFileNameA(hModule, name, MAX_PATH);
      } else {
          ToUtf(wName, name);
      }
      if (lib != NULL) {
          char *end, *p;
          end = strrchr(name, '\\');
          *end = '\0';
          p = strrchr(name, '\\');
          if (p != NULL) {
              end = p;
          }
          *end = '\\';
          strcpy(end + 1, lib);
      }
      TclWinNoBackslash(name);
      Tcl_ListObjAppendElement(NULL, pathPtr, Tcl_NewStringObj(name, -1));
  }
  /*
   *---------------------------------------------------------------------------
   *
   * ToUtf --
   *
   *      Convert a char string to a UTF string.
   *
   * Results:
   *      None.
   *
   * Side effects:
   *      None.
   *
   *---------------------------------------------------------------------------
   */
  static int
  ToUtf(
      CONST WCHAR *wSrc,
      char *dst)
  {
      char *start;
      start = dst;
      while (*wSrc != '\0') {
          dst += Tcl_UniCharToUtf(*wSrc, dst);
          wSrc++;
      }
      *dst = '\0';
      return dst - start;
  }
  /*
   *---------------------------------------------------------------------------
   *
   * 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.
   *
   * Results:
   *      None.
   *
   * Side effects:
   *      The Tcl library path is converted from native encoding to UTF-8.
   *
   *---------------------------------------------------------------------------
   */
  void
  TclpSetInitialEncodings()
  {
      CONST char *encoding;
      char buf[4 + TCL_INTEGER_SPACE];
      int platformId;
      Tcl_Obj *pathPtr;
      platformId = TclWinGetPlatformId();
      TclWinSetInterfaces(platformId == VER_PLATFORM_WIN32_NT);
      wsprintfA(buf, "cp%d", GetACP());
      Tcl_SetSystemEncoding(NULL, buf);
      if (platformId != VER_PLATFORM_WIN32_NT) {
          pathPtr = TclGetLibraryPath();
          if (pathPtr != NULL) {
              int i, 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);
              }
          }
      }
      /*
       * Keep this encoding preloaded.  The IO package uses it for gets on a
       * binary channel.
       */
      encoding = "iso8859-1";
      Tcl_GetEncoding(NULL, encoding);
  }
  /*
   *---------------------------------------------------------------------------
   *
   * TclpSetVariables --
   *
   *      Performs platform-specific interpreter initialization related to
   *      the tcl_platform and env variables, and other platform-specific
   *      things.
   *
   * Results:
   *      None.
   *
   * Side effects:
   *      Sets "tclDefaultLibrary", "tcl_platform", and "env(HOME)" Tcl
   *      variables.
   *
   *----------------------------------------------------------------------
   */
  void
  TclpSetVariables(interp)
      Tcl_Interp *interp;         /* Interp to initialize. */
  {
      char *ptr;
      char buffer[TCL_INTEGER_SPACE * 2];
      SYSTEM_INFO sysInfo;
      OemId *oemId;
      OSVERSIONINFOA osInfo;
      Tcl_DString ds;
      osInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFOA);
      GetVersionExA(&osInfo);
      oemId = (OemId *) &sysInfo;
      GetSystemInfo(&sysInfo);
      /*
       * Initialize the tclDefaultLibrary variable from the registry.
       */
      Tcl_SetVar(interp, "tclDefaultLibrary", "", TCL_GLOBAL_ONLY);
      /*
       * Define the tcl_platform array.
       */
      Tcl_SetVar2(interp, "tcl_platform", "platform", "windows",
              TCL_GLOBAL_ONLY);
      if (osInfo.dwPlatformId < NUMPLATFORMS) {
          Tcl_SetVar2(interp, "tcl_platform", "os",
                  platforms[osInfo.dwPlatformId], TCL_GLOBAL_ONLY);
      }
      wsprintfA(buffer, "%d.%d", osInfo.dwMajorVersion, osInfo.dwMinorVersion);
      Tcl_SetVar2(interp, "tcl_platform", "osVersion", buffer, TCL_GLOBAL_ONLY);
      if (oemId->wProcessorArchitecture < NUMPROCESSORS) {
          Tcl_SetVar2(interp, "tcl_platform", "machine",
                  processors[oemId->wProcessorArchitecture],
                  TCL_GLOBAL_ONLY);
      }
  #ifdef _DEBUG
      /*
       * The existence of the "debug" element of the tcl_platform array indicates
       * that this particular Tcl shell has been compiled with debug information.
       * Using "info exists tcl_platform(debug)" a Tcl script can direct the
       * interpreter to load debug versions of DLLs with the load command.
       */
      Tcl_SetVar2(interp, "tcl_platform", "debug", "1",
              TCL_GLOBAL_ONLY);
  #endif
      /*
       * Set up the HOME environment variable from the HOMEDRIVE & HOMEPATH
       * environment variables, if necessary.
       */
      Tcl_DStringInit(&ds);
      ptr = Tcl_GetVar2(interp, "env", "HOME", TCL_GLOBAL_ONLY);
      if (ptr == NULL) {
          ptr = Tcl_GetVar2(interp, "env", "HOMEDRIVE", TCL_GLOBAL_ONLY);
          if (ptr != NULL) {
              Tcl_DStringAppend(&ds, ptr, -1);
          }
          ptr = Tcl_GetVar2(interp, "env", "HOMEPATH", TCL_GLOBAL_ONLY);
          if (ptr != NULL) {
              Tcl_DStringAppend(&ds, ptr, -1);
          }
          if (Tcl_DStringLength(&ds) > 0) {
              Tcl_SetVar2(interp, "env", "HOME", Tcl_DStringValue(&ds),
                      TCL_GLOBAL_ONLY);
          } else {
              Tcl_SetVar2(interp, "env", "HOME", "c:\\", TCL_GLOBAL_ONLY);
          }
      }
      /*
       * Initialize the user name from the environment first, since this is much
       * faster than asking the system.
       */
      Tcl_DStringSetLength(&ds, 100);
      if (TclGetEnv("USERNAME", &ds) == NULL) {
          if (GetUserName(Tcl_DStringValue(&ds), &Tcl_DStringLength(&ds)) == 0) {
              Tcl_DStringSetLength(&ds, 0);
          }
      }
      Tcl_SetVar2(interp, "tcl_platform", "user", Tcl_DStringValue(&ds),
              TCL_GLOBAL_ONLY);
      Tcl_DStringFree(&ds);
  }
  /*
   *----------------------------------------------------------------------
   *
   * TclpFindVariable --
   *
   *      Locate the entry in environ for a given name.  On Unix this
   *      routine is case sensetive, on Windows this matches mioxed case.
   *
   * Results:
   *      The return value is the index in environ of an entry with the
   *      name "name", or -1 if there is no such entry.   The integer at
   *      *lengthPtr is filled in with the length of name (if a matching
   *      entry is found) or the length of the environ array (if no matching
   *      entry is found).
   *
   * Side effects:
   *      None.
   *
   *----------------------------------------------------------------------
   */
  int
  TclpFindVariable(name, lengthPtr)
      CONST char *name;           /* Name of desired environment variable
                                   * (UTF-8). */
      int *lengthPtr;             /* Used to return length of name (for
                                   * successful searches) or number of non-NULL
                                   * entries in environ (for unsuccessful
                                   * searches). */
  {
      int i, length, result = -1;
      register CONST char *env, *p1, *p2;
      char *envUpper, *nameUpper;
      Tcl_DString envString;
      /*
       * Convert the name to all upper case for the case insensitive
       * comparison.
       */
      length = strlen(name);
      nameUpper = (char *) ckalloc((unsigned) length+1);
      memcpy((VOID *) nameUpper, (VOID *) name, (size_t) length+1);
      Tcl_UtfToUpper(nameUpper);
      Tcl_DStringInit(&envString);
      for (i = 0, env = environ[i]; env != NULL; i++, env = environ[i]) {
          /*
           * Chop the env string off after the equal sign, then Convert
           * the name to all upper case, so we do not have to convert
           * all the characters after the equal sign.
           */
          envUpper = Tcl_ExternalToUtfDString(NULL, env, -1, &envString);
          p1 = strchr(envUpper, '=');
          if (p1 == NULL) {
              continue;
          }
          length = p1 - envUpper;
          Tcl_DStringSetLength(&envString, length+1);
          Tcl_UtfToUpper(envUpper);
          p1 = envUpper;
          p2 = nameUpper;
          for (; *p2 == *p1; p1++, p2++) {
              /* NULL loop body. */
          }
          if ((*p1 == '=') && (*p2 == '\0')) {
              *lengthPtr = length;
              result = i;
              goto done;
          }
          Tcl_DStringFree(&envString);
      }
      *lengthPtr = i;
      done:
      Tcl_DStringFree(&envString);
      ckfree(nameUpper);
      return result;
  }
  /*
   *----------------------------------------------------------------------
   *
   * Tcl_Init --
   *
   *      This procedure is typically invoked by Tcl_AppInit procedures
   *      to perform additional initialization for a Tcl interpreter,
   *      such as sourcing the "init.tcl" script.
   *
   * Results:
   *      Returns a standard Tcl completion code and sets the interp's
   *      result if there is an error.
   *
   * Side effects:
   *      Depends on what's in the init.tcl script.
   *
   *----------------------------------------------------------------------
   */
  int
  Tcl_Init(interp)
      Tcl_Interp *interp;         /* Interpreter to initialize. */
  {
      Tcl_Obj *pathPtr;
      if (tclPreInitScript != NULL) {
          if (Tcl_Eval(interp, tclPreInitScript) == TCL_ERROR) {
              return (TCL_ERROR);
          };
      }
      pathPtr = TclGetLibraryPath();
      if (pathPtr == NULL) {
          pathPtr = Tcl_NewObj();
      }
      Tcl_SetVar2Ex(interp, "tcl_libPath", NULL, pathPtr, TCL_GLOBAL_ONLY);
      return Tcl_Eval(interp, initScript);
  }
  /*
   *----------------------------------------------------------------------
   *
   * Tcl_SourceRCFile --
   *
   *      This procedure is typically invoked by Tcl_Main of Tk_Main
   *      procedure to source an application specific rc file into the
   *      interpreter at startup time.
   *
   * Results:
   *      None.
   *
   * Side effects:
   *      Depends on what's in the rc script.
   *
   *----------------------------------------------------------------------
   */
  void
  Tcl_SourceRCFile(interp)
      Tcl_Interp *interp;         /* Interpreter to source rc file into. */
  {
      Tcl_DString temp;
      char *fileName;
      Tcl_Channel errChannel;
      fileName = Tcl_GetVar(interp, "tcl_rcFileName", TCL_GLOBAL_ONLY);
      if (fileName != NULL) {
          Tcl_Channel c;
          char *fullName;
          Tcl_DStringInit(&temp);
          fullName = Tcl_TranslateFileName(interp, fileName, &temp);
          if (fullName == NULL) {
              /*
               * Couldn't translate the file name (e.g. it referred to a
               * bogus user or there was no HOME environment variable).
               * Just do nothing.
               */
          } else {
              /*
               * Test for the existence of the rc file before trying to read it.
               */
              c = Tcl_OpenFileChannel(NULL, fullName, "r", 0);
              if (c != (Tcl_Channel) NULL) {
                  Tcl_Close(NULL, c);
                  if (Tcl_EvalFile(interp, fullName) != TCL_OK) {
                      errChannel = Tcl_GetStdChannel(TCL_STDERR);
                      if (errChannel) {
                          Tcl_WriteObj(errChannel, Tcl_GetObjResult(interp));
                          Tcl_WriteChars(errChannel, "\n", 1);
                      }
                  }
              }
          }
          Tcl_DStringFree(&temp);
      }
  }
  /*
   *----------------------------------------------------------------------
   *
   * TclpAsyncMark --
   *
   *      Wake up the main thread from a signal handler.
   *
   * Results:
   *      None.
   *
   * Side effects:
   *      Sends a message to the main thread.
   *
   *----------------------------------------------------------------------
   */
  void
  TclpAsyncMark(async)
      Tcl_AsyncHandler async;             /* Token for handler. */
  {
      /*
       * Need a way to kick the Windows event loop and tell it to go look at
       * asynchronous events.
       */
      PostThreadMessage(mainThreadId, WM_USER, 0, 0);
  }
  /* End of tclwininit.c */

 Legend:



Removed from v.67
 


changed lines


 
Added in v.71
 Legend:



Removed from v.67
 


changed lines


 
Added in v.71
-Removed from v.67
+Added in v.71

dashley@gmail.com	ViewVC Help
Powered by ViewVC 1.1.25