Index: external/tcl/tcl.h
===================================================================
--- external/tcl/tcl.h	(revision e15936c0a3056527d482c327cd48c5b2a548e0d4)
+++ external/tcl/tcl.h	(revision adeddd899f1886a74c386a3b4521f830dcdc36b3)
@@ -488,12 +488,4 @@
 EXTERN int		Tcl_IsShared _ANSI_ARGS_((Tcl_Obj *objPtr));
 
-#ifdef TCL_MEM_DEBUG
-#   define Tcl_IncrRefCount(objPtr) \
-	Tcl_DbIncrRefCount(objPtr, __FILE__, __LINE__)
-#   define Tcl_DecrRefCount(objPtr) \
-	Tcl_DbDecrRefCount(objPtr, __FILE__, __LINE__)
-#   define Tcl_IsShared(objPtr) \
-	Tcl_DbIsShared(objPtr, __FILE__, __LINE__)
-#else
 #   define Tcl_IncrRefCount(objPtr) \
 	++(objPtr)->refCount
@@ -502,10 +494,7 @@
 #   define Tcl_IsShared(objPtr) \
 	((objPtr)->refCount > 1)
-#endif
 
 /*
  * Macros and definitions that help to debug the use of Tcl objects.
- * When TCL_MEM_DEBUG is defined, the Tcl_New* declarations are 
- * overridden to call debugging versions of the object creation procedures.
  */
 
@@ -519,21 +508,4 @@
 EXTERN Tcl_Obj *	Tcl_NewStringObj _ANSI_ARGS_((char *bytes,
 			    int length));
-
-#ifdef TCL_MEM_DEBUG
-#  define Tcl_NewBooleanObj(val) \
-     Tcl_DbNewBooleanObj(val, __FILE__, __LINE__)
-#  define Tcl_NewDoubleObj(val) \
-     Tcl_DbNewDoubleObj(val, __FILE__, __LINE__)
-#  define Tcl_NewIntObj(val) \
-     Tcl_DbNewLongObj(val, __FILE__, __LINE__)
-#  define Tcl_NewListObj(objc, objv) \
-     Tcl_DbNewListObj(objc, objv, __FILE__, __LINE__)
-#  define Tcl_NewLongObj(val) \
-     Tcl_DbNewLongObj(val, __FILE__, __LINE__)
-#  define Tcl_NewObj() \
-     Tcl_DbNewObj(__FILE__, __LINE__)
-#  define Tcl_NewStringObj(bytes, len) \
-     Tcl_DbNewStringObj(bytes, len, __FILE__, __LINE__)
-#endif /* TCL_MEM_DEBUG */
 
 /*
@@ -726,19 +698,4 @@
 			    unsigned int size));
 
-#ifdef TCL_MEM_DEBUG
-
-#  define Tcl_Alloc(x) Tcl_DbCkalloc(x, __FILE__, __LINE__)
-#  define Tcl_Free(x)  Tcl_DbCkfree(x, __FILE__, __LINE__)
-#  define Tcl_Realloc(x,y) Tcl_DbCkrealloc((x), (y),__FILE__, __LINE__)
-#  define ckalloc(x) Tcl_DbCkalloc(x, __FILE__, __LINE__)
-#  define ckfree(x)  Tcl_DbCkfree(x, __FILE__, __LINE__)
-#  define ckrealloc(x,y) Tcl_DbCkrealloc((x), (y),__FILE__, __LINE__)
-
-EXTERN int		Tcl_DumpActiveMemory _ANSI_ARGS_((char *fileName));
-EXTERN void		Tcl_ValidateAllMemory _ANSI_ARGS_((char *file,
-			    int line));
-
-#else
-
 /*
  * If USE_TCLALLOC is true, then we need to call Tcl_Alloc instead of
@@ -760,6 +717,4 @@
 #  define Tcl_DumpActiveMemory(x)
 #  define Tcl_ValidateAllMemory(x,y)
-
-#endif /* TCL_MEM_DEBUG */
 
 /*
Index: external/tcl/tclBasic.c
===================================================================
--- external/tcl/tclBasic.c	(revision e15936c0a3056527d482c327cd48c5b2a548e0d4)
+++ external/tcl/tclBasic.c	(revision adeddd899f1886a74c386a3b4521f830dcdc36b3)
@@ -3287,7 +3287,4 @@
 	    TclInitByteCodeObj(objPtr, &compEnv);
 	    codePtr = (ByteCode *) objPtr->internalRep.otherValuePtr;
-	    if (tclTraceCompile == 2) {
-		TclPrintByteCodeObj(interp, objPtr);
-	    }
 	    TclFreeCompileEnv(&compEnv);
 	} else {
Index: external/tcl/tclCkalloc.c
===================================================================
--- external/tcl/tclCkalloc.c	(revision e15936c0a3056527d482c327cd48c5b2a548e0d4)
+++ external/tcl/tclCkalloc.c	(revision adeddd899f1886a74c386a3b4521f830dcdc36b3)
@@ -22,664 +22,10 @@
 #define TRUE	1
 
-#ifdef TCL_MEM_DEBUG
-
-/*
- * One of the following structures is allocated each time the
- * "memory tag" command is invoked, to hold the current tag.
- */
-
-typedef struct MemTag {
-    int refCount;		/* Number of mem_headers referencing
-				 * this tag. */
-    char string[4];		/* Actual size of string will be as
-				 * large as needed for actual tag.  This
-				 * must be the last field in the structure. */
-} MemTag;
-
-#define TAG_SIZE(bytesInString) ((unsigned) sizeof(MemTag) + bytesInString - 3)
-
-static MemTag *curTagPtr = NULL;/* Tag to use in all future mem_headers
-				 * (set by "memory tag" command). */
-
-/*
- * One of the following structures is allocated just before each
- * dynamically allocated chunk of memory, both to record information
- * about the chunk and to help detect chunk under-runs.
- */
-
-#define LOW_GUARD_SIZE (8 + (32 - (sizeof(long) + sizeof(int)))%8)
-struct mem_header {
-    struct mem_header *flink;
-    struct mem_header *blink;
-    MemTag *tagPtr;		/* Tag from "memory tag" command;  may be
-				 * NULL. */
-    char *file;
-    long length;
-    int line;
-    unsigned char low_guard[LOW_GUARD_SIZE];
-				/* Aligns body on 8-byte boundary, plus
-				 * provides at least 8 additional guard bytes
-				 * to detect underruns. */
-    char body[1];		/* First byte of client's space.  Actual
-				 * size of this field will be larger than
-				 * one. */
-};
-
-static struct mem_header *allocHead = NULL;  /* List of allocated structures */
-
-#define GUARD_VALUE  0141
-
-/*
- * The following macro determines the amount of guard space *above* each
- * chunk of memory.
- */
-
-#define HIGH_GUARD_SIZE 8
-
-/*
- * The following macro computes the offset of the "body" field within
- * mem_header.  It is used to get back to the header pointer from the
- * body pointer that's used by clients.
- */
-
-#define BODY_OFFSET \
-	((unsigned long) (&((struct mem_header *) 0)->body))
-
-static int total_mallocs = 0;
-static int total_frees = 0;
-static int current_bytes_malloced = 0;
-static int maximum_bytes_malloced = 0;
-static int current_malloc_packets = 0;
-static int maximum_malloc_packets = 0;
-static int break_on_malloc = 0;
-static int trace_on_at_malloc = 0;
-static int  alloc_tracing = FALSE;
-static int  init_malloced_bodies = TRUE;
-#ifdef MEM_VALIDATE
-    static int  validate_memory = TRUE;
-#else
-    static int  validate_memory = FALSE;
-#endif
-
-/*
- * Prototypes for procedures defined in this file:
- */
-
-static int		MemoryCmd _ANSI_ARGS_((ClientData clientData,
-			    Tcl_Interp *interp, int argc, char **argv));
-static void		ValidateMemory _ANSI_ARGS_((
-			    struct mem_header *memHeaderP, char *file,
-			    int line, int nukeGuards));
-
-
-/*
- *----------------------------------------------------------------------
- *
- * TclDumpMemoryInfo --
- *     Display the global memory management statistics.
- *
- *----------------------------------------------------------------------
- */
-void
-TclDumpMemoryInfo(outFile) 
-    FILE *outFile;
-{
-        fprintf(outFile,"total mallocs             %10d\n", 
-                total_mallocs);
-        fprintf(outFile,"total frees               %10d\n", 
-                total_frees);
-        fprintf(outFile,"current packets allocated %10d\n", 
-                current_malloc_packets);
-        fprintf(outFile,"current bytes allocated   %10d\n", 
-                current_bytes_malloced);
-        fprintf(outFile,"maximum packets allocated %10d\n", 
-                maximum_malloc_packets);
-        fprintf(outFile,"maximum bytes allocated   %10d\n", 
-                maximum_bytes_malloced);
-}
-
-
-/*
- *----------------------------------------------------------------------
- *
- * ValidateMemory --
- *     Procedure to validate allocted memory guard zones.
- *
- *----------------------------------------------------------------------
- */
-static void
-ValidateMemory(memHeaderP, file, line, nukeGuards)
-    struct mem_header *memHeaderP;
-    char              *file;
-    int                line;
-    int                nukeGuards;
-{
-    unsigned char *hiPtr;
-    int   idx;
-    int   guard_failed = FALSE;
-    int byte;
-    
-    for (idx = 0; idx < LOW_GUARD_SIZE; idx++) {
-        byte = *(memHeaderP->low_guard + idx);
-        if (byte != GUARD_VALUE) {
-            guard_failed = TRUE;
-            fflush(stdout);
-	    byte &= 0xff;
-            fprintf(stderr, "low guard byte %d is 0x%x  \t%c\n", idx, byte,
-		    (isprint(UCHAR(byte)) ? byte : ' '));
-        }
-    }
-    if (guard_failed) {
-        TclDumpMemoryInfo (stderr);
-        fprintf(stderr, "low guard failed at %lx, %s %d\n",
-                 (long unsigned int) memHeaderP->body, file, line);
-        fflush(stderr);  /* In case name pointer is bad. */
-        fprintf(stderr, "%ld bytes allocated at (%s %d)\n", memHeaderP->length,
-		memHeaderP->file, memHeaderP->line);
-        panic ("Memory validation failure");
-    }
-
-    hiPtr = (unsigned char *)memHeaderP->body + memHeaderP->length;
-    for (idx = 0; idx < HIGH_GUARD_SIZE; idx++) {
-        byte = *(hiPtr + idx);
-        if (byte != GUARD_VALUE) {
-            guard_failed = TRUE;
-            fflush (stdout);
-	    byte &= 0xff;
-            fprintf(stderr, "hi guard byte %d is 0x%x  \t%c\n", idx, byte,
-		    (isprint(UCHAR(byte)) ? byte : ' '));
-        }
-    }
-
-    if (guard_failed) {
-        TclDumpMemoryInfo (stderr);
-        fprintf(stderr, "high guard failed at %lx, %s %d\n",
-                 (long unsigned int) memHeaderP->body, file, line);
-        fflush(stderr);  /* In case name pointer is bad. */
-        fprintf(stderr, "%ld bytes allocated at (%s %d)\n",
-		memHeaderP->length, memHeaderP->file,
-		memHeaderP->line);
-        panic("Memory validation failure");
-    }
-
-    if (nukeGuards) {
-        memset ((char *) memHeaderP->low_guard, 0, LOW_GUARD_SIZE); 
-        memset ((char *) hiPtr, 0, HIGH_GUARD_SIZE); 
-    }
-
-}
-
-
-/*
- *----------------------------------------------------------------------
- *
- * Tcl_ValidateAllMemory --
- *     Validates guard regions for all allocated memory.
- *
- *----------------------------------------------------------------------
- */
-void
-Tcl_ValidateAllMemory (file, line)
-    char  *file;
-    int    line;
-{
-    struct mem_header *memScanP;
-
-    for (memScanP = allocHead; memScanP != NULL; memScanP = memScanP->flink)
-        ValidateMemory(memScanP, file, line, FALSE);
-
-}
-
-
-/*
- *----------------------------------------------------------------------
- *
- * Tcl_DumpActiveMemory --
- *     Displays all allocated memory to stderr.
- *
- * Results:
- *     Return TCL_ERROR if an error accessing the file occures, `errno' 
- *     will have the file error number left in it.
- *----------------------------------------------------------------------
- */
-int
-Tcl_DumpActiveMemory (fileName)
-    char *fileName;
-{
-    FILE              *fileP;
-    struct mem_header *memScanP;
-    char              *address;
-
-    fileP = fopen(fileName, "w");
-    if (fileP == NULL)
-        return TCL_ERROR;
-
-    for (memScanP = allocHead; memScanP != NULL; memScanP = memScanP->flink) {
-        address = &memScanP->body [0];
-        fprintf(fileP, "%8lx - %8lx  %7ld @ %s %d %s",
-		(long unsigned int) address,
-                 (long unsigned int) address + memScanP->length - 1,
-		 memScanP->length, memScanP->file, memScanP->line,
-		 (memScanP->tagPtr == NULL) ? "" : memScanP->tagPtr->string);
-	(void) fputc('\n', fileP);
-    }
-    fclose (fileP);
-    return TCL_OK;
-}
-
-
-/*
- *----------------------------------------------------------------------
- *
- * Tcl_DbCkalloc - debugging ckalloc
- *
- *        Allocate the requested amount of space plus some extra for
- *        guard bands at both ends of the request, plus a size, panicing 
- *        if there isn't enough space, then write in the guard bands
- *        and return the address of the space in the middle that the
- *        user asked for.
- *
- *        The second and third arguments are file and line, these contain
- *        the filename and line number corresponding to the caller.
- *        These are sent by the ckalloc macro; it uses the preprocessor
- *        autodefines __FILE__ and __LINE__.
- *
- *----------------------------------------------------------------------
- */
-char *
-Tcl_DbCkalloc(size, file, line)
-    unsigned int size;
-    char        *file;
-    int          line;
-{
-    struct mem_header *result;
-
-    if (validate_memory)
-        Tcl_ValidateAllMemory (file, line);
-
-    result = (struct mem_header *) TclpAlloc((unsigned)size + 
-                              sizeof(struct mem_header) + HIGH_GUARD_SIZE);
-    if (result == NULL) {
-        fflush(stdout);
-        TclDumpMemoryInfo(stderr);
-        panic("unable to alloc %d bytes, %s line %d", size, file, 
-              line);
-    }
-
-    /*
-     * Fill in guard zones and size.  Also initialize the contents of
-     * the block with bogus bytes to detect uses of initialized data.
-     * Link into allocated list.
-     */
-    if (init_malloced_bodies) {
-        memset ((VOID *) result, GUARD_VALUE,
-		size + sizeof(struct mem_header) + HIGH_GUARD_SIZE);
-    } else {
-	memset ((char *) result->low_guard, GUARD_VALUE, LOW_GUARD_SIZE);
-	memset (result->body + size, GUARD_VALUE, HIGH_GUARD_SIZE);
-    }
-    result->length = size;
-    result->tagPtr = curTagPtr;
-    if (curTagPtr != NULL) {
-	curTagPtr->refCount++;
-    }
-    result->file = file;
-    result->line = line;
-    result->flink = allocHead;
-    result->blink = NULL;
-    if (allocHead != NULL)
-        allocHead->blink = result;
-    allocHead = result;
-
-    total_mallocs++;
-    if (trace_on_at_malloc && (total_mallocs >= trace_on_at_malloc)) {
-        (void) fflush(stdout);
-        fprintf(stderr, "reached malloc trace enable point (%d)\n",
-                total_mallocs);
-        fflush(stderr);
-        alloc_tracing = TRUE;
-        trace_on_at_malloc = 0;
-    }
-
-    if (alloc_tracing)
-        fprintf(stderr,"ckalloc %lx %d %s %d\n",
-		(long unsigned int) result->body, size, file, line);
-
-    if (break_on_malloc && (total_mallocs >= break_on_malloc)) {
-        break_on_malloc = 0;
-        (void) fflush(stdout);
-        fprintf(stderr,"reached malloc break limit (%d)\n", 
-                total_mallocs);
-        fprintf(stderr, "program will now enter C debugger\n");
-        (void) fflush(stderr);
-	abort();
-    }
-
-    current_malloc_packets++;
-    if (current_malloc_packets > maximum_malloc_packets)
-        maximum_malloc_packets = current_malloc_packets;
-    current_bytes_malloced += size;
-    if (current_bytes_malloced > maximum_bytes_malloced)
-        maximum_bytes_malloced = current_bytes_malloced;
-
-    return result->body;
-}
-
-
-/*
- *----------------------------------------------------------------------
- *
- * Tcl_DbCkfree - debugging ckfree
- *
- *        Verify that the low and high guards are intact, and if so
- *        then free the buffer else panic.
- *
- *        The guards are erased after being checked to catch duplicate
- *        frees.
- *
- *        The second and third arguments are file and line, these contain
- *        the filename and line number corresponding to the caller.
- *        These are sent by the ckfree macro; it uses the preprocessor
- *        autodefines __FILE__ and __LINE__.
- *
- *----------------------------------------------------------------------
- */
-
-int
-Tcl_DbCkfree(ptr, file, line)
-    char *  ptr;
-    char     *file;
-    int       line;
-{
-    /*
-     * The following cast is *very* tricky.  Must convert the pointer
-     * to an integer before doing arithmetic on it, because otherwise
-     * the arithmetic will be done differently (and incorrectly) on
-     * word-addressed machines such as Crays (will subtract only bytes,
-     * even though BODY_OFFSET is in words on these machines).
-     */
-
-    struct mem_header *memp = (struct mem_header *)
-	    (((unsigned long) ptr) - BODY_OFFSET);
-
-    if (alloc_tracing)
-        fprintf(stderr, "ckfree %lx %ld %s %d\n",
-		(long unsigned int) memp->body, memp->length, file, line);
-
-    if (validate_memory)
-        Tcl_ValidateAllMemory(file, line);
-
-    ValidateMemory(memp, file, line, TRUE);
-    if (init_malloced_bodies) {
-	memset((VOID *) ptr, GUARD_VALUE, (size_t) memp->length);
-    }
-
-    total_frees++;
-    current_malloc_packets--;
-    current_bytes_malloced -= memp->length;
-
-    if (memp->tagPtr != NULL) {
-	memp->tagPtr->refCount--;
-	if ((memp->tagPtr->refCount == 0) && (curTagPtr != memp->tagPtr)) {
-	    TclpFree((char *) memp->tagPtr);
-	}
-    }
-
-    /*
-     * Delink from allocated list
-     */
-    if (memp->flink != NULL)
-        memp->flink->blink = memp->blink;
-    if (memp->blink != NULL)
-        memp->blink->flink = memp->flink;
-    if (allocHead == memp)
-        allocHead = memp->flink;
-    TclpFree((char *) memp);
-    return 0;
-}
-
-
-/*
- *--------------------------------------------------------------------
- *
- * Tcl_DbCkrealloc - debugging ckrealloc
- *
- *	Reallocate a chunk of memory by allocating a new one of the
- *	right size, copying the old data to the new location, and then
- *	freeing the old memory space, using all the memory checking
- *	features of this package.
- *
- *--------------------------------------------------------------------
- */
-char *
-Tcl_DbCkrealloc(ptr, size, file, line)
-    char *ptr;
-    unsigned int size;
-    char *file;
-    int line;
-{
-    char *new;
-    unsigned int copySize;
-
-    /*
-     * See comment from Tcl_DbCkfree before you change the following
-     * line.
-     */
-
-    struct mem_header *memp = (struct mem_header *)
-	    (((unsigned long) ptr) - BODY_OFFSET);
-
-    copySize = size;
-    if (copySize > (unsigned int) memp->length) {
-	copySize = memp->length;
-    }
-    new = Tcl_DbCkalloc(size, file, line);
-    memcpy((VOID *) new, (VOID *) ptr, (size_t) copySize);
-    Tcl_DbCkfree(ptr, file, line);
-    return(new);
-}
-
-
-
-/*
- *----------------------------------------------------------------------
- *
- * Tcl_Alloc, et al. --
- *
- *	These functions are defined in terms of the debugging versions
- *	when TCL_MEM_DEBUG is set.
- *
- * Results:
- *	Same as the debug versions.
- *
- * Side effects:
- *	Same as the debug versions.
- *
- *----------------------------------------------------------------------
- */
-
-#undef Tcl_Alloc
-#undef Tcl_Free
-#undef Tcl_Realloc
-
-char *
-Tcl_Alloc(size)
-    unsigned int size;
-{
-    return Tcl_DbCkalloc(size, "unknown", 0);
-}
-
-void
-Tcl_Free(ptr)
-    char *ptr;
-{
-    Tcl_DbCkfree(ptr, "unknown", 0);
-}
-
-char *
-Tcl_Realloc(ptr, size)
-    char *ptr;
-    unsigned int size;
-{
-    return Tcl_DbCkrealloc(ptr, size, "unknown", 0);
-}
-
-
-/*
- *----------------------------------------------------------------------
- *
- * MemoryCmd --
- *     Implements the TCL memory command:
- *       memory info
- *       memory display
- *       break_on_malloc count
- *       trace_on_at_malloc count
- *       trace on|off
- *       validate on|off
- *
- * Results:
- *     Standard TCL results.
- *
- *----------------------------------------------------------------------
- */
-	/* ARGSUSED */
-static int
-MemoryCmd (clientData, interp, argc, argv)
-    ClientData  clientData;
-    Tcl_Interp *interp;
-    int         argc;
-    char      **argv;
-{
-    char *fileName;
-    Tcl_DString buffer;
-    int result;
-
-    if (argc < 2) {
-	Tcl_AppendResult(interp, "wrong # args: should be \"",
-		argv[0], " option [args..]\"", (char *) NULL);
-	return TCL_ERROR;
-    }
-
-    if (strcmp(argv[1],"active") == 0) {
-        if (argc != 3) {
-	    Tcl_AppendResult(interp, "wrong # args: should be \"",
-		    argv[0], " active file\"", (char *) NULL);
-	    return TCL_ERROR;
-	}
-	fileName = Tcl_TranslateFileName(interp, argv[2], &buffer);
-	if (fileName == NULL) {
-	    return TCL_ERROR;
-	}
-	result = Tcl_DumpActiveMemory (fileName);
-	Tcl_DStringFree(&buffer);
-	if (result != TCL_OK) {
-	    Tcl_AppendResult(interp, "error accessing ", argv[2], 
-		    (char *) NULL);
-	    return TCL_ERROR;
-	}
-	return TCL_OK;
-    }
-    if (strcmp(argv[1],"break_on_malloc") == 0) {
-        if (argc != 3) {
-            goto argError;
-	}
-        if (Tcl_GetInt(interp, argv[2], &break_on_malloc) != TCL_OK) {
-	    return TCL_ERROR;
-	}
-        return TCL_OK;
-    }
-    if (strcmp(argv[1],"info") == 0) {
-        TclDumpMemoryInfo(stdout);
-        return TCL_OK;
-    }
-    if (strcmp(argv[1],"init") == 0) {
-        if (argc != 3) {
-            goto bad_suboption;
-	}
-        init_malloced_bodies = (strcmp(argv[2],"on") == 0);
-        return TCL_OK;
-    }
-    if (strcmp(argv[1],"tag") == 0) {
-	if (argc != 3) {
-	    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
-		    " tag string\"", (char *) NULL);
-	    return TCL_ERROR;
-	}
-	if ((curTagPtr != NULL) && (curTagPtr->refCount == 0)) {
-	    TclpFree((char *) curTagPtr);
-	}
-	curTagPtr = (MemTag *) TclpAlloc(TAG_SIZE(strlen(argv[2])));
-	curTagPtr->refCount = 0;
-	strcpy(curTagPtr->string, argv[2]);
-	return TCL_OK;
-    }
-    if (strcmp(argv[1],"trace") == 0) {
-        if (argc != 3) {
-            goto bad_suboption;
-	}
-        alloc_tracing = (strcmp(argv[2],"on") == 0);
-        return TCL_OK;
-    }
-
-    if (strcmp(argv[1],"trace_on_at_malloc") == 0) {
-        if (argc != 3) {
-            goto argError;
-	}
-        if (Tcl_GetInt(interp, argv[2], &trace_on_at_malloc) != TCL_OK) {
-	    return TCL_ERROR;
-	}
-	return TCL_OK;
-    }
-    if (strcmp(argv[1],"validate") == 0) {
-        if (argc != 3) {
-	    goto bad_suboption;
-	}
-        validate_memory = (strcmp(argv[2],"on") == 0);
-        return TCL_OK;
-    }
-
-    Tcl_AppendResult(interp, "bad option \"", argv[1],
-	    "\": should be active, break_on_malloc, info, init, ",
-	    "tag, trace, trace_on_at_malloc, or validate", (char *) NULL);
-    return TCL_ERROR;
-
-argError:
-    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
-	    " ", argv[1], " count\"", (char *) NULL);
-    return TCL_ERROR;
-
-bad_suboption:
-    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
-	    " ", argv[1], " on|off\"", (char *) NULL);
-    return TCL_ERROR;
-}
-
-
-/*
- *----------------------------------------------------------------------
- *
- * Tcl_InitMemory --
- *     Initialize the memory command.
- *
- *----------------------------------------------------------------------
- */
-void
-Tcl_InitMemory(interp)
-    Tcl_Interp *interp;
-{
-    Tcl_CreateCommand (interp, "memory", MemoryCmd, (ClientData) NULL, 
-	    (Tcl_CmdDeleteProc *) NULL);
-}
-
-#else
-
-
-
 /*
  *----------------------------------------------------------------------
  *
  * Tcl_Alloc --
- *     Interface to TclpAlloc when TCL_MEM_DEBUG is disabled.  It does check
- *     that memory was actually allocated.
+ *	Interface to TclpAlloc.
+ *	It does check that memory was actually allocated.
  *
  *----------------------------------------------------------------------
@@ -722,6 +68,6 @@
  *
  * Tcl_Realloc --
- *     Interface to TclpRealloc when TCL_MEM_DEBUG is disabled.  It does 
- *     check that memory was actually allocated.
+ *	Interface to TclpRealloc.
+ *	It does check that memory was actually allocated.
  *
  *----------------------------------------------------------------------
@@ -765,7 +111,5 @@
  *
  * Tcl_Free --
- *     Interface to TclpFree when TCL_MEM_DEBUG is disabled.  Done here
- *     rather in the macro to keep some modules from being compiled with 
- *     TCL_MEM_DEBUG enabled and some with it disabled.
+ *	Interface to TclpFree.
  *
  *----------------------------------------------------------------------
@@ -778,52 +122,2 @@
         TclpFree(ptr);
 }
-
-int
-Tcl_DbCkfree(ptr, file, line)
-    char *  ptr;
-    char     *file;
-    int       line;
-{
-    TclpFree(ptr);
-    return 0;
-}
-
-
-/*
- *----------------------------------------------------------------------
- *
- * Tcl_InitMemory --
- *     Dummy initialization for memory command, which is only available 
- *     if TCL_MEM_DEBUG is on.
- *
- *----------------------------------------------------------------------
- */
-	/* ARGSUSED */
-void
-Tcl_InitMemory(interp)
-    Tcl_Interp *interp;
-{
-}
-
-#undef Tcl_DumpActiveMemory
-#undef Tcl_ValidateAllMemory
-
-extern int		Tcl_DumpActiveMemory _ANSI_ARGS_((char *fileName));
-extern void		Tcl_ValidateAllMemory _ANSI_ARGS_((char *file,
-			    int line));
-
-int
-Tcl_DumpActiveMemory(fileName)
-    char *fileName;
-{
-    return TCL_OK;
-}
-
-void
-Tcl_ValidateAllMemory(file, line)
-    char  *file;
-    int    line;
-{
-}
-
-#endif
Index: external/tcl/tclCompExpr.c
===================================================================
--- external/tcl/tclCompExpr.c	(revision e15936c0a3056527d482c327cd48c5b2a548e0d4)
+++ external/tcl/tclCompExpr.c	(revision adeddd899f1886a74c386a3b4521f830dcdc36b3)
@@ -31,13 +31,4 @@
 #define ERANGE 34
 #endif
-
-/*
- * Boolean variable that controls whether expression compilation tracing
- * is enabled.
- */
-
-#ifdef TCL_COMPILE_DEBUG
-static int traceCompileExpr = 0;
-#endif /* TCL_COMPILE_DEBUG */
 
 /*
@@ -132,20 +123,4 @@
 #define NOT		(COLON + 1)
 #define BIT_NOT		(NOT + 1)
-
-/*
- * Mapping from tokens to strings; used for debugging messages. These
- * entries must match the order and number of the token definitions above.
- */
-
-#ifdef TCL_COMPILE_DEBUG
-static char *tokenStrings[] = {
-    "LITERAL", "FUNCNAME",
-    "[", "]", "(", ")", "$", "\"", ",", "END", "UNKNOWN",
-    "*", "/", "%", "+", "-",
-    "<<", ">>", "<", ">", "<=", ">=", "==", "!=",
-    "&", "^", "|", "&&", "||", "?", ":",
-    "!", "~"
-};
-#endif /* TCL_COMPILE_DEBUG */
 
 /*
@@ -198,19 +173,4 @@
 			    ExprInfo *infoPtr, CompileEnv *envPtr));
 
-/*
- * Macro used to debug the execution of the recursive descent parser used
- * to compile expressions.
- */
-
-#ifdef TCL_COMPILE_DEBUG
-#define HERE(production, level) \
-    if (traceCompileExpr) { \
-	fprintf(stderr, "%*s%s: token=%s, next=\"%.20s\"\n", \
-		(level), " ", (production), tokenStrings[infoPtr->token], \
-		infoPtr->next); \
-    }
-#else
-#define HERE(production, level)
-#endif /* TCL_COMPILE_DEBUG */
 
 
@@ -277,10 +237,4 @@
 				 * to execute the expression. */
     int result;
-
-#ifdef TCL_COMPILE_DEBUG
-    if (traceCompileExpr) {
-	fprintf(stderr, "expr: string=\"%.30s\"\n", string);
-    }
-#endif /* TCL_COMPILE_DEBUG */
 
     /*
@@ -409,5 +363,4 @@
     int elseCodeOffset, currCodeOffset, jumpDist, result;
     
-    HERE("condExpr", 1);
     result = CompileLorExpr(interp, infoPtr, flags, envPtr);
     if (result != TCL_OK) {
@@ -571,5 +524,4 @@
     Tcl_Obj *objPtr;
     
-    HERE("lorExpr", 2);
     result = CompileLandExpr(interp, infoPtr, flags, envPtr);
     if ((result != TCL_OK) || (infoPtr->token != OR)) {
@@ -739,5 +691,4 @@
     Tcl_Obj *objPtr;
 
-    HERE("landExpr", 3);
     result = CompileBitOrExpr(interp, infoPtr, flags, envPtr);
     if ((result != TCL_OK) || (infoPtr->token != AND)) {
@@ -899,5 +850,4 @@
     int result;
 
-    HERE("bitOrExpr", 4);
     result = CompileBitXorExpr(interp, infoPtr, flags, envPtr);
     if (result != TCL_OK) {
@@ -970,5 +920,4 @@
     int result;
 
-    HERE("bitXorExpr", 5);
     result = CompileBitAndExpr(interp, infoPtr, flags, envPtr);
     if (result != TCL_OK) {
@@ -1041,5 +990,4 @@
     int result;
 
-    HERE("bitAndExpr", 6);
     result = CompileEqualityExpr(interp, infoPtr, flags, envPtr);
     if (result != TCL_OK) {
@@ -1112,5 +1060,4 @@
     int op, result;
 
-    HERE("equalityExpr", 7);
     result = CompileRelationalExpr(interp, infoPtr, flags, envPtr);
     if (result != TCL_OK) {
@@ -1190,5 +1137,4 @@
     int op, result;
 
-    HERE("relationalExpr", 8);
     result = CompileShiftExpr(interp, infoPtr, flags, envPtr);
     if (result != TCL_OK) {
@@ -1277,5 +1223,4 @@
     int op, result;
 
-    HERE("shiftExpr", 9);
     result = CompileAddExpr(interp, infoPtr, flags, envPtr);
     if (result != TCL_OK) {
@@ -1355,5 +1300,4 @@
     int op, result;
 
-    HERE("addExpr", 10);
     result = CompileMultiplyExpr(interp, infoPtr, flags, envPtr);
     if (result != TCL_OK) {
@@ -1433,5 +1377,4 @@
     int op, result;
 
-    HERE("multiplyExpr", 11);
     result = CompileUnaryExpr(interp, infoPtr, flags, envPtr);
     if (result != TCL_OK) {
@@ -1513,5 +1456,4 @@
     int op, result;
 
-    HERE("unaryExpr", 12);
     op = infoPtr->token;
     if ((op == PLUS) || (op == MINUS) || (op == BIT_NOT) || (op == NOT)) {
@@ -1608,5 +1550,4 @@
      */
 
-    HERE("primaryExpr", 13);
     theToken = infoPtr->token;
 
Index: external/tcl/tclCompile.c
===================================================================
--- external/tcl/tclCompile.c	(revision e15936c0a3056527d482c327cd48c5b2a548e0d4)
+++ external/tcl/tclCompile.c	(revision adeddd899f1886a74c386a3b4521f830dcdc36b3)
@@ -17,39 +17,4 @@
 #include "tclInt.h"
 #include "tclCompile.h"
-
-/*
- * Variable that controls whether compilation tracing is enabled and, if so,
- * what level of tracing is desired:
- *    0: no compilation tracing
- *    1: summarize compilation of top level cmds and proc bodies
- *    2: display all instructions of each ByteCode compiled
- * This variable is linked to the Tcl variable "tcl_traceCompile".
- */
-
-int tclTraceCompile = 0;
-static int traceInitialized = 0;
-
-/*
- * Count of the number of compilations and various other compilation-
- * related statistics.
- */
-
-#ifdef TCL_COMPILE_STATS
-long tclNumCompilations = 0;
-double tclTotalSourceBytes = 0.0;
-double tclTotalCodeBytes = 0.0;
-
-double tclTotalInstBytes = 0.0;
-double tclTotalObjBytes = 0.0;
-double tclTotalExceptBytes = 0.0;
-double tclTotalAuxBytes = 0.0;
-double tclTotalCmdMapBytes = 0.0;
-
-double tclCurrentSourceBytes = 0.0;
-double tclCurrentCodeBytes = 0.0;
-
-int tclSourceCount[32];
-int tclByteCodeCount[32];
-#endif /* TCL_COMPILE_STATS */
 
 /*
@@ -443,404 +408,4 @@
  *----------------------------------------------------------------------
  *
- * TclPrintByteCodeObj --
- *
- *	This procedure prints ("disassembles") the instructions of a
- *	bytecode object to stdout.
- *
- * Results:
- *	None.
- *
- * Side effects:
- *	None.
- *
- *----------------------------------------------------------------------
- */
-
-void
-TclPrintByteCodeObj(interp, objPtr)
-    Tcl_Interp *interp;		/* Used only for Tcl_GetStringFromObj. */
-    Tcl_Obj *objPtr;		/* The bytecode object to disassemble. */
-{
-    ByteCode* codePtr = (ByteCode *) objPtr->internalRep.otherValuePtr;
-    unsigned char *codeStart, *codeLimit, *pc;
-    unsigned char *codeDeltaNext, *codeLengthNext;
-    unsigned char *srcDeltaNext, *srcLengthNext;
-    int codeOffset, codeLen, srcOffset, srcLen;
-    int numCmds, numObjs, delta, objBytes, i;
-
-    if (codePtr->refCount <= 0) {
-	return;			/* already freed */
-    }
-
-    codeStart = codePtr->codeStart;
-    codeLimit = (codeStart + codePtr->numCodeBytes);
-    numCmds = codePtr->numCommands;
-    numObjs = codePtr->numObjects;
-
-    objBytes = (numObjs * sizeof(Tcl_Obj));
-    for (i = 0;  i < numObjs;  i++) {
-	Tcl_Obj *litObjPtr = codePtr->objArrayPtr[i];
-	if (litObjPtr->bytes != NULL) {
-	    objBytes += litObjPtr->length;
-	}
-    }
-
-    /*
-     * Print header lines describing the ByteCode.
-     */
-
-    fprintf(stdout, "\nByteCode 0x%x, ref ct %u, epoch %u, interp 0x%x(epoch %u)\n",
-	    (unsigned int) codePtr, codePtr->refCount,
-	    codePtr->compileEpoch, (unsigned int) codePtr->iPtr,
-	    codePtr->iPtr->compileEpoch);
-    fprintf(stdout, "  Source ");
-    TclPrintSource(stdout, codePtr->source,
-	    TclMin(codePtr->numSrcChars, 70));
-    fprintf(stdout, "\n  Cmds %d, chars %d, inst %d, objs %u, aux %d, stk depth %u, code/src %.2f\n",
-	    numCmds, codePtr->numSrcChars, codePtr->numCodeBytes, numObjs,
-	    codePtr->numAuxDataItems, codePtr->maxStackDepth,
-	    (codePtr->numSrcChars?
-	            ((float)codePtr->totalSize)/((float)codePtr->numSrcChars) : 0.0));
-    fprintf(stdout, "  Code %zu = %u(header)+%d(inst)+%d(objs)+%u(exc)+%u(aux)+%d(cmd map)\n",
-	    codePtr->totalSize, sizeof(ByteCode), codePtr->numCodeBytes,
-	    objBytes, (codePtr->numExcRanges * sizeof(ExceptionRange)),
-	    (codePtr->numAuxDataItems * sizeof(AuxData)),
-	    codePtr->numCmdLocBytes);
-
-    /*
-     * If the ByteCode is the compiled body of a Tcl procedure, print
-     * information about that procedure. Note that we don't know the
-     * procedure's name since ByteCode's can be shared among procedures.
-     */
-    
-    if (codePtr->procPtr != NULL) {
-	Proc *procPtr = codePtr->procPtr;
-	int numCompiledLocals = procPtr->numCompiledLocals;
-	fprintf(stdout,
-	        "  Proc 0x%x, ref ct %d, args %d, compiled locals %d\n",
-		(unsigned int) procPtr, procPtr->refCount, procPtr->numArgs,
-		numCompiledLocals);
-	if (numCompiledLocals > 0) {
-	    CompiledLocal *localPtr = procPtr->firstLocalPtr;
-	    for (i = 0;  i < numCompiledLocals;  i++) {
-		fprintf(stdout, "      %d: slot %d%s%s%s%s%s%s",
-			i, localPtr->frameIndex,
-			((localPtr->flags & VAR_SCALAR)?  ", scalar"  : ""),
-			((localPtr->flags & VAR_ARRAY)?  ", array"  : ""),
-			((localPtr->flags & VAR_LINK)?  ", link"  : ""),
-			((localPtr->flags & VAR_ARGUMENT)?  ", arg"  : ""),
-			((localPtr->flags & VAR_TEMPORARY)? ", temp" : ""),
-			((localPtr->flags & VAR_RESOLVED)? ", resolved" : ""));
-		if (TclIsVarTemporary(localPtr)) {
-		    fprintf(stdout,	"\n");
-		} else {
-		    fprintf(stdout,	", name=\"%s\"\n", localPtr->name);
-		}
-		localPtr = localPtr->nextPtr;
-	    }
-	}
-    }
-
-    /*
-     * Print the ExceptionRange array.
-     */
-
-    if (codePtr->numExcRanges > 0) {
-	fprintf(stdout, "  Exception ranges %d, depth %d:\n",
-	        codePtr->numExcRanges, codePtr->maxExcRangeDepth);
-	for (i = 0;  i < codePtr->numExcRanges;  i++) {
-	    ExceptionRange *rangePtr = &(codePtr->excRangeArrayPtr[i]);
-	    fprintf(stdout, "      %d: level %d, %s, pc %d-%d, ",
-		    i, rangePtr->nestingLevel,
-		    ((rangePtr->type == LOOP_EXCEPTION_RANGE)? "loop":"catch"),
-		    rangePtr->codeOffset,
-		    (rangePtr->codeOffset + rangePtr->numCodeBytes - 1));
-	    switch (rangePtr->type) {
-	    case LOOP_EXCEPTION_RANGE:
-		fprintf(stdout,	"continue %d, break %d\n",
-		        rangePtr->continueOffset, rangePtr->breakOffset);
-		break;
-	    case CATCH_EXCEPTION_RANGE:
-		fprintf(stdout,	"catch %d\n", rangePtr->catchOffset);
-		break;
-	    default:
-		panic("TclPrintSource: unrecognized ExceptionRange type %d\n",
-		        rangePtr->type);
-	    }
-	}
-    }
-    
-    /*
-     * If there were no commands (e.g., an expression or an empty string
-     * was compiled), just print all instructions and return.
-     */
-
-    if (numCmds == 0) {
-	pc = codeStart;
-	while (pc < codeLimit) {
-	    fprintf(stdout, "    ");
-	    pc += TclPrintInstruction(codePtr, pc);
-	}
-	return;
-    }
-    
-    /*
-     * Print table showing the code offset, source offset, and source
-     * length for each command. These are encoded as a sequence of bytes.
-     */
-
-    fprintf(stdout, "  Commands %d:", numCmds);
-    codeDeltaNext = codePtr->codeDeltaStart;
-    codeLengthNext = codePtr->codeLengthStart;
-    srcDeltaNext  = codePtr->srcDeltaStart;
-    srcLengthNext = codePtr->srcLengthStart;
-    codeOffset = srcOffset = 0;
-    for (i = 0;  i < numCmds;  i++) {
-	if ((unsigned int) (*codeDeltaNext) == (unsigned int) 0xFF) {
-	    codeDeltaNext++;
-	    delta = TclGetInt4AtPtr(codeDeltaNext);
-	    codeDeltaNext += 4;
-	} else {
-	    delta = TclGetInt1AtPtr(codeDeltaNext);
-	    codeDeltaNext++;
-	}
-	codeOffset += delta;
-
-	if ((unsigned int) (*codeLengthNext) == (unsigned int) 0xFF) {
-	    codeLengthNext++;
-	    codeLen = TclGetInt4AtPtr(codeLengthNext);
-	    codeLengthNext += 4;
-	} else {
-	    codeLen = TclGetInt1AtPtr(codeLengthNext);
-	    codeLengthNext++;
-	}
-	
-	if ((unsigned int) (*srcDeltaNext) == (unsigned int) 0xFF) {
-	    srcDeltaNext++;
-	    delta = TclGetInt4AtPtr(srcDeltaNext);
-	    srcDeltaNext += 4;
-	} else {
-	    delta = TclGetInt1AtPtr(srcDeltaNext);
-	    srcDeltaNext++;
-	}
-	srcOffset += delta;
-
-	if ((unsigned int) (*srcLengthNext) == (unsigned int) 0xFF) {
-	    srcLengthNext++;
-	    srcLen = TclGetInt4AtPtr(srcLengthNext);
-	    srcLengthNext += 4;
-	} else {
-	    srcLen = TclGetInt1AtPtr(srcLengthNext);
-	    srcLengthNext++;
-	}
-	
-	fprintf(stdout,	"%s%4d: pc %d-%d, source %d-%d",
-		((i % 2)? "	" : "\n   "),
-		(i+1), codeOffset, (codeOffset + codeLen - 1),
-		srcOffset, (srcOffset + srcLen - 1));
-    }
-    if ((numCmds > 0) && ((numCmds % 2) != 0)) {
-	fprintf(stdout,	"\n");
-    }
-    
-    /*
-     * Print each instruction. If the instruction corresponds to the start
-     * of a command, print the command's source. Note that we don't need
-     * the code length here.
-     */
-
-    codeDeltaNext = codePtr->codeDeltaStart;
-    srcDeltaNext  = codePtr->srcDeltaStart;
-    srcLengthNext = codePtr->srcLengthStart;
-    codeOffset = srcOffset = 0;
-    pc = codeStart;
-    for (i = 0;  i < numCmds;  i++) {
-	if ((unsigned int) (*codeDeltaNext) == (unsigned int) 0xFF) {
-	    codeDeltaNext++;
-	    delta = TclGetInt4AtPtr(codeDeltaNext);
-	    codeDeltaNext += 4;
-	} else {
-	    delta = TclGetInt1AtPtr(codeDeltaNext);
-	    codeDeltaNext++;
-	}
-	codeOffset += delta;
-
-	if ((unsigned int) (*srcDeltaNext) == (unsigned int) 0xFF) {
-	    srcDeltaNext++;
-	    delta = TclGetInt4AtPtr(srcDeltaNext);
-	    srcDeltaNext += 4;
-	} else {
-	    delta = TclGetInt1AtPtr(srcDeltaNext);
-	    srcDeltaNext++;
-	}
-	srcOffset += delta;
-
-	if ((unsigned int) (*srcLengthNext) == (unsigned int) 0xFF) {
-	    srcLengthNext++;
-	    srcLen = TclGetInt4AtPtr(srcLengthNext);
-	    srcLengthNext += 4;
-	} else {
-	    srcLen = TclGetInt1AtPtr(srcLengthNext);
-	    srcLengthNext++;
-	}
-
-	/*
-	 * Print instructions before command i.
-	 */
-	
-	while ((pc-codeStart) < codeOffset) {
-	    fprintf(stdout, "    ");
-	    pc += TclPrintInstruction(codePtr, pc);
-	}
-
-	fprintf(stdout, "  Command %d: ", (i+1));
-	TclPrintSource(stdout, (codePtr->source + srcOffset),
-	        TclMin(srcLen, 70));
-	fprintf(stdout, "\n");
-    }
-    if (pc < codeLimit) {
-	/*
-	 * Print instructions after the last command.
-	 */
-
-	while (pc < codeLimit) {
-	    fprintf(stdout, "    ");
-	    pc += TclPrintInstruction(codePtr, pc);
-	}
-    }
-}
-
-
-/*
- *----------------------------------------------------------------------
- *
- * TclPrintInstruction --
- *
- *	This procedure prints ("disassembles") one instruction from a
- *	bytecode object to stdout.
- *
- * Results:
- *	Returns the length in bytes of the current instruiction.
- *
- * Side effects:
- *	None.
- *
- *----------------------------------------------------------------------
- */
-
-int
-TclPrintInstruction(codePtr, pc)
-    ByteCode* codePtr;		/* Bytecode containing the instruction. */
-    unsigned char *pc;		/* Points to first byte of instruction. */
-{
-    Proc *procPtr = codePtr->procPtr;
-    unsigned char opCode = *pc;
-    register InstructionDesc *instDesc = &instructionTable[opCode];
-    unsigned char *codeStart = codePtr->codeStart;
-    unsigned int pcOffset = (pc - codeStart);
-    int opnd, elemLen, i, j;
-    Tcl_Obj *elemPtr;
-    char *string;
-    
-    fprintf(stdout, "(%u) %s ", pcOffset, instDesc->name);
-    for (i = 0;  i < instDesc->numOperands;  i++) {
-	switch (instDesc->opTypes[i]) {
-	case OPERAND_INT1:
-	    opnd = TclGetInt1AtPtr(pc+1+i);
-	    if ((i == 0) && ((opCode == INST_JUMP1)
-			     || (opCode == INST_JUMP_TRUE1)
-		             || (opCode == INST_JUMP_FALSE1))) {
-		fprintf(stdout, "%d  	# pc %u", opnd, (pcOffset + opnd));
-	    } else {
-		fprintf(stdout, "%d", opnd);
-	    }
-	    break;
-	case OPERAND_INT4:
-	    opnd = TclGetInt4AtPtr(pc+1+i);
-	    if ((i == 0) && ((opCode == INST_JUMP4)
-			     || (opCode == INST_JUMP_TRUE4)
-		             || (opCode == INST_JUMP_FALSE4))) {
-		fprintf(stdout, "%d  	# pc %u", opnd, (pcOffset + opnd));
-	    } else {
-		fprintf(stdout, "%d", opnd);
-	    }
-	    break;
-	case OPERAND_UINT1:
-	    opnd = TclGetUInt1AtPtr(pc+1+i);
-	    if ((i == 0) && (opCode == INST_PUSH1)) {
-		elemPtr = codePtr->objArrayPtr[opnd];
-		string = Tcl_GetStringFromObj(elemPtr, &elemLen);
-		fprintf(stdout, "%u  	# ", (unsigned int) opnd);
-		TclPrintSource(stdout, string, TclMin(elemLen, 40));
-	    } else if ((i == 0) && ((opCode == INST_LOAD_SCALAR1)
-				    || (opCode == INST_LOAD_ARRAY1)
-				    || (opCode == INST_STORE_SCALAR1)
-				    || (opCode == INST_STORE_ARRAY1))) {
-		int localCt = procPtr->numCompiledLocals;
-		CompiledLocal *localPtr = procPtr->firstLocalPtr;
-		if (opnd >= localCt) {
-		    panic("TclPrintInstruction: bad local var index %u (%u locals)\n",
-			     (unsigned int) opnd, localCt);
-		    return instDesc->numBytes;
-		}
-		for (j = 0;  j < opnd;  j++) {
-		    localPtr = localPtr->nextPtr;
-		}
-		if (TclIsVarTemporary(localPtr)) {
-		    fprintf(stdout, "%u	# temp var %u",
-			    (unsigned int) opnd, (unsigned int) opnd);
-		} else {
-		    fprintf(stdout, "%u	# var ", (unsigned int) opnd);
-		    TclPrintSource(stdout, localPtr->name, 40);
-		}
-	    } else {
-		fprintf(stdout, "%u ", (unsigned int) opnd);
-	    }
-	    break;
-	case OPERAND_UINT4:
-	    opnd = TclGetUInt4AtPtr(pc+1+i);
-	    if (opCode == INST_PUSH4) {
-		elemPtr = codePtr->objArrayPtr[opnd];
-		string = Tcl_GetStringFromObj(elemPtr, &elemLen);
-		fprintf(stdout, "%u  	# ", opnd);
-		TclPrintSource(stdout, string, TclMin(elemLen, 40));
-	    } else if ((i == 0) && ((opCode == INST_LOAD_SCALAR4)
-				    || (opCode == INST_LOAD_ARRAY4)
-				    || (opCode == INST_STORE_SCALAR4)
-				    || (opCode == INST_STORE_ARRAY4))) {
-		int localCt = procPtr->numCompiledLocals;
-		CompiledLocal *localPtr = procPtr->firstLocalPtr;
-		if (opnd >= localCt) {
-		    panic("TclPrintInstruction: bad local var index %u (%u locals)\n",
-			     (unsigned int) opnd, localCt);
-		    return instDesc->numBytes;
-		}
-		for (j = 0;  j < opnd;  j++) {
-		    localPtr = localPtr->nextPtr;
-		}
-		if (TclIsVarTemporary(localPtr)) {
-		    fprintf(stdout, "%u	# temp var %u",
-			    (unsigned int) opnd, (unsigned int) opnd);
-		} else {
-		    fprintf(stdout, "%u	# var ", (unsigned int) opnd);
-		    TclPrintSource(stdout, localPtr->name, 40);
-		}
-	    } else {
-		fprintf(stdout, "%u ", (unsigned int) opnd);
-	    }
-	    break;
-	case OPERAND_NONE:
-	default:
-	    break;
-	}
-    }
-    fprintf(stdout, "\n");
-    return instDesc->numBytes;
-}
-
-
-/*
- *----------------------------------------------------------------------
- *
  * TclPrintSource --
  *
@@ -972,9 +537,4 @@
     register int i;
 
-#ifdef TCL_COMPILE_STATS    
-    tclCurrentSourceBytes -= (double) codePtr->numSrcChars;
-    tclCurrentCodeBytes -= (double) codePtr->totalSize;
-#endif /* TCL_COMPILE_STATS */
-
     /*
      * A single heap object holds the ByteCode structure and its code,
@@ -1067,12 +627,4 @@
     int length, result;
 
-    if (!traceInitialized) {
-        if (Tcl_LinkVar(interp, "tcl_traceCompile",
-	            (char *) &tclTraceCompile,  TCL_LINK_INT) != TCL_OK) {
-            panic("SetByteCodeFromAny: unable to create link for tcl_traceCompile variable");
-        }
-        traceInitialized = 1;
-    }
-    
     string = Tcl_GetStringFromObj(objPtr, &length);
     TclInitCompileEnv(interp, &compEnv, string);
@@ -1113,9 +665,4 @@
     TclFreeCompileEnv(&compEnv);
 
-    if (result == TCL_OK) {
-	if (tclTraceCompile == 2) {
-	    TclPrintByteCodeObj(interp, objPtr);
-	}
-    }
     return result;
 }
@@ -1311,7 +858,4 @@
     int numObjects, i;
     Namespace *namespacePtr;
-#ifdef TCL_COMPILE_STATS
-    int srcLenLog2, sizeLog2;
-#endif /*TCL_COMPILE_STATS*/
 
     codeBytes = (envPtr->codeNext - envPtr->codeStart);
@@ -1342,27 +886,4 @@
     }
     totalSize = (size + objBytes);
-
-#ifdef TCL_COMPILE_STATS
-    tclNumCompilations++;
-    tclTotalSourceBytes += (double) srcLen;
-    tclTotalCodeBytes += (double) totalSize;
-    
-    tclTotalInstBytes += (double) codeBytes;
-    tclTotalObjBytes += (double) objBytes;
-    tclTotalExceptBytes += exceptArrayBytes;
-    tclTotalAuxBytes += (double) auxDataArrayBytes;
-    tclTotalCmdMapBytes += (double) cmdLocBytes;
-
-    tclCurrentSourceBytes += (double) srcLen;
-    tclCurrentCodeBytes += (double) totalSize;
-
-    srcLenLog2 = TclLog2(srcLen);
-    sizeLog2 = TclLog2((int) totalSize);
-    if ((srcLenLog2 > 31) || (sizeLog2 > 31)) {
-	panic("TclInitByteCodeObj: bad source or code sizes\n");
-    }
-    tclSourceCount[srcLenLog2]++;
-    tclByteCodeCount[sizeLog2]++;
-#endif /* TCL_COMPILE_STATS */    
 
     if (envPtr->iPtr->varFramePtr != NULL) {
@@ -1820,30 +1341,4 @@
 		cmdCodeOffset);
 	    
-	if ((!(flags & TCL_BRACKET_TERM))
-	        && (tclTraceCompile >= 1) && (envPtr->procPtr == NULL)) {
-	    /*
-	     * Display a line summarizing the top level command we are about
-	     * to compile.
-	     */
-	    
-	    char *p = cmdSrcStart;
-	    int numChars, complete;
-	    
-	    while ((CHAR_TYPE(p, lastChar) != TCL_COMMAND_END)
-		   || ((*p == ']') && !(flags & TCL_BRACKET_TERM))) {
-		p++;
-	    }
-	    numChars = (p - cmdSrcStart);
-	    complete = 1;
-	    if (numChars > 60) {
-		numChars = 60;
-		complete = 0;
-	    } else if ((numChars >= 2) && (*p == '\n') && (*(p-1) == '{')) {
-		complete = 0;
-	    }
-	    fprintf(stdout, "Compiling: %.*s%s\n",
-		    numChars, cmdSrcStart, (complete? "" : " ..."));
-	}
-	
 	while ((type != TCL_COMMAND_END)
 	        || ((c == ']') && !(flags & TCL_BRACKET_TERM))) {
Index: external/tcl/tclCompile.h
===================================================================
--- external/tcl/tclCompile.h	(revision e15936c0a3056527d482c327cd48c5b2a548e0d4)
+++ external/tcl/tclCompile.h	(revision adeddd899f1886a74c386a3b4521f830dcdc36b3)
@@ -36,53 +36,4 @@
 
 extern Tcl_ObjType	tclCmdNameType;
-
-/*
- * Variable that controls whether compilation tracing is enabled and, if so,
- * what level of tracing is desired:
- *    0: no compilation tracing
- *    1: summarize compilation of top level cmds and proc bodies
- *    2: display all instructions of each ByteCode compiled
- * This variable is linked to the Tcl variable "tcl_traceCompile".
- */
-
-extern int 		tclTraceCompile;
-
-/*
- * Variable that controls whether execution tracing is enabled and, if so,
- * what level of tracing is desired:
- *    0: no execution tracing
- *    1: trace invocations of Tcl procs only
- *    2: trace invocations of all (not compiled away) commands
- *    3: display each instruction executed
- * This variable is linked to the Tcl variable "tcl_traceExec".
- */
-
-extern int 		tclTraceExec;
-
-/*
- * The number of bytecode compilations and various other compilation-related
- * statistics. The tclByteCodeCount and tclSourceCount arrays are used to
- * hold the count of ByteCodes and sources whose sizes fall into various
- * binary decades; e.g., tclByteCodeCount[5] is a count of the ByteCodes
- * with size larger than 2**4 and less than or equal to 2**5.
- */
-
-#ifdef TCL_COMPILE_STATS
-extern long		tclNumCompilations;
-extern double		tclTotalSourceBytes;
-extern double		tclTotalCodeBytes;
-
-extern double		tclTotalInstBytes;
-extern double		tclTotalObjBytes;
-extern double		tclTotalExceptBytes;
-extern double		tclTotalAuxBytes;
-extern double		tclTotalCmdMapBytes;
-
-extern double		tclCurrentSourceBytes;
-extern double		tclCurrentCodeBytes;
-
-extern int		tclSourceCount[32];
-extern int		tclByteCodeCount[32];
-#endif /* TCL_COMPILE_STATS */
 
 /*
@@ -816,14 +767,7 @@
 EXTERN void		TclInitJumpFixupArray _ANSI_ARGS_((
 			    JumpFixupArray *fixupArrayPtr));
-#ifdef TCL_COMPILE_STATS
-EXTERN int		TclLog2 _ANSI_ARGS_((int value));
-#endif /*TCL_COMPILE_STATS*/
 EXTERN int		TclObjIndexForString _ANSI_ARGS_((char *start,
 			    int length, int allocStrRep, int inHeap,
 			    CompileEnv *envPtr));
-EXTERN int		TclPrintInstruction _ANSI_ARGS_((ByteCode* codePtr,
-			    unsigned char *pc));
-EXTERN void		TclPrintSource _ANSI_ARGS_((FILE *outFile,
-			    char *string, int maxChars));
 EXTERN void		TclRegisterAuxDataType _ANSI_ARGS_((AuxDataType *typePtr));
 
Index: external/tcl/tclExecute.c
===================================================================
--- external/tcl/tclExecute.c	(revision e15936c0a3056527d482c327cd48c5b2a548e0d4)
+++ external/tcl/tclExecute.c	(revision adeddd899f1886a74c386a3b4521f830dcdc36b3)
@@ -51,16 +51,4 @@
 
 /*
- * Variable that controls whether execution tracing is enabled and, if so,
- * what level of tracing is desired:
- *    0: no execution tracing
- *    1: trace invocations of Tcl procs only
- *    2: trace invocations of all (not compiled away) commands
- *    3: display each instruction executed
- * This variable is linked to the Tcl variable "tcl_traceExec".
- */
-
-int tclTraceExec = 0;
-
-/*
  * The following global variable is use to signal matherr that Tcl
  * is responsible for the arithmetic, so errors can be handled in a
@@ -102,26 +90,4 @@
 };
     
-/*
- * Mapping from Tcl result codes to strings; used for error and debugging
- * messages. 
- */
-
-#ifdef TCL_COMPILE_DEBUG
-static char *resultStrings[] = {
-    "TCL_OK", "TCL_ERROR", "TCL_RETURN", "TCL_BREAK", "TCL_CONTINUE"
-};
-#endif /* TCL_COMPILE_DEBUG */
-
-/*
- * The following are statistics-related variables that record information
- * about the bytecode compiler and interpreter's operation. This includes
- * an array that records for each instruction how often it is executed.
- */
-
-#ifdef TCL_COMPILE_STATS
-static long numExecutions = 0;
-static int instructionCount[256];
-#endif /* TCL_COMPILE_STATS */
-
 /*
  * Macros for testing floating-point values for certain special cases. Test
@@ -187,66 +153,4 @@
 #define POP_OBJECT() \
     (stackPtr[stackTop--].o)
-
-/*
- * Macros used to trace instruction execution. The macros TRACE,
- * TRACE_WITH_OBJ, and O2S are only used inside TclExecuteByteCode.
- * O2S is only used in TRACE* calls to get a string from an object.
- * 
- * NOTE THAT CLIENTS OF O2S ARE LIKELY TO FAIL IF THE OBJECT'S
- * STRING REP CONTAINS NULLS. 
- */
-
-#ifdef TCL_COMPILE_DEBUG
-	
-#define O2S(objPtr) \
-    Tcl_GetStringFromObj((objPtr), &length)
-	
-#ifdef TCL_COMPILE_STATS
-#define TRACE(a) \
-    if (traceInstructions) { \
-        fprintf(stdout, "%d: %d,%ld (%u) ", iPtr->numLevels, \
-	       stackTop, (tclObjsAlloced - tclObjsFreed), \
-	       (unsigned int)(pc - codePtr->codeStart)); \
-	printf a; \
-        fflush(stdout); \
-    }
-#define TRACE_WITH_OBJ(a, objPtr) \
-    if (traceInstructions) { \
-        fprintf(stdout, "%d: %d,%ld (%u) ", iPtr->numLevels, \
-	       stackTop, (tclObjsAlloced - tclObjsFreed), \
-	       (unsigned int)(pc - codePtr->codeStart)); \
-	printf a; \
-	bytes = Tcl_GetStringFromObj((objPtr), &length); \
-        TclPrintSource(stdout, bytes, TclMin(length, 30)); \
-        fprintf(stdout, "\n"); \
-        fflush(stdout); \
-    }
-#else  /* not TCL_COMPILE_STATS */
-#define TRACE(a) \
-    if (traceInstructions) { \
-        fprintf(stdout, "%d: %d (%u) ", iPtr->numLevels, stackTop, \
-	       (unsigned int)(pc - codePtr->codeStart)); \
-	printf a; \
-        fflush(stdout); \
-    }
-#define TRACE_WITH_OBJ(a, objPtr) \
-    if (traceInstructions) { \
-        fprintf(stdout, "%d: %d (%u) ", iPtr->numLevels, stackTop, \
-	       (unsigned int)(pc - codePtr->codeStart)); \
-	printf a; \
-	bytes = Tcl_GetStringFromObj((objPtr), &length); \
-        TclPrintSource(stdout, bytes, TclMin(length, 30)); \
-        fprintf(stdout, "\n"); \
-        fflush(stdout); \
-    }
-#endif /* TCL_COMPILE_STATS */
-
-#else  /* not TCL_COMPILE_DEBUG */
-	
-#define TRACE(a)
-#define TRACE_WITH_OBJ(a, objPtr)
-#define O2S(objPtr)
-	
-#endif /* TCL_COMPILE_DEBUG */
 
 /*
@@ -274,8 +178,4 @@
 static int		ExprUnaryFunc _ANSI_ARGS_((Tcl_Interp *interp,
 			    ExecEnv *eePtr, ClientData clientData));
-#ifdef TCL_COMPILE_STATS
-static int              EvalStatsCmd _ANSI_ARGS_((ClientData clientData,
-                            Tcl_Interp *interp, int argc, char **argv));
-#endif /* TCL_COMPILE_STATS */
 static void		FreeCmdNameInternalRep _ANSI_ARGS_((
     			    Tcl_Obj *objPtr));
@@ -293,14 +193,5 @@
 static int		SetCmdNameFromAny _ANSI_ARGS_((Tcl_Interp *interp,
 			    Tcl_Obj *objPtr));
-#ifdef TCL_COMPILE_DEBUG
-static char *		StringForResultCode _ANSI_ARGS_((int result));
-#endif /* TCL_COMPILE_DEBUG */
 static void		UpdateStringOfCmdName _ANSI_ARGS_((Tcl_Obj *objPtr));
-#ifdef TCL_COMPILE_DEBUG
-static void		ValidatePcAndStackTop _ANSI_ARGS_((
-			    ByteCode *codePtr, unsigned char *pc,
-			    int stackTop, int stackLowerBound,
-			    int stackUpperBound));
-#endif /* TCL_COMPILE_DEBUG */
 
 /*
@@ -368,10 +259,5 @@
  *
  * Side effects:
- *	This procedure initializes the array of instruction names. If
- *	compiling with the TCL_COMPILE_STATS flag, it initializes the
- *	array that counts the executions of each instruction and it
- *	creates the "evalstats" command. It also registers the command name
- *	Tcl_ObjType. It also establishes the link between the Tcl
- *	"tcl_traceExec" and C "tclTraceExec" variables.
+ *	This procedure initializes the array of instruction names.
  *
  *----------------------------------------------------------------------
@@ -391,18 +277,4 @@
     for (i = 0;  instructionTable[i].name != NULL;  i++) {
 	opName[i] = instructionTable[i].name;
-    }
-
-#ifdef TCL_COMPILE_STATS    
-    (VOID *) memset(instructionCount, 0, sizeof(instructionCount));
-    (VOID *) memset(tclByteCodeCount, 0, sizeof(tclByteCodeCount));
-    (VOID *) memset(tclSourceCount, 0, sizeof(tclSourceCount));
-
-    Tcl_CreateCommand(interp, "evalstats", EvalStatsCmd,
-		      (ClientData) NULL, (Tcl_CmdDeleteProc *) NULL);
-#endif /* TCL_COMPILE_STATS */
-    
-    if (Tcl_LinkVar(interp, "tcl_traceExec", (char *) &tclTraceExec,
-		    TCL_LINK_INT) != TCL_OK) {
-	panic("InitByteCodeExecution: can't create link for tcl_traceExec variable");
     }
 }
@@ -598,12 +470,8 @@
 				 * process break, continue, and errors. */
     int result = TCL_OK;	/* Return code returned after execution. */
-    int traceInstructions = (tclTraceExec == 3);
     Tcl_Obj *valuePtr, *value2Ptr, *namePtr, *objPtr;
     char *bytes;
     int length;
     long i;
-    Tcl_DString command;	/* Used for debugging. If tclTraceExec >= 2
-				 * holds a string representing the last
-				 * command invoked. */
 
     /*
@@ -620,23 +488,4 @@
 
     /*
-     * THIS PROC FAILS IF AN OBJECT'S STRING REP HAS A NULL BYTE.
-     */
-
-    if (tclTraceExec >= 2) {
-	PrintByteCodeInfo(codePtr);
-#ifdef TCL_COMPILE_STATS
-	fprintf(stdout, "  Starting stack top=%d, system objects=%ld\n",
-		eePtr->stackTop, (tclObjsAlloced - tclObjsFreed));
-#else
-	fprintf(stdout, "  Starting stack top=%d\n", eePtr->stackTop);
-#endif /* TCL_COMPILE_STATS */
-	fflush(stdout);
-    }
-
-#ifdef TCL_COMPILE_STATS
-    numExecutions++;
-#endif /* TCL_COMPILE_STATS */
-
-    /*
      * Make sure the catch stack is large enough to hold the maximum number
      * of catch commands that could ever be executing at the same time. This
@@ -659,11 +508,4 @@
 
     /*
-     * Initialize the buffer that holds a string containing the name and
-     * arguments for the last invoked command.
-     */
-
-    Tcl_DStringInit(&command);
-
-    /*
      * Loop executing instructions until a "done" instruction, a TCL_RETURN,
      * or some error.
@@ -671,24 +513,5 @@
 
     for (;;) {
-#ifdef TCL_COMPILE_DEBUG
-	ValidatePcAndStackTop(codePtr, pc, stackTop, initStackTop,
-		eePtr->stackEnd);
-#else /* not TCL_COMPILE_DEBUG */
-	if (traceInstructions) {
-#ifdef TCL_COMPILE_STATS
-	    fprintf(stdout, "%d: %d,%ld ", iPtr->numLevels, stackTop,
-		    (tclObjsAlloced - tclObjsFreed));
-#else /* TCL_COMPILE_STATS */
-	    fprintf(stdout, "%d: %d ", iPtr->numLevels, stackTop);
-#endif /* TCL_COMPILE_STATS */
-	    TclPrintInstruction(codePtr, pc);
-	    fflush(stdout);
-	}
-#endif /* TCL_COMPILE_DEBUG */
-	
 	opCode = *pc;
-#ifdef TCL_COMPILE_STATS    
-	instructionCount[opCode]++;
-#endif /* TCL_COMPILE_STATS */
 
         switch (opCode) {
@@ -710,6 +533,4 @@
 		panic("TclExecuteByteCode execution failure: end stack top != start stack top");
 	    }
-	    TRACE_WITH_OBJ(("done => return code=%d, result is ", result),
-		    iPtr->objResultPtr);
 	    goto done;
 	    
@@ -717,6 +538,4 @@
 	    valuePtr = objArrayPtr[TclGetUInt1AtPtr(pc+1)];
 	    PUSH_OBJECT(valuePtr);
-	    TRACE_WITH_OBJ(("push1 %u => ", TclGetUInt1AtPtr(pc+1)),
-	            valuePtr);
 	    ADJUST_PC(2);
 	    
@@ -724,11 +543,8 @@
 	    valuePtr = objArrayPtr[TclGetUInt4AtPtr(pc+1)];
 	    PUSH_OBJECT(valuePtr);
-	    TRACE_WITH_OBJ(("push4 %u => ", TclGetUInt4AtPtr(pc+1)),
-		    valuePtr);
 	    ADJUST_PC(5);
 	    
 	case INST_POP:
 	    valuePtr = POP_OBJECT();
-	    TRACE_WITH_OBJ(("pop => discarding "), valuePtr);
 	    TclDecrRefCount(valuePtr); /* finished with pop'ed object. */
 	    ADJUST_PC(1);
@@ -737,5 +553,4 @@
 	    valuePtr = stackPtr[stackTop].o;
 	    PUSH_OBJECT(Tcl_DuplicateObj(valuePtr));
-	    TRACE_WITH_OBJ(("dup => "), valuePtr);
 	    ADJUST_PC(1);
 
@@ -790,5 +605,4 @@
 		
 		PUSH_OBJECT(concatObjPtr);
-		TRACE_WITH_OBJ(("concat %u => ", opnd), concatObjPtr);
 		ADJUST_PC(2);
             }
@@ -815,8 +629,4 @@
 				    * Init. to avoid compiler warning. */
 		Tcl_Command cmd;
-#ifdef TCL_COMPILE_DEBUG
-		int isUnknownCmd = 0;
-		char cmdNameBuf[30];
-#endif /* TCL_COMPILE_DEBUG */
 		
 		/*
@@ -867,13 +677,8 @@
 			        "invalid command name \"", cmdName, "\"",
 				(char *) NULL);
-			TRACE(("%s %u => unknown proc not found: ",
-			       opName[opCode], objc));
 			result = TCL_ERROR;
 			goto checkForCatch;
 		    }
 		    cmdPtr = (Command *) cmd;
-#ifdef TCL_COMPILE_DEBUG
-		    isUnknownCmd = 1;
-#endif /*TCL_COMPILE_DEBUG*/			
 		    stackTop++; /* need room for new inserted objv[0] */
 		    for (i = objc;  i >= 0;  i--) {
@@ -918,37 +723,4 @@
 		Tcl_ResetResult(interp);
 
-		if (tclTraceExec >= 2) {
-		    char buffer[50];
-
-		    sprintf(buffer, "%d: (%u) invoking ", iPtr->numLevels,
-			    (unsigned int)(pc - codePtr->codeStart));
-		    Tcl_DStringAppend(&command, buffer, -1);
-		    
-#ifdef TCL_COMPILE_DEBUG
-		    if (traceInstructions) { /* tclTraceExec == 3 */
-			strncpy(cmdNameBuf, cmdName, 20);
-			TRACE(("%s %u => call ", opName[opCode],
-			       (isUnknownCmd? objc-1 : objc)));
-		    } else {
-			fprintf(stdout, "%s", buffer);
-		    }
-#else /* TCL_COMPILE_DEBUG */
-		    fprintf(stdout, "%s", buffer);
-#endif /*TCL_COMPILE_DEBUG*/
-
-		    for (i = 0;  i < objc;  i++) {
-			bytes = TclGetStringFromObj(objv[i], &length);
-			TclPrintSource(stdout, bytes, TclMin(length, 15));
-			fprintf(stdout, " ");
-
-			sprintf(buffer, "\"%.*s\" ", TclMin(length, 15), bytes);
-			Tcl_DStringAppend(&command, buffer, -1);
-		    }
-		    fprintf(stdout, "\n");
-		    fflush(stdout);
-
-		    Tcl_DStringFree(&command);
-		}
-
 		iPtr->cmdCount++;
 		DECACHE_STACK_INFO();
@@ -996,7 +768,4 @@
 		     */
 		    PUSH_OBJECT(Tcl_GetObjResult(interp));
-		    TRACE_WITH_OBJ(("%s %u => ...after \"%.20s\", result=",
-		            opName[opCode], objc, cmdNameBuf),
-			    Tcl_GetObjResult(interp));
 		    ADJUST_PC(pcAdjustment);
 		    
@@ -1015,7 +784,4 @@
                             /*catchOnly*/ 0, codePtr);
 		    if (rangePtr == NULL) {
-		        TRACE(("%s %u => ... after \"%.20s\", no encl. loop or catch, returning %s\n",
-		                opName[opCode], objc, cmdNameBuf,
-			        StringForResultCode(result)));
 			goto abnormalReturn; /* no catch exists to check */
 		    }
@@ -1025,20 +791,10 @@
 			    newPcOffset = rangePtr->breakOffset;
 			} else if (rangePtr->continueOffset == -1) {
-			    TRACE(("%s %u => ... after \"%.20s\", %s, loop w/o continue, checking for catch\n",
-				   opName[opCode], objc, cmdNameBuf,
-				   StringForResultCode(result)));
 			    goto checkForCatch;
 			} else {
 			    newPcOffset = rangePtr->continueOffset;
 			}
-			TRACE(("%s %u => ... after \"%.20s\", %s, range at %d, new pc %d\n",
-			       opName[opCode], objc, cmdNameBuf,
-			       StringForResultCode(result),
-			       rangePtr->codeOffset, newPcOffset));
 			break;
 		    case CATCH_EXCEPTION_RANGE:
-			TRACE(("%s %u => ... after \"%.20s\", %s...\n",
-			       opName[opCode], objc, cmdNameBuf,
-			       StringForResultCode(result)));
 			goto processCatch; /* it will use rangePtr */
 		    default:
@@ -1054,7 +810,4 @@
 		     * enclosing catch exception range, if any.
 		     */
-		    TRACE_WITH_OBJ(("%s %u => ... after \"%.20s\", TCL_ERROR ",
-		            opName[opCode], objc, cmdNameBuf),
-			    Tcl_GetObjResult(interp));
 		    goto checkForCatch;
 
@@ -1065,12 +818,7 @@
 		     * for an enclosing catch exception range, if any.
 		     */
-		    TRACE(("%s %u => ... after \"%.20s\", TCL_RETURN\n",
-		            opName[opCode], objc, cmdNameBuf));
 		    goto checkForCatch;
 
 		default:
-		    TRACE_WITH_OBJ(("%s %u => ... after \"%.20s\", OTHER RETURN CODE %d ",
-		            opName[opCode], objc, cmdNameBuf, result),
-			    Tcl_GetObjResult(interp));
 		    goto checkForCatch;
 		} /* end of switch on result from invoke instruction */
@@ -1088,6 +836,4 @@
 		
 		PUSH_OBJECT(Tcl_GetObjResult(interp));
-		TRACE_WITH_OBJ(("evalStk \"%.30s\" => ", O2S(objPtr)),
-			Tcl_GetObjResult(interp));
 		TclDecrRefCount(objPtr);
 		ADJUST_PC(1);
@@ -1109,6 +855,4 @@
 			codePtr);
 		if (rangePtr == NULL) {
-		    TRACE(("evalStk \"%.30s\" => no encl. loop or catch, returning %s\n",
-			    O2S(objPtr), StringForResultCode(result)));
 		    Tcl_DecrRefCount(objPtr);
 		    goto abnormalReturn;    /* no catch exists to check */
@@ -1119,6 +863,4 @@
 			newPcOffset = rangePtr->breakOffset;
 		    } else if (rangePtr->continueOffset == -1) {
-			TRACE(("evalStk \"%.30s\" => %s, loop w/o continue, checking for catch\n",
-			       O2S(objPtr), StringForResultCode(result)));
 			Tcl_DecrRefCount(objPtr);
 			goto checkForCatch;
@@ -1127,12 +869,6 @@
 		    }
 		    result = TCL_OK;
-		    TRACE_WITH_OBJ(("evalStk \"%.30s\" => %s, range at %d, new pc %d ",
-			    O2S(objPtr), StringForResultCode(result),
-			    rangePtr->codeOffset, newPcOffset), valuePtr);
 		    break;
 		case CATCH_EXCEPTION_RANGE:
-		    TRACE_WITH_OBJ(("evalStk \"%.30s\" => %s ",
-			    O2S(objPtr), StringForResultCode(result)),
-			    valuePtr);
 		    Tcl_DecrRefCount(objPtr);
 		    goto processCatch;  /* it will use rangePtr */
@@ -1144,6 +880,4 @@
 		continue;	/* restart outer instruction loop at pc */
 	    } else { /* eval returned TCL_ERROR, TCL_RETURN, unknown code */
-		TRACE_WITH_OBJ(("evalStk \"%.30s\" => ERROR: ", O2S(objPtr)),
-		        Tcl_GetObjResult(interp));
 		Tcl_DecrRefCount(objPtr);
 		goto checkForCatch;
@@ -1157,11 +891,8 @@
 	    CACHE_STACK_INFO();
 	    if (result != TCL_OK) {
-		TRACE_WITH_OBJ(("exprStk \"%.30s\" => ERROR: ", 
-		        O2S(objPtr)), Tcl_GetObjResult(interp));
 		Tcl_DecrRefCount(objPtr);
 		goto checkForCatch;
 	    }
 	    stackPtr[++stackTop].o = valuePtr; /* already has right refct */
-	    TRACE_WITH_OBJ(("exprStk \"%.30s\" => ", O2S(objPtr)), valuePtr);
 	    TclDecrRefCount(objPtr);
 	    ADJUST_PC(1);
@@ -1182,11 +913,8 @@
 	    CACHE_STACK_INFO();
 	    if (valuePtr == NULL) {
-		TRACE_WITH_OBJ(("%s %u => ERROR: ", opName[opCode], opnd),
-			Tcl_GetObjResult(interp));
 		result = TCL_ERROR;
 		goto checkForCatch;
             }
 	    PUSH_OBJECT(valuePtr);
-	    TRACE_WITH_OBJ(("%s %u => ", opName[opCode], opnd), valuePtr);
 	    ADJUST_PC(pcAdjustment);
 
@@ -1198,6 +926,4 @@
 	    CACHE_STACK_INFO();
 	    if (valuePtr == NULL) {
-		TRACE_WITH_OBJ(("loadScalarStk \"%.30s\" => ERROR: ",
-		        O2S(namePtr)), Tcl_GetObjResult(interp));
 		Tcl_DecrRefCount(namePtr);
 		result = TCL_ERROR;
@@ -1205,6 +931,4 @@
             }
 	    PUSH_OBJECT(valuePtr);
-	    TRACE_WITH_OBJ(("loadScalarStk \"%.30s\" => ",
-		    O2S(namePtr)), valuePtr);
 	    TclDecrRefCount(namePtr);
 	    ADJUST_PC(1);
@@ -1228,7 +952,4 @@
 		CACHE_STACK_INFO();
 		if (valuePtr == NULL) {
-		    TRACE_WITH_OBJ(("%s %u \"%.30s\" => ERROR: ",
-			    opName[opCode], opnd, O2S(elemPtr)),
-			    Tcl_GetObjResult(interp));
 		    Tcl_DecrRefCount(elemPtr);
 		    result = TCL_ERROR;
@@ -1236,6 +957,4 @@
 		}
 		PUSH_OBJECT(valuePtr);
-		TRACE_WITH_OBJ(("%s %u \"%.30s\" => ",
-		        opName[opCode], opnd, O2S(elemPtr)), valuePtr);
 		TclDecrRefCount(elemPtr);
 	    }
@@ -1252,7 +971,4 @@
 		CACHE_STACK_INFO();
 		if (valuePtr == NULL) {
-		    TRACE_WITH_OBJ(("loadArrayStk \"%.30s(%.30s)\" => ERROR: ",
-		            O2S(namePtr), O2S(elemPtr)),
-			    Tcl_GetObjResult(interp));
 		    Tcl_DecrRefCount(namePtr);
 		    Tcl_DecrRefCount(elemPtr);
@@ -1261,6 +977,4 @@
 		}
 		PUSH_OBJECT(valuePtr);
-		TRACE_WITH_OBJ(("loadArrayStk \"%.30s(%.30s)\" => ",
-		        O2S(namePtr), O2S(elemPtr)), valuePtr);
 		TclDecrRefCount(namePtr);
 		TclDecrRefCount(elemPtr);
@@ -1275,6 +989,4 @@
 	    CACHE_STACK_INFO();
 	    if (valuePtr == NULL) {
-		TRACE_WITH_OBJ(("loadStk \"%.30s\" => ERROR: ",
-		        O2S(namePtr)), Tcl_GetObjResult(interp));
 		Tcl_DecrRefCount(namePtr);
 		result = TCL_ERROR;
@@ -1282,6 +994,4 @@
 	    }
 	    PUSH_OBJECT(valuePtr);
-	    TRACE_WITH_OBJ(("loadStk \"%.30s\" => ", O2S(namePtr)),
-		    valuePtr);
 	    TclDecrRefCount(namePtr);
 	    ADJUST_PC(1);
@@ -1303,7 +1013,4 @@
 	    CACHE_STACK_INFO();
 	    if (value2Ptr == NULL) {
-		TRACE_WITH_OBJ(("%s %u <- \"%.30s\" => ERROR: ",
-			opName[opCode], opnd, O2S(valuePtr)),
-			Tcl_GetObjResult(interp));
 		Tcl_DecrRefCount(valuePtr);
 		result = TCL_ERROR;
@@ -1311,6 +1018,4 @@
 	    }
 	    PUSH_OBJECT(value2Ptr);
-	    TRACE_WITH_OBJ(("%s %u <- \"%.30s\" => ",
-		    opName[opCode], opnd, O2S(valuePtr)), value2Ptr);
 	    TclDecrRefCount(valuePtr);
 	    ADJUST_PC(pcAdjustment);
@@ -1324,8 +1029,4 @@
 	    CACHE_STACK_INFO();
 	    if (value2Ptr == NULL) {
-		TRACE_WITH_OBJ(
-			("storeScalarStk \"%.30s\" <- \"%.30s\" => ERROR: ",
-		        O2S(namePtr), O2S(valuePtr)),
-			Tcl_GetObjResult(interp));
 		Tcl_DecrRefCount(namePtr);
 		Tcl_DecrRefCount(valuePtr);
@@ -1334,9 +1035,4 @@
 	    }
 	    PUSH_OBJECT(value2Ptr);
-	    TRACE_WITH_OBJ(
-		    ("storeScalarStk \"%.30s\" <- \"%.30s\" => ",
-		    O2S(namePtr),
-		    O2S(valuePtr)),
-		    value2Ptr);
 	    TclDecrRefCount(namePtr);
 	    TclDecrRefCount(valuePtr);
@@ -1363,8 +1059,4 @@
 		CACHE_STACK_INFO();
 		if (value2Ptr == NULL) {
-		    TRACE_WITH_OBJ(
-			    ("%s %u \"%.30s\" <- \"%.30s\" => ERROR: ",
-			    opName[opCode], opnd, O2S(elemPtr),
-			    O2S(valuePtr)), Tcl_GetObjResult(interp));
 		    Tcl_DecrRefCount(elemPtr);
 		    Tcl_DecrRefCount(valuePtr);
@@ -1373,7 +1065,4 @@
 		}
 		PUSH_OBJECT(value2Ptr);
-		TRACE_WITH_OBJ(("%s %u \"%.30s\" <- \"%.30s\" => ",
-		        opName[opCode], opnd, O2S(elemPtr), O2S(valuePtr)),
-		        value2Ptr);
 		TclDecrRefCount(elemPtr);
 		TclDecrRefCount(valuePtr);
@@ -1393,7 +1082,4 @@
 		CACHE_STACK_INFO();
 		if (value2Ptr == NULL) {
-		    TRACE_WITH_OBJ(("storeArrayStk \"%.30s(%.30s)\" <- \"%.30s\" => ERROR: ",
-		            O2S(namePtr), O2S(elemPtr), O2S(valuePtr)),
-			    Tcl_GetObjResult(interp));
 		    Tcl_DecrRefCount(namePtr);
 		    Tcl_DecrRefCount(elemPtr);
@@ -1403,7 +1089,4 @@
 		}
 		PUSH_OBJECT(value2Ptr);
-		TRACE_WITH_OBJ(("storeArrayStk \"%.30s(%.30s)\" <- \"%.30s\" => ",
-		        O2S(namePtr), O2S(elemPtr), O2S(valuePtr)),
-			value2Ptr);
 		TclDecrRefCount(namePtr);
 		TclDecrRefCount(elemPtr);
@@ -1420,7 +1103,4 @@
 	    CACHE_STACK_INFO();
 	    if (value2Ptr == NULL) {
-		TRACE_WITH_OBJ(("storeStk \"%.30s\" <- \"%.30s\" => ERROR: ",
-		        O2S(namePtr), O2S(valuePtr)),
-			Tcl_GetObjResult(interp));
 		Tcl_DecrRefCount(namePtr);
 		Tcl_DecrRefCount(valuePtr);
@@ -1429,6 +1109,4 @@
 	    }
 	    PUSH_OBJECT(value2Ptr);
-	    TRACE_WITH_OBJ(("storeStk \"%.30s\" <- \"%.30s\" => ",
-		    O2S(namePtr), O2S(valuePtr)), value2Ptr);
 	    TclDecrRefCount(namePtr);
 	    TclDecrRefCount(valuePtr);
@@ -1441,6 +1119,4 @@
 		result = tclIntType.setFromAnyProc(interp, valuePtr);
 		if (result != TCL_OK) {
-		    TRACE_WITH_OBJ(("incrScalar1 %u (by %s) => ERROR converting increment amount to int: ",
-		            opnd, O2S(valuePtr)), Tcl_GetObjResult(interp));
 		    Tcl_DecrRefCount(valuePtr);
 		    goto checkForCatch;
@@ -1452,6 +1128,4 @@
 	    CACHE_STACK_INFO();
 	    if (value2Ptr == NULL) {
-		TRACE_WITH_OBJ(("incrScalar1 %u (by %ld) => ERROR: ",
-		        opnd, i), Tcl_GetObjResult(interp));
 		Tcl_DecrRefCount(valuePtr);
 		result = TCL_ERROR;
@@ -1459,6 +1133,4 @@
 	    }
 	    PUSH_OBJECT(value2Ptr);
-	    TRACE_WITH_OBJ(("incrScalar1 %u (by %ld) => ", opnd, i),
-		    value2Ptr);
 	    TclDecrRefCount(valuePtr);
 	    ADJUST_PC(2);
@@ -1471,7 +1143,4 @@
 		result = tclIntType.setFromAnyProc(interp, valuePtr);
 		if (result != TCL_OK) {
-		    TRACE_WITH_OBJ(("%s \"%.30s\" (by %s) => ERROR converting increment amount to int: ",
-		            opName[opCode], O2S(namePtr), O2S(valuePtr)),
-			    Tcl_GetObjResult(interp));
 		    Tcl_DecrRefCount(namePtr);
 		    Tcl_DecrRefCount(valuePtr);
@@ -1485,7 +1154,4 @@
 	    CACHE_STACK_INFO();
 	    if (value2Ptr == NULL) {
-		TRACE_WITH_OBJ(("%s \"%.30s\" (by %ld) => ERROR: ",
-		        opName[opCode], O2S(namePtr), i),
-			Tcl_GetObjResult(interp));
 		Tcl_DecrRefCount(namePtr);
 		Tcl_DecrRefCount(valuePtr);
@@ -1494,6 +1160,4 @@
 	    }
 	    PUSH_OBJECT(value2Ptr);
-	    TRACE_WITH_OBJ(("%s \"%.30s\" (by %ld) => ",
-	            opName[opCode], O2S(namePtr), i), value2Ptr);
 	    Tcl_DecrRefCount(namePtr);
 	    Tcl_DecrRefCount(valuePtr);
@@ -1510,7 +1174,4 @@
 		    result = tclIntType.setFromAnyProc(interp, valuePtr);
 		    if (result != TCL_OK) {
-			TRACE_WITH_OBJ(("incrArray1 %u \"%.30s\" (by %s) => ERROR converting increment amount to int: ",
-		                opnd, O2S(elemPtr), O2S(valuePtr)),
-			        Tcl_GetObjResult(interp));
 			Tcl_DecrRefCount(elemPtr);
 			Tcl_DecrRefCount(valuePtr);
@@ -1524,7 +1185,4 @@
 		CACHE_STACK_INFO();
 		if (value2Ptr == NULL) {
-		    TRACE_WITH_OBJ(("incrArray1 %u \"%.30s\" (by %ld) => ERROR: ",
-		            opnd, O2S(elemPtr), i),
-			    Tcl_GetObjResult(interp));
 		    Tcl_DecrRefCount(elemPtr);
 		    Tcl_DecrRefCount(valuePtr);
@@ -1533,6 +1191,4 @@
 		}
 		PUSH_OBJECT(value2Ptr);
-		TRACE_WITH_OBJ(("incrArray1 %u \"%.30s\" (by %ld) => ",
-	                opnd, O2S(elemPtr), i), value2Ptr);
 		Tcl_DecrRefCount(elemPtr);
 		Tcl_DecrRefCount(valuePtr);
@@ -1550,7 +1206,4 @@
 		    result = tclIntType.setFromAnyProc(interp, valuePtr);
 		    if (result != TCL_OK) {
-		        TRACE_WITH_OBJ(("incrArrayStk \"%.30s(%.30s)\" (by %s) => ERROR converting increment amount to int: ",
-		                O2S(namePtr), O2S(elemPtr), O2S(valuePtr)),
-			        Tcl_GetObjResult(interp));
 			Tcl_DecrRefCount(namePtr);
 			Tcl_DecrRefCount(elemPtr);
@@ -1565,7 +1218,4 @@
 		CACHE_STACK_INFO();
 		if (value2Ptr == NULL) {
-		    TRACE_WITH_OBJ(("incrArrayStk \"%.30s(%.30s)\" (by %ld) => ERROR: ",
-		            O2S(namePtr), O2S(elemPtr), i),
-			    Tcl_GetObjResult(interp));
 		    Tcl_DecrRefCount(namePtr);
 		    Tcl_DecrRefCount(elemPtr);
@@ -1575,6 +1225,4 @@
 		}
 		PUSH_OBJECT(value2Ptr);
-		TRACE_WITH_OBJ(("incrArrayStk \"%.30s(%.30s)\" (by %ld) => ",
-	                O2S(namePtr), O2S(elemPtr), i), value2Ptr);
 		Tcl_DecrRefCount(namePtr);
 		Tcl_DecrRefCount(elemPtr);
@@ -1590,12 +1238,8 @@
 	    CACHE_STACK_INFO();
 	    if (value2Ptr == NULL) {
-		TRACE_WITH_OBJ(("incrScalar1Imm %u %ld => ERROR: ",
-		        opnd, i), Tcl_GetObjResult(interp));
 		result = TCL_ERROR;
 		goto checkForCatch;
 	    }
 	    PUSH_OBJECT(value2Ptr);
-	    TRACE_WITH_OBJ(("incrScalar1Imm %u %ld => ", opnd, i),
-		    value2Ptr);
 	    ADJUST_PC(3);
 
@@ -1609,7 +1253,4 @@
 	    CACHE_STACK_INFO();
 	    if (value2Ptr == NULL) {
-		TRACE_WITH_OBJ(("%s \"%.30s\" %ld => ERROR: ",
-		        opName[opCode], O2S(namePtr), i),
-			Tcl_GetObjResult(interp));
 		result = TCL_ERROR;
 		Tcl_DecrRefCount(namePtr);
@@ -1617,6 +1258,4 @@
 	    }
 	    PUSH_OBJECT(value2Ptr);
-	    TRACE_WITH_OBJ(("%s \"%.30s\" %ld => ",
-	            opName[opCode], O2S(namePtr), i), value2Ptr);
 	    TclDecrRefCount(namePtr);
 	    ADJUST_PC(2);
@@ -1634,7 +1273,4 @@
 		CACHE_STACK_INFO();
 		if (value2Ptr == NULL) {
-		    TRACE_WITH_OBJ(("incrArray1Imm %u \"%.30s\" (by %ld) => ERROR: ",
-		            opnd, O2S(elemPtr), i),
-			    Tcl_GetObjResult(interp));
 		    Tcl_DecrRefCount(elemPtr);
 		    result = TCL_ERROR;
@@ -1642,6 +1278,4 @@
 		}
 		PUSH_OBJECT(value2Ptr);
-		TRACE_WITH_OBJ(("incrArray1Imm %u \"%.30s\" (by %ld) => ",
-	                opnd, O2S(elemPtr), i), value2Ptr);
 		Tcl_DecrRefCount(elemPtr);
 	    }
@@ -1660,7 +1294,4 @@
 		CACHE_STACK_INFO();
 		if (value2Ptr == NULL) {
-		    TRACE_WITH_OBJ(("incrArrayStkImm \"%.30s(%.30s)\" (by %ld) => ERROR: ",
-		            O2S(namePtr), O2S(elemPtr), i),
-			    Tcl_GetObjResult(interp));
 		    Tcl_DecrRefCount(namePtr);
 		    Tcl_DecrRefCount(elemPtr);
@@ -1669,6 +1300,4 @@
 		}
 		PUSH_OBJECT(value2Ptr);
-		TRACE_WITH_OBJ(("incrArrayStkImm \"%.30s(%.30s)\" (by %ld) => ",
-	                O2S(namePtr), O2S(elemPtr), i), value2Ptr);
 		Tcl_DecrRefCount(namePtr);
 		Tcl_DecrRefCount(elemPtr);
@@ -1678,12 +1307,8 @@
 	case INST_JUMP1:
 	    opnd = TclGetInt1AtPtr(pc+1);
-	    TRACE(("jump1 %d => new pc %u\n", opnd,
-		   (unsigned int)(pc + opnd - codePtr->codeStart)));
 	    ADJUST_PC(opnd);
 
 	case INST_JUMP4:
 	    opnd = TclGetInt4AtPtr(pc+1);
-	    TRACE(("jump4 %d => new pc %u\n", opnd,
-		   (unsigned int)(pc + opnd - codePtr->codeStart)));
 	    ADJUST_PC(opnd);
 
@@ -1709,6 +1334,4 @@
 		    result = Tcl_GetBooleanFromObj(interp, valuePtr, &b);
 		    if (result != TCL_OK) {
-			TRACE_WITH_OBJ(("%s %d => ERROR: ", opName[opCode],
-				opnd), Tcl_GetObjResult(interp));
 			Tcl_DecrRefCount(valuePtr);
 			goto checkForCatch;
@@ -1716,12 +1339,7 @@
 		}
 		if (b) {
-		    TRACE(("%s %d => %.20s true, new pc %u\n",
-			    opName[opCode], opnd, O2S(valuePtr),
-		            (unsigned int)(pc+opnd - codePtr->codeStart)));
 		    TclDecrRefCount(valuePtr);
 		    ADJUST_PC(opnd);
 		} else {
-		    TRACE(("%s %d => %.20s false\n", opName[opCode], opnd,
-		            O2S(valuePtr)));
 		    TclDecrRefCount(valuePtr);
 		    ADJUST_PC(pcAdjustment);
@@ -1750,6 +1368,4 @@
 		    result = Tcl_GetBooleanFromObj(interp, valuePtr, &b);
 		    if (result != TCL_OK) {
-			TRACE_WITH_OBJ(("%s %d => ERROR: ", opName[opCode],
-				opnd), Tcl_GetObjResult(interp));
 			Tcl_DecrRefCount(valuePtr);
 			goto checkForCatch;
@@ -1757,12 +1373,7 @@
 		}
 		if (b) {
-		    TRACE(("%s %d => %.20s true\n", opName[opCode], opnd,
-		            O2S(valuePtr)));
 		    TclDecrRefCount(valuePtr);
 		    ADJUST_PC(pcAdjustment);
 		} else {
-		    TRACE(("%s %d => %.20s false, new pc %u\n",
-			    opName[opCode], opnd, O2S(valuePtr),
-			   (unsigned int)(pc + opnd - codePtr->codeStart)));
 		    TclDecrRefCount(valuePtr);
 		    ADJUST_PC(opnd);
@@ -1804,7 +1415,4 @@
 		    }
 		    if (result != TCL_OK) {
-			TRACE(("%s \"%.20s\" => ILLEGAL TYPE %s \n",
-			        opName[opCode], O2S(valuePtr),
-			        (t1Ptr? t1Ptr->name : "null")));
 			IllegalExprOperandType(interp, opCode, valuePtr);
 			Tcl_DecrRefCount(valuePtr);
@@ -1830,7 +1438,4 @@
 		    }
 		    if (result != TCL_OK) {
-			TRACE(("%s \"%.20s\" => ILLEGAL TYPE %s \n",
-			        opName[opCode], O2S(value2Ptr),
-			        (t2Ptr? t2Ptr->name : "null")));
 			IllegalExprOperandType(interp, opCode, value2Ptr);
 			Tcl_DecrRefCount(valuePtr);
@@ -1851,11 +1456,6 @@
 		if (Tcl_IsShared(valuePtr)) {
 		    PUSH_OBJECT(Tcl_NewLongObj(iResult));
-		    TRACE(("%s %.20s %.20s => %d\n", opName[opCode],
-			   O2S(valuePtr), O2S(value2Ptr), iResult));
 		    TclDecrRefCount(valuePtr);
 		} else {	/* reuse the valuePtr object */
-		    TRACE(("%s %.20s %.20s => %d\n", 
-			   opName[opCode], /* NB: stack top is off by 1 */
-			   O2S(valuePtr), O2S(value2Ptr), iResult));
 		    Tcl_SetLongObj(valuePtr, iResult);
 		    ++stackTop; /* valuePtr now on stk top has right r.c. */
@@ -2013,11 +1613,6 @@
 		if (Tcl_IsShared(valuePtr)) {
 		    PUSH_OBJECT(Tcl_NewLongObj(iResult));
-		    TRACE(("%s %.20s %.20s => %ld\n", opName[opCode],
-		        O2S(valuePtr), O2S(value2Ptr), iResult));
 		    TclDecrRefCount(valuePtr);
 		} else {	/* reuse the valuePtr object */
-		    TRACE(("%s %.20s %.20s => %ld\n",
-			opName[opCode], /* NB: stack top is off by 1 */
-		        O2S(valuePtr), O2S(value2Ptr), iResult));
 		    Tcl_SetLongObj(valuePtr, iResult);
 		    ++stackTop; /* valuePtr now on stk top has right r.c. */
@@ -2049,8 +1644,4 @@
 			    valuePtr, &i);
 		    if (result != TCL_OK) {
-			TRACE(("%s %.20s %.20s => ILLEGAL 1st TYPE %s\n",
-			      opName[opCode], O2S(valuePtr), O2S(value2Ptr),
-			      (valuePtr->typePtr?
-				   valuePtr->typePtr->name : "null")));
 			IllegalExprOperandType(interp, opCode, valuePtr);
 			Tcl_DecrRefCount(valuePtr);
@@ -2065,8 +1656,4 @@
 			    value2Ptr, &i2);
 		    if (result != TCL_OK) {
-			TRACE(("%s %.20s %.20s => ILLEGAL 2nd TYPE %s\n",
-			      opName[opCode], O2S(valuePtr), O2S(value2Ptr),
-			      (value2Ptr->typePtr?
-				   value2Ptr->typePtr->name : "null")));
 			IllegalExprOperandType(interp, opCode, value2Ptr);
 			Tcl_DecrRefCount(valuePtr);
@@ -2085,5 +1672,4 @@
 		     */
 		    if (i2 == 0) {
-			TRACE(("mod %ld %ld => DIVIDE BY ZERO\n", i, i2));
 			Tcl_DecrRefCount(valuePtr);
 			Tcl_DecrRefCount(value2Ptr);
@@ -2137,10 +1723,6 @@
 		if (Tcl_IsShared(valuePtr)) {
 		    PUSH_OBJECT(Tcl_NewLongObj(iResult));
-		    TRACE(("%s %ld %ld => %ld\n", opName[opCode], i, i2,
-			   iResult));
 		    TclDecrRefCount(valuePtr);
 		} else {	/* reuse the valuePtr object */
-		    TRACE(("%s %ld %ld => %ld\n", opName[opCode], i, i2,
-		        iResult)); /* NB: stack top is off by 1 */
 		    Tcl_SetLongObj(valuePtr, iResult);
 		    ++stackTop; /* valuePtr now on stk top has right r.c. */
@@ -2186,8 +1768,4 @@
 		    }
 		    if (result != TCL_OK) {
-			TRACE(("%s %.20s %.20s => ILLEGAL 1st TYPE %s\n",
-			       opName[opCode], s, O2S(value2Ptr),
-			       (valuePtr->typePtr?
-				    valuePtr->typePtr->name : "null")));
 			IllegalExprOperandType(interp, opCode, valuePtr);
 			Tcl_DecrRefCount(valuePtr);
@@ -2212,8 +1790,4 @@
 		    }
 		    if (result != TCL_OK) {
-			TRACE(("%s %.20s %.20s => ILLEGAL 2nd TYPE %s\n",
-			       opName[opCode], O2S(valuePtr), s,
-			       (value2Ptr->typePtr?
-				    value2Ptr->typePtr->name : "null")));
 			IllegalExprOperandType(interp, opCode, value2Ptr);
 			Tcl_DecrRefCount(valuePtr);
@@ -2246,6 +1820,4 @@
 		    case INST_DIV:
 			if (d2 == 0.0) {
-			    TRACE(("div %.6g %.6g => DIVIDE BY ZERO\n",
-				   d1, d2));
 			    Tcl_DecrRefCount(valuePtr);
 			    Tcl_DecrRefCount(value2Ptr);
@@ -2261,6 +1833,4 @@
 		    
 		    if (IS_NAN(dResult) || IS_INF(dResult)) {
-			TRACE(("%s %.20s %.20s => IEEE FLOATING PT ERROR\n",
-			       opName[opCode], O2S(valuePtr), O2S(value2Ptr)));
 			TclExprFloatError(interp, dResult);
 			result = TCL_ERROR;
@@ -2291,6 +1861,4 @@
 			 */
 			if (i2 == 0) {
-			    TRACE(("div %ld %ld => DIVIDE BY ZERO\n",
-				    i, i2));
 			    Tcl_DecrRefCount(valuePtr);
 			    Tcl_DecrRefCount(value2Ptr);
@@ -2318,20 +1886,12 @@
 		    if (doDouble) {
 			PUSH_OBJECT(Tcl_NewDoubleObj(dResult));
-			TRACE(("%s %.6g %.6g => %.6g\n", opName[opCode],
-			       d1, d2, dResult));
 		    } else {
 			PUSH_OBJECT(Tcl_NewLongObj(iResult));
-			TRACE(("%s %ld %ld => %ld\n", opName[opCode],
-			       i, i2, iResult));
 		    } 
 		    TclDecrRefCount(valuePtr);
 		} else {	    /* reuse the valuePtr object */
 		    if (doDouble) { /* NB: stack top is off by 1 */
-			TRACE(("%s %.6g %.6g => %.6g\n", opName[opCode],
-			       d1, d2, dResult));
 			Tcl_SetDoubleObj(valuePtr, dResult);
 		    } else {
-			TRACE(("%s %ld %ld => %ld\n", opName[opCode],
-			       i, i2, iResult));
 			Tcl_SetLongObj(valuePtr, iResult);
 		    }
@@ -2363,12 +1923,8 @@
 		    }
 		    if (result != TCL_OK) { 
-			TRACE(("%s \"%.20s\" => ILLEGAL TYPE %s \n",
-			        opName[opCode], s,
-			        (tPtr? tPtr->name : "null")));
 			IllegalExprOperandType(interp, opCode, valuePtr);
 			goto checkForCatch;
 		    }
 		}
-		TRACE_WITH_OBJ(("uplus %s => ", O2S(valuePtr)), valuePtr);
 	    }
 	    ADJUST_PC(1);
@@ -2399,7 +1955,4 @@
 		    }
 		    if (result != TCL_OK) {
-			TRACE(("%s \"%.20s\" => ILLEGAL TYPE %s\n",
-			        opName[opCode], s,
-			       (tPtr? tPtr->name : "null")));
 			IllegalExprOperandType(interp, opCode, valuePtr);
 			Tcl_DecrRefCount(valuePtr);
@@ -2417,6 +1970,4 @@
 			objPtr = Tcl_NewLongObj(
 			        (opCode == INST_UMINUS)? -i : !i);
-			TRACE_WITH_OBJ(("%s %ld => ", opName[opCode], i),
-		                objPtr); /* NB: stack top is off by 1 */
 		    } else {
 			d = valuePtr->internalRep.doubleValue;
@@ -2430,6 +1981,4 @@
 			    objPtr = Tcl_NewLongObj((d==0.0)? 1 : 0);
 			}
-			TRACE_WITH_OBJ(("%s %.6g => ", opName[opCode], d),
-		                objPtr); /* NB: stack top is off by 1 */
 		    }
 		    PUSH_OBJECT(objPtr);
@@ -2443,6 +1992,4 @@
 			Tcl_SetLongObj(valuePtr,
 			        (opCode == INST_UMINUS)? -i : !i);
-			TRACE_WITH_OBJ(("%s %ld => ", opName[opCode], i),
-		                valuePtr); /* NB: stack top is off by 1 */
 		    } else {
 			d = valuePtr->internalRep.doubleValue;
@@ -2456,6 +2003,4 @@
 			    Tcl_SetLongObj(valuePtr, (d==0.0)? 1 : 0);
 			}
-			TRACE_WITH_OBJ(("%s %.6g => ", opName[opCode], d),
-		                valuePtr); /* NB: stack top is off by 1 */
 		    }
 		    ++stackTop; /* valuePtr now on stk top has right r.c. */
@@ -2481,6 +2026,4 @@
 			    valuePtr, &i);
 		    if (result != TCL_OK) {   /* try to convert to double */
-			TRACE(("bitnot \"%.20s\" => ILLEGAL TYPE %s\n",
-			       O2S(valuePtr), (tPtr? tPtr->name : "null")));
 			IllegalExprOperandType(interp, opCode, valuePtr);
 			Tcl_DecrRefCount(valuePtr);
@@ -2492,5 +2035,4 @@
 		if (Tcl_IsShared(valuePtr)) {
 		    PUSH_OBJECT(Tcl_NewLongObj(~i));
-		    TRACE(("bitnot 0x%lx => (%lu)\n", i, ~i));
 		    TclDecrRefCount(valuePtr);
 		} else {
@@ -2500,5 +2042,4 @@
 		    Tcl_SetLongObj(valuePtr, ~i);
 		    ++stackTop; /* valuePtr now on stk top has right r.c. */
-		    TRACE(("bitnot 0x%lx => (%lu)\n", i, ~i));
 		}
 	    }
@@ -2515,5 +2056,4 @@
 
 		if ((opnd < 0) || (opnd > LAST_BUILTIN_FUNC)) {
-		    TRACE(("UNRECOGNIZED BUILTIN FUNC CODE %d\n", opnd));
 		    panic("TclExecuteByteCode: unrecognized builtin function code %d", opnd);
 		}
@@ -2528,6 +2068,4 @@
 		    goto checkForCatch;
 		}
-		TRACE_WITH_OBJ(("callBuiltinFunc1 %d => ", opnd),
-		        stackPtr[stackTop].o);
 	    }
 	    ADJUST_PC(2);
@@ -2555,6 +2093,4 @@
 		    goto checkForCatch;
 		}
-		TRACE_WITH_OBJ(("callFunc1 %d => ", objc),
-		        stackPtr[stackTop].o);
 		ADJUST_PC(2);
 	    }
@@ -2627,6 +2163,4 @@
 			d = valuePtr->internalRep.doubleValue;
 			if (IS_NAN(d) || IS_INF(d)) {
-			    TRACE(("tryCvtToNumeric \"%.20s\" => IEEE FLOATING PT ERROR\n",
-			           O2S(valuePtr)));
 			    TclExprFloatError(interp, d);
 			    result = TCL_ERROR;
@@ -2636,11 +2170,4 @@
 		    shared = shared;		/* lint, shared not used. */
 		    converted = converted;	/* lint, converted not used. */
-		    TRACE(("tryCvtToNumeric \"%.20s\" => numeric, %s, %s\n",
-			   O2S(valuePtr),
-			   (converted? "converted" : "not converted"),
-			   (shared? "shared" : "not shared")));
-		} else {
-		    TRACE(("tryCvtToNumeric \"%.20s\" => not numeric\n",
-			   O2S(valuePtr)));
 		}
 	    }
@@ -2660,5 +2187,4 @@
 		    codePtr);
 	    if (rangePtr == NULL) {
-		TRACE(("break => no encl. loop or catch, returning TCL_BREAK\n"));
 		result = TCL_BREAK;
 		goto abnormalReturn; /* no catch exists to check */
@@ -2667,10 +2193,7 @@
 	    case LOOP_EXCEPTION_RANGE:
 		result = TCL_OK;
-		TRACE(("break => range at %d, new pc %d\n",
-		       rangePtr->codeOffset, rangePtr->breakOffset));
 		break;
 	    case CATCH_EXCEPTION_RANGE:
 		result = TCL_BREAK;
-		TRACE(("break => ...\n"));
 		goto processCatch; /* it will use rangePtr */
 	    default:
@@ -2693,5 +2216,4 @@
 		    codePtr);
 	    if (rangePtr == NULL) {
-		TRACE(("continue => no encl. loop or catch, returning TCL_CONTINUE\n"));
 		result = TCL_CONTINUE;
 		goto abnormalReturn;
@@ -2700,15 +2222,11 @@
 	    case LOOP_EXCEPTION_RANGE:
 		if (rangePtr->continueOffset == -1) {
-		    TRACE(("continue => loop w/o continue, checking for catch\n"));
 		    goto checkForCatch;
 		} else {
 		    result = TCL_OK;
-		    TRACE(("continue => range at %d, new pc %d\n",
-			   rangePtr->codeOffset, rangePtr->continueOffset));
 		}
 		break;
 	    case CATCH_EXCEPTION_RANGE:
 		result = TCL_CONTINUE;
-		TRACE(("continue => ...\n"));
 		goto processCatch; /* it will use rangePtr */
 	    default:
@@ -2744,6 +2262,4 @@
 		TclSetVarScalar(iterVarPtr);
 		TclClearVarUndefined(iterVarPtr);
-		TRACE(("foreach_start4 %u => loop iter count temp %d\n", 
-		        opnd, iterTmpIndex));
 	    }
 	    ADJUST_PC(5);
@@ -2794,7 +2310,4 @@
 		    result = Tcl_ListObjLength(interp, listPtr, &listLen);
 		    if (result != TCL_OK) {
-			TRACE_WITH_OBJ(("foreach_step4 %u => ERROR converting list %ld, \"%s\": ",
-			        opnd, i, O2S(listPtr)),
-				Tcl_GetObjResult(interp));
 			goto checkForCatch;
 		    }
@@ -2840,7 +2353,4 @@
 			    CACHE_STACK_INFO();
 			    if (value2Ptr == NULL) {
-				TRACE_WITH_OBJ(("foreach_step4 %u => ERROR init. index temp %d: ",
-				       opnd, varIndex),
-				       Tcl_GetObjResult(interp));
 				if (setEmptyStr) {
 				    Tcl_DecrRefCount(elemPtr); /* unneeded */
@@ -2862,7 +2372,4 @@
 
 		PUSH_OBJECT(Tcl_NewLongObj(continueLoop));
-		TRACE(("foreach_step4 %u => %d lists, iter %d, %s loop\n", 
-		        opnd, numLists, iterNum,
-		        (continueLoop? "continue" : "exit")));
 	    }
 	    ADJUST_PC(5);
@@ -2875,6 +2382,4 @@
 	     */
 	    catchStackPtr[++catchTop] = stackTop;
-	    TRACE(("beginCatch4 %u => catchTop=%d, stackTop=%d\n",
-		    TclGetUInt4AtPtr(pc+1), catchTop, stackTop));
 	    ADJUST_PC(5);
 
@@ -2882,19 +2387,15 @@
 	    catchTop--;
 	    result = TCL_OK;
-	    TRACE(("endCatch => catchTop=%d\n", catchTop));
 	    ADJUST_PC(1);
 
 	case INST_PUSH_RESULT:
 	    PUSH_OBJECT(Tcl_GetObjResult(interp));
-	    TRACE_WITH_OBJ(("pushResult => "), Tcl_GetObjResult(interp));
 	    ADJUST_PC(1);
 
 	case INST_PUSH_RETURN_CODE:
 	    PUSH_OBJECT(Tcl_NewLongObj(result));
-	    TRACE(("pushReturnCode => %u\n", result));
 	    ADJUST_PC(1);
 
 	default:
-	    TRACE(("UNRECOGNIZED INSTRUCTION %u\n", opCode));
 	    panic("TclExecuteByteCode: unrecognized opCode %u", opCode);
 	} /* end of switch on opCode */
@@ -2926,6 +2427,4 @@
 	rangePtr = TclGetExceptionRangeForPc(pc, /*catchOnly*/ 1, codePtr);
 	if (rangePtr == NULL) {
-	    TRACE(("   ... no enclosing catch, returning %s\n",
-		    StringForResultCode(result)));
 	    goto abnormalReturn;
 	}
@@ -2945,7 +2444,4 @@
 	    TclDecrRefCount(valuePtr);
 	}
-	TRACE(("  ... found catch at %d, catchTop=%d, unwound to %d, new pc %u\n",
-	        rangePtr->codeOffset, catchTop, catchStackPtr[catchTop],
-	        (unsigned int)(rangePtr->catchOffset)));
 	pc = (codePtr->codeStart + rangePtr->catchOffset);
 	continue;		/* restart the execution loop at pc */
@@ -2975,140 +2471,4 @@
 #undef STATIC_CATCH_STACK_SIZE
 }
-
-
-/*
- *----------------------------------------------------------------------
- *
- * PrintByteCodeInfo --
- *
- *	This procedure prints a summary about a bytecode object to stdout.
- *	It is called by TclExecuteByteCode when starting to execute the
- *	bytecode object if tclTraceExec has the value 2 or more.
- *
- * Results:
- *	None.
- *
- * Side effects:
- *	None.
- *
- *----------------------------------------------------------------------
- */
-
-static void
-PrintByteCodeInfo(codePtr)
-    register ByteCode *codePtr;	/* The bytecode whose summary is printed
-				 * to stdout. */
-{
-    Proc *procPtr = codePtr->procPtr;
-    int numCmds = codePtr->numCommands;
-    int numObjs = codePtr->numObjects;
-    int objBytes, i;
-
-    objBytes = (numObjs * sizeof(Tcl_Obj));
-    for (i = 0;  i < numObjs;  i++) {
-	Tcl_Obj *litObjPtr = codePtr->objArrayPtr[i];
-	if (litObjPtr->bytes != NULL) {
-	    objBytes += litObjPtr->length;
-	}
-    }
-    
-    fprintf(stdout, "\nExecuting ByteCode 0x%x, ref ct %u, epoch %u, interp 0x%x(epoch %u)\n",
-	    (unsigned int) codePtr, codePtr->refCount,
-	    codePtr->compileEpoch, (unsigned int) codePtr->iPtr,
-	    codePtr->iPtr->compileEpoch);
-    
-    fprintf(stdout, "  Source: ");
-    TclPrintSource(stdout, codePtr->source, 70);
-
-    fprintf(stdout, "\n  Cmds %d, chars %d, inst %u, objs %u, aux %d, stk depth %u, code/src %.2fn",
-            numCmds, codePtr->numSrcChars, codePtr->numCodeBytes, numObjs,
-	    codePtr->numAuxDataItems, codePtr->maxStackDepth,
-	    (codePtr->numSrcChars?
-	            ((float)codePtr->totalSize)/((float)codePtr->numSrcChars) : 0.0));
-
-    fprintf(stdout, "  Code %zu = %u(header)+%d(inst)+%d(objs)+%u(exc)+%u(aux)+%d(cmd map)\n",
-	    codePtr->totalSize, sizeof(ByteCode), codePtr->numCodeBytes,
-	    objBytes, (codePtr->numExcRanges * sizeof(ExceptionRange)),
-	    (codePtr->numAuxDataItems * sizeof(AuxData)),
-	    codePtr->numCmdLocBytes);
-
-    if (procPtr != NULL) {
-	fprintf(stdout,
-		"  Proc 0x%x, ref ct %d, args %d, compiled locals %d\n",
-		(unsigned int) procPtr, procPtr->refCount,
-		procPtr->numArgs, procPtr->numCompiledLocals);
-    }
-}
-
-
-/*
- *----------------------------------------------------------------------
- *
- * ValidatePcAndStackTop --
- *
- *	This procedure is called by TclExecuteByteCode when debugging to
- *	verify that the program counter and stack top are valid during
- *	execution.
- *
- * Results:
- *	None.
- *
- * Side effects:
- *	Prints a message to stderr and panics if either the pc or stack
- *	top are invalid.
- *
- *----------------------------------------------------------------------
- */
-
-#ifdef TCL_COMPILE_DEBUG
-static void
-ValidatePcAndStackTop(codePtr, pc, stackTop, stackLowerBound, stackUpperBound)
-    register ByteCode *codePtr; /* The bytecode whose summary is printed
-				 * to stdout. */
-    unsigned char *pc;		/* Points to first byte of a bytecode
-				 * instruction. The program counter. */
-    int stackTop;		/* Current stack top. Must be between
-				 * stackLowerBound and stackUpperBound
-				 * (inclusive). */
-    int stackLowerBound;	/* Smallest legal value for stackTop. */
-    int stackUpperBound;	/* Greatest legal value for stackTop. */
-{
-    unsigned int relativePc = (unsigned int) (pc - codePtr->codeStart);
-    unsigned int codeStart = (unsigned int) codePtr->codeStart;
-    unsigned int codeEnd = (unsigned int)
-	    (codePtr->codeStart + codePtr->numCodeBytes);
-    unsigned char opCode = *pc;
-
-    if (((unsigned int) pc < codeStart) || ((unsigned int) pc > codeEnd)) {
-	fprintf(stderr, "\nBad instruction pc 0x%x in TclExecuteByteCode\n",
-		(unsigned int) pc);
-	panic("TclExecuteByteCode execution failure: bad pc");
-    }
-    if ((unsigned int) opCode > LAST_INST_OPCODE) {
-	fprintf(stderr, "\nBad opcode %d at pc %u in TclExecuteByteCode\n",
-		(unsigned int) opCode, relativePc);
-	panic("TclExecuteByteCode execution failure: bad opcode");
-    }
-    if ((stackTop < stackLowerBound) || (stackTop > stackUpperBound)) {
-	int numChars;
-	char *cmd = GetSrcInfoForPc(pc, codePtr, &numChars);
-	char *ellipsis = "";
-	
-	fprintf(stderr, "\nBad stack top %d at pc %u in TclExecuteByteCode",
-		stackTop, relativePc);
-	if (cmd != NULL) {
-	    if (numChars > 100) {
-		numChars = 100;
-		ellipsis = "...";
-	    }
-	    fprintf(stderr, "\n executing %.*s%s\n", numChars, cmd,
-		    ellipsis);
-	} else {
-	    fprintf(stderr, "\n");
-	}
-	panic("TclExecuteByteCode execution failure: bad stack top");
-    }
-}
-#endif /* TCL_COMPILE_DEBUG */
 
 
@@ -4271,182 +3631,4 @@
 
 
-#ifdef TCL_COMPILE_STATS
-/*
- *----------------------------------------------------------------------
- *
- * TclLog2 --
- *
- *	Procedure used while collecting compilation statistics to determine
- *	the log base 2 of an integer.
- *
- * Results:
- *	Returns the log base 2 of the operand. If the argument is less
- *	than or equal to zero, a zero is returned.
- *
- * Side effects:
- *	None.
- *
- *----------------------------------------------------------------------
- */
-
-int
-TclLog2(value)
-    register int value;		/* The integer for which to compute the
-				 * log base 2. */
-{
-    register int n = value;
-    register int result = 0;
-
-    while (n > 1) {
-	n = n >> 1;
-	result++;
-    }
-    return result;
-}
-
-
-/*
- *----------------------------------------------------------------------
- *
- * EvalStatsCmd --
- *
- *	Implements the "evalstats" command that prints instruction execution
- *	counts to stdout.
- *
- * Results:
- *	Standard Tcl results.
- *
- * Side effects:
- *	None.
- *
- *----------------------------------------------------------------------
- */
-
-static int
-EvalStatsCmd(unused, interp, argc, argv)
-    ClientData unused;		/* Unused. */
-    Tcl_Interp *interp;		/* The current interpreter. */
-    int argc;			/* The number of arguments. */
-    char **argv;		/* The argument strings. */
-{
-    register double total = 0.0;
-    register int i;
-    int maxSizeDecade = 0;
-    double totalHeaderBytes = (tclNumCompilations * sizeof(ByteCode));
-
-    for (i = 0;  i < 256;  i++) {
-        if (instructionCount[i] != 0) {
-            total += instructionCount[i];
-        }
-    }
-
-    for (i = 31;  i >= 0;  i--) {
-        if ((tclSourceCount[i] > 0) && (tclByteCodeCount[i] > 0)) {
-            maxSizeDecade = i;
-	    break;
-        }
-    } 
-
-    fprintf(stdout, "\nNumber of compilations		%ld\n",
-	    tclNumCompilations);
-    fprintf(stdout, "Number of executions		%ld\n",
-	    numExecutions);
-    fprintf(stdout, "Average executions/compilation	%.0f\n",
-	    ((float) numExecutions/tclNumCompilations));
-    
-    fprintf(stdout, "\nInstructions executed		%.0f\n",
-	    total);
-    fprintf(stdout, "Average instructions/compile	%.0f\n",
-	    total/tclNumCompilations);
-    fprintf(stdout, "Average instructions/execution	%.0f\n",
-	    total/numExecutions);
-    
-    fprintf(stdout, "\nTotal source bytes		%.6g\n",
-	    tclTotalSourceBytes);
-    fprintf(stdout, "Total code bytes		%.6g\n",
-	    tclTotalCodeBytes);
-    fprintf(stdout, "Average code/compilation	%.0f\n",
-	    tclTotalCodeBytes/tclNumCompilations);
-    fprintf(stdout, "Average code/source		%.2f\n",
-	    tclTotalCodeBytes/tclTotalSourceBytes);
-    fprintf(stdout, "Current source bytes		%.6g\n",
-	    tclCurrentSourceBytes);
-    fprintf(stdout, "Current code bytes		%.6g\n",
-	    tclCurrentCodeBytes);
-    fprintf(stdout, "Current code/source		%.2f\n",
-	    tclCurrentCodeBytes/tclCurrentSourceBytes);
-    
-    fprintf(stdout, "\nTotal objects allocated		%ld\n",
-	    tclObjsAlloced);
-    fprintf(stdout, "Total objects freed		%ld\n",
-	    tclObjsFreed);
-    fprintf(stdout, "Current objects:	 	%ld\n",
-	    (tclObjsAlloced - tclObjsFreed));
-
-    fprintf(stdout, "\nBreakdown of code byte requirements:\n");
-    fprintf(stdout, "                   Total bytes      Pct of    Avg per\n");
-    fprintf(stdout, "                                  all code    compile\n");
-    fprintf(stdout, "Total code        %12.6g        100%%   %8.2f\n",
-	    tclTotalCodeBytes, tclTotalCodeBytes/tclNumCompilations);
-    fprintf(stdout, "Header            %12.6g   %8.2f%%   %8.2f\n",
-	    totalHeaderBytes,
-	    ((totalHeaderBytes * 100.0) / tclTotalCodeBytes),
-	    totalHeaderBytes/tclNumCompilations);
-    fprintf(stdout, "Instructions      %12.6g   %8.2f%%   %8.2f\n",
-	    tclTotalInstBytes,
-	    ((tclTotalInstBytes * 100.0) / tclTotalCodeBytes),
-	    tclTotalInstBytes/tclNumCompilations);
-    fprintf(stdout, "Objects           %12.6g   %8.2f%%   %8.2f\n",
-	    tclTotalObjBytes,
-	    ((tclTotalObjBytes * 100.0) / tclTotalCodeBytes),
-	    tclTotalObjBytes/tclNumCompilations);
-    fprintf(stdout, "Exception table   %12.6g   %8.2f%%   %8.2f\n",
-	    tclTotalExceptBytes,
-	    ((tclTotalExceptBytes * 100.0) / tclTotalCodeBytes),
-	    tclTotalExceptBytes/tclNumCompilations);
-    fprintf(stdout, "Auxiliary data    %12.6g   %8.2f%%   %8.2f\n",
-	    tclTotalAuxBytes,
-	    ((tclTotalAuxBytes * 100.0) / tclTotalCodeBytes),
-	    tclTotalAuxBytes/tclNumCompilations);
-    fprintf(stdout, "Command map       %12.6g   %8.2f%%   %8.2f\n",
-	    tclTotalCmdMapBytes,
-	    ((tclTotalCmdMapBytes * 100.0) / tclTotalCodeBytes),
-	    tclTotalCmdMapBytes/tclNumCompilations);
-    
-    fprintf(stdout, "\nSource and ByteCode size distributions:\n");
-    fprintf(stdout, "	 binary decade		source	  code\n");
-    for (i = 0;  i <= maxSizeDecade;  i++) {
-	int decadeLow, decadeHigh;
-
-	if (i == 0) {
-	    decadeLow = 0;
-	} else {
-	    decadeLow = 1 << i;
-	}
-	decadeHigh = (1 << (i+1)) - 1;
-        fprintf(stdout,	"	%6d -%6d		%6d	%6d\n",
-		decadeLow, decadeHigh,
-		tclSourceCount[i], tclByteCodeCount[i]);
-    }
-
-    fprintf(stdout, "\nInstruction counts:\n");
-    for (i = 0;  i < 256;  i++) {
-        if (instructionCount[i]) {
-            fprintf(stdout, "%20s %8d %6.2f%%\n",
-		    opName[i], instructionCount[i],
-		    (instructionCount[i] * 100.0)/total);
-        }
-    }
-
-#ifdef TCL_MEM_DEBUG
-    fprintf(stdout, "\nHeap Statistics:\n");
-    TclDumpMemoryInfo(stdout);
-#endif /* TCL_MEM_DEBUG */
-
-    return TCL_OK;
-}
-#endif /* TCL_COMPILE_STATS */
-
-
 /*
  *----------------------------------------------------------------------
@@ -4758,40 +3940,2 @@
     panic("UpdateStringOfCmdName should never be invoked");
 }
-
-
-#ifdef TCL_COMPILE_DEBUG
-/*
- *----------------------------------------------------------------------
- *
- * StringForResultCode --
- *
- *	Procedure that returns a human-readable string representing a
- *	Tcl result code such as TCL_ERROR. 
- *
- * Results:
- *	If the result code is one of the standard Tcl return codes, the
- *	result is a string representing that code such as "TCL_ERROR".
- *	Otherwise, the result string is that code formatted as a
- *	sequence of decimal digit characters. Note that the resulting
- *	string must not be modified by the caller.
- *
- * Side effects:
- *	None.
- *
- *----------------------------------------------------------------------
- */
-
-static char *
-StringForResultCode(result)
-    int result;			/* The Tcl result code for which to
-				 * generate a string. */
-{
-    static char buf[20];
-    
-    if ((result >= TCL_OK) && (result <= TCL_CONTINUE)) {
-	return resultStrings[result];
-    }
-    TclFormatInt(buf, result);
-    return buf;
-}
-#endif /* TCL_COMPILE_DEBUG */
Index: external/tcl/tclInt.h
===================================================================
--- external/tcl/tclInt.h	(revision e15936c0a3056527d482c327cd48c5b2a548e0d4)
+++ external/tcl/tclInt.h	(revision adeddd899f1886a74c386a3b4521f830dcdc36b3)
@@ -1326,9 +1326,4 @@
 
 extern Tcl_Obj *	tclFreeObjList;
-
-#ifdef TCL_COMPILE_STATS
-extern long		tclObjsAlloced;
-extern long		tclObjsFreed;
-#endif /* TCL_COMPILE_STATS */
 
 /*
@@ -1445,5 +1440,5 @@
 		            int objc, Tcl_Obj *CONST objv[], int flags));
 EXTERN char *		TclpAlloc _ANSI_ARGS_((unsigned int size));
-
+EXTERN void		TclpFree(char *cp);
 EXTERN char *		TclpRealloc _ANSI_ARGS_((char *ptr,
 			    unsigned int size));
@@ -1472,6 +1467,4 @@
 EXTERN int		TclPreventAliasLoop _ANSI_ARGS_((Tcl_Interp *interp,
 		            Tcl_Interp *cmdInterp, Tcl_Command cmd));
-EXTERN void		TclPrintByteCodeObj _ANSI_ARGS_((Tcl_Interp *interp,
-		            Tcl_Obj *objPtr));
 EXTERN void		TclProcCleanupProc _ANSI_ARGS_((Proc *procPtr));
 EXTERN int		TclProcCompileProc _ANSI_ARGS_((Tcl_Interp *interp,
@@ -1688,46 +1681,4 @@
  */
 
-#ifdef TCL_COMPILE_STATS
-#  define TclIncrObjsAllocated() \
-    tclObjsAlloced++
-#  define TclIncrObjsFreed() \
-    tclObjsFreed++
-#else
-#  define TclIncrObjsAllocated()
-#  define TclIncrObjsFreed()
-#endif /* TCL_COMPILE_STATS */
-
-#ifdef TCL_MEM_DEBUG
-#  define TclNewObj(objPtr) \
-    (objPtr) = (Tcl_Obj *) Tcl_DbCkalloc(sizeof(Tcl_Obj), __FILE__, __LINE__); \
-    (objPtr)->refCount = 0; \
-    (objPtr)->bytes    = tclEmptyStringRep; \
-    (objPtr)->length   = 0; \
-    (objPtr)->typePtr  = NULL; \
-    TclIncrObjsAllocated()
-#  define TclDbNewObj(objPtr, file, line) \
-    (objPtr) = (Tcl_Obj *) Tcl_DbCkalloc(sizeof(Tcl_Obj), (file), (line)); \
-    (objPtr)->refCount = 0; \
-    (objPtr)->bytes    = tclEmptyStringRep; \
-    (objPtr)->length   = 0; \
-    (objPtr)->typePtr  = NULL; \
-    TclIncrObjsAllocated()
-#  define TclDecrRefCount(objPtr) \
-    if (--(objPtr)->refCount <= 0) { \
- 	if ((objPtr)->refCount < -1) \
-            panic("Reference count for %lx was negative: %s line %d", \
-		  (objPtr), __FILE__, __LINE__); \
-        if (((objPtr)->bytes != NULL) \
-	        && ((objPtr)->bytes != tclEmptyStringRep)) { \
-	    ckfree((char *) (objPtr)->bytes); \
-        } \
-        if (((objPtr)->typePtr != NULL) \
-	        && ((objPtr)->typePtr->freeIntRepProc != NULL)) { \
-	    (objPtr)->typePtr->freeIntRepProc(objPtr); \
-        } \
-        ckfree((char *) (objPtr)); \
-        TclIncrObjsFreed(); \
-    }
-#else /* not TCL_MEM_DEBUG */
 #  define TclNewObj(objPtr) \
     if (tclFreeObjList == NULL) { \
@@ -1740,6 +1691,5 @@
     (objPtr)->bytes    = tclEmptyStringRep; \
     (objPtr)->length   = 0; \
-    (objPtr)->typePtr  = NULL; \
-    TclIncrObjsAllocated()
+    (objPtr)->typePtr  = NULL;
 #  define TclDecrRefCount(objPtr) \
     if (--(objPtr)->refCount <= 0) { \
@@ -1754,7 +1704,5 @@
         (objPtr)->internalRep.otherValuePtr = (VOID *) tclFreeObjList; \
         tclFreeObjList = (objPtr); \
-        TclIncrObjsFreed(); \
     }
-#endif /* TCL_MEM_DEBUG */
 
 /*
Index: external/tcl/tclListObj.c
===================================================================
--- external/tcl/tclListObj.c	(revision e15936c0a3056527d482c327cd48c5b2a548e0d4)
+++ external/tcl/tclListObj.c	(revision adeddd899f1886a74c386a3b4521f830dcdc36b3)
@@ -46,11 +46,7 @@
  * Tcl_NewListObj --
  *
- *	This procedure is normally called when not debugging: i.e., when
- *	TCL_MEM_DEBUG is not defined. It creates a new list object from an
- *	(objc,objv) array: that is, each of the objc elements of the array
- *	referenced by objv is inserted as an element into a new Tcl object.
- *
- *	When TCL_MEM_DEBUG is defined, this procedure just returns the
- *	result of calling the debugging version Tcl_DbNewListObj.
+ *	This procedure creates a new list object from an (objc,objv) array:
+ *	that is, each of the objc elements of the array	referenced by objv
+ *	is inserted as an element into a new Tcl object.
  *
  * Results:
@@ -66,17 +62,4 @@
  *----------------------------------------------------------------------
  */
-
-#ifdef TCL_MEM_DEBUG
-#undef Tcl_NewListObj
-
-Tcl_Obj *
-Tcl_NewListObj(objc, objv)
-    int objc;			/* Count of objects referenced by objv. */
-    Tcl_Obj *CONST objv[];	/* An array of pointers to Tcl objects. */
-{
-    return Tcl_DbNewListObj(objc, objv, "unknown", 0);
-}
-
-#else /* if not TCL_MEM_DEBUG */
 
 Tcl_Obj *
@@ -112,89 +95,4 @@
     return listPtr;
 }
-#endif /* if TCL_MEM_DEBUG */
-
-
-/*
- *----------------------------------------------------------------------
- *
- * Tcl_DbNewListObj --
- *
- *	This procedure is normally called when debugging: i.e., when
- *	TCL_MEM_DEBUG is defined. It creates new list objects. It is the
- *	same as the Tcl_NewListObj procedure above except that it calls
- *	Tcl_DbCkalloc directly with the file name and line number from its
- *	caller. This simplifies debugging since then the checkmem command
- *	will report the correct file name and line number when reporting
- *	objects that haven't been freed.
- *
- *	When TCL_MEM_DEBUG is not defined, this procedure just returns the
- *	result of calling Tcl_NewListObj.
- *
- * Results:
- *	A new list object is returned that is initialized from the object
- *	pointers in objv. If objc is less than or equal to zero, an empty
- *	object is returned. The new object's string representation
- *	is left NULL. The new list object has ref count 0.
- *
- * Side effects:
- *	The ref counts of the elements in objv are incremented since the
- *	resulting list now refers to them.
- *
- *----------------------------------------------------------------------
- */
-
-#ifdef TCL_MEM_DEBUG
-
-Tcl_Obj *
-Tcl_DbNewListObj(objc, objv, file, line)
-    int objc;			/* Count of objects referenced by objv. */
-    Tcl_Obj *CONST objv[];	/* An array of pointers to Tcl objects. */
-    char *file;			/* The name of the source file calling this
-				 * procedure; used for debugging. */
-    int line;			/* Line number in the source file; used
-				 * for debugging. */
-{
-    register Tcl_Obj *listPtr;
-    register Tcl_Obj **elemPtrs;
-    register List *listRepPtr;
-    int i;
-    
-    TclDbNewObj(listPtr, file, line);
-    
-    if (objc > 0) {
-	Tcl_InvalidateStringRep(listPtr);
-	
-	elemPtrs = (Tcl_Obj **)
-	    ckalloc((unsigned) (objc * sizeof(Tcl_Obj *)));
-	for (i = 0;  i < objc;  i++) {
-	    elemPtrs[i] = objv[i];
-	    Tcl_IncrRefCount(elemPtrs[i]);
-	}
-	
-	listRepPtr = (List *) ckalloc(sizeof(List));
-	listRepPtr->maxElemCount = objc;
-	listRepPtr->elemCount    = objc;
-	listRepPtr->elements     = elemPtrs;
-	
-	listPtr->internalRep.otherValuePtr = (VOID *) listRepPtr;
-	listPtr->typePtr = &tclListType;
-    }
-    return listPtr;
-}
-
-#else /* if not TCL_MEM_DEBUG */
-
-Tcl_Obj *
-Tcl_DbNewListObj(objc, objv, file, line)
-    int objc;			/* Count of objects referenced by objv. */
-    Tcl_Obj *CONST objv[];	/* An array of pointers to Tcl objects. */
-    char *file;			/* The name of the source file calling this
-				 * procedure; used for debugging. */
-    int line;			/* Line number in the source file; used
-				 * for debugging. */
-{
-    return Tcl_NewListObj(objc, objv);
-}
-#endif /* TCL_MEM_DEBUG */
 
 
Index: external/tcl/tclObj.c
===================================================================
--- external/tcl/tclObj.c	(revision e15936c0a3056527d482c327cd48c5b2a548e0d4)
+++ external/tcl/tclObj.c	(revision adeddd899f1886a74c386a3b4521f830dcdc36b3)
@@ -36,14 +36,4 @@
 
 char *tclEmptyStringRep = NULL;
-
-/*
- * Count of the number of Tcl objects every allocated (by Tcl_NewObj) and
- * freed (by TclFreeObj).
- */
-
-#ifdef TCL_COMPILE_STATS
-long tclObjsAlloced = 0;
-long tclObjsFreed = 0;
-#endif /* TCL_COMPILE_STATS */
 
 /*
@@ -417,12 +407,8 @@
  * Tcl_NewObj --
  *
- *	This procedure is normally called when not debugging: i.e., when
- *	TCL_MEM_DEBUG is not defined. It creates new Tcl objects that denote
- *	the empty string. These objects have a NULL object type and NULL
- *	string representation byte pointer. Type managers call this routine
- *	to allocate new objects that they further initialize.
- *
- *	When TCL_MEM_DEBUG is defined, this procedure just returns the
- *	result of calling the debugging version Tcl_DbNewObj.
+ *	This procedure creates new Tcl objects that denote the empty string.
+ *	These objects have a NULL object type and NULL string representation
+ *	byte pointer. Type managers call this routine to allocate new objects
+ *	that they further initialize.
  *
  * Results:
@@ -431,21 +417,6 @@
  *	is set to 0.
  *
- * Side effects:
- *	If compiling with TCL_COMPILE_STATS, this procedure increments
- *	the global count of allocated objects (tclObjsAlloced).
- *
- *----------------------------------------------------------------------
- */
-
-#ifdef TCL_MEM_DEBUG
-#undef Tcl_NewObj
-
-Tcl_Obj *
-Tcl_NewObj()
-{
-    return Tcl_DbNewObj("unknown", 0);
-}
-
-#else /* if not TCL_MEM_DEBUG */
+ *----------------------------------------------------------------------
+ */
 
 Tcl_Obj *
@@ -468,78 +439,6 @@
     objPtr->length   = 0;
     objPtr->typePtr  = NULL;
-#ifdef TCL_COMPILE_STATS
-    tclObjsAlloced++;
-#endif /* TCL_COMPILE_STATS */
     return objPtr;
 }
-#endif /* TCL_MEM_DEBUG */
-
-
-/*
- *----------------------------------------------------------------------
- *
- * Tcl_DbNewObj --
- *
- *	This procedure is normally called when debugging: i.e., when
- *	TCL_MEM_DEBUG is defined. It creates new Tcl objects that denote the
- *	empty string. It is the same as the Tcl_NewObj procedure above
- *	except that it calls Tcl_DbCkalloc directly with the file name and
- *	line number from its caller. This simplifies debugging since then
- *	the checkmem command will report the correct file name and line
- *	number when reporting objects that haven't been freed.
- *
- *	When TCL_MEM_DEBUG is not defined, this procedure just returns the
- *	result of calling Tcl_NewObj.
- *
- * Results:
- *	The result is a newly allocated that represents the empty string.
- *	The new object's typePtr is set NULL and its ref count is set to 0.
- *
- * Side effects:
- *	If compiling with TCL_COMPILE_STATS, this procedure increments
- *	the global count of allocated objects (tclObjsAlloced).
- *
- *----------------------------------------------------------------------
- */
-
-#ifdef TCL_MEM_DEBUG
-
-Tcl_Obj *
-Tcl_DbNewObj(file, line)
-    register char *file;	/* The name of the source file calling this
-				 * procedure; used for debugging. */
-    register int line;		/* Line number in the source file; used
-				 * for debugging. */
-{
-    register Tcl_Obj *objPtr;
-
-    /*
-     * If debugging Tcl's memory usage, allocate the object using ckalloc.
-     * Otherwise, allocate it using the list of free Tcl_Objs we maintain.
-     */
-
-    objPtr = (Tcl_Obj *) Tcl_DbCkalloc(sizeof(Tcl_Obj), file, line);
-    objPtr->refCount = 0;
-    objPtr->bytes    = tclEmptyStringRep;
-    objPtr->length   = 0;
-    objPtr->typePtr  = NULL;
-#ifdef TCL_COMPILE_STATS
-    tclObjsAlloced++;
-#endif /* TCL_COMPILE_STATS */
-    return objPtr;
-}
-
-#else /* if not TCL_MEM_DEBUG */
-
-Tcl_Obj *
-Tcl_DbNewObj(file, line)
-    char *file;			/* The name of the source file calling this
-				 * procedure; used for debugging. */
-    int line;			/* Line number in the source file; used
-				 * for debugging. */
-{
-    return Tcl_NewObj();
-}
-#endif /* TCL_MEM_DEBUG */
 
 
@@ -609,7 +508,5 @@
  *	after deallocating the string representation and calling the
  *	type-specific Tcl_FreeInternalRepProc to deallocate the object's
- *	internal representation. If compiling with TCL_COMPILE_STATS,
- *	this procedure increments the global count of freed objects
- *	(tclObjsFreed).
+ *	internal representation.
  *
  *----------------------------------------------------------------------
@@ -622,10 +519,4 @@
     register Tcl_ObjType *typePtr = objPtr->typePtr;
     
-#ifdef TCL_MEM_DEBUG
-    if ((objPtr)->refCount < -1) {
-	panic("Reference count for %lx was negative", objPtr);
-    }
-#endif /* TCL_MEM_DEBUG */
-
     Tcl_InvalidateStringRep(objPtr);
     if ((typePtr != NULL) && (typePtr->freeIntRepProc != NULL)) {
@@ -634,19 +525,10 @@
 
     /*
-     * If debugging Tcl's memory usage, deallocate the object using ckfree.
-     * Otherwise, deallocate it by adding it onto the list of free
+     * Deallocate the object by adding it onto the list of free
      * Tcl_Objs we maintain.
      */
     
-#ifdef TCL_MEM_DEBUG
-    ckfree((char *) objPtr);
-#else
     objPtr->internalRep.otherValuePtr = (VOID *) tclFreeObjList;
     tclFreeObjList = objPtr;
-#endif /* TCL_MEM_DEBUG */
-
-#ifdef TCL_COMPILE_STATS    
-    tclObjsFreed++;
-#endif /* TCL_COMPILE_STATS */    
 }
 
@@ -794,11 +676,6 @@
  * Tcl_NewBooleanObj --
  *
- *	This procedure is normally called when not debugging: i.e., when
- *	TCL_MEM_DEBUG is not defined. It creates a new boolean object and
- *	initializes it from the argument boolean value. A nonzero
- *	"boolValue" is coerced to 1.
- *
- *	When TCL_MEM_DEBUG is defined, this procedure just returns the
- *	result of calling the debugging version Tcl_DbNewBooleanObj.
+ *	This procedure creates a new boolean object and	initializes it from
+ *	the argument boolean value. A nonzero "boolValue" is coerced to 1.
  *
  * Results:
@@ -811,7 +688,4 @@
  *----------------------------------------------------------------------
  */
-
-#ifdef TCL_MEM_DEBUG
-#undef Tcl_NewBooleanObj
 
 Tcl_Obj *
@@ -819,13 +693,4 @@
     register int boolValue;	/* Boolean used to initialize new object. */
 {
-    return Tcl_DbNewBooleanObj(boolValue, "unknown", 0);
-}
-
-#else /* if not TCL_MEM_DEBUG */
-
-Tcl_Obj *
-Tcl_NewBooleanObj(boolValue)
-    register int boolValue;	/* Boolean used to initialize new object. */
-{
     register Tcl_Obj *objPtr;
 
@@ -837,66 +702,4 @@
     return objPtr;
 }
-#endif /* TCL_MEM_DEBUG */
-
-
-/*
- *----------------------------------------------------------------------
- *
- * Tcl_DbNewBooleanObj --
- *
- *	This procedure is normally called when debugging: i.e., when
- *	TCL_MEM_DEBUG is defined. It creates new boolean objects. It is the
- *	same as the Tcl_NewBooleanObj procedure above except that it calls
- *	Tcl_DbCkalloc directly with the file name and line number from its
- *	caller. This simplifies debugging since then the checkmem command
- *	will report the correct file name and line number when reporting
- *	objects that haven't been freed.
- *
- *	When TCL_MEM_DEBUG is not defined, this procedure just returns the
- *	result of calling Tcl_NewBooleanObj.
- *
- * Results:
- *	The newly created object is returned. This object will have an
- *	invalid string representation. The returned object has ref count 0.
- *
- * Side effects:
- *	None.
- *
- *----------------------------------------------------------------------
- */
-
-#ifdef TCL_MEM_DEBUG
-
-Tcl_Obj *
-Tcl_DbNewBooleanObj(boolValue, file, line)
-    register int boolValue;	/* Boolean used to initialize new object. */
-    char *file;			/* The name of the source file calling this
-				 * procedure; used for debugging. */
-    int line;			/* Line number in the source file; used
-				 * for debugging. */
-{
-    register Tcl_Obj *objPtr;
-
-    TclDbNewObj(objPtr, file, line);
-    objPtr->bytes = NULL;
-    
-    objPtr->internalRep.longValue = (boolValue? 1 : 0);
-    objPtr->typePtr = &tclBooleanType;
-    return objPtr;
-}
-
-#else /* if not TCL_MEM_DEBUG */
-
-Tcl_Obj *
-Tcl_DbNewBooleanObj(boolValue, file, line)
-    register int boolValue;	/* Boolean used to initialize new object. */
-    char *file;			/* The name of the source file calling this
-				 * procedure; used for debugging. */
-    int line;			/* Line number in the source file; used
-				 * for debugging. */
-{
-    return Tcl_NewBooleanObj(boolValue);
-}
-#endif /* TCL_MEM_DEBUG */
 
 
@@ -1178,10 +981,6 @@
  * Tcl_NewDoubleObj --
  *
- *	This procedure is normally called when not debugging: i.e., when
- *	TCL_MEM_DEBUG is not defined. It creates a new double object and
- *	initializes it from the argument double value.
- *
- *	When TCL_MEM_DEBUG is defined, this procedure just returns the
- *	result of calling the debugging version Tcl_DbNewDoubleObj.
+ *	This procedure creates a new double object and initializes it from
+ *	the argument double value.
  *
  * Results:
@@ -1194,7 +993,4 @@
  *----------------------------------------------------------------------
  */
-
-#ifdef TCL_MEM_DEBUG
-#undef Tcl_NewDoubleObj
 
 Tcl_Obj *
@@ -1202,13 +998,4 @@
     register double dblValue;	/* Double used to initialize the object. */
 {
-    return Tcl_DbNewDoubleObj(dblValue, "unknown", 0);
-}
-
-#else /* if not TCL_MEM_DEBUG */
-
-Tcl_Obj *
-Tcl_NewDoubleObj(dblValue)
-    register double dblValue;	/* Double used to initialize the object. */
-{
     register Tcl_Obj *objPtr;
 
@@ -1220,66 +1007,4 @@
     return objPtr;
 }
-#endif /* if TCL_MEM_DEBUG */
-
-
-/*
- *----------------------------------------------------------------------
- *
- * Tcl_DbNewDoubleObj --
- *
- *	This procedure is normally called when debugging: i.e., when
- *	TCL_MEM_DEBUG is defined. It creates new double objects. It is the
- *	same as the Tcl_NewDoubleObj procedure above except that it calls
- *	Tcl_DbCkalloc directly with the file name and line number from its
- *	caller. This simplifies debugging since then the checkmem command
- *	will report the correct file name and line number when reporting
- *	objects that haven't been freed.
- *
- *	When TCL_MEM_DEBUG is not defined, this procedure just returns the
- *	result of calling Tcl_NewDoubleObj.
- *
- * Results:
- *	The newly created object is returned. This object will have an
- *	invalid string representation. The returned object has ref count 0.
- *
- * Side effects:
- *	None.
- *
- *----------------------------------------------------------------------
- */
-
-#ifdef TCL_MEM_DEBUG
-
-Tcl_Obj *
-Tcl_DbNewDoubleObj(dblValue, file, line)
-    register double dblValue;	/* Double used to initialize the object. */
-    char *file;			/* The name of the source file calling this
-				 * procedure; used for debugging. */
-    int line;			/* Line number in the source file; used
-				 * for debugging. */
-{
-    register Tcl_Obj *objPtr;
-
-    TclDbNewObj(objPtr, file, line);
-    objPtr->bytes = NULL;
-    
-    objPtr->internalRep.doubleValue = dblValue;
-    objPtr->typePtr = &tclDoubleType;
-    return objPtr;
-}
-
-#else /* if not TCL_MEM_DEBUG */
-
-Tcl_Obj *
-Tcl_DbNewDoubleObj(dblValue, file, line)
-    register double dblValue;	/* Double used to initialize the object. */
-    char *file;			/* The name of the source file calling this
-				 * procedure; used for debugging. */
-    int line;			/* Line number in the source file; used
-				 * for debugging. */
-{
-    return Tcl_NewDoubleObj(dblValue);
-}
-#endif /* TCL_MEM_DEBUG */
 
 
@@ -1531,10 +1256,5 @@
  * Tcl_NewIntObj --
  *
- *	If a client is compiled with TCL_MEM_DEBUG defined, calls to
- *	Tcl_NewIntObj to create a new integer object end up calling the
- *	debugging procedure Tcl_DbNewLongObj instead.
- *
- *	Otherwise, if the client is compiled without TCL_MEM_DEBUG defined,
- *	calls to Tcl_NewIntObj result in a call to one of the two
+ *	Calls to Tcl_NewIntObj result in a call to one of the two
  *	Tcl_NewIntObj implementations below. We provide two implementations
  *	so that the Tcl core can be compiled to do memory debugging of the 
@@ -1556,20 +1276,8 @@
  */
 
-#ifdef TCL_MEM_DEBUG
-#undef Tcl_NewIntObj
-
 Tcl_Obj *
 Tcl_NewIntObj(intValue)
     register int intValue;	/* Int used to initialize the new object. */
 {
-    return Tcl_DbNewLongObj((long)intValue, "unknown", 0);
-}
-
-#else /* if not TCL_MEM_DEBUG */
-
-Tcl_Obj *
-Tcl_NewIntObj(intValue)
-    register int intValue;	/* Int used to initialize the new object. */
-{
     register Tcl_Obj *objPtr;
 
@@ -1581,5 +1289,4 @@
     return objPtr;
 }
-#endif /* if TCL_MEM_DEBUG */
 
 
@@ -1856,10 +1563,5 @@
  * Tcl_NewLongObj --
  *
- *	If a client is compiled with TCL_MEM_DEBUG defined, calls to
- *	Tcl_NewLongObj to create a new long integer object end up calling
- *	the debugging procedure Tcl_DbNewLongObj instead.
- *
- *	Otherwise, if the client is compiled without TCL_MEM_DEBUG defined,
- *	calls to Tcl_NewLongObj result in a call to one of the two
+ *	Calls to Tcl_NewLongObj result in a call to one of the two
  *	Tcl_NewLongObj implementations below. We provide two implementations
  *	so that the Tcl core can be compiled to do memory debugging of the 
@@ -1881,7 +1583,4 @@
  */
 
-#ifdef TCL_MEM_DEBUG
-#undef Tcl_NewLongObj
-
 Tcl_Obj *
 Tcl_NewLongObj(longValue)
@@ -1889,14 +1588,4 @@
 				 * new object. */
 {
-    return Tcl_DbNewLongObj(longValue, "unknown", 0);
-}
-
-#else /* if not TCL_MEM_DEBUG */
-
-Tcl_Obj *
-Tcl_NewLongObj(longValue)
-    register long longValue;	/* Long integer used to initialize the
-				 * new object. */
-{
     register Tcl_Obj *objPtr;
 
@@ -1908,5 +1597,4 @@
     return objPtr;
 }
-#endif /* if TCL_MEM_DEBUG */
 
 
@@ -1916,20 +1604,5 @@
  * Tcl_DbNewLongObj --
  *
- *	If a client is compiled with TCL_MEM_DEBUG defined, calls to
- *	Tcl_NewIntObj and Tcl_NewLongObj to create new integer or
- *	long integer objects end up calling the debugging procedure
- *	Tcl_DbNewLongObj instead. We provide two implementations of
- *	Tcl_DbNewLongObj so that whether the Tcl core is compiled to do
- *	memory debugging of the core is independent of whether a client
- *	requests debugging for itself.
- *
- *	When the core is compiled with TCL_MEM_DEBUG defined,
- *	Tcl_DbNewLongObj calls Tcl_DbCkalloc directly with the file name and
- *	line number from its caller. This simplifies debugging since then
- *	the checkmem command will report the caller's file name and line
- *	number when reporting objects that haven't been freed.
- *
- *	Otherwise, when the core is compiled without TCL_MEM_DEBUG defined,
- *	this procedure just returns the result of calling Tcl_NewLongObj.
+ *	This procedure just returns the result of calling Tcl_NewLongObj.
  *
  * Results:
@@ -1943,6 +1616,4 @@
  *----------------------------------------------------------------------
  */
-
-#ifdef TCL_MEM_DEBUG
 
 Tcl_Obj *
@@ -1955,28 +1626,6 @@
 				 * for debugging. */
 {
-    register Tcl_Obj *objPtr;
-
-    TclDbNewObj(objPtr, file, line);
-    objPtr->bytes = NULL;
-    
-    objPtr->internalRep.longValue = longValue;
-    objPtr->typePtr = &tclIntType;
-    return objPtr;
-}
-
-#else /* if not TCL_MEM_DEBUG */
-
-Tcl_Obj *
-Tcl_DbNewLongObj(longValue, file, line)
-    register long longValue;	/* Long integer used to initialize the
-				 * new object. */
-    char *file;			/* The name of the source file calling this
-				 * procedure; used for debugging. */
-    int line;			/* Line number in the source file; used
-				 * for debugging. */
-{
     return Tcl_NewLongObj(longValue);
 }
-#endif /* TCL_MEM_DEBUG */
 
 
@@ -2060,125 +1709,2 @@
     return result;
 }
-
-
-/*
- *----------------------------------------------------------------------
- *
- * Tcl_DbIncrRefCount --
- *
- *	This procedure is normally called when debugging: i.e., when
- *	TCL_MEM_DEBUG is defined. This checks to see whether or not
- *	the memory has been freed before incrementing the ref count.
- *
- *	When TCL_MEM_DEBUG is not defined, this procedure just increments
- *	the reference count of the object.
- *
- * Results:
- *	None.
- *
- * Side effects:
- *	The object's ref count is incremented.
- *
- *----------------------------------------------------------------------
- */
-
-void
-Tcl_DbIncrRefCount(objPtr, file, line)
-    register Tcl_Obj *objPtr;	/* The object we are adding a reference to. */
-    char *file;			/* The name of the source file calling this
-				 * procedure; used for debugging. */
-    int line;			/* Line number in the source file; used
-				 * for debugging. */
-{
-#ifdef TCL_MEM_DEBUG
-    if (objPtr->refCount == 0x61616161) {
-	fprintf(stderr, "file = %s, line = %d\n", file, line);
-	fflush(stderr);
-	panic("Trying to increment refCount of previously disposed object.");
-    }
-#endif
-    ++(objPtr)->refCount;
-}
-
-
-/*
- *----------------------------------------------------------------------
- *
- * Tcl_DbDecrRefCount --
- *
- *	This procedure is normally called when debugging: i.e., when
- *	TCL_MEM_DEBUG is defined. This checks to see whether or not
- *	the memory has been freed before incrementing the ref count.
- *
- *	When TCL_MEM_DEBUG is not defined, this procedure just increments
- *	the reference count of the object.
- *
- * Results:
- *	None.
- *
- * Side effects:
- *	The object's ref count is incremented.
- *
- *----------------------------------------------------------------------
- */
-
-void
-Tcl_DbDecrRefCount(objPtr, file, line)
-    register Tcl_Obj *objPtr;	/* The object we are adding a reference to. */
-    char *file;			/* The name of the source file calling this
-				 * procedure; used for debugging. */
-    int line;			/* Line number in the source file; used
-				 * for debugging. */
-{
-#ifdef TCL_MEM_DEBUG
-    if (objPtr->refCount == 0x61616161) {
-	fprintf(stderr, "file = %s, line = %d\n", file, line);
-	fflush(stderr);
-	panic("Trying to decrement refCount of previously disposed object.");
-    }
-#endif
-    if (--(objPtr)->refCount <= 0) {
-	TclFreeObj(objPtr);
-    }
-}
-
-
-/*
- *----------------------------------------------------------------------
- *
- * Tcl_DbIsShared --
- *
- *	This procedure is normally called when debugging: i.e., when
- *	TCL_MEM_DEBUG is defined. This checks to see whether or not
- *	the memory has been freed before incrementing the ref count.
- *
- *	When TCL_MEM_DEBUG is not defined, this procedure just decrements
- *	the reference count of the object and throws it away if the count
- *	is 0 or less.
- *
- * Results:
- *	None.
- *
- * Side effects:
- *	The object's ref count is incremented.
- *
- *----------------------------------------------------------------------
- */
-
-int
-Tcl_DbIsShared(objPtr, file, line)
-    register Tcl_Obj *objPtr;	/* The object we are adding a reference to. */
-    char *file;			/* The name of the source file calling this
-				 * procedure; used for debugging. */
-    int line;			/* Line number in the source file; used
-				 * for debugging. */
-{
-#ifdef TCL_MEM_DEBUG
-    if (objPtr->refCount == 0x61616161) {
-	fprintf(stderr, "file = %s, line = %d\n", file, line);
-	fflush(stderr);
-	panic("Trying to check whether previously disposed object is shared.");
-    }
-#endif
-    return ((objPtr)->refCount > 1);
-}
Index: external/tcl/tclProc.c
===================================================================
--- external/tcl/tclProc.c	(revision e15936c0a3056527d482c327cd48c5b2a548e0d4)
+++ external/tcl/tclProc.c	(revision adeddd899f1886a74c386a3b4521f830dcdc36b3)
@@ -985,15 +985,4 @@
      */
 
-    if (tclTraceExec >= 1) {
-	fprintf(stdout, "Calling proc ");
-	for (i = 0;  i < objc;  i++) {
-	    bytes = Tcl_GetStringFromObj(objv[i], &length);
-	    TclPrintSource(stdout, bytes, TclMin(length, 15));
-	    fprintf(stdout, " ");
-	}
-	fprintf(stdout, "\n");
-	fflush(stdout);
-    }
-
     iPtr->returnCode = TCL_OK;
     procPtr->refCount++;
@@ -1119,20 +1108,4 @@
  	int numChars;
  	char *ellipsis;
- 	
- 	if (tclTraceCompile >= 1) {
- 	    /*
- 	     * Display a line summarizing the top level command we
- 	     * are about to compile.
- 	     */
- 
- 	    numChars = strlen(procName);
- 	    ellipsis = "";
- 	    if (numChars > 50) {
- 		numChars = 50;
- 		ellipsis = "...";
- 	    }
- 	    fprintf(stdout, "Compiling %s \"%.*s%s\"\n",
- 		    description, numChars, procName, ellipsis);
- 	}
  	
  	/*
Index: external/tcl/tclStringObj.c
===================================================================
--- external/tcl/tclStringObj.c	(revision e15936c0a3056527d482c327cd48c5b2a548e0d4)
+++ external/tcl/tclStringObj.c	(revision adeddd899f1886a74c386a3b4521f830dcdc36b3)
@@ -50,10 +50,6 @@
  * Tcl_NewStringObj --
  *
- *	This procedure is normally called when not debugging: i.e., when
- *	TCL_MEM_DEBUG is not defined. It creates a new string object and
- *	initializes it from the byte pointer and length arguments.
- *
- *	When TCL_MEM_DEBUG is defined, this procedure just returns the
- *	result of calling the debugging version Tcl_DbNewStringObj.
+ *	This procedure creates a new string object and initializes it from
+ *	the byte pointer and length arguments.
  *
  * Results:
@@ -70,7 +66,4 @@
  *----------------------------------------------------------------------
  */
-
-#ifdef TCL_MEM_DEBUG
-#undef Tcl_NewStringObj
 
 Tcl_Obj *
@@ -83,18 +76,4 @@
 				 * NULL byte. */
 {
-    return Tcl_DbNewStringObj(bytes, length, "unknown", 0);
-}
-
-#else /* if not TCL_MEM_DEBUG */
-
-Tcl_Obj *
-Tcl_NewStringObj(bytes, length)
-    register char *bytes;	/* Points to the first of the length bytes
-				 * used to initialize the new object. */
-    register int length;	/* The number of bytes to copy from "bytes"
-				 * when initializing the new object. If 
-				 * negative, use bytes up to the first
-				 * NULL byte. */
-{
     register Tcl_Obj *objPtr;
 
@@ -106,80 +85,4 @@
     return objPtr;
 }
-#endif /* TCL_MEM_DEBUG */
-
-
-/*
- *----------------------------------------------------------------------
- *
- * Tcl_DbNewStringObj --
- *
- *	This procedure is normally called when debugging: i.e., when
- *	TCL_MEM_DEBUG is defined. It creates new string objects. It is the
- *	same as the Tcl_NewStringObj procedure above except that it calls
- *	Tcl_DbCkalloc directly with the file name and line number from its
- *	caller. This simplifies debugging since then the checkmem command
- *	will report the correct file name and line number when reporting
- *	objects that haven't been freed.
- *
- *	When TCL_MEM_DEBUG is not defined, this procedure just returns the
- *	result of calling Tcl_NewStringObj.
- *
- * Results:
- *	A newly created string object is returned that has ref count zero.
- *
- * Side effects:
- *	The new object's internal string representation will be set to a
- *	copy of the length bytes starting at "bytes". If "length" is
- *	negative, use bytes up to the first NULL byte; i.e., assume "bytes"
- *	points to a C-style NULL-terminated string. The object's type is set
- *	to NULL. An extra NULL is added to the end of the new object's byte
- *	array.
- *
- *----------------------------------------------------------------------
- */
-
-#ifdef TCL_MEM_DEBUG
-
-Tcl_Obj *
-Tcl_DbNewStringObj(bytes, length, file, line)
-    register char *bytes;	/* Points to the first of the length bytes
-				 * used to initialize the new object. */
-    register int length;	/* The number of bytes to copy from "bytes"
-				 * when initializing the new object. If 
-				 * negative, use bytes up to the first
-				 * NULL byte. */
-    char *file;			/* The name of the source file calling this
-				 * procedure; used for debugging. */
-    int line;			/* Line number in the source file; used
-				 * for debugging. */
-{
-    register Tcl_Obj *objPtr;
-
-    if (length < 0) {
-	length = (bytes? strlen(bytes) : 0);
-    }
-    TclDbNewObj(objPtr, file, line);
-    TclInitStringRep(objPtr, bytes, length);
-    return objPtr;
-}
-
-#else /* if not TCL_MEM_DEBUG */
-
-Tcl_Obj *
-Tcl_DbNewStringObj(bytes, length, file, line)
-    register char *bytes;	/* Points to the first of the length bytes
-				 * used to initialize the new object. */
-    register int length;	/* The number of bytes to copy from "bytes"
-				 * when initializing the new object. If 
-				 * negative, use bytes up to the first
-				 * NULL byte. */
-    char *file;			/* The name of the source file calling this
-				 * procedure; used for debugging. */
-    int line;			/* Line number in the source file; used
-				 * for debugging. */
-{
-    return Tcl_NewStringObj(bytes, length);
-}
-#endif /* TCL_MEM_DEBUG */
 
 
Index: external/tcl/tclVar.c
===================================================================
--- external/tcl/tclVar.c	(revision e15936c0a3056527d482c327cd48c5b2a548e0d4)
+++ external/tcl/tclVar.c	(revision adeddd899f1886a74c386a3b4521f830dcdc36b3)
@@ -711,22 +711,4 @@
     char *msg;
 
-#ifdef TCL_COMPILE_DEBUG
-    Proc *procPtr = varFramePtr->procPtr;
-    int localCt = procPtr->numCompiledLocals;
-
-    if (compiledLocals == NULL) {
-	fprintf(stderr, "\nTclGetIndexedScalar: can't get local %i in frame 0x%x, no compiled locals\n",
-		localIndex, (unsigned int) varFramePtr);
-	panic("TclGetIndexedScalar: no compiled locals in frame 0x%x",
-		(unsigned int) varFramePtr);
-    }
-    if ((localIndex < 0) || (localIndex >= localCt)) {
-	fprintf(stderr, "\nTclGetIndexedScalar: can't get local %i in frame 0x%x with %i locals\n",
-		localIndex, (unsigned int) varFramePtr, localCt);
-	panic("TclGetIndexedScalar: bad local index %i in frame 0x%x",
-		localIndex, (unsigned int) varFramePtr);
-    }
-#endif /* TCL_COMPILE_DEBUG */
-    
     varPtr = &(compiledLocals[localIndex]);
     varName = varPtr->name;
@@ -832,22 +814,4 @@
     int new;
 
-#ifdef TCL_COMPILE_DEBUG
-    Proc *procPtr = varFramePtr->procPtr;
-    int localCt = procPtr->numCompiledLocals;
-
-    if (compiledLocals == NULL) {
-	fprintf(stderr, "\nTclGetElementOfIndexedArray: can't get element of local %i in frame 0x%x, no compiled locals\n",
-		localIndex, (unsigned int) varFramePtr);
-	panic("TclGetIndexedScalar: no compiled locals in frame 0x%x",
-		(unsigned int) varFramePtr);
-    }
-    if ((localIndex < 0) || (localIndex >= localCt)) {
-	fprintf(stderr, "\nTclGetIndexedScalar: can't get element of local %i in frame 0x%x with %i locals\n",
-		localIndex, (unsigned int) varFramePtr, localCt);
-	panic("TclGetElementOfIndexedArray: bad local index %i in frame 0x%x",
-		localIndex, (unsigned int) varFramePtr);
-    }
-#endif /* TCL_COMPILE_DEBUG */
-
     /*
      * THIS FAILS IF THE ELEMENT NAME OBJECT'S STRING REP HAS A NULL BYTE.
@@ -1449,22 +1413,4 @@
     Tcl_Obj *resultPtr = NULL;
 
-#ifdef TCL_COMPILE_DEBUG
-    Proc *procPtr = varFramePtr->procPtr;
-    int localCt = procPtr->numCompiledLocals;
-
-    if (compiledLocals == NULL) {
-	fprintf(stderr, "\nTclSetIndexedScalar: can't set local %i in frame 0x%x, no compiled locals\n",
-		localIndex, (unsigned int) varFramePtr);
-	panic("TclSetIndexedScalar: no compiled locals in frame 0x%x",
-		(unsigned int) varFramePtr);
-    }
-    if ((localIndex < 0) || (localIndex >= localCt)) {
-	fprintf(stderr, "\nTclSetIndexedScalar: can't set local %i in frame 0x%x with %i locals\n",
-		localIndex, (unsigned int) varFramePtr, localCt);
-	panic("TclSetIndexedScalar: bad local index %i in frame 0x%x",
-		localIndex, (unsigned int) varFramePtr);
-    }
-#endif /* TCL_COMPILE_DEBUG */
-    
     varPtr = &(compiledLocals[localIndex]);
     varName = varPtr->name;
@@ -1635,22 +1581,4 @@
     int new;
     
-#ifdef TCL_COMPILE_DEBUG
-    Proc *procPtr = varFramePtr->procPtr;
-    int localCt = procPtr->numCompiledLocals;
-
-    if (compiledLocals == NULL) {
-	fprintf(stderr, "\nTclSetElementOfIndexedArray: can't set element of local %i in frame 0x%x, no compiled locals\n",
-		localIndex, (unsigned int) varFramePtr);
-	panic("TclSetIndexedScalar: no compiled locals in frame 0x%x",
-		(unsigned int) varFramePtr);
-    }
-    if ((localIndex < 0) || (localIndex >= localCt)) {
-	fprintf(stderr, "\nTclSetIndexedScalar: can't set elememt of local %i in frame 0x%x with %i locals\n",
-		localIndex, (unsigned int) varFramePtr, localCt);
-	panic("TclSetElementOfIndexedArray: bad local index %i in frame 0x%x",
-		localIndex, (unsigned int) varFramePtr);
-    }
-#endif /* TCL_COMPILE_DEBUG */
-
     /*
      * THIS FAILS IF THE ELEMENT NAME OBJECT'S STRING REP HAS A NULL BYTE.
